kopia lustrzana https://github.com/inkstitch/inkstitch
1777 wiersze
65 KiB
Python
1777 wiersze
65 KiB
Python
#!/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()
|