io_curve_svg/import_svg.py

   1 # SPDX-License-Identifier: GPL-2.0-or-later
   2
   3 import re
   4 import xml.dom.minidom
   5 from math import cos, sin, tan, atan2, pi, ceil
   6
   7 import bpy
   8 from mathutils import Vector, Matrix
   9 from bpy.app.translations import pgettext_tip as tip_
  10
  11 from . import svg_colors
  12 from .svg_util import (units,
  13                        srgb_to_linearrgb,
  14                        check_points_equal,
  15                        parse_array_of_floats,
  16                        read_float)
  17
  18 #### Common utilities ####
  19
  20 SVGEmptyStyles = {'useFill': None,
  21                   'fill': None}
  22
  23
  24 def SVGCreateCurve(context):
  25     """
  26     Create new curve object to hold splines in
  27     """
  28
  29     cu = bpy.data.curves.new("Curve", 'CURVE')
  30     obj = bpy.data.objects.new("Curve", cu)
  31
  32     context['collection'].objects.link(obj)
  33
  34     return obj
  35
  36
  37 def SVGFinishCurve():
  38     """
  39     Finish curve creation
  40     """
  41
  42     pass
  43
  44
  45 def SVGFlipHandle(x, y, x1, y1):
  46     """
  47     Flip handle around base point
  48     """
  49
  50     x = x + (x - x1)
  51     y = y + (y - y1)
  52
  53     return x, y
  54
  55
  56 def SVGParseCoord(coord, size):
  57     """
  58     Parse coordinate component to common basis
  59
  60     Needed to handle coordinates set in cm, mm, inches.
  61     """
  62
  63     token, last_char = read_float(coord)
  64     val = float(token)
  65     unit = coord[last_char:].strip()  # strip() in case there is a space
  66
  67     if unit == '%':
  68         return float(size) / 100.0 * val
  69     return val * units[unit]
  70
  71
  72 def SVGRectFromNode(node, context):
  73     """
  74     Get display rectangle from node
  75     """
  76
  77     w = context['rect'][0]
  78     h = context['rect'][1]
  79
  80     if node.getAttribute('viewBox'):
  81         viewBox = node.getAttribute('viewBox').replace(',', ' ').split()
  82         w = SVGParseCoord(viewBox[2], w)
  83         h = SVGParseCoord(viewBox[3], h)
  84     else:
  85         if node.getAttribute('width'):
  86             w = SVGParseCoord(node.getAttribute('width'), w)
  87
  88         if node.getAttribute('height'):
  89             h = SVGParseCoord(node.getAttribute('height'), h)
  90
  91     return (w, h)
  92
  93
  94 def SVGMatrixFromNode(node, context):
  95     """
  96     Get transformation matrix from given node
  97     """
  98
  99     tagName = node.tagName.lower()
 100     tags = ['svg:svg', 'svg:use', 'svg:symbol']
 101
 102     if tagName not in tags and 'svg:' + tagName not in tags:
 103         return Matrix()
 104
 105     rect = context['rect']
 106     has_user_coordinate = (len(context['rects']) > 1)
 107
 108     m = Matrix()
 109     x = SVGParseCoord(node.getAttribute('x') or '0', rect[0])
 110     y = SVGParseCoord(node.getAttribute('y') or '0', rect[1])
 111     w = SVGParseCoord(node.getAttribute('width') or str(rect[0]), rect[0])
 112     h = SVGParseCoord(node.getAttribute('height') or str(rect[1]), rect[1])
 113
 114     m = Matrix.Translation(Vector((x, y, 0.0)))
 115     if has_user_coordinate:
 116         if rect[0] != 0 and rect[1] != 0:
 117             m = m @ Matrix.Scale(w / rect[0], 4, Vector((1.0, 0.0, 0.0)))
 118             m = m @ Matrix.Scale(h / rect[1], 4, Vector((0.0, 1.0, 0.0)))
 119
 120     if node.getAttribute('viewBox'):
 121         viewBox = node.getAttribute('viewBox').replace(',', ' ').split()
 122         vx = SVGParseCoord(viewBox[0], w)
 123         vy = SVGParseCoord(viewBox[1], h)
 124         vw = SVGParseCoord(viewBox[2], w)
 125         vh = SVGParseCoord(viewBox[3], h)
 126
 127         if vw == 0 or vh == 0:
 128             return m
 129
 130         if has_user_coordinate or (w != 0 and h != 0):
 131             sx = w / vw
 132             sy = h / vh
 133             scale = min(sx, sy)
 134         else:
 135             scale = 1.0
 136             w = vw
 137             h = vh
 138
 139         tx = (w - vw * scale) / 2
 140         ty = (h - vh * scale) / 2
 141         m = m @ Matrix.Translation(Vector((tx, ty, 0.0)))
 142
 143         m = m @ Matrix.Translation(Vector((-vx, -vy, 0.0)))
 144         m = m @ Matrix.Scale(scale, 4, Vector((1.0, 0.0, 0.0)))
 145         m = m @ Matrix.Scale(scale, 4, Vector((0.0, 1.0, 0.0)))
 146
 147     return m
 148
 149
 150 def SVGParseTransform(transform):
 151     """
 152     Parse transform string and return transformation matrix
 153     """
 154
 155     m = Matrix()
 156     r = re.compile(r'\s*([A-z]+)\s*\((.*?)\)')
 157
 158     for match in r.finditer(transform):
 159         func = match.group(1)
 160         params = match.group(2)
 161         params = params.replace(',', ' ').split()
 162
 163         proc = SVGTransforms.get(func)
 164         if proc is None:
 165             raise Exception('Unknown transform function: ' + func)
 166
 167         m = m @ proc(params)
 168
 169     return m
 170
 171
 172 def SVGGetMaterial(color, context):
 173     """
 174     Get material for specified color
 175     """
 176
 177     materials = context['materials']
 178     rgb_re = re.compile(r'^\s*rgb\s*\(\s*(\d+)\s*,\s*(\d+)\s*,(\d+)\s*\)\s*$')
 179
 180     if color in materials:
 181         return materials[color]
 182
 183     diff = None
 184     if color.startswith('#'):
 185         color = color[1:]
 186
 187         if len(color) == 3:
 188             color = color[0] * 2 + color[1] * 2 + color[2] * 2
 189
 190         diff = (int(color[0:2], 16), int(color[2:4], 16), int(color[4:6], 16))
 191     elif color in svg_colors.SVGColors:
 192         diff = svg_colors.SVGColors[color]
 193     elif rgb_re.match(color):
 194         c = rgb_re.findall(color)[0]
 195         diff = (float(c[0]), float(c[1]), float(c[2]))
 196     else:
 197         return None
 198
 199     diffuse_color = ([x / 255.0 for x in diff])
 200
 201     if context['do_colormanage']:
 202         diffuse_color[0] = srgb_to_linearrgb(diffuse_color[0])
 203         diffuse_color[1] = srgb_to_linearrgb(diffuse_color[1])
 204         diffuse_color[2] = srgb_to_linearrgb(diffuse_color[2])
 205
 206     mat = bpy.data.materials.new(name='SVGMat')
 207     mat.diffuse_color = (*diffuse_color, 1.0)
 208
 209     materials[color] = mat
 210
 211     return mat
 212
 213
 214 def SVGTransformTranslate(params):
 215     """
 216     translate SVG transform command
 217     """
 218
 219     tx = float(params[0])
 220     ty = float(params[1]) if len(params) > 1 else 0.0
 221
 222     return Matrix.Translation(Vector((tx, ty, 0.0)))
 223
 224
 225 def SVGTransformMatrix(params):
 226     """
 227     matrix SVG transform command
 228     """
 229
 230     a = float(params[0])
 231     b = float(params[1])
 232     c = float(params[2])
 233     d = float(params[3])
 234     e = float(params[4])
 235     f = float(params[5])
 236
 237     return Matrix(((a, c, 0.0, e),
 238                    (b, d, 0.0, f),
 239                    (0, 0, 1.0, 0),
 240                    (0, 0, 0.0, 1)))
 241
 242
 243 def SVGTransformScale(params):
 244     """
 245     scale SVG transform command
 246     """
 247
 248     sx = float(params[0])
 249     sy = float(params[1]) if len(params) > 1 else sx
 250
 251     m = Matrix()
 252
 253     m = m @ Matrix.Scale(sx, 4, Vector((1.0, 0.0, 0.0)))
 254     m = m @ Matrix.Scale(sy, 4, Vector((0.0, 1.0, 0.0)))
 255
 256     return m
 257
 258
 259 def SVGTransformSkewY(params):
 260     """
 261     skewY SVG transform command
 262     """
 263
 264     ang = float(params[0]) * pi / 180.0
 265
 266     return Matrix(((1.0, 0.0, 0.0),
 267                   (tan(ang), 1.0, 0.0),
 268                   (0.0, 0.0, 1.0))).to_4x4()
 269
 270
 271 def SVGTransformSkewX(params):
 272     """
 273     skewX SVG transform command
 274     """
 275
 276     ang = float(params[0]) * pi / 180.0
 277
 278     return Matrix(((1.0, tan(ang), 0.0),
 279                   (0.0, 1.0, 0.0),
 280                   (0.0, 0.0, 1.0))).to_4x4()
 281
 282
 283 def SVGTransformRotate(params):
 284     """
 285     skewX SVG transform command
 286     """
 287
 288     ang = float(params[0]) * pi / 180.0
 289     cx = cy = 0.0
 290
 291     if len(params) >= 3:
 292         cx = float(params[1])
 293         cy = float(params[2])
 294
 295     tm = Matrix.Translation(Vector((cx, cy, 0.0)))
 296     rm = Matrix.Rotation(ang, 4, Vector((0.0, 0.0, 1.0)))
 297
 298     return tm @ rm @ tm.inverted()
 299
 300 SVGTransforms = {'translate': SVGTransformTranslate,
 301                  'scale': SVGTransformScale,
 302                  'skewX': SVGTransformSkewX,
 303                  'skewY': SVGTransformSkewY,
 304                  'matrix': SVGTransformMatrix,
 305                  'rotate': SVGTransformRotate}
 306
 307
 308 def SVGParseStyles(node, context):
 309     """
 310     Parse node to get different styles for displaying geometries
 311     (materials, filling flags, etc..)
 312     """
 313
 314     styles = SVGEmptyStyles.copy()
 315
 316     style = node.getAttribute('style')
 317     if style:
 318         elems = style.split(';')
 319         for elem in elems:
 320             s = elem.split(':')
 321
 322             if len(s) != 2:
 323                 continue
 324
 325             name = s[0].strip().lower()
 326             val = s[1].strip()
 327
 328             if name == 'fill':
 329                 val = val.lower()
 330                 if val == 'none':
 331                     styles['useFill'] = False
 332                 else:
 333                     styles['useFill'] = True
 334                     styles['fill'] = SVGGetMaterial(val, context)
 335
 336         if styles['useFill'] is None:
 337             styles['useFill'] = True
 338             styles['fill'] = SVGGetMaterial('#000', context)
 339
 340         return styles
 341
 342     if styles['useFill'] is None:
 343         fill = node.getAttribute('fill')
 344         if fill:
 345             fill = fill.lower()
 346             if fill == 'none':
 347                 styles['useFill'] = False
 348             else:
 349                 styles['useFill'] = True
 350                 styles['fill'] = SVGGetMaterial(fill, context)
 351
 352     if styles['useFill'] is None and context['style']:
 353         styles = context['style'].copy()
 354
 355     if styles['useFill'] is None:
 356         styles['useFill'] = True
 357         styles['fill'] = SVGGetMaterial('#000', context)
 358
 359     return styles
 360
 361 def id_names_from_node(node, ob):
 362     if node.getAttribute('id'):
 363         name = node.getAttribute('id')
 364         ob.name = name
 365         ob.data.name = name
 366
 367 #### SVG path helpers ####
 368
 369
 370 class SVGPathData:
 371     """
 372     SVG Path data token supplier
 373     """
 374
 375     __slots__ = ('_data',   # List of tokens
 376                  '_index',  # Index of current token in tokens list
 377                  '_len')    # Length of tokens list
 378
 379     def __init__(self, d):
 380         """
 381         Initialize new path data supplier
 382
 383         d - the definition of the outline of a shape
 384         """
 385
 386         spaces = ' ,\t'
 387         commands = {'m', 'l', 'h', 'v', 'c', 's', 'q', '', 't', 'a', 'z'}
 388         current_command = ''
 389         tokens = []
 390
 391         i = 0
 392         n = len(d)
 393         while i < n:
 394             c = d[i]
 395
 396             if c in spaces:
 397                 pass
 398             elif c.lower() in commands:
 399                 tokens.append(c)
 400                 current_command = c
 401                 arg_index = 1
 402             elif c in ['-', '.'] or c.isdigit():
 403                 # Special case for 'a/A' commands.
 404                 # Arguments 4 and 5 are either 0 or 1 and might not
 405                 # be separated from the next argument with space or comma.
 406                 if current_command.lower() == 'a':
 407                     if arg_index % 7 in [4,5]:
 408                         token = d[i]
 409                         last_char = i + 1
 410                     else:
 411                         token, last_char = read_float(d, i)
 412                 else:
 413                     token, last_char = read_float(d, i)
 414
 415                 arg_index += 1
 416                 tokens.append(token)
 417
 418                 # in most cases len(token) and (last_char - i) are the same
 419                 # but with whitespace or ',' prefix they are not.
 420
 421                 i += (last_char - i) - 1
 422
 423             i += 1
 424
 425         self._data = tokens
 426         self._index = 0
 427         self._len = len(tokens)
 428
 429     def eof(self):
 430         """
 431         Check if end of data reached
 432         """
 433
 434         return self._index >= self._len
 435
 436     def cur(self):
 437         """
 438         Return current token
 439         """
 440
 441         if self.eof():
 442             return None
 443
 444         return self._data[self._index]
 445
 446     def lookupNext(self):
 447         """
 448         get next token without moving pointer
 449         """
 450
 451         if self.eof():
 452             return None
 453
 454         return self._data[self._index]
 455
 456     def next(self):
 457         """
 458         Return current token and go to next one
 459         """
 460
 461         if self.eof():
 462             return None
 463
 464         token = self._data[self._index]
 465         self._index += 1
 466
 467         return token
 468
 469     def nextCoord(self):
 470         """
 471         Return coordinate created from current token and move to next token
 472         """
 473
 474         token = self.next()
 475
 476         if token is None:
 477             return None
 478
 479         return float(token)
 480
 481
 482 class SVGPathParser:
 483     """
 484     Parser of SVG path data
 485     """
 486
 487     __slots__ = ('_data',  # Path data supplird
 488                  '_point',  # Current point coordinate
 489                  '_handle',  # Last handle coordinate
 490                  '_splines',  # List of all splies created during parsing
 491                  '_spline',  # Currently handling spline
 492                  '_commands',   # Hash of all supported path commands
 493                  '_use_fill',  # Splines would be filled, so expected to be closed
 494                  )
 495
 496     def __init__(self, d, use_fill):
 497         """
 498         Initialize path parser
 499
 500         d - the definition of the outline of a shape
 501         """
 502
 503         self._data = SVGPathData(d)
 504         self._point = None   # Current point
 505         self._handle = None  # Last handle
 506         self._splines = []   # List of splines in path
 507         self._spline = None  # Current spline
 508         self._use_fill = use_fill
 509
 510         self._commands = {'M': self._pathMoveTo,
 511                           'L': self._pathLineTo,
 512                           'H': self._pathLineTo,
 513                           'V': self._pathLineTo,
 514                           'C': self._pathCurveToCS,
 515                           'S': self._pathCurveToCS,
 516                           'Q': self._pathCurveToQT,
 517                           'T': self._pathCurveToQT,
 518                           'A': self._pathCurveToA,
 519                           'Z': self._pathClose,
 520
 521                           'm': self._pathMoveTo,
 522                           'l': self._pathLineTo,
 523                           'h': self._pathLineTo,
 524                           'v': self._pathLineTo,
 525                           'c': self._pathCurveToCS,
 526                           's': self._pathCurveToCS,
 527                           'q': self._pathCurveToQT,
 528                           't': self._pathCurveToQT,
 529                           'a': self._pathCurveToA,
 530                           'z': self._pathClose}
 531
 532     def _getCoordPair(self, relative, point):
 533         """
 534         Get next coordinate pair
 535         """
 536
 537         x = self._data.nextCoord()
 538         y = self._data.nextCoord()
 539
 540         if relative and point is not None:
 541             x += point[0]
 542             y += point[1]
 543
 544         return x, y
 545
 546     def _appendPoint(self, x, y, handle_left=None, handle_left_type='VECTOR',
 547                     handle_right=None, handle_right_type='VECTOR'):
 548         """
 549         Append point to spline
 550
 551         If there's no active spline, create one and set it's first point
 552         to current point coordinate
 553         """
 554
 555         if self._spline is None:
 556             self._spline = {'points': [],
 557                             'closed': False}
 558
 559             self._splines.append(self._spline)
 560
 561         if len(self._spline['points']) > 0:
 562             # Not sure about specifications, but Illustrator could create
 563             # last point at the same position, as start point (which was
 564             # reached by MoveTo command) to set needed handle coords.
 565             # It's also could use last point at last position to make path
 566             # filled.
 567
 568             first = self._spline['points'][0]
 569             if check_points_equal((first['x'], first['y']), (x, y)):
 570                 if handle_left is not None:
 571                     first['handle_left'] = handle_left
 572                     first['handle_left_type'] = 'FREE'
 573
 574                 if handle_left_type != 'VECTOR':
 575                     first['handle_left_type'] = handle_left_type
 576
 577                 if self._data.eof() or self._data.lookupNext().lower() == 'm':
 578                     self._spline['closed'] = True
 579
 580                 return
 581
 582             last = self._spline['points'][-1]
 583             if last['handle_right_type'] == 'VECTOR' and handle_left_type == 'FREE':
 584                 last['handle_right'] = (last['x'], last['y'])
 585                 last['handle_right_type'] = 'FREE'
 586             if last['handle_right_type'] == 'FREE' and handle_left_type == 'VECTOR':
 587                 handle_left = (x, y)
 588                 handle_left_type = 'FREE'
 589
 590         point = {'x': x,
 591                  'y': y,
 592
 593                  'handle_left': handle_left,
 594                  'handle_left_type': handle_left_type,
 595
 596                  'handle_right': handle_right,
 597                  'handle_right_type': handle_right_type}
 598
 599         self._spline['points'].append(point)
 600
 601     def _updateHandle(self, handle=None, handle_type=None):
 602         """
 603         Update right handle of previous point when adding new point to spline
 604         """
 605
 606         point = self._spline['points'][-1]
 607
 608         if handle_type is not None:
 609             point['handle_right_type'] = handle_type
 610
 611         if handle is not None:
 612             point['handle_right'] = handle
 613
 614     def _pathMoveTo(self, code):
 615         """
 616         MoveTo path command
 617         """
 618
 619         relative = code.islower()
 620         x, y = self._getCoordPair(relative, self._point)
 621
 622         self._spline = None  # Flag to start new spline
 623         self._point = (x, y)
 624
 625         cur = self._data.cur()
 626         while cur is not None and not cur.isalpha():
 627             x, y = self._getCoordPair(relative, self._point)
 628
 629             if self._spline is None:
 630                 self._appendPoint(self._point[0], self._point[1])
 631
 632             self._appendPoint(x, y)
 633
 634             self._point = (x, y)
 635             cur = self._data.cur()
 636
 637         self._handle = None
 638
 639     def _pathLineTo(self, code):
 640         """
 641         LineTo path command
 642         """
 643
 644         c = code.lower()
 645
 646         cur = self._data.cur()
 647         while cur is not None and not cur.isalpha():
 648             if c == 'l':
 649                 x, y = self._getCoordPair(code == 'l', self._point)
 650             elif c == 'h':
 651                 x = self._data.nextCoord()
 652                 y = self._point[1]
 653             else:
 654                 x = self._point[0]
 655                 y = self._data.nextCoord()
 656
 657             if code == 'h':
 658                 x += self._point[0]
 659             elif code == 'v':
 660                 y += self._point[1]
 661
 662             if self._spline is None:
 663                 self._appendPoint(self._point[0], self._point[1])
 664
 665             self._appendPoint(x, y)
 666
 667             self._point = (x, y)
 668             cur = self._data.cur()
 669
 670         self._handle = None
 671
 672     def _pathCurveToCS(self, code):
 673         """
 674         Cubic BEZIER CurveTo path command
 675         """
 676
 677         c = code.lower()
 678         cur = self._data.cur()
 679         while cur is not None and not cur.isalpha():
 680             if c == 'c':
 681                 x1, y1 = self._getCoordPair(code.islower(), self._point)
 682                 x2, y2 = self._getCoordPair(code.islower(), self._point)
 683             else:
 684                 if self._handle is not None:
 685                     x1, y1 = SVGFlipHandle(self._point[0], self._point[1],
 686                                         self._handle[0], self._handle[1])
 687                 else:
 688                     x1, y1 = self._point
 689
 690                 x2, y2 = self._getCoordPair(code.islower(), self._point)
 691
 692             x, y = self._getCoordPair(code.islower(), self._point)
 693
 694             if self._spline is None:
 695                 self._appendPoint(self._point[0], self._point[1],
 696                     handle_left_type='FREE', handle_left=self._point,
 697                     handle_right_type='FREE', handle_right=(x1, y1))
 698             else:
 699                 self._updateHandle(handle=(x1, y1), handle_type='FREE')
 700
 701             self._appendPoint(x, y,
 702                 handle_left_type='FREE', handle_left=(x2, y2),
 703                 handle_right_type='FREE', handle_right=(x, y))
 704
 705             self._point = (x, y)
 706             self._handle = (x2, y2)
 707             cur = self._data.cur()
 708
 709     def _pathCurveToQT(self, code):
 710         """
 711         Quadratic BEZIER CurveTo path command
 712         """
 713
 714         c = code.lower()
 715         cur = self._data.cur()
 716
 717         while cur is not None and not cur.isalpha():
 718             if c == 'q':
 719                 x1, y1 = self._getCoordPair(code.islower(), self._point)
 720             else:
 721                 if self._handle is not None:
 722                     x1, y1 = SVGFlipHandle(self._point[0], self._point[1],
 723                                            self._handle[0], self._handle[1])
 724                 else:
 725                     x1, y1 = self._point
 726
 727             x, y = self._getCoordPair(code.islower(), self._point)
 728
 729             if not check_points_equal((x, y), self._point):
 730                 if self._spline is None:
 731                     self._appendPoint(self._point[0], self._point[1],
 732                         handle_left_type='FREE', handle_left=self._point,
 733                         handle_right_type='FREE', handle_right=self._point)
 734
 735                 self._appendPoint(x, y,
 736                     handle_left_type='FREE', handle_left=(x1, y1),
 737                     handle_right_type='FREE', handle_right=(x, y))
 738
 739             self._point = (x, y)
 740             self._handle = (x1, y1)
 741             cur = self._data.cur()
 742
 743     def _calcArc(self, rx, ry, ang, fa, fs, x, y):
 744         """
 745         Calc arc paths
 746
 747         Copied and adoptedfrom paths_svg2obj.py script for Blender 2.49
 748         which is Copyright (c) jm soler juillet/novembre 2004-april 2009,
 749         """
 750
 751         cpx = self._point[0]
 752         cpy = self._point[1]
 753         rx = abs(rx)
 754         ry = abs(ry)
 755         px = abs((cos(ang) * (cpx - x) + sin(ang) * (cpy - y)) * 0.5) ** 2.0
 756         py = abs((cos(ang) * (cpy - y) - sin(ang) * (cpx - x)) * 0.5) ** 2.0
 757         rpx = rpy = 0.0
 758
 759         if abs(rx) > 0.0:
 760             px = px / (rx ** 2.0)
 761
 762         if abs(ry) > 0.0:
 763             rpy = py / (ry ** 2.0)
 764
 765         pl = rpx + rpy
 766         if pl > 1.0:
 767             pl = pl ** 0.5
 768             rx *= pl
 769             ry *= pl
 770
 771         carx = sarx = cary = sary = 0.0
 772
 773         if abs(rx) > 0.0:
 774             carx = cos(ang) / rx
 775             sarx = sin(ang) / rx
 776
 777         if abs(ry) > 0.0:
 778             cary = cos(ang) / ry
 779             sary = sin(ang) / ry
 780
 781         x0 = carx * cpx + sarx * cpy
 782         y0 = -sary * cpx + cary * cpy
 783         x1 = carx * x + sarx * y
 784         y1 = -sary * x + cary * y
 785         d = (x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0)
 786
 787         if abs(d) > 0.0:
 788             sq = 1.0 / d - 0.25
 789         else:
 790             sq = -0.25
 791
 792         if sq < 0.0:
 793             sq = 0.0
 794
 795         sf = sq ** 0.5
 796         if fs == fa:
 797             sf = -sf
 798
 799         xc = 0.5 * (x0 + x1) - sf * (y1 - y0)
 800         yc = 0.5 * (y0 + y1) + sf * (x1 - x0)
 801         ang_0 = atan2(y0 - yc, x0 - xc)
 802         ang_1 = atan2(y1 - yc, x1 - xc)
 803         ang_arc = ang_1 - ang_0
 804
 805         if ang_arc < 0.0 and fs == 1:
 806             ang_arc += 2.0 * pi
 807         elif ang_arc > 0.0 and fs == 0:
 808             ang_arc -= 2.0 * pi
 809
 810         n_segs = int(ceil(abs(ang_arc * 2.0 / (pi * 0.5 + 0.001))))
 811
 812         if self._spline is None:
 813             self._appendPoint(cpx, cpy,
 814                 handle_left_type='FREE', handle_left=(cpx, cpy),
 815                 handle_right_type='FREE', handle_right=(cpx, cpy))
 816
 817         for i in range(n_segs):
 818             ang0 = ang_0 + i * ang_arc / n_segs
 819             ang1 = ang_0 + (i + 1) * ang_arc / n_segs
 820             ang_demi = 0.25 * (ang1 - ang0)
 821             t = 2.66666 * sin(ang_demi) * sin(ang_demi) / sin(ang_demi * 2.0)
 822             x1 = xc + cos(ang0) - t * sin(ang0)
 823             y1 = yc + sin(ang0) + t * cos(ang0)
 824             x2 = xc + cos(ang1)
 825             y2 = yc + sin(ang1)
 826             x3 = x2 + t * sin(ang1)
 827             y3 = y2 - t * cos(ang1)
 828
 829             coord1 = ((cos(ang) * rx) * x1 + (-sin(ang) * ry) * y1,
 830                       (sin(ang) * rx) * x1 + (cos(ang) * ry) * y1)
 831             coord2 = ((cos(ang) * rx) * x3 + (-sin(ang) * ry) * y3,
 832                       (sin(ang) * rx) * x3 + (cos(ang) * ry) * y3)
 833             coord3 = ((cos(ang) * rx) * x2 + (-sin(ang) * ry) * y2,
 834                       (sin(ang) * rx) * x2 + (cos(ang) * ry) * y2)
 835
 836             self._updateHandle(handle=coord1, handle_type='FREE')
 837
 838             self._appendPoint(coord3[0], coord3[1],
 839                 handle_left_type='FREE', handle_left=coord2,
 840                 handle_right_type='FREE', handle_right=coord3)
 841
 842     def _pathCurveToA(self, code):
 843         """
 844         Elliptical arc CurveTo path command
 845         """
 846
 847         cur = self._data.cur()
 848
 849         while cur is not None and not cur.isalpha():
 850             rx = float(self._data.next())
 851             ry = float(self._data.next())
 852             ang = float(self._data.next()) / 180 * pi
 853             fa = float(self._data.next())
 854             fs = float(self._data.next())
 855             x, y = self._getCoordPair(code.islower(), self._point)
 856
 857             self._calcArc(rx, ry, ang, fa, fs, x, y)
 858
 859             self._point = (x, y)
 860             self._handle = None
 861             cur = self._data.cur()
 862
 863     def _pathClose(self, code):
 864         """
 865         Close path command
 866         """
 867
 868         if self._spline:
 869             self._spline['closed'] = True
 870
 871             cv = self._spline['points'][0]
 872             self._point = (cv['x'], cv['y'])
 873
 874     def _pathCloseImplicitly(self):
 875         """
 876         Close path implicitly without changing current point coordinate
 877         """
 878
 879         if self._spline:
 880             self._spline['closed'] = True
 881
 882     def parse(self):
 883         """
 884         Execute parser
 885         """
 886
 887         closed = False
 888
 889         while not self._data.eof():
 890             code = self._data.next()
 891             cmd = self._commands.get(code)
 892
 893             if cmd is None:
 894                 raise Exception('Unknown path command: {0}' . format(code))
 895
 896             if code in {'Z', 'z'}:
 897                 closed = True
 898             else:
 899                 closed = False
 900
 901             if code in {'M', 'm'} and self._use_fill and not closed:
 902                 self._pathCloseImplicitly() # Ensure closed before MoveTo path command
 903
 904             cmd(code)
 905         if self._use_fill and not closed:
 906             self._pathCloseImplicitly() # Ensure closed at the end of parsing
 907
 908     def getSplines(self):
 909         """
 910         Get splines definitions
 911         """
 912
 913         return self._splines
 914
 915
 916 class SVGGeometry:
 917     """
 918     Abstract SVG geometry
 919     """
 920
 921     __slots__ = ('_node',  # XML node for geometry
 922                  '_context',  # Global SVG context (holds matrices stack, i.e.)
 923                  '_creating')  # Flag if geometry is already creating
 924                                # for this node
 925                                # need to detect cycles for USE node
 926
 927     def __init__(self, node, context):
 928         """
 929         Initialize SVG geometry
 930         """
 931
 932         self._node = node
 933         self._context = context
 934         self._creating = False
 935
 936         if hasattr(node, 'getAttribute'):
 937             defs = context['defines']
 938
 939             attr_id = node.getAttribute('id')
 940             if attr_id and defs.get('#' + attr_id) is None:
 941                 defs['#' + attr_id] = self
 942
 943             className = node.getAttribute('class')
 944             if className and defs.get(className) is None:
 945                 defs[className] = self
 946
 947     def _pushRect(self, rect):
 948         """
 949         Push display rectangle
 950         """
 951
 952         self._context['rects'].append(rect)
 953         self._context['rect'] = rect
 954
 955     def _popRect(self):
 956         """
 957         Pop display rectangle
 958         """
 959
 960         self._context['rects'].pop()
 961         self._context['rect'] = self._context['rects'][-1]
 962
 963     def _pushMatrix(self, matrix):
 964         """
 965         Push transformation matrix
 966         """
 967
 968         current_matrix = self._context['matrix']
 969         self._context['matrix_stack'].append(current_matrix)
 970         self._context['matrix'] = current_matrix @ matrix
 971
 972     def _popMatrix(self):
 973         """
 974         Pop transformation matrix
 975         """
 976
 977         old_matrix = self._context['matrix_stack'].pop()
 978         self._context['matrix'] = old_matrix
 979
 980     def _pushStyle(self, style):
 981         """
 982         Push style
 983         """
 984
 985         self._context['styles'].append(style)
 986         self._context['style'] = style
 987
 988     def _popStyle(self):
 989         """
 990         Pop style
 991         """
 992
 993         self._context['styles'].pop()
 994         self._context['style'] = self._context['styles'][-1]
 995
 996     def _transformCoord(self, point):
 997         """
 998         Transform SVG-file coords
 999         """
1000
1001         v = Vector((point[0], point[1], 0.0))
1002
1003         return self._context['matrix'] @ v
1004
1005     def getNodeMatrix(self):
1006         """
1007         Get transformation matrix of node
1008         """
1009
1010         return SVGMatrixFromNode(self._node, self._context)
1011
1012     def parse(self):
1013         """
1014         Parse XML node to memory
1015         """
1016
1017         pass
1018
1019     def _doCreateGeom(self, instancing):
1020         """
1021         Internal handler to create real geometries
1022         """
1023
1024         pass
1025
1026     def getTransformMatrix(self):
1027         """
1028         Get matrix created from "transform" attribute
1029         """
1030
1031         transform = self._node.getAttribute('transform')
1032
1033         if transform:
1034             return SVGParseTransform(transform)
1035
1036         return None
1037
1038     def createGeom(self, instancing):
1039         """
1040         Create real geometries
1041         """
1042
1043         if self._creating:
1044             return
1045
1046         self._creating = True
1047
1048         matrix = self.getTransformMatrix()
1049         if matrix is not None:
1050             self._pushMatrix(matrix)
1051
1052         self._doCreateGeom(instancing)
1053
1054         if matrix is not None:
1055             self._popMatrix()
1056
1057         self._creating = False
1058
1059
1060 class SVGGeometryContainer(SVGGeometry):
1061     """
1062     Container of SVG geometries
1063     """
1064
1065     __slots__ = ('_geometries',  # List of chold geometries
1066                  '_styles')  # Styles, used for displaying
1067
1068     def __init__(self, node, context):
1069         """
1070         Initialize SVG geometry container
1071         """
1072
1073         super().__init__(node, context)
1074
1075         self._geometries = []
1076         self._styles = SVGEmptyStyles
1077
1078     def parse(self):
1079         """
1080         Parse XML node to memory
1081         """
1082
1083         if type(self._node) is xml.dom.minidom.Element:
1084             self._styles = SVGParseStyles(self._node, self._context)
1085
1086         self._pushStyle(self._styles)
1087
1088         for node in self._node.childNodes:
1089             if type(node) is not xml.dom.minidom.Element:
1090                 continue
1091
1092             ob = parseAbstractNode(node, self._context)
1093             if ob is not None:
1094                 self._geometries.append(ob)
1095
1096         self._popStyle()
1097
1098     def _doCreateGeom(self, instancing):
1099         """
1100         Create real geometries
1101         """
1102
1103         for geom in self._geometries:
1104             geom.createGeom(instancing)
1105
1106     def getGeometries(self):
1107         """
1108         Get list of parsed geometries
1109         """
1110
1111         return self._geometries
1112
1113
1114 class SVGGeometryPATH(SVGGeometry):
1115     """
1116     SVG path geometry
1117     """
1118
1119     __slots__ = ('_splines',  # List of splines after parsing
1120                  '_styles')  # Styles, used for displaying
1121
1122     def __init__(self, node, context):
1123         """
1124         Initialize SVG path
1125         """
1126
1127         super().__init__(node, context)
1128
1129         self._splines = []
1130         self._styles = SVGEmptyStyles
1131
1132     def parse(self):
1133         """
1134         Parse SVG path node
1135         """
1136
1137         d = self._node.getAttribute('d')
1138
1139         self._styles = SVGParseStyles(self._node, self._context)
1140
1141         pathParser = SVGPathParser(d, self._styles['useFill'])
1142         pathParser.parse()
1143
1144         self._splines = pathParser.getSplines()
1145
1146     def _doCreateGeom(self, instancing):
1147         """
1148         Create real geometries
1149         """
1150
1151         ob = SVGCreateCurve(self._context)
1152         cu = ob.data
1153
1154         id_names_from_node(self._node, ob)
1155
1156         if self._styles['useFill']:
1157             cu.dimensions = '2D'
1158             cu.fill_mode = 'BOTH'
1159             cu.materials.append(self._styles['fill'])
1160         else:
1161             cu.dimensions = '3D'
1162
1163         for spline in self._splines:
1164             act_spline = None
1165
1166             if spline['closed'] and len(spline['points']) >= 2:
1167                 first = spline['points'][0]
1168                 last = spline['points'][-1]
1169                 if (    first['handle_left_type'] == 'FREE' and
1170                         last['handle_right_type'] == 'VECTOR'):
1171                     last['handle_right_type'] = 'FREE'
1172                     last['handle_right'] = (last['x'], last['y'])
1173                 if (    last['handle_right_type'] == 'FREE' and
1174                         first['handle_left_type'] == 'VECTOR'):
1175                     first['handle_left_type'] = 'FREE'
1176                     first['handle_left'] = (first['x'], first['y'])
1177
1178             for point in spline['points']:
1179                 co = self._transformCoord((point['x'], point['y']))
1180
1181                 if act_spline is None:
1182                     cu.splines.new('BEZIER')
1183
1184                     act_spline = cu.splines[-1]
1185                     act_spline.use_cyclic_u = spline['closed']
1186                 else:
1187                     act_spline.bezier_points.add(1)
1188
1189                 bezt = act_spline.bezier_points[-1]
1190                 bezt.co = co
1191
1192                 bezt.handle_left_type = point['handle_left_type']
1193                 if point['handle_left'] is not None:
1194                     handle = point['handle_left']
1195                     bezt.handle_left = self._transformCoord(handle)
1196
1197                 bezt.handle_right_type = point['handle_right_type']
1198                 if point['handle_right'] is not None:
1199                     handle = point['handle_right']
1200                     bezt.handle_right = self._transformCoord(handle)
1201
1202         SVGFinishCurve()
1203
1204
1205 class SVGGeometryDEFS(SVGGeometryContainer):
1206     """
1207     Container for referenced elements
1208     """
1209
1210     def createGeom(self, instancing):
1211         """
1212         Create real geometries
1213         """
1214
1215         pass
1216
1217
1218 class SVGGeometrySYMBOL(SVGGeometryContainer):
1219     """
1220     Referenced element
1221     """
1222
1223     def _doCreateGeom(self, instancing):
1224         """
1225         Create real geometries
1226         """
1227
1228         self._pushMatrix(self.getNodeMatrix())
1229
1230         super()._doCreateGeom(False)
1231
1232         self._popMatrix()
1233
1234     def createGeom(self, instancing):
1235         """
1236         Create real geometries
1237         """
1238
1239         if not instancing:
1240             return
1241
1242         super().createGeom(instancing)
1243
1244
1245 class SVGGeometryG(SVGGeometryContainer):
1246     """
1247     Geometry group
1248     """
1249
1250     pass
1251
1252
1253 class SVGGeometryUSE(SVGGeometry):
1254     """
1255     User of referenced elements
1256     """
1257
1258     def _doCreateGeom(self, instancing):
1259         """
1260         Create real geometries
1261         """
1262
1263         ref = self._node.getAttribute('xlink:href')
1264         geom = self._context['defines'].get(ref)
1265
1266         if geom is not None:
1267             rect = SVGRectFromNode(self._node, self._context)
1268             self._pushRect(rect)
1269
1270             self._pushMatrix(self.getNodeMatrix())
1271
1272             geom.createGeom(True)
1273
1274             self._popMatrix()
1275
1276             self._popRect()
1277
1278
1279 class SVGGeometryRECT(SVGGeometry):
1280     """
1281     SVG rectangle
1282     """
1283
1284     __slots__ = ('_rect',  # coordinate and dimensions of rectangle
1285                  '_radius',  # Rounded corner radiuses
1286                  '_styles')  # Styles, used for displaying
1287
1288     def __init__(self, node, context):
1289         """
1290         Initialize new rectangle
1291         """
1292
1293         super().__init__(node, context)
1294
1295         self._rect = ('0', '0', '0', '0')
1296         self._radius = ('0', '0')
1297         self._styles = SVGEmptyStyles
1298
1299     def parse(self):
1300         """
1301         Parse SVG rectangle node
1302         """
1303
1304         self._styles = SVGParseStyles(self._node, self._context)
1305
1306         rect = []
1307         for attr in ['x', 'y', 'width', 'height']:
1308             val = self._node.getAttribute(attr)
1309             rect.append(val or '0')
1310
1311         self._rect = (rect)
1312
1313         rx = self._node.getAttribute('rx')
1314         ry = self._node.getAttribute('ry')
1315
1316         self._radius = (rx, ry)
1317
1318     def _appendCorner(self, spline, coord, firstTime, rounded):
1319         """
1320         Append new corner to rectangle
1321         """
1322
1323         handle = None
1324         if len(coord) == 3:
1325             handle = self._transformCoord(coord[2])
1326             coord = (coord[0], coord[1])
1327
1328         co = self._transformCoord(coord)
1329
1330         if not firstTime:
1331             spline.bezier_points.add(1)
1332
1333         bezt = spline.bezier_points[-1]
1334         bezt.co = co
1335
1336         if rounded:
1337             if handle:
1338                 bezt.handle_left_type = 'VECTOR'
1339                 bezt.handle_right_type = 'FREE'
1340
1341                 bezt.handle_right = handle
1342             else:
1343                 bezt.handle_left_type = 'FREE'
1344                 bezt.handle_right_type = 'VECTOR'
1345                 bezt.handle_left = co
1346
1347         else:
1348             bezt.handle_left_type = 'VECTOR'
1349             bezt.handle_right_type = 'VECTOR'
1350
1351     def _doCreateGeom(self, instancing):
1352         """
1353         Create real geometries
1354         """
1355
1356         # Run-time parsing -- percents would be correct only if
1357         # parsing them now
1358         crect = self._context['rect']
1359         rect = []
1360
1361         for i in range(4):
1362             rect.append(SVGParseCoord(self._rect[i], crect[i % 2]))
1363
1364         r = self._radius
1365         rx = ry = 0.0
1366
1367         if r[0] and r[1]:
1368             rx = min(SVGParseCoord(r[0], rect[0]), rect[2] / 2)
1369             ry = min(SVGParseCoord(r[1], rect[1]), rect[3] / 2)
1370         elif r[0]:
1371             rx = min(SVGParseCoord(r[0], rect[0]), rect[2] / 2)
1372             ry = min(rx, rect[3] / 2)
1373             rx = ry = min(rx, ry)
1374         elif r[1]:
1375             ry = min(SVGParseCoord(r[1], rect[1]), rect[3] / 2)
1376             rx = min(ry, rect[2] / 2)
1377             rx = ry = min(rx, ry)
1378
1379         radius = (rx, ry)
1380
1381         # Geometry creation
1382         ob = SVGCreateCurve(self._context)
1383         cu = ob.data
1384
1385         id_names_from_node(self._node, ob)
1386
1387         if self._styles['useFill']:
1388             cu.dimensions = '2D'
1389             cu.fill_mode = 'BOTH'
1390             cu.materials.append(self._styles['fill'])
1391         else:
1392             cu.dimensions = '3D'
1393
1394         cu.splines.new('BEZIER')
1395
1396         spline = cu.splines[-1]
1397         spline.use_cyclic_u = True
1398
1399         x, y = rect[0], rect[1]
1400         w, h = rect[2], rect[3]
1401         rx, ry = radius[0], radius[1]
1402         rounded = False
1403
1404         if rx or ry:
1405             #
1406             #      0 _______ 1
1407             #     /           \
1408             #    /             \
1409             #   7               2
1410             #   |               |
1411             #   |               |
1412             #   6               3
1413             #    \             /
1414             #     \           /
1415             #      5 _______ 4
1416             #
1417
1418             # Optional third component -- right handle coord
1419             coords = [(x + rx, y),
1420                       (x + w - rx, y, (x + w, y)),
1421                       (x + w, y + ry),
1422                       (x + w, y + h - ry, (x + w, y + h)),
1423                       (x + w - rx, y + h),
1424                       (x + rx, y + h, (x, y + h)),
1425                       (x, y + h - ry),
1426                       (x, y + ry, (x, y))]
1427
1428             rounded = True
1429         else:
1430             coords = [(x, y), (x + w, y), (x + w, y + h), (x, y + h)]
1431
1432         firstTime = True
1433         for coord in coords:
1434             self._appendCorner(spline, coord, firstTime, rounded)
1435             firstTime = False
1436
1437         SVGFinishCurve()
1438
1439
1440 class SVGGeometryELLIPSE(SVGGeometry):
1441     """
1442     SVG ellipse
1443     """
1444
1445     __slots__ = ('_cx',  # X-coordinate of center
1446                  '_cy',  # Y-coordinate of center
1447                  '_rx',  # X-axis radius of circle
1448                  '_ry',  # Y-axis radius of circle
1449                  '_styles')  # Styles, used for displaying
1450
1451     def __init__(self, node, context):
1452         """
1453         Initialize new ellipse
1454         """
1455
1456         super().__init__(node, context)
1457
1458         self._cx = '0.0'
1459         self._cy = '0.0'
1460         self._rx = '0.0'
1461         self._ry = '0.0'
1462         self._styles = SVGEmptyStyles
1463
1464     def parse(self):
1465         """
1466         Parse SVG ellipse node
1467         """
1468
1469         self._styles = SVGParseStyles(self._node, self._context)
1470
1471         self._cx = self._node.getAttribute('cx') or '0'
1472         self._cy = self._node.getAttribute('cy') or '0'
1473         self._rx = self._node.getAttribute('rx') or '0'
1474         self._ry = self._node.getAttribute('ry') or '0'
1475
1476     def _doCreateGeom(self, instancing):
1477         """
1478         Create real geometries
1479         """
1480
1481         # Run-time parsing -- percents would be correct only if
1482         # parsing them now
1483         crect = self._context['rect']
1484
1485         cx = SVGParseCoord(self._cx, crect[0])
1486         cy = SVGParseCoord(self._cy, crect[1])
1487         rx = SVGParseCoord(self._rx, crect[0])
1488         ry = SVGParseCoord(self._ry, crect[1])
1489
1490         if not rx or not ry:
1491             # Automaic handles will work incorrect in this case
1492             return
1493
1494         # Create circle
1495         ob = SVGCreateCurve(self._context)
1496         cu = ob.data
1497
1498         id_names_from_node(self._node, ob)
1499
1500         if self._styles['useFill']:
1501             cu.dimensions = '2D'
1502             cu.fill_mode = 'BOTH'
1503             cu.materials.append(self._styles['fill'])
1504         else:
1505             cu.dimensions = '3D'
1506
1507         coords = [((cx - rx, cy),
1508                    (cx - rx, cy + ry * 0.552),
1509                    (cx - rx, cy - ry * 0.552)),
1510
1511                   ((cx, cy - ry),
1512                    (cx - rx * 0.552, cy - ry),
1513                    (cx + rx * 0.552, cy - ry)),
1514
1515                   ((cx + rx, cy),
1516                    (cx + rx, cy - ry * 0.552),
1517                    (cx + rx, cy + ry * 0.552)),
1518
1519                   ((cx, cy + ry),
1520                    (cx + rx * 0.552, cy + ry),
1521                    (cx - rx * 0.552, cy + ry))]
1522
1523         spline = None
1524         for coord in coords:
1525             co = self._transformCoord(coord[0])
1526             handle_left = self._transformCoord(coord[1])
1527             handle_right = self._transformCoord(coord[2])
1528
1529             if spline is None:
1530                 cu.splines.new('BEZIER')
1531                 spline = cu.splines[-1]
1532                 spline.use_cyclic_u = True
1533             else:
1534                 spline.bezier_points.add(1)
1535
1536             bezt = spline.bezier_points[-1]
1537             bezt.co = co
1538             bezt.handle_left_type = 'FREE'
1539             bezt.handle_right_type = 'FREE'
1540             bezt.handle_left = handle_left
1541             bezt.handle_right = handle_right
1542
1543         SVGFinishCurve()
1544
1545
1546 class SVGGeometryCIRCLE(SVGGeometryELLIPSE):
1547     """
1548     SVG circle
1549     """
1550
1551     def parse(self):
1552         """
1553         Parse SVG circle node
1554         """
1555
1556         self._styles = SVGParseStyles(self._node, self._context)
1557
1558         self._cx = self._node.getAttribute('cx') or '0'
1559         self._cy = self._node.getAttribute('cy') or '0'
1560
1561         r = self._node.getAttribute('r') or '0'
1562         self._rx = self._ry = r
1563
1564
1565 class SVGGeometryLINE(SVGGeometry):
1566     """
1567     SVG line
1568     """
1569
1570     __slots__ = ('_x1',  # X-coordinate of beginning
1571                  '_y1',  # Y-coordinate of beginning
1572                  '_x2',  # X-coordinate of ending
1573                  '_y2')  # Y-coordinate of ending
1574
1575     def __init__(self, node, context):
1576         """
1577         Initialize new line
1578         """
1579
1580         super().__init__(node, context)
1581
1582         self._x1 = '0.0'
1583         self._y1 = '0.0'
1584         self._x2 = '0.0'
1585         self._y2 = '0.0'
1586
1587     def parse(self):
1588         """
1589         Parse SVG line node
1590         """
1591
1592         self._x1 = self._node.getAttribute('x1') or '0'
1593         self._y1 = self._node.getAttribute('y1') or '0'
1594         self._x2 = self._node.getAttribute('x2') or '0'
1595         self._y2 = self._node.getAttribute('y2') or '0'
1596
1597     def _doCreateGeom(self, instancing):
1598         """
1599         Create real geometries
1600         """
1601
1602         # Run-time parsing -- percents would be correct only if
1603         # parsing them now
1604         crect = self._context['rect']
1605
1606         x1 = SVGParseCoord(self._x1, crect[0])
1607         y1 = SVGParseCoord(self._y1, crect[1])
1608         x2 = SVGParseCoord(self._x2, crect[0])
1609         y2 = SVGParseCoord(self._y2, crect[1])
1610
1611         # Create cline
1612         ob = SVGCreateCurve(self._context)
1613         cu = ob.data
1614
1615         id_names_from_node(self._node, ob)
1616
1617         coords = [(x1, y1), (x2, y2)]
1618         spline = None
1619
1620         for coord in coords:
1621             co = self._transformCoord(coord)
1622
1623             if spline is None:
1624                 cu.splines.new('BEZIER')
1625                 spline = cu.splines[-1]
1626                 spline.use_cyclic_u = True
1627             else:
1628                 spline.bezier_points.add(1)
1629
1630             bezt = spline.bezier_points[-1]
1631             bezt.co = co
1632             bezt.handle_left_type = 'VECTOR'
1633             bezt.handle_right_type = 'VECTOR'
1634
1635         SVGFinishCurve()
1636
1637
1638 class SVGGeometryPOLY(SVGGeometry):
1639     """
1640     Abstract class for handling poly-geometries
1641     (polylines and polygons)
1642     """
1643
1644     __slots__ = ('_points',  # Array of points for poly geometry
1645                  '_styles',  # Styles, used for displaying
1646                  '_closed')  # Should generated curve be closed?
1647
1648     def __init__(self, node, context):
1649         """
1650         Initialize new poly geometry
1651         """
1652
1653         super().__init__(node, context)
1654
1655         self._points = []
1656         self._styles = SVGEmptyStyles
1657         self._closed = False
1658
1659     def parse(self):
1660         """
1661         Parse poly node
1662         """
1663
1664         self._styles = SVGParseStyles(self._node, self._context)
1665
1666         points = parse_array_of_floats(self._node.getAttribute('points'))
1667
1668         prev = None
1669         self._points = []
1670
1671         for p in points:
1672             if prev is None:
1673                 prev = p
1674             else:
1675                 self._points.append((prev, p))
1676                 prev = None
1677
1678     def _doCreateGeom(self, instancing):
1679         """
1680         Create real geometries
1681         """
1682
1683         ob = SVGCreateCurve(self._context)
1684         cu = ob.data
1685
1686         id_names_from_node(self._node, ob)
1687
1688         if self._closed and self._styles['useFill']:
1689             cu.dimensions = '2D'
1690             cu.fill_mode = 'BOTH'
1691             cu.materials.append(self._styles['fill'])
1692         else:
1693             cu.dimensions = '3D'
1694
1695         spline = None
1696
1697         for point in self._points:
1698             co = self._transformCoord(point)
1699
1700             if spline is None:
1701                 cu.splines.new('BEZIER')
1702                 spline = cu.splines[-1]
1703                 spline.use_cyclic_u = self._closed
1704             else:
1705                 spline.bezier_points.add(1)
1706
1707             bezt = spline.bezier_points[-1]
1708             bezt.co = co
1709             bezt.handle_left_type = 'VECTOR'
1710             bezt.handle_right_type = 'VECTOR'
1711
1712         SVGFinishCurve()
1713
1714
1715 class SVGGeometryPOLYLINE(SVGGeometryPOLY):
1716     """
1717     SVG polyline geometry
1718     """
1719
1720     pass
1721
1722
1723 class SVGGeometryPOLYGON(SVGGeometryPOLY):
1724     """
1725     SVG polygon geometry
1726     """
1727
1728     def __init__(self, node, context):
1729         """
1730         Initialize new polygon geometry
1731         """
1732
1733         super().__init__(node, context)
1734
1735         self._closed = True
1736
1737
1738 class SVGGeometrySVG(SVGGeometryContainer):
1739     """
1740     Main geometry holder
1741     """
1742
1743     def _doCreateGeom(self, instancing):
1744         """
1745         Create real geometries
1746         """
1747
1748         rect = SVGRectFromNode(self._node, self._context)
1749
1750         matrix = self.getNodeMatrix()
1751
1752         # Better SVG compatibility: match svg-document units
1753         # with blender units
1754
1755         viewbox = []
1756         unit = ''
1757
1758         if self._node.getAttribute('height'):
1759             raw_height = self._node.getAttribute('height')
1760             token, last_char = read_float(raw_height)
1761             document_height = float(token)
1762             unit = raw_height[last_char:].strip()
1763
1764         if self._node.getAttribute('viewBox'):
1765             viewbox = parse_array_of_floats(self._node.getAttribute('viewBox'))
1766
1767         if len(viewbox) == 4 and unit in ('cm', 'mm', 'in', 'pt', 'pc'):
1768
1769             #convert units to BU:
1770             unitscale = units[unit] / 90 * 1000 / 39.3701
1771
1772             #apply blender unit scale:
1773             unitscale = unitscale / bpy.context.scene.unit_settings.scale_length
1774
1775             matrix = matrix @ Matrix.Scale(unitscale, 4, Vector((1.0, 0.0, 0.0)))
1776             matrix = matrix @ Matrix.Scale(unitscale, 4, Vector((0.0, 1.0, 0.0)))
1777
1778         # match document origin with 3D space origin.
1779         if self._node.getAttribute('viewBox'):
1780             viewbox = parse_array_of_floats(self._node.getAttribute('viewBox'))
1781             matrix = matrix @ matrix.Translation([0.0, - viewbox[1] - viewbox[3], 0.0])
1782
1783         self._pushMatrix(matrix)
1784         self._pushRect(rect)
1785
1786         super()._doCreateGeom(False)
1787
1788         self._popRect()
1789         self._popMatrix()
1790
1791
1792 class SVGLoader(SVGGeometryContainer):
1793     """
1794     SVG file loader
1795     """
1796
1797     def getTransformMatrix(self):
1798         """
1799         Get matrix created from "transform" attribute
1800         """
1801
1802         # SVG document doesn't support transform specification
1803         # it can't even hold attributes
1804
1805         return None
1806
1807     def __init__(self, context, filepath, do_colormanage):
1808         """
1809         Initialize SVG loader
1810         """
1811         import os
1812
1813         svg_name = os.path.basename(filepath)
1814         scene = context.scene
1815         collection = bpy.data.collections.new(name=svg_name)
1816         scene.collection.children.link(collection)
1817
1818         node = xml.dom.minidom.parse(filepath)
1819
1820         m = Matrix()
1821         m = m @ Matrix.Scale(1.0 / 90.0 * 0.3048 / 12.0, 4, Vector((1.0, 0.0, 0.0)))
1822         m = m @ Matrix.Scale(-1.0 / 90.0 * 0.3048 / 12.0, 4, Vector((0.0, 1.0, 0.0)))
1823
1824         rect = (0, 0)
1825
1826         self._context = {'defines': {},
1827                          'rects': [rect],
1828                          'rect': rect,
1829                          'matrix_stack': [],
1830                          'matrix': m,
1831                          'materials': {},
1832                          'styles': [None],
1833                          'style': None,
1834                          'do_colormanage': do_colormanage,
1835                          'collection': collection}
1836
1837         super().__init__(node, self._context)
1838
1839
1840 svgGeometryClasses = {
1841     'svg': SVGGeometrySVG,
1842     'path': SVGGeometryPATH,
1843     'defs': SVGGeometryDEFS,
1844     'symbol': SVGGeometrySYMBOL,
1845     'use': SVGGeometryUSE,
1846     'rect': SVGGeometryRECT,
1847     'ellipse': SVGGeometryELLIPSE,
1848     'circle': SVGGeometryCIRCLE,
1849     'line': SVGGeometryLINE,
1850     'polyline': SVGGeometryPOLYLINE,
1851     'polygon': SVGGeometryPOLYGON,
1852     'g': SVGGeometryG}
1853
1854
1855 def parseAbstractNode(node, context):
1856     name = node.tagName.lower()
1857
1858     if name.startswith('svg:'):
1859         name = name[4:]
1860
1861     geomClass = svgGeometryClasses.get(name)
1862
1863     if geomClass is not None:
1864         ob = geomClass(node, context)
1865         ob.parse()
1866
1867         return ob
1868
1869     return None
1870
1871
1872 def load_svg(context, filepath, do_colormanage):
1873     """
1874     Load specified SVG file
1875     """
1876
1877     if bpy.ops.object.mode_set.poll():
1878         bpy.ops.object.mode_set(mode='OBJECT')
1879
1880     loader = SVGLoader(context, filepath, do_colormanage)
1881     loader.parse()
1882     loader.createGeom(False)
1883
1884
1885 def load(operator, context, filepath=""):
1886
1887     # error in code should raise exceptions but loading
1888     # non SVG files can give useful messages.
1889     do_colormanage = context.scene.display_settings.display_device != 'NONE'
1890     try:
1891         load_svg(context, filepath, do_colormanage)
1892     except (xml.parsers.expat.ExpatError, UnicodeEncodeError) as e:
1893         import traceback
1894         traceback.print_exc()
1895
1896         operator.report({'WARNING'}, tip_("Unable to parse XML, %s:%s for file %r") % (type(e).__name__, e, filepath))
1897         return {'CANCELLED'}
1898
1899     return {'FINISHED'}