# ##### BEGIN GPL LICENSE BLOCK #####
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#
# ##### END GPL LICENSE BLOCK #####
# <pep8 compliant>
import re
import xml.dom.minidom
from math import cos, sin, tan, atan2, pi, ceil
import bpy
from mathutils import Vector, Matrix
from . import svg_colors
#### Common utilities ####
# TODO: 'em' and 'ex' aren't actually supported
SVGUnits = {'': 1.0,
'px': 1.0,
'in': 90,
'mm': 90 / 25.4,
'cm': 90 / 2.54,
'pt': 1.25,
'pc': 15.0,
'em': 1.0,
'ex': 1.0}
SVGEmptyStyles = {'useFill': None,
'fill': None}
def SVGParseFloat(s, i=0):
"""
Parse first float value from string
Returns value as string
"""
start = i
n = len(s)
token = ''
# Ski[ leading whitespace characters
while i < n and (s[i].isspace() or s[i] == ','):
i += 1
if i == n:
return None
# Read sign
if s[i] == '-':
token += '-'
i += 1
elif s[i] == '+':
i += 1
# Read integer part
if s[i].isdigit():
while i < n and s[i].isdigit():
token += s[i]
i += 1
# Fractional part
if i < n and s[i] == '.':
token += '.'
i += 1
if s[i].isdigit():
while i < n and s[i].isdigit():
token += s[i]
i += 1
else:
raise Exception('Invalid float value near ' + s[start:start + 10])
# Degree
if i < n and (s[i] == 'e' or s[i] == 'E'):
token += s[i]
i += 1
if s[i] == '+' or s[i] == '-':
token += s[i]
i += 1
if s[i].isdigit():
while i < n and s[i].isdigit():
token += s[i]
i += 1
else:
raise Exception('Invalid float value near ' +
s[start:start + 10])
else:
raise Exception('Invalid float value near ' + s[start:start + 10])
return token
def SVGCreateCurve():
"""
Create new curve object to hold splines in
"""
cu = bpy.data.curves.new("Curve", 'CURVE')
obj = bpy.data.objects.new("Curve", cu)
bpy.context.scene.objects.link(obj)
return obj
def SVGFinishCurve():
"""
Finish curve creation
"""
pass
def SVGFlipHandle(x, y, x1, y1):
"""
Flip handle around base point
"""
x = x + (x - x1)
y = y + (y - y1)
return x, y
def SVGParseCoord(coord, size):
"""
Parse coordinate component to common basis
Needed to handle coordinates set in cm, mm, iches..
"""
token = SVGParseFloat(coord)
val = float(token)
unit = coord[len(token):]
if unit == '%':
return float(size) / 100.0 * val
else:
return val * SVGUnits[unit]
return val
def SVGRectFromNode(node, context):
"""
Get display rectangle from node
"""
w = context['rect'][0]
h = context['rect'][1]
if node.getAttribute('viewBox'):
viewBox = node.getAttribute('viewBox').split()
w = SVGParseCoord(viewBox[2], w)
h = SVGParseCoord(viewBox[3], h)
else:
if node.getAttribute('width'):
w = SVGParseCoord(node.getAttribute('width'), w)
if node.getAttribute('height'):
h = SVGParseCoord(node.getAttribute('height'), h)
return (w, h)
def SVGMatrixFromNode(node, context):
"""
Get transformation matrix from given node
"""
tagName = node.tagName.lower()
tags = ['svg:svg', 'svg:use', 'svg:symbol']
if tagName not in tags and 'svg:' + tagName not in tags:
return Matrix()
rect = context['rect']
m = Matrix()
x = SVGParseCoord(node.getAttribute('x') or '0', rect[0])
y = SVGParseCoord(node.getAttribute('y') or '0', rect[1])
w = SVGParseCoord(node.getAttribute('width') or str(rect[0]), rect[0])
h = SVGParseCoord(node.getAttribute('height') or str(rect[1]), rect[1])
m = m.Translation(Vector((x, y, 0.0)))
if len(context['rects']) > 1:
m = m * m.Scale(w / rect[0], 4, Vector((1.0, 0.0, 0.0)))
m = m * m.Scale(h / rect[1], 4, Vector((0.0, 1.0, 0.0)))
if node.getAttribute('viewBox'):
viewBox = node.getAttribute('viewBox').split()
vx = SVGParseCoord(viewBox[0], w)
vy = SVGParseCoord(viewBox[1], h)
vw = SVGParseCoord(viewBox[2], w)
vh = SVGParseCoord(viewBox[3], h)
sx = w / vw
sy = h / vh
scale = min(sx, sy)
tx = (w - vw * scale) / 2
ty = (h - vh * scale) / 2
m = m * m.Translation(Vector((tx, ty, 0.0)))
m = m * m.Translation(Vector((-vx, -vy, 0.0)))
m = m * m.Scale(scale, 4, Vector((1.0, 0.0, 0.0)))
m = m * m.Scale(scale, 4, Vector((0.0, 1.0, 0.0)))
return m
def SVGParseTransform(transform):
"""
Parse transform string and return transformation matrix
"""
m = Matrix()
r = re.compile('\s*([A-z]+)\s*\((.*?)\)')
for match in r.finditer(transform):
func = match.group(1)
params = match.group(2)
params = params.replace(',', ' ').split()
proc = SVGTransforms.get(func)
if proc is None:
raise Exception('Unknown trasnform function: ' + func)
m = m * proc(params)
return m
def SVGGetMaterial(color, context):
"""
Get material for specified color
"""
materials = context['materials']
rgb_re = re.compile('^\s*rgb\s*\(\s*(\d+)\s*,\s*(\d+)\s*,(\d+)\s*\)\s*$')
if color in materials:
return materials[color]
diff = None
if color.startswith('#'):
color = color[1:]
if len(color) == 3:
color = color[0] * 2 + color[1] * 2 + color[2] * 2
diff = (int(color[0:2], 16), int(color[2:4], 16), int(color[4:6], 16))
elif color in svg_colors.SVGColors:
diff = svg_colors.SVGColors[color]
elif rgb_re.match(color):
c = rgb_re.findall(color) [0]
diff = (float(c[0]), float(c[1]), float(c[2]))
else:
return None
mat = bpy.data.materials.new(name='SVGMat')
mat.diffuse_color = ([x / 255.0 for x in diff])
materials[color] = mat
return mat
def SVGTransformTranslate(params):
"""
translate SVG transform command
"""
tx = float(params[0])
ty = float(params[1])
return Matrix.Translation(Vector((tx, ty, 0.0)))
def SVGTransformMatrix(params):
"""
matrix SVG transform command
"""
a = float(params[0])
b = float(params[1])
c = float(params[2])
d = float(params[3])
e = float(params[4])
f = float(params[5])
return Matrix(((a, b, 0.0, 0.0),
(c, d, 0.0, 0.0),
(0, 0, 1.0, 0.0),
(e, f, 0.0, 1.0)))
def SVGTransformScale(params):
"""
scale SVG transform command
"""
sx = sy = float(params[0])
if len(params) > 1:
sy = float(params[1])
m = Matrix()
m = m * m.Scale(sx, 4, Vector((1.0, 0.0, 0.0)))
m = m * m.Scale(sy, 4, Vector((0.0, 1.0, 0.0)))
return m
def SVGTransformSkewX(params):
"""
skewX SVG transform command
"""
ang = float(params[0]) * pi / 180.0
return Matrix(((1.0, 0.0, 0.0),
(tan(ang), 1.0, 0.0),
(0.0, 0.0, 1.0))).to_4x4()
def SVGTransformSkewY(params):
"""
skewX SVG transform command
"""
ang = float(params[0]) * pi / 180.0
return Matrix(((1.0, tan(ang), 0.0),
(0.0, 1.0, 0.0),
(0.0, 0.0, 1.0))).to_4x4()
def SVGTransformRotate(params):
"""
skewX SVG transform command
"""
ang = float(params[0]) * pi / 180.0
cx = cy = 0.0
if len(params) >= 3:
cx = float(params[1])
cy = float(params[2])
tm = Matrix.Translation(Vector((cx, cy, 0.0)))
rm = Matrix.Rotation(ang, 4, Vector((0.0, 0.0, 1.0)))
return tm * rm * tm.inverted()
SVGTransforms = {'translate': SVGTransformTranslate,
'scale': SVGTransformScale,
'skewX': SVGTransformSkewX,
'skewY': SVGTransformSkewY,
'matrix': SVGTransformMatrix,
'rotate': SVGTransformRotate}
def SVGParseStyles(node, context):
"""
Parse node to get different styles for displaying geometries
(materilas, filling flags, etc..)
"""
styles = SVGEmptyStyles.copy()
style = node.getAttribute('style')
if style:
elems = style.split(';')
for elem in elems:
s = elem.split(':')
if len(s) != 2:
continue
name = s[0].strip().lower()
val = s[1].strip()
if name == 'fill':
val = val.lower()
if val == 'none':
styles['useFill'] = False
else:
styles['useFill'] = True
styles['fill'] = SVGGetMaterial(val, context)
return styles
if styles['useFill'] is None:
fill = node.getAttribute('fill')
if fill:
fill = fill.lower()
if fill == 'none':
styles['useFill'] = False
else:
styles['useFill'] = True
styles['fill'] = SVGGetMaterial(fill, context)
return styles
#### SVG path helpers ####
class SVGPathData:
"""
SVG Path data token supplier
"""
__slots__ = ('_data', # List of tokens
'_index', # Index of current token in tokens list
'_len') # Lenght og tokens list
def __init__(self, d):
"""
Initialize new path data supplier
d - the definition of the outline of a shape
"""
spaces = ' ,\t'
commands = ['m', 'l', 'h', 'v', 'c', 's', 'q', '', 't', 'a', 'z']
tokens = []
i = 0
n = len(d)
while i < n:
c = d[i]
if c in spaces:
pass
elif c.lower() in commands:
tokens.append(c)
elif c in ['-', '.'] or c.isdigit():
token = SVGParseFloat(d, i)
tokens.append(token)
i += len(token) - 1
i += 1
self._data = tokens
self._index = 0
self._len = len(tokens)
def eof(self):
"""
Check if end of data reached
"""
return self._index >= self._len
def cur(self):
"""
Return current token
"""
if self.eof():
return None
return self._data[self._index]
def next(self):
"""
Return current token and go to next one
"""
if self.eof():
return None
token = self._data[self._index]
self._index += 1
return token
def nextCoord(self):
"""
Return coordinate created from current token and move to next token
"""
token = self.next()
if token is None:
return None
return float(token)
class SVGPathParser:
"""
Parser of SVG path data
"""
__slots__ = ('_data', # Path data supplird
'_point', # Current point coorfinate
'_handle', # Last handle coordinate
'_splines', # List of all splies created during parsing
'_spline', # Currently handling spline
'_commands') # Hash of all supported path commands
def __init__(self, d):
"""
Initialize path parser
d - the definition of the outline of a shape
"""
self._data = SVGPathData(d)
self._point = None # Current point
self._handle = None # Last handle
self._splines = [] # List of splines in path
self._spline = None # Current spline
self._commands = {'M': self._pathMoveTo,
'L': self._pathLineTo,
'H': self._pathLineTo,
'V': self._pathLineTo,
'C': self._pathCurveToCS,
'S': self._pathCurveToCS,
'Q': self._pathCurveToQT,
'T': self._pathCurveToQT,
'A': self._pathCurveToA,
'Z': self._pathClose,
'm': self._pathMoveTo,
'l': self._pathLineTo,
'h': self._pathLineTo,
'v': self._pathLineTo,
'c': self._pathCurveToCS,
's': self._pathCurveToCS,
'q': self._pathCurveToQT,
't': self._pathCurveToQT,
'a': self._pathCurveToA,
'z': self._pathClose}
def _getCoordPair(self, relative, point):
"""
Get next coordinate pair
"""
x = self._data.nextCoord()
y = self._data.nextCoord()
if relative and point is not None:
x += point[0]
y += point[1]
return x, y
def _appendPoint(self, x, y, handle_left=None, handle_left_type='VECTOR',
handle_right=None, handle_right_type='VECTOR'):
"""
Append point to spline
If there's no active spline, create one and set it's first point
to current point coordinate
"""
if self._spline is None:
self._spline = {'points': [],
'closed': False}
self._splines.append(self._spline)
point = {'x': x,
'y': y,
'handle_left': handle_left,
'handle_left_type': handle_left_type,
'handle_right': handle_right,
'handle_right_type': handle_right_type}
self._spline['points'].append(point)
def _updateHandle(self, handle=None, handle_type=None):
"""
Update right handle of previous point when adding new point to spline
"""
point = self._spline['points'][-1]
if handle_type is not None:
point['handle_right_type'] = handle_type
if handle is not None:
point['handle_right'] = handle
def _pathMoveTo(self, code):
"""
MoveTo path command
"""
relative = code.islower()
x, y = self._getCoordPair(relative, self._point)
self._spline = None # Flag to start new spline
self._point = (x, y)
cur = self._data.cur()
while cur is not None and not cur.isalpha():
x, y = self._getCoordPair(relative, self._point)
if self._spline is None:
self._appendPoint(self._point[0], self._point[1])
self._appendPoint(x, y)
self._point = (x, y)
cur = self._data.cur()
self._handle = None
def _pathLineTo(self, code):
"""
LineTo path command
"""
c = code.lower()
cur = self._data.cur()
while cur is not None and not cur.isalpha():
if c == 'l':
x, y = self._getCoordPair(code == 'l', self._point)
elif c == 'h':
x = self._data.nextCoord()
y = self._point[1]
else:
x = self._point[0]
y = self._data.nextCoord()
if code == 'h':
x += self._point[0]
elif code == 'v':
y += self._point[1]
if self._spline is None:
self._appendPoint(self._point[0], self._point[1])
self._appendPoint(x, y)
self._point = (x, y)
cur = self._data.cur()
self._handle = None
def _pathCurveToCS(self, code):
"""
Cubic BEZIER CurveTo path command
"""
c = code.lower()
cur = self._data.cur()
while cur is not None and not cur.isalpha():
if c == 'c':
x1, y1 = self._getCoordPair(code.islower(), self._point)
x2, y2 = self._getCoordPair(code.islower(), self._point)
else:
if self._handle is not None:
x1, y1 = SVGFlipHandle(self._point[0], self._point[1],
self._handle[0], self._handle[1])
else:
x1, y1 = self._point
x2, y2 = self._getCoordPair(code.islower(), self._point)
x, y = self._getCoordPair(code.islower(), self._point)
if self._spline is None:
self._appendPoint(self._point[0], self._point[1],
handle_left_type='FREE', handle_left=self._point,
handle_right_type='FREE', handle_right=(x1, y1))
else:
self._updateHandle(handle=(x1, y1), handle_type='FREE')
self._appendPoint(x, y,
handle_left_type='FREE', handle_left=(x2, y2),
handle_right_type='FREE', handle_right=(x, y))
self._point = (x, y)
self._handle = (x2, y2)
cur = self._data.cur()
def _pathCurveToQT(self, code):
"""
Qyadracic BEZIER CurveTo path command
"""
c = code.lower()
cur = self._data.cur()
while cur is not None and not cur.isalpha():
if c == 'q':
x1, y1 = self._getCoordPair(code.islower(), self._point)
else:
if self._handle is not None:
x1, y1 = SVGFlipHandle(self._point[0], self._point[1],
self._handle[0], self._handle[1])
else:
x1, y1 = self._point
x, y = self._getCoordPair(code.islower(), self._point)
if self._spline is None:
self._appendPoint(self._point[0], self._point[1],
handle_left_type='FREE', handle_left=self._point,
handle_right_type='FREE', handle_right=self._point)
self._appendPoint(x, y,
handle_left_type='FREE', handle_left=(x1, y1),
handle_right_type='FREE', handle_right=(x, y))
self._point = (x, y)
self._handle = (x1, y1)
cur = self._data.cur()
def _calcArc(self, rx, ry, ang, fa, fs, x, y):
"""
Calc arc paths
Copied and adoptedfrom paths_svg2obj.py scring for Blender 2.49
which is Copyright (c) jm soler juillet/novembre 2004-april 2009,
"""
cpx = self._point[0]
cpy = self._point[1]
rx = abs(rx)
ry = abs(ry)
px = abs((cos(ang) * (cpx - x) + sin(ang) * (cpy - y)) * 0.5) ** 2.0
py = abs((cos(ang) * (cpy - y) - sin(ang) * (cpx - x)) * 0.5) ** 2.0
rpx = rpy = 0.0
if abs(rx) > 0.0:
px = px / (rx ** 2.0)
if abs(ry) > 0.0:
rpy = py / (ry ** 2.0)
pl = rpx + rpy
if pl > 1.0:
pl = pl ** 0.5
rx *= pl
ry *= pl
carx = sarx = cary = sary = 0.0
if abs(rx) > 0.0:
carx = cos(ang) / rx
sarx = sin(ang) / rx
if abs(ry) > 0.0:
cary = cos(ang) / ry
sary = sin(ang) / ry
x0 = carx * cpx + sarx * cpy
y0 = -sary * cpx + cary * cpy
x1 = carx * x + sarx * y
y1 = -sary * x + cary * y
d = (x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0)
if abs(d) > 0.0:
sq = 1.0 / d - 0.25
else:
sq = -0.25
if sq < 0.0:
sq = 0.0
sf = sq ** 0.5
if fs == fa:
sf = -sf
xc = 0.5 * (x0 + x1) - sf * (y1 - y0)
yc = 0.5 * (y0 + y1) + sf * (x1 - x0)
ang_0 = atan2(y0 - yc, x0 - xc)
ang_1 = atan2(y1 - yc, x1 - xc)
ang_arc = ang_1 - ang_0
if ang_arc < 0.0 and fs == 1:
ang_arc += 2.0 * pi
elif ang_arc > 0.0 and fs == 0:
ang_arc -= 2.0 * pi
n_segs = int(ceil(abs(ang_arc * 2.0 / (pi * 0.5 + 0.001))))
if self._spline is None:
self._appendPoint(cpx, cpy,
handle_left_type='FREE', handle_left=(cpx, cpy),
handle_right_type='FREE', handle_right=(cpx, cpy))
for i in range(n_segs):
ang0 = ang_0 + i * ang_arc / n_segs
ang1 = ang_0 + (i + 1) * ang_arc / n_segs
ang_demi = 0.25 * (ang1 - ang0)
t = 2.66666 * sin(ang_demi) * sin(ang_demi) / sin(ang_demi * 2.0)
x1 = xc + cos(ang0) - t * sin(ang0)
y1 = yc + sin(ang0) + t * cos(ang0)
x2 = xc + cos(ang1)
y2 = yc + sin(ang1)
x3 = x2 + t * sin(ang1)
y3 = y2 - t * cos(ang1)
coord1 = ((cos(ang) * rx) * x1 + (-sin(ang) * ry) * y1,
(sin(ang) * rx) * x1 + (cos(ang) * ry) * y1)
coord2 = ((cos(ang) * rx) * x3 + (-sin(ang) * ry) * y3,
(sin(ang) * rx) * x3 + (cos(ang) * ry) * y3)
coord3 = ((cos(ang) * rx) * x2 + (-sin(ang) * ry) * y2,
(sin(ang) * rx) * x2 + (cos(ang) * ry) * y2)
self._updateHandle(handle=coord1, handle_type='FREE')
self._appendPoint(coord3[0], coord3[1],
handle_left_type='FREE', handle_left=coord2,
handle_right_type='FREE', handle_right=coord3)
def _pathCurveToA(self, code):
"""
Elliptical arc CurveTo path command
"""
c = code.lower()
cur = self._data.cur()
while cur is not None and not cur.isalpha():
rx = float(self._data.next())
ry = float(self._data.next())
ang = float(self._data.next()) / 180 * pi
fa = float(self._data.next())
fs = float(self._data.next())
x, y = self._getCoordPair(code.islower(), self._point)
self._calcArc(rx, ry, ang, fa, fs, x, y)
self._point = (x, y)
self._handle = None
cur = self._data.cur()
def _pathClose(self, code):
"""
Close path command
"""
if self._spline:
self._spline['closed'] = True
def parse(self):
"""
Execute parser
"""
while not self._data.eof():
code = self._data.next()
cmd = self._commands.get(code)
if cmd is None:
raise Exception('Unknown path command: {0}' . format(code))
cmd(code)
def getSplines(self):
"""
Get splines definitions
"""
return self._splines
class SVGGeometry:
"""
Abstract SVG geometry
"""
__slots__ = ('_node', # XML node for geometry
'_context', # Global SVG context (holds matrices stack, i.e.)
'_creating') # Flag if geometry is already creating
# for this node
# need to detect cycles for USE node
def __init__(self, node, context):
"""
Initialize SVG geometry
"""
self._node = node
self._context = context
self._creating = False
if hasattr(node, 'getAttribute'):
defs = context['defines']
id = node.getAttribute('id')
if id and defs.get('#' + id) is None:
defs['#' + id] = self
className = node.getAttribute('class')
if className and defs.get(className) is None:
defs[className] = self
def _pushRect(self, rect):
"""
Push display rectangle
"""
self._context['rects'].append(rect)
self._context['rect'] = rect
def _popRect(self):
"""
Pop display rectangle
"""
self._context['rects'].pop
self._context['rect'] = self._context['rects'][-1]
def _pushMatrix(self, matrix):
"""
Push transformation matrix
"""
self._context['transform'].append(matrix)
self._context['matrix'] = self._context['matrix'] * matrix
def _popMatrix(self):
"""
Pop transformation matrix
"""
matrix = self._context['transform'].pop()
self._context['matrix'] = self._context['matrix'] * matrix.inverted()
def _transformCoord(self, point):
"""
Transform SVG-file coords
"""
v = Vector((point[0], point[1], 0.0))
return v * self._context['matrix']
def getNodeMatrix(self):
"""
Get transformation matrix of node
"""
return SVGMatrixFromNode(self._node, self._context)
def parse(self):
"""
Parse XML node to memory
"""
pass
def _doCreateGeom(self):
"""
Internal handler to create real geometries
"""
pass
def getTransformMatrix(self):
"""
Get matrix created from "transform" attribute
"""
transform = self._node.getAttribute('transform')
if transform:
return SVGParseTransform(transform)
return None
def createGeom(self):
"""
Create real geometries
"""
if self._creating:
return
self._creating = True
matrix = self.getTransformMatrix()
if matrix is not None:
self._pushMatrix(matrix)
self._doCreateGeom()
if matrix is not None:
self._popMatrix()
self._creating = False
class SVGGeometryContainer(SVGGeometry):
"""
Container of SVG geometries
"""
__slots__ = ('_geometries') # List of chold geometries
def __init__(self, node, context):
"""
Initialize SVG geometry container
"""
super().__init__(node, context)
self._geometries = []
def parse(self):
"""
Parse XML node to memory
"""
for node in self._node.childNodes:
if type(node) is not xml.dom.minidom.Element:
continue
ob = parseAbstractNode(node, self._context)
if ob is not None:
self._geometries.append(ob)
def _doCreateGeom(self):
"""
Create real geometries
"""
for geom in self._geometries:
geom.createGeom()
def getGeometries(self):
"""
Get list of parsed geometries
"""
return self._geometries
class SVGGeometryPATH(SVGGeometry):
"""
SVG path geometry
"""
__slots__ = ('_splines', # List of splines after parsing
'_styles') # Styles, used for displaying
def __init__(self, node, context):
"""
Initialize SVG path
"""
super().__init__(node, context)
self._splines = []
self._styles = SVGEmptyStyles
def parse(self):
"""
Parse SVG path node
"""
d = self._node.getAttribute('d')
pathParser = SVGPathParser(d)
pathParser.parse()
self._splines = pathParser.getSplines()
self._styles = SVGParseStyles(self._node, self._context)
def _doCreateGeom(self):
"""
Create real geometries
"""
ob = SVGCreateCurve()
cu = ob.data
if self._node.getAttribute('id'):
cu.name = self._node.getAttribute('id')
if self._styles['useFill']:
cu.dimensions = '2D'
cu.materials.append(self._styles['fill'])
else:
cu.dimensions = '3D'
for spline in self._splines:
act_spline = None
for point in spline['points']:
co = self._transformCoord((point['x'], point['y']))
if act_spline is None:
cu.splines.new('BEZIER')
act_spline = cu.splines[-1]
act_spline.use_cyclic_u = spline['closed']
else:
act_spline.bezier_points.add()
bezt = act_spline.bezier_points[-1]
bezt.co = co
bezt.handle_left_type = point['handle_left_type']
if point['handle_left'] is not None:
handle = point['handle_left']
bezt.handle_left = self._transformCoord(handle)
bezt.handle_right_type = point['handle_right_type']
if point['handle_right'] is not None:
handle = point['handle_right']
bezt.handle_right = self._transformCoord(handle)
SVGFinishCurve()
class SVGGeometryDEFS(SVGGeometryContainer):
"""
Container for referenced elements
"""
def _doCreateGeom(self):
"""
Create real geometries
"""
pass
class SVGGeometrySYMBOL(SVGGeometryContainer):
"""
Referenced element
"""
def _doCreateGeom(self):
"""
Create real geometries
"""
pass
class SVGGeometryG(SVGGeometryContainer):
"""
Geometry group
"""
pass
class SVGGeometryUSE(SVGGeometry):
"""
User of referenced elements
"""
def _doCreateGeom(self):
"""
Create real geometries
"""
geometries = []
ref = self._node.getAttribute('xlink:href')
geom = self._context['defines'].get(ref)
if geom is not None:
rect = SVGRectFromNode(self._node, self._context)
self._pushRect(rect)
self._pushMatrix(self.getNodeMatrix())
geomMatrix = None
nodeMatrix = None
if not isinstance(geom, SVGGeometryUSE):
geomMatrix = geom.getTransformMatrix()
if isinstance(geom, SVGGeometrySYMBOL):
nodeMatrix = geom.getNodeMatrix()
if nodeMatrix:
self._pushMatrix(nodeMatrix)
if geomMatrix:
self._pushMatrix(geomMatrix)
if isinstance(geom, SVGGeometryContainer):
geometries = geom.getGeometries()
else:
geometries = [geom]
for g in geometries:
g.createGeom()
if geomMatrix:
self._popMatrix()
if nodeMatrix:
self._popMatrix()
self._popMatrix()
self._popRect()
class SVGGeometryRECT(SVGGeometry):
"""
SVG rectangle
"""
__slots__ = ('_rect', # coordinate and domensions of rectangle
'_radius', # Rounded corner radiuses
'_styles') # Styles, used for displaying
def __init__(self, node, context):
"""
Initialize new rectangle
"""
super().__init__(node, context)
self._rect = ('0', '0', '0', '0')
self._radius = ('0', '0')
self._styles = SVGEmptyStyles
def parse(self):
"""
Parse SVG rectangle node
"""
self._styles = SVGParseStyles(self._node, self._context)
rect = []
for attr in ['x', 'y', 'width', 'height']:
val = self._node.getAttribute(attr)
rect.append(val or '0')
self._rect = (rect)
rx = self._node.getAttribute('rx')
ry = self._node.getAttribute('ry')
self._radius = (rx, ry)
def _appendCorner(self, spline, coord, firstTime, rounded):
"""
Append new corner to rectangle
"""
handle = None
if len(coord) == 3:
handle = self._transformCoord(coord[2])
coord = (coord[0], coord[1])
co = self._transformCoord(coord)
if not firstTime:
spline.bezier_points.add()
bezt = spline.bezier_points[-1]
bezt.co = co
if rounded:
if handle:
bezt.handle_left_type = 'VECTOR'
bezt.handle_right_type = 'FREE'
bezt.handle_right = handle
else:
bezt.handle_left_type = 'FREE'
bezt.handle_right_type = 'VECTOR'
bezt.handle_left = co
else:
bezt.handle_left_type = 'VECTOR'
bezt.handle_right_type = 'VECTOR'
def _doCreateGeom(self):
"""
Create real geometries
"""
# Run-time parsing -- percents would be correct only if
# parsing them now
crect = self._context['rect']
rect = []
for i in range(4):
rect.append(SVGParseCoord(self._rect[i], crect[i % 2]))
r = self._radius
rx = ry = 0.0
if r[0] and r[1]:
rx = min(SVGParseCoord(r[0], rect[0]), rect[2] / 2)
ry = min(SVGParseCoord(r[1], rect[1]), rect[3] / 2)
elif r[0]:
rx = min(SVGParseCoord(r[0], rect[0]), rect[2] / 2)
ry = min(rx, rect[3] / 2)
rx = ry = min(rx, ry)
elif r[1]:
ry = min(SVGParseCoord(r[1], rect[1]), rect[3] / 2)
rx = min(ry, rect[2] / 2)
rx = ry = min(rx, ry)
radius = (rx, ry)
# Geometry creation
ob = SVGCreateCurve()
cu = ob.data
if self._styles['useFill']:
cu.dimensions = '2D'
cu.materials.append(self._styles['fill'])
else:
cu.dimensions = '3D'
cu.splines.new('BEZIER')
spline = cu.splines[-1]
spline.use_cyclic_u = True
x, y = rect[0], rect[1]
w, h = rect[2], rect[3]
rx, ry = radius[0], radius[1]
rounded = False
if rx or ry:
#
# 0 _______ 1
# / \
# / \
# 7 2
# | |
# | |
# 6 3
# \ /
# \ /
# 5 _______ 4
#
# Optional third component -- right handle coord
coords = [(x + rx, y),
(x + w - rx, y, (x + w, y)),
(x + w, y + ry),
(x + w, y + h - ry, (x + w, y + h)),
(x + w - rx, y + h),
(x + rx, y + h, (x, y + h)),
(x, y + h - ry),
(x, y + ry, (x, y))]
rounded = True
else:
coords = [(x, y), (x + w, y), (x + w, y + h), (x, y + h)]
firstTime = True
for coord in coords:
self._appendCorner(spline, coord, firstTime, rounded)
firstTime = False
SVGFinishCurve()
class SVGGeometryELLIPSE(SVGGeometry):
"""
SVG ellipse
"""
__slots__ = ('_cx', # X-coordinate of center
'_cy', # Y-coordinate of center
'_rx', # X-axis radius of circle
'_ry', # Y-axis radius of circle
'_styles') # Styles, used for displaying
def __init__(self, node, context):
"""
Initialize new ellipse
"""
super().__init__(node, context)
self._cx = '0.0'
self._cy = '0.0'
self._rx = '0.0'
self._ry = '0.0'
self._styles = SVGEmptyStyles
def parse(self):
"""
Parse SVG ellipse node
"""
self._styles = SVGParseStyles(self._node, self._context)
self._cx = self._node.getAttribute('cx') or '0'
self._cy = self._node.getAttribute('cy') or '0'
self._rx = self._node.getAttribute('rx') or '0'
self._ry = self._node.getAttribute('ry') or '0'
def _doCreateGeom(self):
"""
Create real geometries
"""
# Run-time parsing -- percents would be correct only if
# parsing them now
crect = self._context['rect']
cx = SVGParseCoord(self._cx, crect[0])
cy = SVGParseCoord(self._cy, crect[1])
rx = SVGParseCoord(self._rx, crect[0])
ry = SVGParseCoord(self._ry, crect[1])
if not rx or not ry:
# Automaic handles will work incorrect in this case
return
# Create circle
ob = SVGCreateCurve()
cu = ob.data
if self._styles['useFill']:
cu.dimensions = '2D'
cu.materials.append(self._styles['fill'])
else:
cu.dimensions = '3D'
coords = [((cx - rx, cy),
(cx - rx, cy + ry * 0.552),
(cx - rx, cy - ry * 0.552)),
((cx, cy - ry),
(cx - rx * 0.552, cy - ry),
(cx + rx * 0.552, cy - ry)),
((cx + rx, cy),
(cx + rx, cy - ry * 0.552),
(cx + rx, cy + ry * 0.552)),
((cx, cy + ry),
(cx + rx * 0.552, cy + ry),
(cx - rx * 0.552, cy + ry))]
spline = None
for coord in coords:
co = self._transformCoord(coord[0])
handle_left = self._transformCoord(coord[1])
handle_right = self._transformCoord(coord[2])
if spline is None:
cu.splines.new('BEZIER')
spline = cu.splines[-1]
spline.use_cyclic_u = True
else:
spline.bezier_points.add()
bezt = spline.bezier_points[-1]
bezt.co = co
bezt.handle_left_type = 'FREE'
bezt.handle_right_type = 'FREE'
bezt.handle_left = handle_left
bezt.handle_right = handle_right
SVGFinishCurve()
class SVGGeometryCIRCLE(SVGGeometryELLIPSE):
"""
SVG circle
"""
def parse(self):
"""
Parse SVG circle node
"""
self._styles = SVGParseStyles(self._node, self._context)
self._cx = self._node.getAttribute('cx') or '0'
self._cy = self._node.getAttribute('cy') or '0'
r = self._node.getAttribute('r') or '0'
self._rx = self._ry = r
class SVGGeometryLINE(SVGGeometry):
"""
SVG line
"""
__slots__ = ('_x1', # X-coordinate of beginning
'_y1', # Y-coordinate of beginning
'_x2', # X-coordinate of ending
'_y2') # Y-coordinate of ending
def __init__(self, node, context):
"""
Initialize new line
"""
super().__init__(node, context)
self._x1 = '0.0'
self._y1 = '0.0'
self._x2 = '0.0'
self._y2 = '0.0'
def parse(self):
"""
Parse SVG line node
"""
self._x1 = self._node.getAttribute('x1') or '0'
self._y1 = self._node.getAttribute('y1') or '0'
self._x2 = self._node.getAttribute('x2') or '0'
self._y2 = self._node.getAttribute('y2') or '0'
def _doCreateGeom(self):
"""
Create real geometries
"""
# Run-time parsing -- percents would be correct only if
# parsing them now
crect = self._context['rect']
x1 = SVGParseCoord(self._x1, crect[0])
y1 = SVGParseCoord(self._y1, crect[1])
x2 = SVGParseCoord(self._x2, crect[0])
y2 = SVGParseCoord(self._y2, crect[1])
# Create cline
ob = SVGCreateCurve()
cu = ob.data
coords = [(x1, y1), (x2, y2)]
spline = None
for coord in coords:
co = self._transformCoord(coord)
if spline is None:
cu.splines.new('BEZIER')
spline = cu.splines[-1]
spline.use_cyclic_u = True
else:
spline.bezier_points.add()
bezt = spline.bezier_points[-1]
bezt.co = co
bezt.handle_left_type = 'VECTOR'
bezt.handle_right_type = 'VECTOR'
SVGFinishCurve()
class SVGGeometryPOLY(SVGGeometry):
"""
Abstract class for handling poly-geometries
(polylines and polygons)
"""
__slots__ = ('_points', # Array of points for poly geometry
'_styles', # Styles, used for displaying
'_closed') # Should generated curve be closed?
def __init__(self, node, context):
"""
Initialize new poly geometry
"""
super().__init__(node, context)
self._points = []
self._styles = SVGEmptyStyles
self._closed = False
def parse(self):
"""
Parse poly node
"""
self._styles = SVGParseStyles(self._node, self._context)
points = self._node.getAttribute('points')
points = points.replace(',', ' ').replace('-', ' -')
points = points.split()
prev = None
self._points = []
for p in points:
if prev is None:
prev = p
else:
self._points.append((float(prev), float(p)))
prev = None
def _doCreateGeom(self):
"""
Create real geometries
"""
ob = SVGCreateCurve()
cu = ob.data
if self._closed and self._styles['useFill']:
cu.dimensions = '2D'
cu.materials.append(self._styles['fill'])
else:
cu.dimensions = '3D'
spline = None
for point in self._points:
co = self._transformCoord(point)
if spline is None:
cu.splines.new('BEZIER')
spline = cu.splines[-1]
spline.use_cyclic_u = self._closed
else:
spline.bezier_points.add()
bezt = spline.bezier_points[-1]
bezt.co = co
bezt.handle_left_type = 'VECTOR'
bezt.handle_right_type = 'VECTOR'
SVGFinishCurve()
class SVGGeometryPOLYLINE(SVGGeometryPOLY):
"""
SVG polyline geometry
"""
pass
class SVGGeometryPOLYGON(SVGGeometryPOLY):
"""
SVG polygon geometry
"""
def __init__(self, node, context):
"""
Initialize new polygon geometry
"""
super().__init__(node, context)
self._closed = True
class SVGGeometrySVG(SVGGeometryContainer):
"""
Main geometry holder
"""
def _doCreateGeom(self):
"""
Create real geometries
"""
rect = SVGRectFromNode(self._node, self._context)
self._pushMatrix(self.getNodeMatrix())
self._pushRect(rect)
super()._doCreateGeom()
self._popRect()
self._popMatrix()
class SVGLoader(SVGGeometryContainer):
"""
SVG file loader
"""
def getTransformMatrix(self):
"""
Get matrix created from "transform" attribute
"""
# SVG document doesn't support transform specification
# it can't even hold attributes
return None
def __init__(self, filepath):
"""
Initialize SVG loader
"""
node = xml.dom.minidom.parse(filepath)
m = Matrix()
m = m * m.Scale(1.0 / 90.0, 4, Vector((1.0, 0.0, 0.0)))
m = m * m.Scale(-1.0 / 90.0, 4, Vector((0.0, 1.0, 0.0)))
rect = (1, 1)
self._context = {'defines': {},
'transform': [],
'rects': [rect],
'rect': rect,
'matrix': m,
'materials': {}}
super().__init__(node, self._context)
svgGeometryClasses = {
'svg': SVGGeometrySVG,
'path': SVGGeometryPATH,
'defs': SVGGeometryDEFS,
'symbol': SVGGeometrySYMBOL,
'use': SVGGeometryUSE,
'rect': SVGGeometryRECT,
'ellipse': SVGGeometryELLIPSE,
'circle': SVGGeometryCIRCLE,
'line': SVGGeometryLINE,
'polyline': SVGGeometryPOLYLINE,
'polygon': SVGGeometryPOLYGON,
'g': SVGGeometryG}
def parseAbstractNode(node, context):
name = node.tagName.lower()
if name.startswith('svg:'):
name = name[4:]
geomClass = svgGeometryClasses.get(name)
if geomClass is not None:
ob = geomClass(node, context)
ob.parse()
return ob
return None
def load_svg(filepath):
"""
Load specified SVG file
"""
if bpy.ops.object.mode_set.poll():
bpy.ops.object.mode_set(mode='OBJECT')
loader = SVGLoader(filepath)
loader.parse()
loader.createGeom()
def load(operator, context, filepath=""):
load_svg(filepath)
return {'FINISHED'}