render_freestyle_svg.py

   1 # ##### BEGIN GPL LICENSE BLOCK #####
   2 #
   3 #  This program is free software; you can redistribute it and/or
   4 #  modify it under the terms of the GNU General Public License
   5 #  as published by the Free Software Foundation; either version 2
   6 #  of the License, or (at your option) any later version.
   7 #
   8 #  This program is distributed in the hope that it will be useful,
   9 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11 #  GNU General Public License for more details.
  12 #
  13 #  You should have received a copy of the GNU General Public License
  14 #  along with this program; if not, write to the Free Software Foundation,
  15 #  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  16 #
  17 # ##### END GPL LICENSE BLOCK #####
  18
  19 # <pep8 compliant>
  20
  21 bl_info = {
  22     "name": "Freestyle SVG Exporter",
  23     "author": "Folkert de Vries",
  24     "version": (1, 0),
  25     "blender": (2, 72, 1),
  26     "location": "Properties > Render > Freestyle SVG Export",
  27     "description": "Exports Freestyle's stylized edges in SVG format",
  28     "warning": "",
  29     "wiki_url": "",
  30     "category": "Render",
  31     }
  32
  33 import bpy
  34 import parameter_editor
  35 import itertools
  36 import os
  37
  38 import xml.etree.cElementTree as et
  39
  40 from bpy.app.handlers import persistent
  41 from collections import OrderedDict
  42 from functools import partial
  43 from mathutils import Vector
  44
  45 from freestyle.types import (
  46         StrokeShader,
  47         Interface0DIterator,
  48         Operators,
  49         Nature,
  50         StrokeVertex,
  51         )
  52 from freestyle.utils import (
  53     getCurrentScene,
  54     BoundingBox,
  55     is_poly_clockwise,
  56     StrokeCollector,
  57     material_from_fedge,
  58     get_object_name,
  59     )
  60 from freestyle.functions import (
  61     GetShapeF1D,
  62     CurveMaterialF0D,
  63     )
  64 from freestyle.predicates import (
  65         AndBP1D,
  66         AndUP1D,
  67         ContourUP1D,
  68         ExternalContourUP1D,
  69         MaterialBP1D,
  70         NotBP1D,
  71         NotUP1D,
  72         OrBP1D,
  73         OrUP1D,
  74         pyNatureUP1D,
  75         pyZBP1D,
  76         pyZDiscontinuityBP1D,
  77         QuantitativeInvisibilityUP1D,
  78         SameShapeIdBP1D,
  79         TrueBP1D,
  80         TrueUP1D,
  81         )
  82 from freestyle.chainingiterators import ChainPredicateIterator
  83 from parameter_editor import get_dashed_pattern
  84
  85 from bpy.props import (
  86         BoolProperty,
  87         EnumProperty,
  88         PointerProperty,
  89         )
  90
  91
  92 # use utf-8 here to keep ElementTree happy, end result is utf-16
  93 svg_primitive = """<?xml version="1.0" encoding="ascii" standalone="no"?>
  94 <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
  95   "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
  96 <svg xmlns="http://www.w3.org/2000/svg" version="1.1" width="{:d}" height="{:d}">
  97 </svg>"""
  98
  99
 100 # xml namespaces
 101 namespaces = {
 102     "inkscape": "http://www.inkscape.org/namespaces/inkscape",
 103     "svg": "http://www.w3.org/2000/svg",
 104     "sodipodi": "http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd",
 105     "": "http://www.w3.org/2000/svg",
 106     }
 107
 108
 109 # wrap XMLElem.find, so the namespaces don't need to be given as an argument
 110 def find_xml_elem(obj, search, namespaces, *, all=False):
 111     if all:
 112         return obj.findall(search, namespaces=namespaces)
 113     return obj.find(search, namespaces=namespaces)
 114
 115 find_svg_elem = partial(find_xml_elem, namespaces=namespaces)
 116
 117
 118 def render_height(scene):
 119     return int(scene.render.resolution_y * scene.render.resolution_percentage / 100)
 120
 121
 122 def render_width(scene):
 123     return int(scene.render.resolution_x * scene.render.resolution_percentage / 100)
 124
 125
 126 def format_rgb(color):
 127     return 'rgb({}, {}, {})'.format(*(int(v * 255) for v in color))
 128
 129
 130 # stores the state of the render, used to differ between animation and single frame renders.
 131 class RenderState:
 132
 133     # Note that this flag is set to False only after the first frame
 134     # has been written to file.
 135     is_preview = True
 136
 137
 138 @persistent
 139 def render_init(scene):
 140     RenderState.is_preview = True
 141
 142
 143 @persistent
 144 def render_write(scene):
 145     RenderState.is_preview = False
 146
 147
 148 def is_preview_render(scene):
 149     return RenderState.is_preview or scene.svg_export.mode == 'FRAME'
 150
 151
 152 def create_path(scene):
 153     """Creates the output path for the svg file"""
 154     path = os.path.dirname(scene.render.frame_path())
 155     file_dir_path = os.path.dirname(bpy.data.filepath)
 156
 157     # try to use the given path if it is absolute
 158     if os.path.isabs(path):
 159         dirname = path
 160
 161     # otherwise, use current file's location as a start for the relative path
 162     elif bpy.data.is_saved and file_dir_path:
 163         dirname = os.path.normpath(os.path.join(file_dir_path, path))
 164
 165     # otherwise, use the folder from which blender was called as the start
 166     else:
 167         dirname = os.path.abspath(bpy.path.abspath(path))
 168
 169
 170     basename = bpy.path.basename(scene.render.filepath)
 171     if scene.svg_export.mode == 'FRAME':
 172         frame = "{:04d}".format(scene.frame_current)
 173     else:
 174         frame = "{:04d}-{:04d}".format(scene.frame_start, scene.frame_end)
 175
 176     return os.path.join(dirname, basename + frame + ".svg")
 177
 178
 179 class SVGExporterLinesetPanel(bpy.types.Panel):
 180     """Creates a Panel in the Render Layers context of the properties editor"""
 181     bl_idname = "RENDER_PT_SVGExporterLinesetPanel"
 182     bl_space_type = 'PROPERTIES'
 183     bl_label = "Freestyle Line Style SVG Export"
 184     bl_region_type = 'WINDOW'
 185     bl_context = "render_layer"
 186
 187     def draw(self, context):
 188         layout = self.layout
 189
 190         scene = context.scene
 191         svg = scene.svg_export
 192         freestyle = scene.render.layers.active.freestyle_settings
 193
 194         try:
 195             linestyle = freestyle.linesets.active.linestyle
 196
 197         except AttributeError:
 198             # Linestyles can be removed, so 0 linestyles is possible.
 199             # there is nothing to draw in those cases.
 200             # see https://developer.blender.org/T49855
 201             return
 202
 203         else:
 204             layout.active = (svg.use_svg_export and freestyle.mode != 'SCRIPT')
 205             row = layout.row()
 206             column = row.column()
 207             column.prop(linestyle, 'use_export_strokes')
 208
 209             column = row.column()
 210             column.active = svg.object_fill
 211             column.prop(linestyle, 'use_export_fills')
 212
 213             row = layout.row()
 214             row.prop(linestyle, "stroke_color_mode", expand=True)
 215
 216
 217 class SVGExport(bpy.types.PropertyGroup):
 218     """Implements the properties for the SVG exporter"""
 219     bl_idname = "RENDER_PT_svg_export"
 220
 221     use_svg_export: BoolProperty(
 222             name="SVG Export",
 223             description="Export Freestyle edges to an .svg format",
 224             )
 225     split_at_invisible: BoolProperty(
 226             name="Split at Invisible",
 227             description="Split the stroke at an invisible vertex",
 228             )
 229     object_fill: BoolProperty(
 230             name="Fill Contours",
 231             description="Fill the contour with the object's material color",
 232             )
 233     mode: EnumProperty(
 234             name="Mode",
 235             items=(
 236                 ('FRAME', "Frame", "Export a single frame", 0),
 237                 ('ANIMATION', "Animation", "Export an animation", 1),
 238                 ),
 239             default='FRAME',
 240             )
 241     line_join_type: EnumProperty(
 242             name="Linejoin",
 243             items=(
 244                 ('MITER', "Miter", "Corners are sharp", 0),
 245                 ('ROUND', "Round", "Corners are smoothed", 1),
 246                 ('BEVEL', "Bevel", "Corners are bevelled", 2),
 247                 ),
 248             default='ROUND',
 249             )
 250
 251
 252 class SVGExporterPanel(bpy.types.Panel):
 253     """Creates a Panel in the render context of the properties editor"""
 254     bl_idname = "RENDER_PT_SVGExporterPanel"
 255     bl_space_type = 'PROPERTIES'
 256     bl_label = "Freestyle SVG Export"
 257     bl_region_type = 'WINDOW'
 258     bl_context = "render"
 259
 260     def draw_header(self, context):
 261         self.layout.prop(context.scene.svg_export, "use_svg_export", text="")
 262
 263     def draw(self, context):
 264         layout = self.layout
 265
 266         scene = context.scene
 267         svg = scene.svg_export
 268         freestyle = scene.render.layers.active.freestyle_settings
 269
 270         layout.active = (svg.use_svg_export and freestyle.mode != 'SCRIPT')
 271
 272         row = layout.row()
 273         row.prop(svg, "mode", expand=True)
 274
 275         row = layout.row()
 276         row.prop(svg, "split_at_invisible")
 277         row.prop(svg, "object_fill")
 278
 279         row = layout.row()
 280         row.prop(svg, "line_join_type", expand=True)
 281
 282
 283 @persistent
 284 def svg_export_header(scene):
 285     if not (scene.render.use_freestyle and scene.svg_export.use_svg_export):
 286         return
 287
 288     # write the header only for the first frame when animation is being rendered
 289     if not is_preview_render(scene) and scene.frame_current != scene.frame_start:
 290         return
 291
 292     # this may fail still. The error is printed to the console.
 293     with open(create_path(scene), "w") as f:
 294         f.write(svg_primitive.format(render_width(scene), render_height(scene)))
 295
 296
 297 @persistent
 298 def svg_export_animation(scene):
 299     """makes an animation of the exported SVG file """
 300     render = scene.render
 301     svg = scene.svg_export
 302
 303     if render.use_freestyle and svg.use_svg_export and not is_preview_render(scene):
 304         write_animation(create_path(scene), scene.frame_start, render.fps)
 305
 306
 307 def write_animation(filepath, frame_begin, fps):
 308     """Adds animate tags to the specified file."""
 309     tree = et.parse(filepath)
 310     root = tree.getroot()
 311
 312     linesets = find_svg_elem(tree, ".//svg:g[@inkscape:groupmode='lineset']", all=True)
 313     for i, lineset in enumerate(linesets):
 314         name = lineset.get('id')
 315         frames = find_svg_elem(lineset, ".//svg:g[@inkscape:groupmode='frame']", all=True)
 316         n_of_frames = len(frames)
 317         keyTimes = ";".join(str(round(x / n_of_frames, 3)) for x in range(n_of_frames)) + ";1"
 318
 319         style = {
 320             'attributeName': 'display',
 321             'values': "none;" * (n_of_frames - 1) + "inline;none",
 322             'repeatCount': 'indefinite',
 323             'keyTimes': keyTimes,
 324             'dur': "{:.3f}s".format(n_of_frames / fps),
 325             }
 326
 327         for j, frame in enumerate(frames):
 328             id = 'anim_{}_{:06n}'.format(name, j + frame_begin)
 329             # create animate tag
 330             frame_anim = et.XML('<animate id="{}" begin="{:.3f}s" />'.format(id, (j - n_of_frames) / fps))
 331             # add per-lineset style attributes
 332             frame_anim.attrib.update(style)
 333             # add to the current frame
 334             frame.append(frame_anim)
 335
 336     # write SVG to file
 337     indent_xml(root)
 338     tree.write(filepath, encoding='ascii', xml_declaration=True)
 339
 340
 341 # - StrokeShaders - #
 342 class SVGPathShader(StrokeShader):
 343     """Stroke Shader for writing stroke data to a .svg file."""
 344     def __init__(self, name, style, filepath, res_y, split_at_invisible, stroke_color_mode, frame_current):
 345         StrokeShader.__init__(self)
 346         # attribute 'name' of 'StrokeShader' objects is not writable, so _name is used
 347         self._name = name
 348         self.filepath = filepath
 349         self.h = res_y
 350         self.frame_current = frame_current
 351         self.elements = []
 352         self.split_at_invisible = split_at_invisible
 353         self.stroke_color_mode = stroke_color_mode # BASE | FIRST | LAST
 354         self.style = style
 355
 356
 357     @classmethod
 358     def from_lineset(cls, lineset, filepath, res_y, split_at_invisible, use_stroke_color, frame_current, *, name=""):
 359         """Builds a SVGPathShader using data from the given lineset"""
 360         name = name or lineset.name
 361         linestyle = lineset.linestyle
 362         # extract style attributes from the linestyle and scene
 363         svg = getCurrentScene().svg_export
 364         style = {
 365             'fill': 'none',
 366             'stroke-width': linestyle.thickness,
 367             'stroke-linecap': linestyle.caps.lower(),
 368             'stroke-opacity': linestyle.alpha,
 369             'stroke': format_rgb(linestyle.color),
 370             'stroke-linejoin': svg.line_join_type.lower(),
 371             }
 372         # get dashed line pattern (if specified)
 373         if linestyle.use_dashed_line:
 374             style['stroke-dasharray'] = ",".join(str(elem) for elem in get_dashed_pattern(linestyle))
 375         # return instance
 376         return cls(name, style, filepath, res_y, split_at_invisible, use_stroke_color, frame_current)
 377
 378
 379     @staticmethod
 380     def pathgen(stroke, style, height, split_at_invisible, stroke_color_mode, f=lambda v: not v.attribute.visible):
 381         """Generator that creates SVG paths (as strings) from the current stroke """
 382         if len(stroke) <= 1:
 383             return ""
 384
 385         if stroke_color_mode != 'BASE':
 386             # try to use the color of the first or last vertex
 387             try:
 388                 index = 0 if stroke_color_mode == 'FIRST' else -1
 389                 color = format_rgb(stroke[index].attribute.color)
 390                 style["stroke"] = color
 391             except (ValueError, IndexError):
 392                 # default is linestyle base color
 393                 pass
 394
 395         # put style attributes into a single svg path definition
 396         path = '\n<path ' + "".join('{}="{}" '.format(k, v) for k, v in style.items()) + 'd=" M '
 397
 398         it = iter(stroke)
 399         # start first path
 400         yield path
 401         for v in it:
 402             x, y = v.point
 403             yield '{:.3f}, {:.3f} '.format(x, height - y)
 404             if split_at_invisible and v.attribute.visible is False:
 405                 # end current and start new path;
 406                 yield '" />' + path
 407                 # fast-forward till the next visible vertex
 408                 it = itertools.dropwhile(f, it)
 409                 # yield next visible vertex
 410                 svert = next(it, None)
 411                 if svert is None:
 412                     break
 413                 x, y = svert.point
 414                 yield '{:.3f}, {:.3f} '.format(x, height - y)
 415         # close current path
 416         yield '" />'
 417
 418     def shade(self, stroke):
 419         stroke_to_paths = "".join(self.pathgen(stroke, self.style, self.h, self.split_at_invisible, self.stroke_color_mode)).split("\n")
 420         # convert to actual XML. Empty strokes are empty strings; they are ignored.
 421         self.elements.extend(et.XML(elem) for elem in stroke_to_paths if elem) # if len(elem.strip()) > len(self.path))
 422
 423     def write(self):
 424         """Write SVG data tree to file """
 425         tree = et.parse(self.filepath)
 426         root = tree.getroot()
 427         name = self._name
 428         scene = bpy.context.scene
 429
 430         # create <g> for lineset as a whole (don't overwrite)
 431         # when rendering an animation, frames will be nested in here, otherwise a group of strokes and optionally fills.
 432         lineset_group = find_svg_elem(tree, ".//svg:g[@id='{}']".format(name))
 433         if lineset_group is None:
 434             lineset_group = et.XML('<g/>')
 435             lineset_group.attrib = {
 436                 'id': name,
 437                 'xmlns:inkscape': namespaces["inkscape"],
 438                 'inkscape:groupmode': 'lineset',
 439                 'inkscape:label': name,
 440                 }
 441             root.append(lineset_group)
 442
 443         # create <g> for the current frame
 444         id = "frame_{:04n}".format(self.frame_current)
 445
 446         stroke_group = et.XML("<g/>")
 447         stroke_group.attrib = {
 448             'xmlns:inkscape': namespaces["inkscape"],
 449             'inkscape:groupmode': 'layer',
 450             'id': 'strokes',
 451             'inkscape:label': 'strokes'
 452             }
 453         # nest the structure
 454         stroke_group.extend(self.elements)
 455         if scene.svg_export.mode == 'ANIMATION':
 456             frame_group = et.XML("<g/>")
 457             frame_group.attrib = {'id': id, 'inkscape:groupmode': 'frame', 'inkscape:label': id}
 458             frame_group.append(stroke_group)
 459             lineset_group.append(frame_group)
 460         else:
 461             lineset_group.append(stroke_group)
 462
 463         # write SVG to file
 464         print("SVG Export: writing to", self.filepath)
 465         indent_xml(root)
 466         tree.write(self.filepath, encoding='ascii', xml_declaration=True)
 467
 468
 469 class SVGFillBuilder:
 470     def __init__(self, filepath, height, name):
 471         self.filepath = filepath
 472         self._name = name
 473         self.stroke_to_fill = partial(self.stroke_to_svg, height=height)
 474
 475     @staticmethod
 476     def pathgen(vertices, path, height):
 477         yield path
 478         for point in vertices:
 479             x, y = point
 480             yield '{:.3f}, {:.3f} '.format(x, height - y)
 481         yield ' z" />'  # closes the path; connects the current to the first point
 482
 483
 484     @staticmethod
 485     def get_merged_strokes(strokes):
 486         def extend_stroke(stroke, vertices):
 487             for vert in map(StrokeVertex, vertices):
 488                 stroke.insert_vertex(vert, stroke.stroke_vertices_end())
 489             return stroke
 490
 491         base_strokes = tuple(stroke for stroke in strokes if not is_poly_clockwise(stroke))
 492         merged_strokes = OrderedDict((s, list()) for s in base_strokes)
 493
 494         for stroke in filter(is_poly_clockwise, strokes):
 495             for base in base_strokes:
 496                 # don't merge when diffuse colors don't match
 497                 if diffuse_from_stroke(stroke) != diffuse_from_stroke(stroke):
 498                     continue
 499                 # only merge when the 'hole' is inside the base
 500                 elif stroke_inside_stroke(stroke, base):
 501                     merged_strokes[base].append(stroke)
 502                     break
 503                 # if it isn't a hole, it is likely that there are two strokes belonging
 504                 # to the same object separated by another object. let's try to join them
 505                 elif (get_object_name(base) == get_object_name(stroke) and
 506                       diffuse_from_stroke(stroke) == diffuse_from_stroke(stroke)):
 507                     base = extend_stroke(base, (sv for sv in stroke))
 508                     break
 509             else:
 510                 # if all else fails, treat this stroke as a base stroke
 511                 merged_strokes.update({stroke:  []})
 512         return merged_strokes
 513
 514
 515     def stroke_to_svg(self, stroke, height, parameters=None):
 516         if parameters is None:
 517             *color, alpha = diffuse_from_stroke(stroke)
 518             color = tuple(int(255 * c) for c in color)
 519             parameters = {
 520                 'fill_rule': 'evenodd',
 521                 'stroke': 'none',
 522                 'fill-opacity': alpha,
 523                 'fill': 'rgb' + repr(color),
 524             }
 525         param_str = " ".join('{}="{}"'.format(k, v) for k, v in parameters.items())
 526         path = '<path {} d=" M '.format(param_str)
 527         vertices = (svert.point for svert in stroke)
 528         s = "".join(self.pathgen(vertices, path, height))
 529         result = et.XML(s)
 530         return result
 531
 532     def create_fill_elements(self, strokes):
 533         """Creates ElementTree objects by merging stroke objects together and turning them into SVG paths."""
 534         merged_strokes = self.get_merged_strokes(strokes)
 535         for k, v in merged_strokes.items():
 536             base = self.stroke_to_fill(k)
 537             fills = (self.stroke_to_fill(stroke).get("d") for stroke in v)
 538             merged_points = " ".join(fills)
 539             base.attrib['d'] += merged_points
 540             yield base
 541
 542     def write(self, strokes):
 543         """Write SVG data tree to file """
 544
 545         tree = et.parse(self.filepath)
 546         root = tree.getroot()
 547         scene = bpy.context.scene
 548         name = self._name
 549
 550         lineset_group = find_svg_elem(tree, ".//svg:g[@id='{}']".format(self._name))
 551         if lineset_group is None:
 552             lineset_group = et.XML('<g/>')
 553             lineset_group.attrib = {
 554                 'id': name,
 555                 'xmlns:inkscape': namespaces["inkscape"],
 556                 'inkscape:groupmode': 'lineset',
 557                 'inkscape:label': name,
 558                 }
 559             root.append(lineset_group)
 560             print('added new lineset group ', name)
 561
 562
 563         # <g> for the fills of the current frame
 564         fill_group = et.XML('<g/>')
 565         fill_group.attrib = {
 566             'xmlns:inkscape': namespaces["inkscape"],
 567             'inkscape:groupmode': 'layer',
 568             'inkscape:label': 'fills',
 569             'id': 'fills'
 570            }
 571
 572         fill_elements = self.create_fill_elements(strokes)
 573         fill_group.extend(reversed(tuple(fill_elements)))
 574         if scene.svg_export.mode == 'ANIMATION':
 575             # add the fills to the <g> of the current frame
 576             frame_group = find_svg_elem(lineset_group, ".//svg:g[@id='frame_{:04n}']".format(scene.frame_current))
 577             frame_group.insert(0, fill_group)
 578         else:
 579             lineset_group.insert(0, fill_group)
 580
 581         # write SVG to file
 582         indent_xml(root)
 583         tree.write(self.filepath, encoding='ascii', xml_declaration=True)
 584
 585
 586 def stroke_inside_stroke(a, b):
 587     box_a = BoundingBox.from_sequence(svert.point for svert in a)
 588     box_b = BoundingBox.from_sequence(svert.point for svert in b)
 589     return box_a.inside(box_b)
 590
 591
 592 def diffuse_from_stroke(stroke, curvemat=CurveMaterialF0D()):
 593     material = curvemat(Interface0DIterator(stroke))
 594     return material.diffuse
 595
 596 # - Callbacks - #
 597 class ParameterEditorCallback(object):
 598     """Object to store callbacks for the Parameter Editor in"""
 599     def lineset_pre(self, scene, layer, lineset):
 600         raise NotImplementedError()
 601
 602     def modifier_post(self, scene, layer, lineset):
 603         raise NotImplementedError()
 604
 605     def lineset_post(self, scene, layer, lineset):
 606         raise NotImplementedError()
 607
 608
 609
 610 class SVGPathShaderCallback(ParameterEditorCallback):
 611     @classmethod
 612     def poll(cls, scene, linestyle):
 613         return scene.render.use_freestyle and scene.svg_export.use_svg_export and linestyle.use_export_strokes
 614
 615     @classmethod
 616     def modifier_post(cls, scene, layer, lineset):
 617         if not cls.poll(scene, lineset.linestyle):
 618             return []
 619
 620         split = scene.svg_export.split_at_invisible
 621         stroke_color_mode = lineset.linestyle.stroke_color_mode
 622         cls.shader = SVGPathShader.from_lineset(
 623                 lineset, create_path(scene),
 624                 render_height(scene), split, stroke_color_mode, scene.frame_current, name=layer.name + '_' + lineset.name)
 625         return [cls.shader]
 626
 627     @classmethod
 628     def lineset_post(cls, scene, layer, lineset):
 629         if not cls.poll(scene, lineset.linestyle):
 630             return []
 631         cls.shader.write()
 632
 633
 634 class SVGFillShaderCallback(ParameterEditorCallback):
 635     @classmethod
 636     def poll(cls, scene, linestyle):
 637         return scene.render.use_freestyle and scene.svg_export.use_svg_export and scene.svg_export.object_fill and linestyle.use_export_fills
 638
 639     @classmethod
 640     def lineset_post(cls, scene, layer, lineset):
 641         if not cls.poll(scene, lineset.linestyle):
 642             return
 643
 644         # reset the stroke selection (but don't delete the already generated strokes)
 645         Operators.reset(delete_strokes=False)
 646         # Unary Predicates: visible and correct edge nature
 647         upred = AndUP1D(
 648             QuantitativeInvisibilityUP1D(0),
 649             OrUP1D(ExternalContourUP1D(),
 650                    pyNatureUP1D(Nature.BORDER)),
 651             )
 652         # select the new edges
 653         Operators.select(upred)
 654         # Binary Predicates
 655         bpred = AndBP1D(
 656             MaterialBP1D(),
 657             NotBP1D(pyZDiscontinuityBP1D()),
 658             )
 659         bpred = OrBP1D(bpred, AndBP1D(NotBP1D(bpred), AndBP1D(SameShapeIdBP1D(), MaterialBP1D())))
 660         # chain the edges
 661         Operators.bidirectional_chain(ChainPredicateIterator(upred, bpred))
 662         # export SVG
 663         collector = StrokeCollector()
 664         Operators.create(TrueUP1D(), [collector])
 665
 666         builder = SVGFillBuilder(create_path(scene), render_height(scene), layer.name + '_' + lineset.name)
 667         builder.write(collector.strokes)
 668         # make strokes used for filling invisible
 669         for stroke in collector.strokes:
 670             for svert in stroke:
 671                 svert.attribute.visible = False
 672
 673
 674
 675 def indent_xml(elem, level=0, indentsize=4):
 676     """Prettifies XML code (used in SVG exporter) """
 677     i = "\n" + level * " " * indentsize
 678     if len(elem):
 679         if not elem.text or not elem.text.strip():
 680             elem.text = i + " " * indentsize
 681         if not elem.tail or not elem.tail.strip():
 682             elem.tail = i
 683         for elem in elem:
 684             indent_xml(elem, level + 1)
 685         if not elem.tail or not elem.tail.strip():
 686             elem.tail = i
 687     elif level and (not elem.tail or not elem.tail.strip()):
 688         elem.tail = i
 689
 690
 691 def register_namespaces(namespaces=namespaces):
 692     for name, url in namespaces.items():
 693         if name != 'svg': # creates invalid xml
 694             et.register_namespace(name, url)
 695
 696 @persistent
 697 def handle_versions(self):
 698     # We don't modify startup file because it assumes to
 699     # have all the default values only.
 700     if not bpy.data.is_saved:
 701         return
 702
 703     # Revision https://developer.blender.org/rBA861519e44adc5674545fa18202dc43c4c20f2d1d
 704     # changed the default for fills.
 705     # fix by Sergey https://developer.blender.org/T46150
 706     if bpy.data.version <= (2, 76, 0):
 707         for linestyle in bpy.data.linestyles:
 708             linestyle.use_export_fills = True
 709
 710
 711
 712 classes = (
 713     SVGExporterPanel,
 714     SVGExporterLinesetPanel,
 715     SVGExport,
 716     )
 717
 718
 719 def register():
 720     linestyle = bpy.types.FreestyleLineStyle
 721     linestyle.use_export_strokes = BoolProperty(
 722             name="Export Strokes",
 723             description="Export strokes for this Line Style",
 724             default=True,
 725             )
 726     linestyle.stroke_color_mode = EnumProperty(
 727             name="Stroke Color Mode",
 728             items=(
 729                 ('BASE', "Base Color", "Use the linestyle's base color", 0),
 730                 ('FIRST', "First Vertex", "Use the color of a stroke's first vertex", 1),
 731                 ('FINAL', "Final Vertex", "Use the color of a stroke's final vertex", 2),
 732                 ),
 733             default='BASE',
 734             )
 735     linestyle.use_export_fills = BoolProperty(
 736             name="Export Fills",
 737             description="Export fills for this Line Style",
 738             default=False,
 739             )
 740
 741     for cls in classes:
 742         bpy.utils.register_class(cls)
 743     bpy.types.Scene.svg_export = PointerProperty(type=SVGExport)
 744
 745
 746     # add callbacks
 747     bpy.app.handlers.render_init.append(render_init)
 748     bpy.app.handlers.render_write.append(render_write)
 749     bpy.app.handlers.render_pre.append(svg_export_header)
 750     bpy.app.handlers.render_complete.append(svg_export_animation)
 751
 752     # manipulate shaders list
 753     parameter_editor.callbacks_modifiers_post.append(SVGPathShaderCallback.modifier_post)
 754     parameter_editor.callbacks_lineset_post.append(SVGPathShaderCallback.lineset_post)
 755     parameter_editor.callbacks_lineset_post.append(SVGFillShaderCallback.lineset_post)
 756
 757     # register namespaces
 758     register_namespaces()
 759
 760     # handle regressions
 761     bpy.app.handlers.version_update.append(handle_versions)
 762
 763
 764 def unregister():
 765
 766     for cls in classes:
 767         bpy.utils.unregister_class(cls)
 768     del bpy.types.Scene.svg_export
 769     linestyle = bpy.types.FreestyleLineStyle
 770     del linestyle.use_export_strokes
 771     del linestyle.use_export_fills
 772
 773     # remove callbacks
 774     bpy.app.handlers.render_init.remove(render_init)
 775     bpy.app.handlers.render_write.remove(render_write)
 776     bpy.app.handlers.render_pre.remove(svg_export_header)
 777     bpy.app.handlers.render_complete.remove(svg_export_animation)
 778
 779     # manipulate shaders list
 780     parameter_editor.callbacks_modifiers_post.remove(SVGPathShaderCallback.modifier_post)
 781     parameter_editor.callbacks_lineset_post.remove(SVGPathShaderCallback.lineset_post)
 782     parameter_editor.callbacks_lineset_post.remove(SVGFillShaderCallback.lineset_post)
 783
 784     bpy.app.handlers.version_update.remove(handle_versions)
 785
 786
 787 if __name__ == "__main__":
 788     register()