kopia lustrzana https://github.com/inkstitch/inkstitch
566 wiersze
19 KiB
Python
566 wiersze
19 KiB
Python
# Authors: see git history
|
|
#
|
|
# Copyright (c) 2010 Authors
|
|
# Licensed under the GNU GPL version 3.0 or later. See the file LICENSE for details.
|
|
|
|
import math
|
|
from itertools import chain
|
|
|
|
import networkx as nx
|
|
from shapely import geometry as shgeo
|
|
from shapely.geometry import Point as ShapelyPoint
|
|
|
|
import inkex
|
|
|
|
from ..commands import add_commands
|
|
from ..elements import SatinColumn, Stroke
|
|
from ..i18n import _
|
|
from ..svg import PIXELS_PER_MM, generate_unique_id, line_strings_to_csp
|
|
from ..svg.tags import INKSCAPE_LABEL, INKSTITCH_ATTRIBS
|
|
from ..utils import Point as InkstitchPoint
|
|
from ..utils import cache, cut
|
|
from .utils.autoroute import (add_elements_to_group, add_jumps,
|
|
create_new_group, find_path,
|
|
get_starting_and_ending_nodes,
|
|
preserve_original_groups,
|
|
remove_original_elements)
|
|
from ..utils.threading import check_stop_flag
|
|
|
|
|
|
class SatinSegment(object):
|
|
"""A portion of SatinColumn.
|
|
|
|
Attributes:
|
|
satin -- the SatinColumn instance
|
|
start -- how far along the satin this graph edge starts (a float from 0.0 to 1.0)
|
|
end -- how far along the satin this graph edge ends (a float from 0.0 to 1.0)
|
|
reverse -- if True, reverse the direction of the satin
|
|
"""
|
|
|
|
def __init__(self, satin, start=0.0, end=1.0, reverse=False, original_satin=None):
|
|
"""Initialize a SatinEdge.
|
|
|
|
Arguments:
|
|
satin -- the SatinColumn instance
|
|
start, end -- a tuple or Point falling somewhere on the
|
|
satin column, OR a floating point specifying a
|
|
normalized projection of a distance along the satin
|
|
(0.0 to 1.0 inclusive)
|
|
reverse -- boolean
|
|
"""
|
|
|
|
self.satin = satin
|
|
self.original_satin = original_satin or self.satin
|
|
self.reverse = reverse
|
|
|
|
# start and end are stored as normalized projections
|
|
self.start = self._parse_init_param(start)
|
|
self.end = self._parse_init_param(end)
|
|
|
|
if self.start > self.end:
|
|
self.end, self.start = self.start, self.end
|
|
self.reverse = True
|
|
|
|
def _parse_init_param(self, param):
|
|
if isinstance(param, (float, int)):
|
|
return param
|
|
elif isinstance(param, (tuple, InkstitchPoint, ShapelyPoint)):
|
|
return self.satin.center.project(ShapelyPoint(param), normalized=True)
|
|
|
|
def to_satin(self):
|
|
satin = self.satin
|
|
|
|
if self.start > 0.0:
|
|
before, satin = satin.split(self.start)
|
|
|
|
if self.end < 1.0:
|
|
satin, after = satin.split(
|
|
(self.end - self.start) / (1.0 - self.start))
|
|
|
|
if self.reverse:
|
|
satin = satin.reverse()
|
|
|
|
satin = satin.apply_transform()
|
|
|
|
_ensure_even_repeats(satin)
|
|
|
|
return satin
|
|
|
|
to_element = to_satin
|
|
|
|
def to_running_stitch(self):
|
|
return RunningStitch(self.center_line, self.original_satin)
|
|
|
|
def break_up(self, segment_size):
|
|
"""Break this SatinSegment up into SatinSegments of the specified size."""
|
|
|
|
num_segments = int(math.ceil(self.center_line.length / segment_size))
|
|
segments = []
|
|
for i in range(num_segments):
|
|
segments.append(SatinSegment(self.satin,
|
|
float(i) / num_segments,
|
|
float(i + 1) / num_segments,
|
|
self.reverse,
|
|
self.original_satin))
|
|
|
|
if self.reverse:
|
|
segments.reverse()
|
|
|
|
return segments
|
|
|
|
def reversed(self):
|
|
"""Return a copy of this SatinSegment in the opposite direction."""
|
|
return SatinSegment(self.satin, self.start, self.end, not self.reverse)
|
|
|
|
@property
|
|
def center_line(self):
|
|
center_line = self.satin.center_line
|
|
|
|
if self.start < 1.0:
|
|
before, center_line = cut(center_line, self.start, normalized=True)
|
|
|
|
if self.end > 0.0:
|
|
center_line, after = cut(
|
|
center_line, (self.end - self.start) / (1.0 - self.start), normalized=True)
|
|
|
|
if self.reverse:
|
|
center_line = shgeo.LineString(reversed(center_line.coords))
|
|
|
|
return center_line
|
|
|
|
@property
|
|
@cache
|
|
def start_point(self):
|
|
return self.satin.center_line.interpolate(self.start, normalized=True)
|
|
|
|
@property
|
|
@cache
|
|
def end_point(self):
|
|
return self.satin.center_line.interpolate(self.end, normalized=True)
|
|
|
|
@property
|
|
def original_node(self):
|
|
return self.original_satin.node
|
|
|
|
def is_sequential(self, other):
|
|
"""Check if a satin segment immediately follows this one on the same satin."""
|
|
|
|
if not isinstance(other, SatinSegment):
|
|
return False
|
|
|
|
if self.satin is not other.satin:
|
|
return False
|
|
|
|
if self.reverse != other.reverse:
|
|
return False
|
|
|
|
if self.reverse:
|
|
return self.start == other.end
|
|
else:
|
|
return self.end == other.start
|
|
|
|
def __add__(self, other):
|
|
"""Combine two sequential SatinSegments.
|
|
|
|
If self.is_sequential(other) is not True then adding results in
|
|
undefined behavior.
|
|
"""
|
|
if self.reverse:
|
|
return SatinSegment(self.satin, other.start, self.end, reverse=True)
|
|
else:
|
|
return SatinSegment(self.satin, self.start, other.end)
|
|
|
|
def __eq__(self, other):
|
|
# Two SatinSegments are equal if they refer to the same section of the same
|
|
# satin (even if in opposite directions).
|
|
return self.satin is other.satin and self.start == other.start and self.end == other.end
|
|
|
|
def __hash__(self):
|
|
return hash((id(self.satin), self.start, self.end))
|
|
|
|
def __repr__(self):
|
|
return "SatinSegment(%s, %s, %s, %s)" % (self.satin, self.start, self.end, self.reverse)
|
|
|
|
|
|
class JumpStitch(object):
|
|
"""A jump stitch between two points."""
|
|
|
|
def __init__(self, start, end, source_element, destination_element):
|
|
"""Initialize a JumpStitch.
|
|
|
|
Arguments:
|
|
start, end -- instances of shgeo.Point
|
|
"""
|
|
|
|
self.start = start
|
|
self.end = end
|
|
self.source_element = source_element
|
|
self.destination_element = destination_element
|
|
|
|
def is_sequential(self, other):
|
|
# Don't bother joining jump stitches.
|
|
return False
|
|
|
|
@property
|
|
@cache
|
|
def length(self):
|
|
return self.start.distance(self.end)
|
|
|
|
def as_line_string(self):
|
|
return shgeo.LineString((self.start, self.end))
|
|
|
|
def should_trim(self):
|
|
actual_jump = self.as_line_string().difference(self.source_element.shape)
|
|
actual_jump = actual_jump.difference(self.destination_element.shape)
|
|
|
|
return actual_jump.length > PIXELS_PER_MM
|
|
|
|
|
|
class RunningStitch(object):
|
|
"""Running stitch along a path."""
|
|
|
|
def __init__(self, path_or_stroke, original_element=None):
|
|
if isinstance(path_or_stroke, Stroke):
|
|
# Technically a Stroke object's underlying path could have multiple
|
|
# subpaths. We don't have a particularly good way of dealing with
|
|
# that so we'll just use the first one.
|
|
self.path = shgeo.LineString(path_or_stroke.paths[0])
|
|
original_element = path_or_stroke
|
|
else:
|
|
self.path = path_or_stroke
|
|
|
|
self.original_element = original_element
|
|
self.running_stitch_length = \
|
|
original_element.node.get(INKSTITCH_ATTRIBS['running_stitch_length_mm'], '') or \
|
|
original_element.node.get(INKSTITCH_ATTRIBS['center_walk_underlay_stitch_length_mm'], '') or \
|
|
original_element.node.get(INKSTITCH_ATTRIBS['contour_underlay_stitch_length_mm'], '')
|
|
|
|
def to_element(self):
|
|
node = inkex.PathElement()
|
|
d = str(inkex.paths.CubicSuperPath(line_strings_to_csp([self.path])))
|
|
node.set("d", d)
|
|
|
|
dasharray = inkex.Style("stroke-dasharray:0.5,0.5;")
|
|
style = inkex.Style(self.original_element.node.get('style', '')) + dasharray
|
|
node.set("style", str(style))
|
|
node.set(INKSTITCH_ATTRIBS['running_stitch_length_mm'], self.running_stitch_length)
|
|
|
|
stroke = Stroke(node)
|
|
|
|
return stroke
|
|
|
|
@property
|
|
@cache
|
|
def start_point(self):
|
|
return self.path.interpolate(0.0, normalized=True)
|
|
|
|
@property
|
|
@cache
|
|
def end_point(self):
|
|
return self.path.interpolate(1.0, normalized=True)
|
|
|
|
@property
|
|
def original_node(self):
|
|
return self.original_element.node
|
|
|
|
@cache
|
|
def reversed(self):
|
|
return RunningStitch(shgeo.LineString(reversed(self.path.coords)), self.original_element)
|
|
|
|
def is_sequential(self, other):
|
|
if not isinstance(other, RunningStitch):
|
|
return False
|
|
|
|
if self.original_element is not other.original_element:
|
|
return False
|
|
|
|
return self.path.distance(other.path) < 0.5
|
|
|
|
def __add__(self, other):
|
|
new_path = shgeo.LineString(chain(self.path.coords, other.path.coords))
|
|
return RunningStitch(new_path, self.original_element)
|
|
|
|
|
|
def auto_satin(elements, preserve_order=False, starting_point=None, ending_point=None, trim=False):
|
|
"""Find an optimal order to stitch a list of SatinColumns.
|
|
|
|
Add running stitch and jump stitches as necessary to construct a stitch
|
|
order. Cut satins as necessary to minimize jump stitch length.
|
|
|
|
For example, consider three satins making up the letters "PO":
|
|
|
|
* one vertical satin for the "P"
|
|
* the loop of the "P"
|
|
* the "O"
|
|
|
|
A good stitch path would be:
|
|
|
|
1. up the leg
|
|
2. down through half of the loop
|
|
3. running stitch to the bottom of the loop
|
|
4. satin stitch back up to the middle of the loop
|
|
5. jump to the closest point on the O
|
|
6. satin stitch around the O
|
|
|
|
If passed, stitching will start from starting_point and end at
|
|
ending_point. It is expected that the starting and ending points will
|
|
fall on satin columns in the list. If they don't, the nearest
|
|
point on a satin column in the list will be used.
|
|
|
|
If preserve_order is True, then the algorithm is constrained to keep the
|
|
satins in the same order they were in the original list. It will only split
|
|
them and add running stitch as necessary to achieve an optimal stitch path.
|
|
|
|
Elements should be primarily made up of SatinColumn instances. Some Stroke
|
|
instances (that are running stitch) can be included to indicate how to travel
|
|
between two SatinColumns. This works best when preserve_order is True.
|
|
|
|
If preserve_order is True, then the elements and any newly-created elements
|
|
will be in the same position in the SVG DOM. If preserve_order is False, then
|
|
the elements will be removed from their current position in SVG DOM and added
|
|
to a newly-created group node.
|
|
|
|
If trim is True, then Trim commands will be added to avoid jump stitches.
|
|
|
|
Returns: a list of Element instances making up the stitching order chosen.
|
|
Jumps between objects are implied if they are not right next to each
|
|
other.
|
|
"""
|
|
|
|
# save these for create_new_group() call below
|
|
parent = elements[0].node.getparent()
|
|
index = parent.index(elements[0].node)
|
|
|
|
graph = build_graph(elements, preserve_order)
|
|
add_jumps(graph, elements, preserve_order)
|
|
starting_node, ending_node = get_starting_and_ending_nodes(
|
|
graph, elements, preserve_order, starting_point, ending_point)
|
|
path = find_path(graph, starting_node, ending_node)
|
|
operations = path_to_operations(graph, path)
|
|
operations = collapse_sequential_segments(operations)
|
|
new_elements, trims, original_parents = operations_to_elements_and_trims(operations, preserve_order)
|
|
|
|
remove_original_elements(elements)
|
|
|
|
if preserve_order:
|
|
preserve_original_groups(new_elements, original_parents)
|
|
else:
|
|
group = create_new_group(parent, index, _("Auto-Route"))
|
|
add_elements_to_group(new_elements, group)
|
|
|
|
name_elements(new_elements, preserve_order)
|
|
|
|
if trim:
|
|
new_elements = add_trims(new_elements, trims)
|
|
|
|
return new_elements
|
|
|
|
|
|
def build_graph(elements, preserve_order=False):
|
|
if preserve_order:
|
|
graph = nx.DiGraph()
|
|
else:
|
|
graph = nx.Graph()
|
|
|
|
# Take each satin and dice it up into pieces 1mm long. This allows many
|
|
# possible spots for jump-stitches between satins. NetworkX will find the
|
|
# best spots for us.
|
|
|
|
for element in elements:
|
|
check_stop_flag()
|
|
|
|
segments = []
|
|
if isinstance(element, Stroke):
|
|
segments.append(RunningStitch(element))
|
|
elif isinstance(element, SatinColumn):
|
|
whole_satin = SatinSegment(element)
|
|
segments = whole_satin.break_up(PIXELS_PER_MM)
|
|
|
|
for segment in segments:
|
|
# This is necessary because shapely points aren't hashable and thus
|
|
# can't be used as nodes directly.
|
|
graph.add_node(str(segment.start_point), point=segment.start_point, element=element)
|
|
graph.add_node(str(segment.end_point), point=segment.end_point, element=element)
|
|
graph.add_edge(str(segment.start_point), str(
|
|
segment.end_point), segment=segment, element=element)
|
|
|
|
if preserve_order:
|
|
# The graph is a directed graph, but we want to allow travel in
|
|
# any direction in a satin, so we add the edge in the opposite
|
|
# direction too.
|
|
graph.add_edge(str(segment.end_point), str(
|
|
segment.start_point), segment=segment, element=element)
|
|
|
|
return graph
|
|
|
|
|
|
def reversed_path(path):
|
|
"""Generator for a version of the path travelling in the opposite direction.
|
|
|
|
Example:
|
|
|
|
[(1, 2), (2, 3), (3, 4), (4, 5), (5, 1)] =>
|
|
[(1, 5), (5, 4), (4, 3), (3, 2), (2, 1)]
|
|
"""
|
|
|
|
for node1, node2 in reversed(path):
|
|
yield (node2, node1)
|
|
|
|
|
|
def path_to_operations(graph, path):
|
|
"""Convert an edge path to a list of SatinSegment and JumpStitch instances."""
|
|
|
|
graph = nx.Graph(graph)
|
|
|
|
operations = []
|
|
|
|
for start, end in path:
|
|
segment = graph[start][end].get('segment')
|
|
if segment:
|
|
start_point = graph.nodes[start]['point']
|
|
if segment.start_point != start_point:
|
|
segment = segment.reversed()
|
|
operations.append(segment)
|
|
else:
|
|
operations.append(JumpStitch(graph.nodes[start]['point'],
|
|
graph.nodes[end]['point'],
|
|
graph.nodes[start]['element'],
|
|
graph.nodes[end]['element']))
|
|
|
|
# find_path() will have duplicated some of the edges in the graph. We don't
|
|
# want to sew the same satin twice. If a satin section appears twice in the
|
|
# path, we'll sew the first occurrence as running stitch. It will later be
|
|
# covered by the satin stitch.
|
|
seen = set()
|
|
|
|
for i, item in reversed(list(enumerate(operations))):
|
|
if isinstance(item, SatinSegment):
|
|
if item in seen:
|
|
operations[i] = item.to_running_stitch()
|
|
else:
|
|
seen.add(item)
|
|
|
|
return operations
|
|
|
|
|
|
def collapse_sequential_segments(old_operations):
|
|
old_operations = iter(old_operations)
|
|
new_operations = [next(old_operations)]
|
|
|
|
for operation in old_operations:
|
|
if new_operations[-1].is_sequential(operation):
|
|
new_operations[-1] += operation
|
|
else:
|
|
new_operations.append(operation)
|
|
|
|
return new_operations
|
|
|
|
|
|
def operations_to_elements_and_trims(operations, preserve_order):
|
|
"""Convert a list of operations to Elements and locations of trims.
|
|
|
|
Returns:
|
|
(elements, trims, original_parents)
|
|
|
|
elements -- a list of Element instances
|
|
trims -- indices of nodes after which the thread should be trimmed
|
|
original_parents -- a parallel list of the original SVG parent nodes that spawned each element
|
|
"""
|
|
|
|
elements = []
|
|
trims = []
|
|
original_parent_nodes = []
|
|
|
|
for operation in operations:
|
|
# Ignore JumpStitch operations. Jump stitches in Ink/Stitch are
|
|
# implied and added by Embroider if needed.
|
|
if isinstance(operation, (SatinSegment, RunningStitch)):
|
|
elements.append(operation.to_element())
|
|
original_parent_nodes.append(operation.original_node.getparent())
|
|
elif isinstance(operation, (JumpStitch)):
|
|
if elements and operation.should_trim():
|
|
trims.append(len(elements) - 1)
|
|
|
|
return elements, list(set(trims)), original_parent_nodes
|
|
|
|
|
|
def name_elements(new_elements, preserve_order):
|
|
"""Give the newly-created SVG objects useful names.
|
|
|
|
Objects will be named like this:
|
|
|
|
* AutoSatin 1
|
|
* AutoSatin 2
|
|
* AutoSatin Running Stitch 3
|
|
* AutoSatin 4
|
|
* AutoSatin Running Stitch 5
|
|
...
|
|
|
|
Objects are numbered starting with 1. Satins are named "AutoSatin #", and
|
|
running stitches are named "AutoSatin Running Stitch #".
|
|
|
|
If preserve_order is true and the element already has an INKSCAPE_LABEL,
|
|
we'll leave it alone. That way users can see which original satin the new
|
|
satin(s) came from.
|
|
|
|
SVG element IDs are also set. Since these need to be unique across the
|
|
document, the numbers will likely not match up with the numbers in the
|
|
name we set.
|
|
"""
|
|
|
|
index = 1
|
|
for element in new_elements:
|
|
if isinstance(element, SatinColumn):
|
|
element.node.set("id", generate_unique_id(element.node, "autosatin"))
|
|
else:
|
|
element.node.set("id", generate_unique_id(element.node, "autosatinrun"))
|
|
|
|
if not (preserve_order and INKSCAPE_LABEL in element.node.attrib):
|
|
if isinstance(element, SatinColumn):
|
|
# L10N Label for a satin column created by Auto-Route Satin Columns and Lettering extensions
|
|
element.node.set(INKSCAPE_LABEL, _("AutoSatin %d") % index)
|
|
else:
|
|
# L10N Label for running stitch (underpathing) created by Auto-Route Satin Columns amd Lettering extensions
|
|
element.node.set(INKSCAPE_LABEL, _("AutoSatin Running Stitch %d") % index)
|
|
|
|
index += 1
|
|
|
|
|
|
def _ensure_even_repeats(element):
|
|
# center underlay can have an odd number of repeats, this would cause jumps in auto route satin
|
|
# so let's set it to an even number of repeats, but not lower than 2
|
|
if int(element.node.get(INKSTITCH_ATTRIBS['center_walk_underlay_repeats'], 2)) % 2 == 1:
|
|
repeats = max(int(element.node.get(INKSTITCH_ATTRIBS['center_walk_underlay_repeats'])) - 1, 2)
|
|
element.node.set(INKSTITCH_ATTRIBS['center_walk_underlay_repeats'], repeats)
|
|
|
|
|
|
def add_trims(elements, trim_indices):
|
|
"""Add trim commands on the specified elements.
|
|
|
|
If any running stitches immediately follow a trim, they are eliminated.
|
|
When we're trimming, there's no need to try to reduce the jump length,
|
|
so the running stitch would be a waste of time (and thread).
|
|
"""
|
|
|
|
trim_indices = set(trim_indices)
|
|
new_elements = []
|
|
just_trimmed = False
|
|
for i, element in enumerate(elements):
|
|
if just_trimmed and isinstance(element, Stroke):
|
|
element.node.getparent().remove(element.node)
|
|
continue
|
|
|
|
if i in trim_indices:
|
|
add_commands(element, ["trim"])
|
|
just_trimmed = True
|
|
else:
|
|
just_trimmed = False
|
|
|
|
new_elements.append(element)
|
|
|
|
# trim at the end, too
|
|
if i not in trim_indices:
|
|
add_commands(element, ["trim"])
|
|
|
|
return new_elements
|