kopia lustrzana https://github.com/inkstitch/inkstitch
105 wiersze
3.2 KiB
Python
105 wiersze
3.2 KiB
Python
from inkex import Path
|
|
from shapely import geometry as shgeo
|
|
|
|
from ..i18n import _
|
|
from ..utils import cache
|
|
from ..utils.geometry import Point
|
|
from .element import EmbroideryElement, Patch, param
|
|
from .validation import ValidationWarning
|
|
|
|
|
|
class PolylineWarning(ValidationWarning):
|
|
name = _("Polyline Object")
|
|
description = _("This object is an SVG PolyLine. Ink/Stitch can work with this shape, "
|
|
"but you can't edit it in Inkscape. Convert it to a manual stitch path "
|
|
"to allow editing.")
|
|
steps_to_solve = [
|
|
_("* Select this object."),
|
|
_("* Do Path > Object to Path."),
|
|
_('* Optional: Run the Params extension and check the "manual stitch" box.')
|
|
]
|
|
|
|
|
|
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.
|
|
|
|
element_name = "Polyline"
|
|
|
|
@property
|
|
@param('polyline', _('Manual stitch along path'), type='toggle', inverse=True)
|
|
def polyline(self):
|
|
return self.get_boolean_param("polyline")
|
|
|
|
@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
|
|
@cache
|
|
def shape(self):
|
|
return shgeo.LineString(self.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 = self.node.get_path()
|
|
path = Path(path).to_superpath()
|
|
|
|
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", "#000000")
|
|
|
|
@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 validation_warnings(self):
|
|
yield PolylineWarning(self.points[0])
|
|
|
|
def to_patches(self, last_patch):
|
|
patch = Patch(color=self.color)
|
|
|
|
for stitch in self.stitches:
|
|
patch.add_stitch(Point(*stitch))
|
|
|
|
return [patch]
|