#!/usr/bin/python
#
# Important resources:
# lxml interface for walking SVG tree:
# http://codespeak.net/lxml/tutorial.html#elementpath
# Inkscape library for extracting paths from SVG:
# http://wiki.inkscape.org/wiki/index.php/Python_modules_for_extensions#simplepath.py
# Shapely computational geometry library:
# http://gispython.org/shapely/manual.html#multipolygons
# Embroidery file format documentation:
# http://www.achatina.de/sewing/main/TECHNICL.HTM

import sys
import traceback
sys.path.append("/usr/share/inkscape/extensions")
import os
import subprocess
from copy import deepcopy
import time
from itertools import chain, izip, groupby
from collections import deque
import inkex
import simplepath
import simplestyle
import simpletransform
from bezmisc import bezierlength, beziertatlength, bezierpointatt
from cspsubdiv import cspsubdiv
import cubicsuperpath
import math
import lxml.etree as etree
import shapely.geometry as shgeo
import shapely.affinity as affinity
import shapely.ops
import networkx
from pprint import pformat

import inkstitch
from inkstitch import _, cache, dbg, param, EmbroideryElement, get_nodes, SVG_POLYLINE_TAG, SVG_GROUP_TAG, PIXELS_PER_MM, get_viewbox_transform

class Fill(EmbroideryElement):
    def __init__(self, *args, **kwargs):
        super(Fill, self).__init__(*args, **kwargs)

    @property
    @param('auto_fill', _('Manually routed fill stitching'), type='toggle', inverse=True, default=True)
    def auto_fill(self):
        return self.get_boolean_param('auto_fill', True)

    @property
    @param('angle', _('Angle of lines of stitches'), unit='deg', type='float', default=0)
    @cache
    def angle(self):
        return math.radians(self.get_float_param('angle', 0))

    @property
    def color(self):
        return self.get_style("fill")

    @property
    @param('flip', _('Flip fill (start right-to-left)'), type='boolean', default=False)
    def flip(self):
        return self.get_boolean_param("flip", False)

    @property
    @param('row_spacing_mm', _('Spacing between rows'), unit='mm', type='float', default=0.25)
    def row_spacing(self):
        return max(self.get_float_param("row_spacing_mm", 0.25), 0.01)

    @property
    def end_row_spacing(self):
        return self.get_float_param("end_row_spacing_mm")

    @property
    @param('max_stitch_length_mm', _('Maximum fill stitch length'), unit='mm', type='float', default=3.0)
    def max_stitch_length(self):
        return max(self.get_float_param("max_stitch_length_mm", 3.0), 0.01)

    @property
    @param('staggers', _('Stagger rows this many times before repeating'), type='int', default=4)
    def staggers(self):
        return self.get_int_param("staggers", 4)

    @property
    @cache
    def paths(self):
        return self.flatten(self.parse_path())

    @property
    @cache
    def shape(self):
        poly_ary = []
        for sub_path in self.paths:
            point_ary = []
            last_pt = None
            for pt in sub_path:
                if (last_pt is not None):
                    vp = (pt[0] - last_pt[0], pt[1] - last_pt[1])
                    dp = math.sqrt(math.pow(vp[0], 2.0) + math.pow(vp[1], 2.0))
                    # dbg.write("dp %s\n" % dp)
                    if (dp > 0.01):
                        # I think too-close points confuse shapely.
                        point_ary.append(pt)
                        last_pt = pt
                else:
                    last_pt = pt
            if point_ary:
                poly_ary.append(point_ary)

        # shapely's idea of "holes" are to subtract everything in the second set
        # from the first. So let's at least make sure the "first" thing is the
        # biggest path.
        # TODO: actually figure out which things are holes and which are shells
        poly_ary.sort(key=lambda point_list: shgeo.Polygon(point_list).area, reverse=True)

        polygon = shgeo.MultiPolygon([(poly_ary[0], poly_ary[1:])])
        # print >> sys.stderr, "polygon valid:", polygon.is_valid
        return polygon

    @cache
    def east(self, angle):
        # "east" is the name of the direction that is to the right along a row
        return inkstitch.Point(1, 0).rotate(-angle)

    @cache
    def north(self, angle):
        return self.east(angle).rotate(math.pi / 2)

    def row_num(self, point, angle, row_spacing):
        return round((point * self.north(angle)) / row_spacing)

    def adjust_stagger(self, stitch, angle, row_spacing, max_stitch_length):
        row_num = self.row_num(stitch, angle, row_spacing)
        row_stagger = row_num % self.staggers
        stagger_offset = (float(row_stagger) / self.staggers) * max_stitch_length
        offset = ((stitch * self.east(angle)) - stagger_offset) % max_stitch_length

        return stitch - offset * self.east(angle)

    def intersect_region_with_grating(self, angle=None, row_spacing=None, end_row_spacing=None):
        if angle is None:
            angle = self.angle

        if row_spacing is None:
            row_spacing = self.row_spacing

        if end_row_spacing is None:
            end_row_spacing = self.end_row_spacing

        # the max line length I'll need to intersect the whole shape is the diagonal
        (minx, miny, maxx, maxy) = self.shape.bounds
        upper_left = inkstitch.Point(minx, miny)
        lower_right = inkstitch.Point(maxx, maxy)
        length = (upper_left - lower_right).length()
        half_length = length / 2.0

        # Now get a unit vector rotated to the requested angle.  I use -angle
        # because shapely rotates clockwise, but my geometry textbooks taught
        # me to consider angles as counter-clockwise from the X axis.
        direction = inkstitch.Point(1, 0).rotate(-angle)

        # and get a normal vector
        normal = direction.rotate(math.pi / 2)

        # I'll start from the center, move in the normal direction some amount,
        # and then walk left and right half_length in each direction to create
        # a line segment in the grating.
        center = inkstitch.Point((minx + maxx) / 2.0, (miny + maxy) / 2.0)

        # I need to figure out how far I need to go along the normal to get to
        # the edge of the shape.  To do that, I'll rotate the bounding box
        # angle degrees clockwise and ask for the new bounding box.  The max
        # and min y tell me how far to go.

        _, start, _, end = affinity.rotate(self.shape, angle, origin='center', use_radians=True).bounds

        # convert start and end to be relative to center (simplifies things later)
        start -= center.y
        end -= center.y

        height = abs(end - start)

        print >> dbg, "grating:", start, end, height, row_spacing, end_row_spacing

        # offset start slightly so that rows are always an even multiple of
        # row_spacing_px from the origin.  This makes it so that abutting
        # fill regions at the same angle and spacing always line up nicely.
        start -= (start + normal * center) % row_spacing

        rows = []

        current_row_y = start

        while current_row_y < end:
            p0 = center + normal * current_row_y + direction * half_length
            p1 = center + normal * current_row_y - direction * half_length
            endpoints = [p0.as_tuple(), p1.as_tuple()]
            grating_line = shgeo.LineString(endpoints)

            res = grating_line.intersection(self.shape)

            if (isinstance(res, shgeo.MultiLineString)):
                runs = map(lambda line_string: line_string.coords, res.geoms)
            else:
                if res.is_empty or len(res.coords) == 1:
                    # ignore if we intersected at a single point or no points
                    runs = []
                else:
                    runs = [res.coords]

            if runs:
                runs.sort(key=lambda seg: (inkstitch.Point(*seg[0]) - upper_left).length())

                if self.flip:
                    runs.reverse()
                    runs = map(lambda run: tuple(reversed(run)), runs)

                rows.append(runs)

            if end_row_spacing:
                current_row_y += row_spacing + (end_row_spacing - row_spacing) * ((current_row_y - start) / height)
            else:
                current_row_y += row_spacing

        return rows

    def make_quadrilateral(self, segment1, segment2):
        return shgeo.Polygon((segment1[0], segment1[1], segment2[1], segment2[0], segment1[0]))

    def is_same_run(self, segment1, segment2):
        if shgeo.LineString(segment1).distance(shgeo.LineString(segment2)) > self.row_spacing * 1.1:
            return False

        quad = self.make_quadrilateral(segment1, segment2)
        quad_area = quad.area
        intersection_area = self.shape.intersection(quad).area

        return (intersection_area / quad_area) >= 0.9

    def pull_runs(self, rows):
        # Given a list of rows, each containing a set of line segments,
        # break the area up into contiguous patches of line segments.
        #
        # This is done by repeatedly pulling off the first line segment in
        # each row and calling that a shape.  We have to be careful to make
        # sure that the line segments are part of the same shape.  Consider
        # the letter "H", with an embroidery angle of 45 degrees.  When
        # we get to the bottom of the lower left leg, the next row will jump
        # over to midway up the lower right leg.  We want to stop there and
        # start a new patch.

        # for row in rows:
        #    print >> sys.stderr, len(row)

        # print >>sys.stderr, "\n".join(str(len(row)) for row in rows)

        runs = []
        count = 0
        while (len(rows) > 0):
            run = []
            prev = None

            for row_num in xrange(len(rows)):
                row = rows[row_num]
                first, rest = row[0], row[1:]

                # TODO: only accept actually adjacent rows here
                if prev is not None and not self.is_same_run(prev, first):
                    break

                run.append(first)
                prev = first

                rows[row_num] = rest

            # print >> sys.stderr, len(run)
            runs.append(run)
            rows = [row for row in rows if len(row) > 0]

            count += 1

        return runs

    def stitch_row(self, patch, beg, end, angle, row_spacing, max_stitch_length):
        # We want our stitches to look like this:
        #
        # ---*-----------*-----------
        # ------*-----------*--------
        # ---------*-----------*-----
        # ------------*-----------*--
        # ---*-----------*-----------
        #
        # Each successive row of stitches will be staggered, with
        # num_staggers rows before the pattern repeats.  A value of
        # 4 gives a nice fill while hiding the needle holes.  The
        # first row is offset 0%, the second 25%, the third 50%, and
        # the fourth 75%.
        #
        # Actually, instead of just starting at an offset of 0, we
        # can calculate a row's offset relative to the origin.  This
        # way if we have two abutting fill regions, they'll perfectly
        # tile with each other.  That's important because we often get
        # abutting fill regions from pull_runs().


        beg = inkstitch.Point(*beg)
        end = inkstitch.Point(*end)

        row_direction = (end - beg).unit()
        segment_length = (end - beg).length()

        # only stitch the first point if it's a reasonable distance away from the
        # last stitch
        if not patch.stitches or (beg - patch.stitches[-1]).length() > 0.5 * PIXELS_PER_MM:
            patch.add_stitch(beg)

        first_stitch = self.adjust_stagger(beg, angle, row_spacing, max_stitch_length)

        # we might have chosen our first stitch just outside this row, so move back in
        if (first_stitch - beg) * row_direction < 0:
            first_stitch += row_direction * max_stitch_length

        offset = (first_stitch - beg).length()

        while offset < segment_length:
            patch.add_stitch(beg + offset * row_direction)
            offset += max_stitch_length

        if (end - patch.stitches[-1]).length() > 0.1 * PIXELS_PER_MM:
            patch.add_stitch(end)


    def section_to_patch(self, group_of_segments, angle=None, row_spacing=None, max_stitch_length=None):
        if max_stitch_length is None:
            max_stitch_length = self.max_stitch_length

        if row_spacing is None:
            row_spacing = self.row_spacing

        if angle is None:
            angle = self.angle

        # print >> sys.stderr, len(groups_of_segments)

        patch = Patch(color=self.color)
        first_segment = True
        swap = False
        last_end = None

        for segment in group_of_segments:
            (beg, end) = segment

            if (swap):
                (beg, end) = (end, beg)

            self.stitch_row(patch, beg, end, angle, row_spacing, max_stitch_length)

            swap = not swap

        return patch

    def to_patches(self, last_patch):
        rows_of_segments = self.intersect_region_with_grating()
        groups_of_segments = self.pull_runs(rows_of_segments)

        return [self.section_to_patch(group) for group in groups_of_segments]


class MaxQueueLengthExceeded(Exception):
    pass

class AutoFill(Fill):
    @property
    @param('auto_fill', _('Automatically routed fill stitching'), type='toggle', default=True)
    def auto_fill(self):
        return self.get_boolean_param('auto_fill', True)

    @property
    @cache
    def outline(self):
        return self.shape.boundary[0]

    @property
    @cache
    def outline_length(self):
        return self.outline.length

    @property
    def flip(self):
        return False

    @property
    @param('running_stitch_length_mm', _('Running stitch length (traversal between sections)'), unit='mm', type='float', default=1.5)
    def running_stitch_length(self):
        return max(self.get_float_param("running_stitch_length_mm", 1.5), 0.01)

    @property
    @param('fill_underlay', _('Underlay'), type='toggle', group=_('AutoFill Underlay'), default=False)
    def fill_underlay(self):
        return self.get_boolean_param("fill_underlay", default=False)

    @property
    @param('fill_underlay_angle', _('Fill angle (default: fill angle + 90 deg)'), unit='deg', group=_('AutoFill Underlay'), type='float')
    @cache
    def fill_underlay_angle(self):
        underlay_angle = self.get_float_param("fill_underlay_angle")

        if underlay_angle:
            return math.radians(underlay_angle)
        else:
            return self.angle + math.pi / 2.0

    @property
    @param('fill_underlay_row_spacing_mm', _('Row spacing (default: 3x fill row spacing)'), unit='mm', group=_('AutoFill Underlay'), type='float')
    @cache
    def fill_underlay_row_spacing(self):
        return self.get_float_param("fill_underlay_row_spacing_mm") or self.row_spacing * 3

    @property
    @param('fill_underlay_max_stitch_length_mm', _('Max stitch length'), unit='mm', group=_('AutoFill Underlay'), type='float')
    @cache
    def fill_underlay_max_stitch_length(self):
        return self.get_float_param("fill_underlay_max_stitch_length_mm") or self.max_stitch_length

    def which_outline(self, coords):
        """return the index of the outline on which the point resides

        Index 0 is the outer boundary of the fill region.  1+ are the
        outlines of the holes.
        """

        # I'd use an intersection check, but floating point errors make it
        # fail sometimes.

        point = shgeo.Point(*coords)
        outlines = list(enumerate(self.shape.boundary))
        closest = min(outlines, key=lambda (index, outline): outline.distance(point))

        return closest[0]

    def project(self, coords, outline_index):
        """project the point onto the specified outline

        This returns the distance along the outline at which the point resides.
        """

        return self.shape.boundary.project(shgeo.Point(*coords))

    def build_graph(self, segments, angle, row_spacing):
        """build a graph representation of the grating segments

        This function builds a specialized graph (as in graph theory) that will
        help us determine a stitching path.  The idea comes from this paper:

        http://www.sciencedirect.com/science/article/pii/S0925772100000158

        The goal is to build a graph that we know must have an Eulerian Path.
        An Eulerian Path is a path from edge to edge in the graph that visits
        every edge exactly once and ends at the node it started at.  Algorithms
        exist to build such a path, and we'll use Hierholzer's algorithm.

        A graph must have an Eulerian Path if every node in the graph has an
        even number of edges touching it.  Our goal here is to build a graph
        that will have this property.

        Based on the paper linked above, we'll build the graph as follows:

          * nodes are the endpoints of the grating segments, where they meet
            with the outer outline of the region the outlines of the interior
            holes in the region.
          * edges are:
            * each section of the outer and inner outlines of the region,
              between nodes
            * double every other edge in the outer and inner hole outlines

        Doubling up on some of the edges seems as if it will just mean we have
        to stitch those spots twice.  This may be true, but it also ensures
        that every node has 4 edges touching it, ensuring that a valid stitch
        path must exist.
        """

        graph = networkx.MultiGraph()

        # First, add the grating segments as edges.  We'll use the coordinates
        # of the endpoints as nodes, which networkx will add automatically.
        for segment in segments:
            # networkx allows us to label nodes with arbitrary data.  We'll
            # mark this one as a grating segment.
            graph.add_edge(*segment, key="segment")

        for node in graph.nodes():
            outline_index = self.which_outline(node)
            outline_projection = self.project(node, outline_index)

            # Tag each node with its index and projection.
            graph.add_node(node, index=outline_index, projection=outline_projection)

        nodes = list(graph.nodes(data=True)) # returns a list of tuples: [(node, {data}), (node, {data}) ...]
        nodes.sort(key=lambda node: (node[1]['index'], node[1]['projection']))

        for outline_index, nodes in groupby(nodes, key=lambda node: node[1]['index']):
            nodes = [ node for node, data in nodes ]

            # heuristic: change the order I visit the nodes in the outline if necessary.
            # If the start and endpoints are in the same row, I can't tell which row
            # I should treat it as being in.
            for i in xrange(len(nodes)):
                row0 = self.row_num(inkstitch.Point(*nodes[0]), angle, row_spacing)
                row1 = self.row_num(inkstitch.Point(*nodes[1]), angle, row_spacing)

                if row0 == row1:
                    nodes = nodes[1:] + [nodes[0]]
                else:
                    break

            # heuristic: it's useful to try to keep the duplicated edges in the same rows.
            # this prevents the BFS from having to search a ton of edges.
            row_num = min(row0, row1)
            if row_num % 2 == 0:
                edge_set = 0
            else:
                edge_set = 1

            #print >> sys.stderr, outline_index, "es", edge_set, "rn", row_num, inkstitch.Point(*nodes[0]) * self.north(angle), inkstitch.Point(*nodes[1]) * self.north(angle)

            # add an edge between each successive node
            for i, (node1, node2) in enumerate(zip(nodes, nodes[1:] + [nodes[0]])):
                graph.add_edge(node1, node2, key="outline")

                # duplicate edges contained in every other row (exactly half
                # will be duplicated)
                row_num = min(self.row_num(inkstitch.Point(*node1), angle, row_spacing),
                              self.row_num(inkstitch.Point(*node2), angle, row_spacing))

                # duplicate every other edge around this outline
                if i % 2 == edge_set:
                    graph.add_edge(node1, node2, key="extra")


        if not networkx.is_eulerian(graph):
            raise Exception(_("Unable to autofill.  This most often happens because your shape is made up of multiple sections that aren't connected."))

        return graph

    def node_list_to_edge_list(self, node_list):
        return zip(node_list[:-1], node_list[1:])

    def bfs_for_loop(self, graph, starting_node, max_queue_length=2000):
        to_search = deque()
        to_search.appendleft(([starting_node], set(), 0))

        while to_search:
            if len(to_search) > max_queue_length:
                raise MaxQueueLengthExceeded()

            path, visited_edges, visited_segments = to_search.pop()
            ending_node = path[-1]

            # get a list of neighbors paired with the key of the edge I can follow to get there
            neighbors = [
                        (node, key)
                            for node, adj in graph.adj[ending_node].iteritems()
                            for key in adj
                    ]

            # heuristic: try grating segments first
            neighbors.sort(key=lambda (dest, key): key == "segment", reverse=True)

            for next_node, key in neighbors:
                # skip if I've already followed this edge
                edge = (tuple(sorted((ending_node, next_node))), key)
                if edge in visited_edges:
                    continue

                new_path = path + [next_node]

                if key == "segment":
                    new_visited_segments = visited_segments + 1
                else:
                    new_visited_segments = visited_segments

                if next_node == starting_node:
                    # ignore trivial loops (down and back a doubled edge)
                    if len(new_path) > 3:
                        return self.node_list_to_edge_list(new_path), new_visited_segments

                new_visited_edges = visited_edges.copy()
                new_visited_edges.add(edge)

                to_search.appendleft((new_path, new_visited_edges, new_visited_segments))

    def find_loop(self, graph, starting_nodes):
        """find a loop in the graph that is connected to the existing path

        Start at a candidate node and search through edges to find a path
        back to that node.  We'll use a breadth-first search (BFS) in order to
        find the shortest available loop.

        In most cases, the BFS should not need to search far to find a loop.
        The queue should stay relatively short.

        An added heuristic will be used: if the BFS queue's length becomes
        too long, we'll abort and try a different starting point.  Due to
        the way we've set up the graph, there's bound to be a better choice
        somewhere else.
        """

        #loop = self.simple_loop(graph, starting_nodes[-2])

        #if loop:
        #    print >> sys.stderr, "simple_loop success"
        #    starting_nodes.pop()
        #    starting_nodes.pop()
        #    return loop

        loop = None
        retry = []
        max_queue_length = 2000

        while not loop:
            while not loop and starting_nodes:
                starting_node = starting_nodes.pop()
                #print >> sys.stderr, "find loop from", starting_node

                try:
                    # Note: if bfs_for_loop() returns None, no loop can be
                    # constructed from the starting_node (because the
                    # necessary edges have already been consumed).  In that
                    # case we discard that node and try the next.
                    loop = self.bfs_for_loop(graph, starting_node, max_queue_length)

                    if not loop:
                        print >> dbg, "failed on", starting_node
                        dbg.flush()
                except MaxQueueLengthExceeded:
                    print >> dbg, "gave up on", starting_node
                    dbg.flush()
                    # We're giving up on this node for now.  We could try
                    # this node again later, so add it to the bottm of the
                    # stack.
                    retry.append(starting_node)

            # Darn, couldn't find a loop.  Try harder.
            starting_nodes.extendleft(retry)
            max_queue_length *= 2

        starting_nodes.extendleft(retry)
        return loop

    def insert_loop(self, path, loop):
        """insert a sub-loop into an existing path

        The path will be a series of edges describing a path through the graph
        that ends where it starts.  The loop will be similar, and its starting
        point will be somewhere along the path.

        Insert the loop into the path, resulting in a longer path.

        Both the path and the loop will be a list of edges specified as a
        start and end point.  The points will be specified in order, such
        that they will look like this:

        ((p1, p2), (p2, p3), (p3, p4) ... (pn, p1))

        path will be modified in place.
        """

        loop_start = loop[0][0]

        for i, (start, end) in enumerate(path):
            if start == loop_start:
                break

        path[i:i] = loop

    def find_stitch_path(self, graph, segments):
        """find a path that visits every grating segment exactly once

        Theoretically, we just need to find an Eulerian Path in the graph.
        However, we don't actually care whether every single edge is visited.
        The edges on the outline of the region are only there to help us get
        from one grating segment to the next.

        We'll build a "cycle" (a path that ends where it starts) using
        Hierholzer's algorithm.  We'll stop once we've visited every grating
        segment.

        Hierholzer's algorithm says to select an arbitrary starting node at
        each step.  In order to produce a reasonable stitch path, we'll select
        the vertex carefully such that we get back-and-forth traversal like
        mowing a lawn.

        To do this, we'll use a simple heuristic: try to start from nodes in
        the order of most-recently-visited first.
        """

        original_graph = graph
        graph = graph.copy()
        num_segments = len(segments)
        segments_visited = 0
        nodes_visited = deque()

        # start with a simple loop: down one segment and then back along the
        # outer border to the starting point.
        path = [segments[0], list(reversed(segments[0]))]

        graph.remove_edges_from(path)

        segments_visited += 1
        nodes_visited.extend(segments[0])

        while segments_visited < num_segments:
            result = self.find_loop(graph, nodes_visited)

            if not result:
                print >> sys.stderr, _("Unexpected error while generating fill stitches. Please send your SVG file to lexelby@github.")
                break

            loop, segments = result

            print >> dbg, "found loop:", loop
            dbg.flush()

            segments_visited += segments
            nodes_visited += [edge[0] for edge in loop]
            graph.remove_edges_from(loop)

            self.insert_loop(path, loop)

            #if segments_visited >= 12:
            #    break

        # Now we have a loop that covers every grating segment.  It returns to
        # where it started, which is unnecessary, so we'll snip the last bit off.
        #while original_graph.has_edge(*path[-1], key="outline"):
        #    path.pop()

        return path

    def collapse_sequential_outline_edges(self, graph, path):
        """collapse sequential edges that fall on the same outline

        When the path follows multiple edges along the outline of the region,
        replace those edges with the starting and ending points.  We'll use
        these to stitch along the outline later on.
        """

        start_of_run = None
        new_path = []

        for edge in path:
            if graph.has_edge(*edge, key="segment"):
                if start_of_run:
                    # close off the last run
                    new_path.append((start_of_run, edge[0]))
                    start_of_run = None

                new_path.append(edge)
            else:
                if not start_of_run:
                    start_of_run = edge[0]

        if start_of_run:
            # if we were still in a run, close it off
            new_path.append((start_of_run, edge[1]))

        return new_path

    def outline_distance(self, outline, p1, p2):
        # how far around the outline (and in what direction) do I need to go
        # to get from p1 to p2?

        p1_projection = outline.project(shgeo.Point(p1))
        p2_projection = outline.project(shgeo.Point(p2))

        distance = p2_projection - p1_projection

        if abs(distance) > self.outline_length / 2.0:
            # if we'd have to go more than halfway around, it's faster to go
            # the other way
            if distance < 0:
                return distance + self.outline_length
            elif distance > 0:
                return distance - self.outline_length
            else:
                # this ought not happen, but just for completeness, return 0 if
                # p1 and p0 are the same point
                return 0
        else:
            return distance

    def connect_points(self, patch, start, end):
        outline_index = self.which_outline(start)
        outline = self.shape.boundary[outline_index]

        pos = outline.project(shgeo.Point(start))
        distance = self.outline_distance(outline, start, end)
        stitches = abs(int(distance / self.running_stitch_length))

        direction = math.copysign(1.0, distance)
        one_stitch = self.running_stitch_length * direction

        print >> dbg, "connect_points:", outline_index, start, end, distance, stitches, direction
        dbg.flush()

        patch.add_stitch(inkstitch.Point(*start))

        for i in xrange(stitches):
            pos = (pos + one_stitch) % self.outline_length

            patch.add_stitch(inkstitch.Point(*outline.interpolate(pos).coords[0]))

        end = inkstitch.Point(*end)
        if (end - patch.stitches[-1]).length() > 0.1 * PIXELS_PER_MM:
            patch.add_stitch(end)

        print >> dbg, "end connect_points"
        dbg.flush()

    def path_to_patch(self, graph, path, angle, row_spacing, max_stitch_length):
        path = self.collapse_sequential_outline_edges(graph, path)

        patch = Patch(color=self.color)
        #patch.add_stitch(inkstitch.Point(*path[0][0]))

        #for edge in path:
        #    patch.add_stitch(inkstitch.Point(*edge[1]))

        for edge in path:
            if graph.has_edge(*edge, key="segment"):
                self.stitch_row(patch, edge[0], edge[1], angle, row_spacing, max_stitch_length)
            else:
                self.connect_points(patch, *edge)

        return patch

    def do_auto_fill(self, angle, row_spacing, max_stitch_length, starting_point=None):
        patches = []

        print >> dbg, "start do_auto_fill"
        dbg.flush()

        rows_of_segments = self.intersect_region_with_grating(angle, row_spacing)
        segments = [segment for row in rows_of_segments for segment in row]

        graph = self.build_graph(segments, angle, row_spacing)
        path = self.find_stitch_path(graph, segments)

        if starting_point:
            patch = Patch(self.color)
            self.connect_points(patch, starting_point, path[0][0])
            patches.append(patch)

        patches.append(self.path_to_patch(graph, path, angle, row_spacing, max_stitch_length))

        print >> dbg, "end do_auto_fill"
        dbg.flush()

        return patches


    def to_patches(self, last_patch):
        patches = []

        if last_patch is None:
            starting_point = None
        else:
            nearest_point = self.outline.interpolate(self.outline.project(shgeo.Point(last_patch.stitches[-1])))
            starting_point = inkstitch.Point(*nearest_point.coords[0])

        if self.fill_underlay:
            patches.extend(self.do_auto_fill(self.fill_underlay_angle, self.fill_underlay_row_spacing, self.fill_underlay_max_stitch_length, starting_point))
            starting_point = patches[-1].stitches[-1]

        patches.extend(self.do_auto_fill(self.angle, self.row_spacing, self.max_stitch_length, starting_point))

        print >> dbg, "end AutoFill.to_patches"
        dbg.flush()

        return patches


class Stroke(EmbroideryElement):
    @property
    @param('satin_column', _('Satin stitch along paths'), type='toggle', inverse=True)
    def satin_column(self):
        return self.get_boolean_param("satin_column")

    @property
    def color(self):
        return self.get_style("stroke")

    @property
    @cache
    def width(self):
        stroke_width = self.get_style("stroke-width")

        if stroke_width.endswith("px"):
            stroke_width = stroke_width[:-2]

        return float(stroke_width)

    @property
    def dashed(self):
        return self.get_style("stroke-dasharray") is not None

    @property
    @param('running_stitch_length_mm', _('Running stitch length'), unit='mm', type='float', default=1.5)
    def running_stitch_length(self):
        return max(self.get_float_param("running_stitch_length_mm", 1.5), 0.01)

    @property
    @param('zigzag_spacing_mm', _('Zig-zag spacing (peak-to-peak)'), unit='mm', type='float', default=0.4)
    @cache
    def zigzag_spacing(self):
        return max(self.get_float_param("zigzag_spacing_mm", 0.4), 0.01)

    @property
    @param('repeats', _('Repeats'), type='int', default="1")
    def repeats(self):
        return self.get_int_param("repeats", 1)

    @property
    def paths(self):
        return self.flatten(self.parse_path())

    def is_running_stitch(self):
        # stroke width <= 0.5 pixels is deprecated in favor of dashed lines
        return self.dashed or self.width <= 0.5

    def stroke_points(self, emb_point_list, zigzag_spacing, stroke_width):
        patch = Patch(color=self.color)
        p0 = emb_point_list[0]
        rho = 0.0
        side = 1
        last_segment_direction = None

        for repeat in xrange(self.repeats):
            if repeat % 2 == 0:
                order = range(1, len(emb_point_list))
            else:
                order = range(-2, -len(emb_point_list) - 1, -1)

            for segi in order:
                p1 = emb_point_list[segi]

                # how far we have to go along segment
                seg_len = (p1 - p0).length()
                if (seg_len == 0):
                    continue

                # vector pointing along segment
                along = (p1 - p0).unit()

                # vector pointing to edge of stroke width
                perp = along.rotate_left() * (stroke_width * 0.5)

                if stroke_width == 0.0 and last_segment_direction is not None:
                    if abs(1.0 - along * last_segment_direction) > 0.5:
                        # if greater than 45 degree angle, stitch the corner
                        rho = zigzag_spacing
                        patch.add_stitch(p0)

                # iteration variable: how far we are along segment
                while (rho <= seg_len):
                    left_pt = p0 + along * rho + perp * side
                    patch.add_stitch(left_pt)
                    rho += zigzag_spacing
                    side = -side

                p0 = p1
                last_segment_direction = along
                rho -= seg_len

            if (p0 - patch.stitches[-1]).length() > 0.1:
                patch.add_stitch(p0)

        return patch

    def to_patches(self, last_patch):
        patches = []

        for path in self.paths:
            path = [inkstitch.Point(x, y) for x, y in path]
            if self.is_running_stitch():
                patch = self.stroke_points(path, self.running_stitch_length, stroke_width=0.0)
            else:
                patch = self.stroke_points(path, self.zigzag_spacing / 2.0, stroke_width=self.width)

            patches.append(patch)

        return patches


class SatinColumn(EmbroideryElement):
    def __init__(self, *args, **kwargs):
        super(SatinColumn, self).__init__(*args, **kwargs)

    @property
    @param('satin_column', _('Custom satin column'), type='toggle')
    def satin_column(self):
        return self.get_boolean_param("satin_column")

    @property
    def color(self):
        return self.get_style("stroke")

    @property
    @param('zigzag_spacing_mm', _('Zig-zag spacing (peak-to-peak)'), unit='mm', type='float', default=0.4)
    def zigzag_spacing(self):
        # peak-to-peak distance between zigzags
        return max(self.get_float_param("zigzag_spacing_mm", 0.4), 0.01)

    @property
    @param('pull_compensation_mm', _('Pull compensation'), unit='mm', type='float')
    def pull_compensation(self):
        # In satin stitch, the stitches have a tendency to pull together and
        # narrow the entire column.  We can compensate for this by stitching
        # wider than we desire the column to end up.
        return self.get_float_param("pull_compensation_mm", 0)

    @property
    @param('contour_underlay', _('Contour underlay'), type='toggle', group=_('Contour Underlay'))
    def contour_underlay(self):
        # "Contour underlay" is stitching just inside the rectangular shape
        # of the satin column; that is, up one side and down the other.
        return self.get_boolean_param("contour_underlay")

    @property
    @param('contour_underlay_stitch_length_mm', _('Stitch length'), unit='mm', group=_('Contour Underlay'), type='float', default=1.5)
    def contour_underlay_stitch_length(self):
        return max(self.get_float_param("contour_underlay_stitch_length_mm", 1.5), 0.01)

    @property
    @param('contour_underlay_inset_mm', _('Contour underlay inset amount'), unit='mm', group=_('Contour Underlay'), type='float', default=0.4)
    def contour_underlay_inset(self):
        # how far inside the edge of the column to stitch the underlay
        return self.get_float_param("contour_underlay_inset_mm", 0.4)

    @property
    @param('center_walk_underlay', _('Center-walk underlay'), type='toggle', group=_('Center-Walk Underlay'))
    def center_walk_underlay(self):
        # "Center walk underlay" is stitching down and back in the centerline
        # between the two sides of the satin column.
        return self.get_boolean_param("center_walk_underlay")

    @property
    @param('center_walk_underlay_stitch_length_mm', _('Stitch length'), unit='mm', group=_('Center-Walk Underlay'), type='float', default=1.5)
    def center_walk_underlay_stitch_length(self):
        return max(self.get_float_param("center_walk_underlay_stitch_length_mm", 1.5), 0.01)

    @property
    @param('zigzag_underlay', _('Zig-zag underlay'), type='toggle', group=_('Zig-zag Underlay'))
    def zigzag_underlay(self):
        return self.get_boolean_param("zigzag_underlay")

    @property
    @param('zigzag_underlay_spacing_mm', _('Zig-Zag spacing (peak-to-peak)'), unit='mm', group=_('Zig-zag Underlay'), type='float', default=3)
    def zigzag_underlay_spacing(self):
        return max(self.get_float_param("zigzag_underlay_spacing_mm", 3), 0.01)

    @property
    @param('zigzag_underlay_inset_mm', _('Inset amount (default: half of contour underlay inset)'), unit='mm', group=_('Zig-zag Underlay'), type='float')
    def zigzag_underlay_inset(self):
        # how far in from the edge of the satin the points in the zigzags
        # should be

        # Default to half of the contour underlay inset.  That is, if we're
        # doing both contour underlay and zigzag underlay, make sure the
        # points of the zigzag fall outside the contour underlay but inside
        # the edges of the satin column.
        return self.get_float_param("zigzag_underlay_inset_mm") or self.contour_underlay_inset / 2.0

    @property
    @cache
    def csp(self):
        return self.parse_path()

    @property
    @cache
    def flattened_beziers(self):
        if len(self.csp) == 2:
            return self.simple_flatten_beziers()
        else:
            return self.flatten_beziers_with_rungs()


    def flatten_beziers_with_rungs(self):
        input_paths = [self.flatten([path]) for path in self.csp]
        input_paths = [shgeo.LineString(path[0]) for path in input_paths]

        paths = input_paths[:]
        paths.sort(key=lambda path: path.length, reverse=True)

        # Imagine a satin column as a curvy ladder.
        # The two long paths are the "rails" of the ladder.  The remainder are
        # the "rungs".
        rails = paths[:2]
        rungs = shgeo.MultiLineString(paths[2:])

        # The rails should stay in the order they were in the original CSP.
        # (this lets the user control where the satin starts and ends)
        rails.sort(key=lambda rail: input_paths.index(rail))

        result = []

        for rail in rails:
            if not rail.is_simple:
                self.fatal(_("One or more rails crosses itself, and this is not allowed.  Please split into multiple satin columns."))

            # handle null intersections here?
            linestrings = shapely.ops.split(rail, rungs)

            print >> dbg, "rails and rungs", [str(rail) for rail in rails], [str(rung) for rung in rungs]
            if len(linestrings.geoms) < len(rungs.geoms) + 1:
                self.fatal(_("satin column: One or more of the rungs doesn't intersect both rails.") + "  " + _("Each rail should intersect both rungs once."))
            elif len(linestrings.geoms) > len(rungs.geoms) + 1:
                self.fatal(_("satin column: One or more of the rungs intersects the rails more than once.") + "  " + _("Each rail should intersect both rungs once."))

            paths = [[inkstitch.Point(*coord) for coord in ls.coords] for ls in linestrings.geoms]
            result.append(paths)

        return zip(*result)


    def simple_flatten_beziers(self):
        # Given a pair of paths made up of bezier segments, flatten
        # each individual bezier segment into line segments that approximate
        # the curves.  Retain the divisions between beziers -- we'll use those
        # later.

        paths = []

        for path in self.csp:
            # See the documentation in the parent class for parse_path() for a
            # description of the format of the CSP.  Each bezier is constructed
            # using two neighboring 3-tuples in the list.

            flattened_path = []

            # iterate over pairs of 3-tuples
            for prev, current in zip(path[:-1], path[1:]):
                flattened_segment = self.flatten([[prev, current]])
                flattened_segment = [inkstitch.Point(x, y) for x, y in flattened_segment[0]]
                flattened_path.append(flattened_segment)

            paths.append(flattened_path)

        return zip(*paths)

    def validate_satin_column(self):
        # The node should have exactly two paths with no fill.  Each
        # path should have the same number of points, meaning that they
        # will both be made up of the same number of bezier curves.

        node_id = self.node.get("id")

        if self.get_style("fill") is not None:
            self.fatal(_("satin column: object %s has a fill (but should not)") % node_id)

        if len(self.csp) == 2:
            if len(self.csp[0]) != len(self.csp[1]):
                self.fatal(_("satin column: object %(id)s has two paths with an unequal number of points (%(length1)d and %(length2)d)") % \
                             dict(id=node_id, length1=len(self.csp[0]), length2=len(self.csp[1])))

    def offset_points(self, pos1, pos2, offset_px):
        # Expand or contract two points about their midpoint.  This is
        # useful for pull compensation and insetting underlay.

        distance = (pos1 - pos2).length()

        if distance < 0.0001:
            # if they're the same point, we don't know which direction
            # to offset in, so we have to just return the points
            return pos1, pos2

        # don't contract beyond the midpoint, or we'll start expanding
        if offset_px < -distance / 2.0:
            offset_px = -distance / 2.0

        pos1 = pos1 + (pos1 - pos2).unit() * offset_px
        pos2 = pos2 + (pos2 - pos1).unit() * offset_px

        return pos1, pos2

    def walk(self, path, start_pos, start_index, distance):
        # Move <distance> pixels along <path>, which is a sequence of line
        # segments defined by points.

        # <start_index> is the index of the line segment in <path> that
        # we're currently on.  <start_pos> is where along that line
        # segment we are.  Return a new position and index.

        # print >> dbg, "walk", start_pos, start_index, distance

        pos = start_pos
        index = start_index
        last_index = len(path) - 1
        distance_remaining = distance

        while True:
            if index >= last_index:
                return pos, index

            segment_end = path[index + 1]
            segment = segment_end - pos
            segment_length = segment.length()

            if segment_length > distance_remaining:
                # our walk ends partway along this segment
                return pos + segment.unit() * distance_remaining, index
            else:
                # our walk goes past the end of this segment, so advance
                # one point
                index += 1
                distance_remaining -= segment_length
                pos = segment_end

    def walk_paths(self, spacing, offset):
        # Take a bezier segment from each path in turn, and plot out an
        # equal number of points on each bezier.  Return the points plotted.
        # The points will be contracted or expanded by offset using
        # offset_points().

        points = [[], []]

        def add_pair(pos1, pos2):
            pos1, pos2 = self.offset_points(pos1, pos2, offset)
            points[0].append(pos1)
            points[1].append(pos2)

        # We may not be able to fit an even number of zigzags in each pair of
        # beziers.  We'll store the remaining bit of the beziers after handling
        # each section.
        remainder_path1 = []
        remainder_path2 = []

        for segment1, segment2 in self.flattened_beziers:
            subpath1 = remainder_path1 + segment1
            subpath2 = remainder_path2 + segment2

            len1 = shgeo.LineString(subpath1).length
            len2 = shgeo.LineString(subpath2).length

            # Base the number of stitches in each section on the _longest_ of
            # the two beziers. Otherwise, things could get too sparse when one
            # side is significantly longer (e.g. when going around a corner).
            # The risk here is that we poke a hole in the fabric if we try to
            # cram too many stitches on the short bezier.  The user will need
            # to avoid this through careful construction of paths.
            #
            # TODO: some commercial machine embroidery software compensates by
            # pulling in some of the "inner" stitches toward the center a bit.

            # note, this rounds down using integer-division
            num_points = max(len1, len2) / spacing

            spacing1 = len1 / num_points
            spacing2 = len2 / num_points

            pos1 = subpath1[0]
            index1 = 0

            pos2 = subpath2[0]
            index2 = 0

            for i in xrange(int(num_points)):
                add_pair(pos1, pos2)

                pos1, index1 = self.walk(subpath1, pos1, index1, spacing1)
                pos2, index2 = self.walk(subpath2, pos2, index2, spacing2)

            if index1 < len(subpath1) - 1:
                remainder_path1 = [pos1] + subpath1[index1 + 1:]
            else:
                remainder_path1 = []

            if index2 < len(subpath2) - 1:
                remainder_path2 = [pos2] + subpath2[index2 + 1:]
            else:
                remainder_path2 = []

        # We're off by one in the algorithm above, so we need one more
        # pair of points.  We also want to add points at the very end to
        # make sure we match the vectors on screen as best as possible.
        # Try to avoid doing both if they're going to stack up too
        # closely.

        end1 = remainder_path1[-1]
        end2 = remainder_path2[-1]

        if (end1 - pos1).length() > 0.3 * spacing:
            add_pair(pos1, pos2)

        add_pair(end1, end2)

        return points

    def do_contour_underlay(self):
        # "contour walk" underlay: do stitches up one side and down the
        # other.
        forward, back = self.walk_paths(self.contour_underlay_stitch_length,
                                        -self.contour_underlay_inset)
        return Patch(color=self.color, stitches=(forward + list(reversed(back))))

    def do_center_walk(self):
        # Center walk underlay is just a running stitch down and back on the
        # center line between the bezier curves.

        # Do it like contour underlay, but inset all the way to the center.
        forward, back = self.walk_paths(self.center_walk_underlay_stitch_length,
                                        -100000)
        return Patch(color=self.color, stitches=(forward + list(reversed(back))))

    def do_zigzag_underlay(self):
        # zigzag underlay, usually done at a much lower density than the
        # satin itself.  It looks like this:
        #
        # \/\/\/\/\/\/\/\/\/\/|
        # /\/\/\/\/\/\/\/\/\/\|
        #
        # In combination with the "contour walk" underlay, this is the
        # "German underlay" described here:
        #   http://www.mrxstitch.com/underlay-what-lies-beneath-machine-embroidery/

        patch = Patch(color=self.color)

        sides = self.walk_paths(self.zigzag_underlay_spacing / 2.0,
                                -self.zigzag_underlay_inset)

        # This organizes the points in each side in the order that they'll be
        # visited.
        sides = [sides[0][::2] + list(reversed(sides[0][1::2])),
                 sides[1][1::2] + list(reversed(sides[1][::2]))]

        # This fancy bit of iterable magic just repeatedly takes a point
        # from each side in turn.
        for point in chain.from_iterable(izip(*sides)):
            patch.add_stitch(point)

        return patch

    def do_satin(self):
        # satin: do a zigzag pattern, alternating between the paths.  The
        # zigzag looks like this to make the satin stitches look perpendicular
        # to the column:
        #
        # /|/|/|/|/|/|/|/|

        # print >> dbg, "satin", self.zigzag_spacing, self.pull_compensation

        patch = Patch(color=self.color)

        sides = self.walk_paths(self.zigzag_spacing, self.pull_compensation)

        # Like in zigzag_underlay(): take a point from each side in turn.
        for point in chain.from_iterable(izip(*sides)):
            patch.add_stitch(point)

        return patch

    def to_patches(self, last_patch):
        # Stitch a variable-width satin column, zig-zagging between two paths.

        # The algorithm will draw zigzags between each consecutive pair of
        # beziers.  The boundary points between beziers serve as "checkpoints",
        # allowing the user to control how the zigzags flow around corners.

        # First, verify that we have valid paths.
        self.validate_satin_column()

        patches = []

        if self.center_walk_underlay:
            patches.append(self.do_center_walk())

        if self.contour_underlay:
            patches.append(self.do_contour_underlay())

        if self.zigzag_underlay:
            # zigzag underlay comes after contour walk underlay, so that the
            # zigzags sit on the contour walk underlay like rail ties on rails.
            patches.append(self.do_zigzag_underlay())

        patches.append(self.do_satin())

        return patches


class Polyline(EmbroideryElement):
    # Handle a <polyline> element, which is treated as a set of points to
    # stitch exactly.
    #
    # <polyline> elements are pretty rare in SVG, from what I can tell.
    # Anything you can do with a <polyline> can also be done with a <p>, and
    # much more.
    #
    # Notably, EmbroiderModder2 uses <polyline> elements when converting from
    # common machine embroidery file formats to SVG.  Handling those here lets
    # users use File -> Import to pull in existing designs they may have
    # obtained, for example purchased fonts.

    @property
    def points(self):
       # example: "1,2 0,0 1.5,3 4,2"

       points = self.node.get('points')
       points = points.split(" ")
       points = [[float(coord) for coord in point.split(",")] for point in points]

       return points

    @property
    def path(self):
        # A polyline is a series of connected line segments described by their
        # points.  In order to make use of the existing logic for incorporating
        # svg transforms that is in our superclass, we'll convert the polyline
        # to a degenerate cubic superpath in which the bezier handles are on
        # the segment endpoints.

        path = [[[point[:], point[:], point[:]] for point in self.points]]

        return path

    @property
    @cache
    def csp(self):
        csp = self.parse_path()

        return csp

    @property
    def color(self):
        # EmbroiderModder2 likes to use the `stroke` property directly instead
        # of CSS.
        return self.get_style("stroke") or self.node.get("stroke")

    @property
    def stitches(self):
        # For a <polyline>, we'll stitch the points exactly as they exist in
        # the SVG, with no stitch spacing interpolation, flattening, etc.

        # See the comments in the parent class's parse_path method for a
        # description of the CSP data structure.

        stitches = [point for handle_before, point, handle_after in self.csp[0]]

        return stitches

    def to_patches(self, last_patch):
        patch = Patch(color=self.color)

        for stitch in self.stitches:
            patch.add_stitch(inkstitch.Point(*stitch))

        return [patch]

def detect_classes(node):
    if node.tag == SVG_POLYLINE_TAG:
        return [Polyline]
    else:
        element = EmbroideryElement(node)

        if element.get_boolean_param("satin_column"):
            return [SatinColumn]
        else:
            classes = []

            if element.get_style("fill"):
                if element.get_boolean_param("auto_fill", True):
                    classes.append(AutoFill)
                else:
                    classes.append(Fill)

            if element.get_style("stroke"):
                classes.append(Stroke)

            if element.get_boolean_param("stroke_first", False):
                classes.reverse()

            return classes


class Patch:
    def __init__(self, color=None, stitches=None, trim_after=False, stop_after=False):
        self.color = color
        self.stitches = stitches or []
        self.trim_after = trim_after
        self.stop_after = stop_after

    def __add__(self, other):
        if isinstance(other, Patch):
            return Patch(self.color, self.stitches + other.stitches)
        else:
            raise TypeError("Patch can only be added to another Patch")

    def add_stitch(self, stitch):
        self.stitches.append(stitch)

    def reverse(self):
        return Patch(self.color, self.stitches[::-1])


def process_stop_after(stitches):
    # The user wants the machine to pause after this patch.  This can
    # be useful for applique and similar on multi-needle machines that
    # normally would not stop between colors.
    #
    # On such machines, the user assigns needles to the colors in the
    # design before starting stitching.  C01, C02, etc are normal
    # needles, but C00 is special.  For a block of stitches assigned
    # to C00, the machine will continue sewing with the last color it
    # had and pause after it completes the C00 block.
    #
    # That means we need to introduce an artificial color change
    # shortly before the current stitch so that the user can set that
    # to C00.  We'll go back 3 stitches and do that:

    if len(stitches) >= 3:
        stitches[-3].stop = True

    # and also add a color change on this stitch, completing the C00
    # block:

    stitches[-1].stop = True

    # reference for the above: https://github.com/lexelby/inkstitch/pull/29#issuecomment-359175447


def process_trim(stitches, next_stitch):
    # DST (and maybe other formats?) has no actual TRIM instruction.
    # Instead, 3 sequential JUMPs cause the machine to trim the thread.
    #
    # To support both DST and other formats, we'll add a TRIM and two
    # JUMPs.  The TRIM will be converted to a JUMP by libembroidery
    # if saving to DST, resulting in the 3-jump sequence.

    delta = next_stitch - stitches[-1]
    delta = delta * (1/4.0)

    pos = stitches[-1]

    for i in xrange(3):
        pos += delta
        stitches.append(inkstitch.Stitch(pos.x, pos.y, stitches[-1].color, jump=True))

    # first one should be TRIM instead of JUMP
    stitches[-3].jump = False
    stitches[-3].trim = True


def patches_to_stitches(patch_list, collapse_len_px=0):
    stitches = []

    last_stitch = None
    last_color = None
    need_trim = False
    for patch in patch_list:
        if not patch.stitches:
            continue

        jump_stitch = True
        for stitch in patch.stitches:
            if last_stitch and last_color == patch.color:
                l = (stitch - last_stitch).length()
                if l <= 0.1:
                    # filter out duplicate successive stitches
                    jump_stitch = False
                    continue

                if jump_stitch:
                    # consider collapsing jump stitch, if it is pretty short
                    if l < collapse_len_px:
                        # dbg.write("... collapsed\n")
                        jump_stitch = False

            if stitches and last_color and last_color != patch.color:
                # add a color change
                stitches.append(inkstitch.Stitch(last_stitch.x, last_stitch.y, last_color, stop=True))

            if need_trim:
                process_trim(stitches, stitch)
                need_trim = False

            if jump_stitch:
                stitches.append(inkstitch.Stitch(stitch.x, stitch.y, patch.color, jump=True))

            stitches.append(inkstitch.Stitch(stitch.x, stitch.y, patch.color, jump=False))

            jump_stitch = False
            last_stitch = stitch
            last_color = patch.color

        if patch.trim_after:
            need_trim = True

        if patch.stop_after:
            process_stop_after(stitches)

    return stitches

def stitches_to_polylines(stitches):
    polylines = []
    last_color = None
    last_stitch = None
    trimming = False

    for stitch in stitches:
        if stitch.color != last_color or stitch.trim:
            trimming = True
            polylines.append([stitch.color, []])

        if trimming and (stitch.jump or stitch.trim):
            continue

        trimming = False

        polylines[-1][1].append(stitch.as_tuple())

        last_color = stitch.color
        last_stitch = stitch

    return polylines

def emit_inkscape(parent, stitches):
    transform = get_viewbox_transform(parent.getroottree().getroot())

    # we need to correct for the viewbox
    transform = simpletransform.invertTransform(transform)
    transform = simpletransform.formatTransform(transform)

    for color, polyline in stitches_to_polylines(stitches):
        # dbg.write('polyline: %s %s\n' % (color, repr(polyline)))
        inkex.etree.SubElement(parent,
                               inkex.addNS('polyline', 'svg'),
                               {'style': simplestyle.formatStyle(
                                   {'stroke': color if color is not None else '#000000',
                                    'stroke-width': "0.4",
                                    'fill': 'none'}),
                                   'points': " ".join(",".join(str(coord) for coord in point) for point in polyline),
                                'transform': transform
                                })

def get_elements(effect):
    elements = []
    nodes = get_nodes(effect)

    for node in nodes:
        classes = detect_classes(node)
        elements.extend(cls(node) for cls in classes)

    return elements


def elements_to_patches(elements):
    patches = []
    for element in elements:
        if patches:
            last_patch = patches[-1]
        else:
            last_patch = None

        patches.extend(element.embroider(last_patch))

    return patches

class Embroider(inkex.Effect):

    def __init__(self, *args, **kwargs):
        inkex.Effect.__init__(self)
        self.OptionParser.add_option("-c", "--collapse_len_mm",
                                     action="store", type="float",
                                     dest="collapse_length_mm", default=0.0,
                                     help="max collapse length (mm)")
        self.OptionParser.add_option("--hide_layers",
                                     action="store", type="choice",
                                     choices=["true", "false"],
                                     dest="hide_layers", default="true",
                                     help="Hide all other layers when the embroidery layer is generated")
        self.OptionParser.add_option("-O", "--output_format",
                                     action="store", type="string",
                                     dest="output_format", default="csv",
                                     help="Output file extenstion (default: csv)")
        self.OptionParser.add_option("-P", "--path",
                                     action="store", type="string",
                                     dest="path", default=".",
                                     help="Directory in which to store output file")
        self.OptionParser.add_option("-F", "--output-file",
                                     action="store", type="string",
                                     dest="output_file",
                                     help="Output filename.")
        self.OptionParser.add_option("-b", "--max-backups",
                                     action="store", type="int",
                                     dest="max_backups", default=5,
                                     help="Max number of backups of output files to keep.")
        self.OptionParser.usage += _("\n\nSeeing a 'no such option' message?  Please restart Inkscape to fix.")

    def get_output_path(self):
        if self.options.output_file:
            output_path = os.path.join(self.options.path, self.options.output_file)
        else:
            svg_filename = self.document.getroot().get(inkex.addNS('docname', 'sodipodi'), "embroidery.svg")
            csv_filename = svg_filename.replace('.svg', '.%s' % self.options.output_format)
            output_path = os.path.join(self.options.path, csv_filename)

        def add_suffix(path, suffix):
            if suffix > 0:
                path = "%s.%s" % (path, suffix)

            return path

        def move_if_exists(path, suffix=0):
            source = add_suffix(path, suffix)

            if suffix >= self.options.max_backups:
                return

            dest = add_suffix(path, suffix + 1)

            if os.path.exists(source):
                move_if_exists(path, suffix + 1)
                os.rename(source, dest)

        move_if_exists(output_path)

        return output_path

    def hide_layers(self):
        for g in self.document.getroot().findall(SVG_GROUP_TAG):
            if g.get(inkex.addNS("groupmode", "inkscape")) == "layer":
                g.set("style", "display:none")

    def effect(self):
        # Printing anything other than a valid SVG on stdout blows inkscape up.
        old_stdout = sys.stdout
        sys.stdout = sys.stderr

        self.patch_list = []

        self.elements = get_elements(self)

        if not self.elements:
            if self.selected:
                inkex.errormsg(_("No embroiderable paths selected."))
            else:
                inkex.errormsg(_("No embroiderable paths found in document."))
            inkex.errormsg(_("Tip: use Path -> Object to Path to convert non-paths before embroidering."))
            return

        if self.options.hide_layers:
            self.hide_layers()

        patches = elements_to_patches(self.elements)
        stitches = patches_to_stitches(patches, self.options.collapse_length_mm * PIXELS_PER_MM)
        inkstitch.write_embroidery_file(self.get_output_path(), stitches)

        new_layer = inkex.etree.SubElement(self.document.getroot(), SVG_GROUP_TAG, {})
        new_layer.set('id', self.uniqueId("embroidery"))
        new_layer.set(inkex.addNS('label', 'inkscape'), _('Embroidery'))
        new_layer.set(inkex.addNS('groupmode', 'inkscape'), 'layer')

        emit_inkscape(new_layer, stitches)

        sys.stdout = old_stdout

if __name__ == '__main__':
    sys.setrecursionlimit(100000)
    e = Embroider()

    try:
        e.affect()
    except KeyboardInterrupt:
        print >> dbg, "interrupted!"

        print >> dbg, traceback.format_exc()

    dbg.flush()