diff options
Diffstat (limited to 'lib')
| -rw-r--r-- | lib/elements/fill_stitch.py | 33 | ||||
| -rw-r--r-- | lib/elements/satin_column.py | 38 | ||||
| -rw-r--r-- | lib/stitches/auto_fill.py | 46 | ||||
| -rw-r--r-- | lib/stitches/fill.py | 4 | ||||
| -rw-r--r-- | lib/utils/clamp_path.py | 23 | ||||
| -rw-r--r-- | lib/utils/geometry.py | 31 | ||||
| -rw-r--r-- | lib/utils/list.py | 4 |
7 files changed, 138 insertions, 41 deletions
diff --git a/lib/elements/fill_stitch.py b/lib/elements/fill_stitch.py index 188c2ad7..c539cf7e 100644 --- a/lib/elements/fill_stitch.py +++ b/lib/elements/fill_stitch.py @@ -597,6 +597,37 @@ class FillStitch(EmbroideryElement): return self.get_float_param('herringbone_width_mm', 0) @property + @param( + 'pull_compensation_mm', + _('Pull compensation'), + tooltip=_('Fill stitch can pull the fabric together, resulting in a shape narrower than you draw in Inkscape. ' + 'This setting expands each row of stitches outward from the center of the row by a fixed length. ' + 'Two values separated by a space may be used for an asymmetric effect.'), + select_items=[('fill_method', 'auto_fill')], + unit=_('mm (each side)'), + type='float', + default=0, + sort_index=26) + @cache + def pull_compensation_px(self): + return np.maximum(self.get_split_mm_param_as_px("pull_compensation_mm", (0, 0)), 0) + + @property + @param( + 'pull_compensation_percent', + _('Pull compensation percentage'), + tooltip=_('Additional pull compensation which varies as a percentage of row width. ' + 'Two values separated by a space may be used for an asymmetric effect.'), + select_items=[('fill_method', 'auto_fill')], + unit=_('% (each side)'), + type='float', + default=0, + sort_index=27) + @cache + def pull_compensation_percent(self): + return np.maximum(self.get_split_float_param("pull_compensation_percent", (0, 0)), 0) + + @property def color(self): # SVG spec says the default fill is black return self.get_style("fill", "#000000") @@ -1027,6 +1058,8 @@ class FillStitch(EmbroideryElement): self.enable_random_stitch_length, self.random_stitch_length_jitter, self.random_seed, + self.pull_compensation_px, + self.pull_compensation_percent / 100, ) ) return [stitch_group] diff --git a/lib/elements/satin_column.py b/lib/elements/satin_column.py index c031f229..dd04b507 100644 --- a/lib/elements/satin_column.py +++ b/lib/elements/satin_column.py @@ -20,7 +20,7 @@ from ..metadata import InkStitchMetadata from ..stitch_plan import StitchGroup from ..stitches import running_stitch from ..svg import line_strings_to_csp, point_lists_to_csp -from ..utils import Point, cache, cut, cut_multiple, prng +from ..utils import Point, cache, cut, cut_multiple, offset_points, prng from ..utils.param import ParamOption from ..utils.threading import check_stop_flag from .element import PIXELS_PER_MM, EmbroideryElement, param @@ -260,7 +260,7 @@ class SatinColumn(EmbroideryElement): 'pull_compensation_percent', _('Pull compensation percentage'), tooltip=_('Additional pull compensation which varies as a percentage of stitch width. ' - 'Two values separated by a space may be used for an aysmmetric effect.'), + 'Two values separated by a space may be used for an asymmetric effect.'), unit=_('% (each side)'), type='float', default=0, @@ -276,7 +276,7 @@ class SatinColumn(EmbroideryElement): _('Pull compensation'), tooltip=_('Satin stitches pull the fabric together, resulting in a column narrower than you draw in Inkscape. ' 'This setting expands each pair of needle penetrations outward from the center of the satin column by a fixed length. ' - 'Two values separated by a space may be used for an aysmmetric effect.'), + 'Two values separated by a space may be used for an asymmetric effect.'), unit=_('mm (each side)'), type='float', default=0, @@ -1015,34 +1015,6 @@ class SatinColumn(EmbroideryElement): center_walk = [center_walk[0], center_walk[0]] return shgeo.LineString(center_walk) - def offset_points(self, pos1, pos2, offset_px, offset_proportional): - # 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 - - # calculate the offset for each side - offset_a = offset_px[0] + (distance * offset_proportional[0]) - offset_b = offset_px[1] + (distance * offset_proportional[1]) - offset_total = offset_a + offset_b - - # don't contract beyond the midpoint, or we'll start expanding - if offset_total < -distance: - scale = -distance / offset_total - offset_a = offset_a * scale - offset_b = offset_b * scale - - # convert offset to float before using because it may be a numpy.float64 - out1 = pos1 + (pos1 - pos2).unit() * float(offset_a) - out2 = pos2 + (pos2 - pos1).unit() * float(offset_b) - - return out1, out2 - def _stitch_distance(self, pos0, pos1, previous_pos0, previous_pos1): """Return the distance from one stitch to the next.""" @@ -1567,7 +1539,7 @@ class SatinColumn(EmbroideryElement): offset_px[0] = -inset_px if b.distance(pairs[i-1][1]) < min_dist: offset_px[1] = -inset_px - shortened.append(self.offset_points(a, b, offset_px, (0, 0))) + shortened.append(offset_points(a, b, offset_px, (0, 0))) return shortened def _get_inset_point(self, point1, point2, distance_fraction): @@ -1656,7 +1628,7 @@ class SatinProcessor: else: offset_prop = self.offset_proportional - a, b = self.satin.offset_points(pos0, pos1, self.offset_px, offset_prop) + a, b = offset_points(pos0, pos1, self.offset_px, offset_prop) return a, b def get_stitch_spacing_multiple(self): diff --git a/lib/stitches/auto_fill.py b/lib/stitches/auto_fill.py index d3db978a..84832fc8 100644 --- a/lib/stitches/auto_fill.py +++ b/lib/stitches/auto_fill.py @@ -11,8 +11,8 @@ from typing import Iterator import networkx from shapely import geometry as shgeo -from shapely import segmentize -from shapely.ops import snap +from shapely import make_valid, segmentize +from shapely.ops import snap, unary_union from shapely.strtree import STRtree from ..debug.debug import debug @@ -22,7 +22,8 @@ from ..utils import cache from ..utils.clamp_path import clamp_path_to_polygon from ..utils.geometry import Point as InkstitchPoint from ..utils.geometry import (ensure_multi_line_string, - line_string_to_point_list) + line_string_to_point_list, offset_points) +from ..utils.list import is_all_zeroes from ..utils.prng import join_args from ..utils.smoothing import smooth_path from ..utils.threading import check_stop_flag @@ -82,12 +83,18 @@ def auto_fill(shape, gap_fill_rows=0, enable_random_stitch_length=False, random_sigma=0.0, - random_seed=""): + random_seed="", + pull_compensation_px=(0, 0), + pull_compensation_percent=(0, 0)): + has_pull_compensation = not is_all_zeroes(pull_compensation_px) or not is_all_zeroes(pull_compensation_percent) + if has_pull_compensation: + spacing = min(row_spacing, end_row_spacing or row_spacing) + shape = adjust_shape_for_pull_compensation(shape, angle, spacing, pull_compensation_px, pull_compensation_percent) + rows = intersect_region_with_grating(shape, angle, row_spacing, end_row_spacing) if not rows: # Small shapes may not intersect with the grating at all. return fallback(shape, running_stitch_length, running_stitch_tolerance) - segments = [segment for row in rows for segment in row] fill_stitch_graph = build_fill_stitch_graph(shape, segments, starting_point, ending_point) @@ -120,6 +127,34 @@ def round_to_multiple_of_2(number): return number +@debug.time +def adjust_shape_for_pull_compensation(shape, angle, row_spacing, pull_compensation_px, pull_compensation_percent): + rows = intersect_region_with_grating(shape, angle, row_spacing) + if not rows: + return shape + segments = [segment for row in rows for segment in row] + segments = apply_pull_compensation(segments, pull_compensation_px, pull_compensation_percent) + + lines = [shgeo.LineString((start, end)) for start, end in segments] + buffer_amount = row_spacing/2 + 0.01 + buffered_lines = [line.buffer(buffer_amount) for line in lines] + + polygon = unary_union(buffered_lines) + return make_valid(polygon) + + +def apply_pull_compensation(segments, pull_compensation_px, pull_compensation_percent): + new_segments = [] + for segment in segments: + start = InkstitchPoint.from_tuple(segment[0]) + end = InkstitchPoint.from_tuple(segment[1]) + end = InkstitchPoint.from_tuple(segment[1]) + new_start, new_end = offset_points(start, end, pull_compensation_px, pull_compensation_percent) + new_segments.append((new_start.as_tuple(), new_end.as_tuple())) + + return new_segments + + def which_outline(shape, coords): """return the index of the outline on which the point resides @@ -374,7 +409,6 @@ def build_travel_graph(fill_stitch_graph, shape, fill_stitch_angle, underpath): calculation. We also weight the interior edges extra proportional to how close they are to the boundary. """ - graph = networkx.MultiGraph() # Add all the nodes from the main graph. This will be all of the endpoints diff --git a/lib/stitches/fill.py b/lib/stitches/fill.py index 4f3e2208..8480ea0b 100644 --- a/lib/stitches/fill.py +++ b/lib/stitches/fill.py @@ -113,10 +113,10 @@ def intersect_region_with_grating(shape, angle, row_spacing, end_row_spacing=Non # 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 = InkstitchPoint(1, 0).rotate(-angle) + direction = InkstitchPoint(-1, 0).rotate(-angle) # and get a normal vector - normal = direction.rotate(math.pi / 2) + 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 diff --git a/lib/utils/clamp_path.py b/lib/utils/clamp_path.py index 0f58f83c..fcb34a4b 100644 --- a/lib/utils/clamp_path.py +++ b/lib/utils/clamp_path.py @@ -1,5 +1,6 @@ from shapely.geometry import LineString, MultiPolygon from shapely.geometry import Point as ShapelyPoint +from shapely.ops import nearest_points from shapely.prepared import prep from .geometry import (Point, ensure_geometry_collection, @@ -14,6 +15,9 @@ def path_to_segments(path): def segments_to_path(segments): """Convert a list of contiguous LineStrings into a list of Points.""" + if not segments: + return [] + coords = [segments[0].coords[0]] for segment in segments: @@ -68,6 +72,22 @@ def find_border(polygon, point): return polygon.exterior +def clamp_fully_external_path(path, polygon): + """Clamp a path that lies entirely outside a polygon.""" + + start = ShapelyPoint(path[0]) + end = ShapelyPoint(path[-1]) + + start_on_outline = nearest_points(start, polygon.exterior)[1].buffer(0.01, resolution=1) + end_on_outline = nearest_points(end, polygon.exterior)[1].buffer(0.01, resolution=1) + + border_pieces = ensure_multi_line_string(polygon.exterior.difference(MultiPolygon((start_on_outline, end_on_outline)))).geoms + border_pieces = fix_starting_point(border_pieces) + shorter = min(border_pieces, key=lambda piece: piece.length) + + return adjust_line_end(shorter, start) + + def clamp_path_to_polygon(path, polygon): """Constrain a path to a Polygon. @@ -143,4 +163,7 @@ def clamp_path_to_polygon(path, polygon): else: was_inside = False + if not result: + return clamp_fully_external_path(path, polygon) + return segments_to_path(result) diff --git a/lib/utils/geometry.py b/lib/utils/geometry.py index 24cf8459..541d9cbc 100644 --- a/lib/utils/geometry.py +++ b/lib/utils/geometry.py @@ -197,6 +197,37 @@ def cut_path(points, length): return [Point(*point) for point in subpath.coords] +def offset_points(pos1, pos2, offset_px, offset_proportional): + """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 + + # calculate the offset for each side + offset_a = offset_px[0] + (distance * offset_proportional[0]) + offset_b = offset_px[1] + (distance * offset_proportional[1]) + offset_total = offset_a + offset_b + + # don't contract beyond the midpoint, or we'll start expanding + if offset_total < -distance: + scale = -distance / offset_total + offset_a = offset_a * scale + offset_b = offset_b * scale + + # convert offset to float before using because it may be a numpy.float64 + out1 = pos1 + (pos1 - pos2).unit() * float(offset_a) + out2 = pos2 + (pos2 - pos1).unit() * float(offset_b) + + return out1, out2 + + class Point: def __init__(self, x: typing.Union[float, numpy.float64], y: typing.Union[float, numpy.float64]): self.x = float(x) diff --git a/lib/utils/list.py b/lib/utils/list.py index efa3969e..e5838b5a 100644 --- a/lib/utils/list.py +++ b/lib/utils/list.py @@ -21,3 +21,7 @@ def poprandom(sequence, rng=_rng): sequence[index] = last_item return item + + +def is_all_zeroes(sequence): + return all(item == 0 for item in sequence) |