From 7445b91851f6bd4abc255490f917f6c578bbf0f1 Mon Sep 17 00:00:00 2001 From: Kaalleen <36401965+kaalleen@users.noreply.github.com> Date: Thu, 10 Nov 2022 14:03:32 +0100 Subject: lettering: ignore invalid glyph layers (#1892) --- lib/elements/fill_stitch.py | 3 ++- lib/lettering/font_variant.py | 5 ++++- lib/stitches/fill.py | 2 +- lib/stitches/guided_fill.py | 2 +- 4 files changed, 8 insertions(+), 4 deletions(-) (limited to 'lib') diff --git a/lib/elements/fill_stitch.py b/lib/elements/fill_stitch.py index ca44e3cc..a5248952 100644 --- a/lib/elements/fill_stitch.py +++ b/lib/elements/fill_stitch.py @@ -216,7 +216,8 @@ class FillStitch(EmbroideryElement): @property @param('staggers', _('Stagger rows this many times before repeating'), - tooltip=_('Length of the cycle by which successive stitch rows are staggered. Fractional values are allowed and can have less visible diagonals than integer values.'), + tooltip=_('Length of the cycle by which successive stitch rows are staggered.' + 'Fractional values are allowed and can have less visible diagonals than integer values.'), type='int', sort_index=6, select_items=[('fill_method', 0), ('fill_method', 2), ('fill_method', 3)], diff --git a/lib/lettering/font_variant.py b/lib/lettering/font_variant.py index a7f353fe..ecdba137 100644 --- a/lib/lettering/font_variant.py +++ b/lib/lettering/font_variant.py @@ -69,7 +69,10 @@ class FontVariant(object): self._clean_group(layer) layer.attrib[INKSCAPE_LABEL] = layer.attrib[INKSCAPE_LABEL].replace("GlyphLayer-", "", 1) glyph_name = layer.attrib[INKSCAPE_LABEL] - self.glyphs[glyph_name] = Glyph(layer) + try: + self.glyphs[glyph_name] = Glyph(layer) + except AttributeError: + pass def _clean_group(self, group): # We'll repurpose the layer as a container group labelled with the diff --git a/lib/stitches/fill.py b/lib/stitches/fill.py index ed4ff655..60a0cb7d 100644 --- a/lib/stitches/fill.py +++ b/lib/stitches/fill.py @@ -38,7 +38,7 @@ def row_num(point, angle, row_spacing): def adjust_stagger(stitch, angle, row_spacing, max_stitch_length, staggers): if staggers == 0: - staggers = 1 # sanity check to avoid division by zero. + staggers = 1 # sanity check to avoid division by zero. this_row_num = row_num(stitch, angle, row_spacing) stagger_phase = (this_row_num / staggers) % 1 stagger_offset = stagger_phase * max_stitch_length diff --git a/lib/stitches/guided_fill.py b/lib/stitches/guided_fill.py index 6a92f8e8..14c58b7a 100644 --- a/lib/stitches/guided_fill.py +++ b/lib/stitches/guided_fill.py @@ -149,7 +149,7 @@ def take_only_line_strings(thing): def apply_stitches(line, max_stitch_length, num_staggers, row_spacing, row_num): if num_staggers == 0: - num_staggers = 1 # sanity check to avoid division by zero. + num_staggers = 1 # sanity check to avoid division by zero. start = ((row_num / num_staggers) % 1) * max_stitch_length projections = np.arange(start, line.length, max_stitch_length) points = np.array([line.interpolate(projection).coords[0] for projection in projections]) -- cgit v1.2.3 From 8d0e80e5f10cc05cc3b14b1b8061c8e6aa6a2fef Mon Sep 17 00:00:00 2001 From: Kaalleen <36401965+kaalleen@users.noreply.github.com> Date: Tue, 22 Nov 2022 09:49:08 +0100 Subject: fix clone positioning and angles (#1837) --- lib/elements/clone.py | 81 +++++++++++++++++++++++++++++++++------------------ lib/svg/tags.py | 1 + 2 files changed, 54 insertions(+), 28 deletions(-) (limited to 'lib') diff --git a/lib/elements/clone.py b/lib/elements/clone.py index d9185012..b5507e4f 100644 --- a/lib/elements/clone.py +++ b/lib/elements/clone.py @@ -3,12 +3,13 @@ # Copyright (c) 2010 Authors # Licensed under the GNU GPL version 3.0 or later. See the file LICENSE for details. -from math import atan, degrees +from math import atan2, degrees, radians + +from inkex import CubicSuperPath, Path, Transform from ..commands import is_command_symbol from ..i18n import _ from ..svg.path import get_node_transform -from ..svg.svg import find_elements from ..svg.tags import (EMBROIDERABLE_TAGS, INKSTITCH_ATTRIBS, SVG_USE_TAG, XLINK_HREF) from ..utils import cache @@ -60,7 +61,16 @@ class Clone(EmbroideryElement): type='float') @cache def clone_fill_angle(self): - return self.get_float_param('angle', 0) + return self.get_float_param('angle') or None + + @property + @param('flip_angle', + _('Flip angle'), + tooltip=_("Flip automatically calucalted angle if it appears to be wrong."), + type='boolean') + @cache + def flip_angle(self): + return self.get_boolean_param('flip_angle') def clone_to_element(self, node): from .utils import node_to_elements @@ -73,33 +83,51 @@ class Clone(EmbroideryElement): if source_node.tag not in EMBROIDERABLE_TAGS: return [] - self.node.style = source_node.specified_style() - - # a. a custom set fill angle - # b. calculated rotation for the cloned fill element to look exactly as it's source - param = INKSTITCH_ATTRIBS['angle'] - if self.clone_fill_angle is not None: - angle = self.clone_fill_angle + old_transform = source_node.get('transform', '') + source_transform = source_node.composed_transform() + source_path = Path(source_node.get_path()).transform(source_transform) + transform = Transform(source_node.get('transform', '')) @ -source_transform + transform @= self.node.composed_transform() @ Transform(source_node.get('transform', '')) + source_node.set('transform', transform) + + old_angle = float(source_node.get(INKSTITCH_ATTRIBS['angle'], 0)) + if self.clone_fill_angle is None: + rot = transform.add_rotate(-old_angle) + angle = self._get_rotation(rot, source_node, source_path) + if angle is not None: + source_node.set(INKSTITCH_ATTRIBS['angle'], angle) else: - # clone angle - clone_mat = self.node.composed_transform() - clone_angle = degrees(atan(-clone_mat[1][0]/clone_mat[1][1])) - # source node angle - source_mat = source_node.composed_transform() - source_angle = degrees(atan(-source_mat[1][0]/source_mat[1][1])) - # source node fill angle - source_fill_angle = source_node.get(param, 0) - - angle = clone_angle + float(source_fill_angle) - source_angle - self.node.set(param, str(angle)) - - elements = self.clone_to_element(self.node) + source_node.set(INKSTITCH_ATTRIBS['angle'], self.clone_fill_angle) + elements = self.clone_to_element(source_node) for element in elements: - patches.extend(element.to_stitch_groups(last_patch)) + stitch_groups = element.to_stitch_groups(last_patch) + patches.extend(stitch_groups) + source_node.set('transform', old_transform) + source_node.set(INKSTITCH_ATTRIBS['angle'], old_angle) return patches + def _get_rotation(self, transform, source_node, source_path): + try: + rotation = transform.rotation_degrees() + except ValueError: + source_path = CubicSuperPath(source_path)[0] + clone_path = Path(source_node.get_path()).transform(source_node.composed_transform()) + clone_path = CubicSuperPath(clone_path)[0] + + angle_source = atan2(source_path[1][1][1] - source_path[0][1][1], source_path[1][1][0] - source_path[0][1][0]) + angle_clone = atan2(clone_path[1][1][1] - clone_path[0][1][1], clone_path[1][1][0] - clone_path[0][1][0]) + angle_embroidery = radians(-float(source_node.get(INKSTITCH_ATTRIBS['angle'], 0))) + + diff = angle_source - angle_embroidery + rotation = degrees(diff + angle_clone) + + if self.flip_angle: + rotation = -degrees(diff - angle_clone) + + return -rotation + def get_clone_style(self, style_name, node, default=None): style = node.style[style_name] or default return style @@ -132,7 +160,4 @@ def is_embroiderable_clone(node): def get_clone_source(node): - source_id = node.get(XLINK_HREF)[1:] - xpath = ".//*[@id='%s']" % (source_id) - source_node = find_elements(node, xpath)[0] - return source_node + return node.href diff --git a/lib/svg/tags.py b/lib/svg/tags.py index d113bb6d..6452cbf3 100644 --- a/lib/svg/tags.py +++ b/lib/svg/tags.py @@ -53,6 +53,7 @@ inkstitch_attribs = [ 'force_lock_stitches', # clone 'clone', + 'flip_angle', # polyline 'polyline', # fill -- cgit v1.2.3 From 4c845df846889e50016bcc0a7d56df5d01102fdf Mon Sep 17 00:00:00 2001 From: Kaalleen <36401965+kaalleen@users.noreply.github.com> Date: Tue, 22 Nov 2022 09:50:21 +0100 Subject: small zigzag warning (#1891) --- lib/elements/stroke.py | 23 ++++++++++++++++++++++- 1 file changed, 22 insertions(+), 1 deletion(-) (limited to 'lib') diff --git a/lib/elements/stroke.py b/lib/elements/stroke.py index ce973c0e..2854adaf 100644 --- a/lib/elements/stroke.py +++ b/lib/elements/stroke.py @@ -39,6 +39,14 @@ class MultipleGuideLineWarning(ValidationWarning): ] +class SmallZigZagWarning(ValidationWarning): + name = _("Small ZigZag") + description = _("This zig zag stitch has a stroke width smaller than 0.5 units.") + steps_to_solve = [ + _("Set your stroke to be dashed to indicate running stitch. Any kind of dash will work.") + ] + + class Stroke(EmbroideryElement): element_name = _("Stroke") @@ -481,6 +489,15 @@ class Stroke(EmbroideryElement): return guide_lines['satin'][0] return guide_lines['stroke'][0] + def _representative_point(self): + # if we just take the center of a line string we could end up on some point far away from the actual line + try: + coords = list(self.shape.coords) + except NotImplementedError: + # linear rings to not have a coordinate sequence + coords = list(self.shape.exterior.coords) + return coords[int(len(coords)/2)] + def validation_warnings(self): if self.stroke_method == 1 and self.skip_start + self.skip_end >= self.line_count: yield IgnoreSkipValues(self.shape.centroid) @@ -489,4 +506,8 @@ class Stroke(EmbroideryElement): if self.stroke_method == 1: guide_lines = get_marker_elements(self.node, "guide-line", False, True, True) if sum(len(x) for x in guide_lines.values()) > 1: - yield MultipleGuideLineWarning(self.shape.centroid) + yield MultipleGuideLineWarning(self._representative_point()) + + stroke_width, units = parse_length_with_units(self.get_style("stroke-width", "1")) + if not self.dashed and stroke_width <= 0.5: + yield SmallZigZagWarning(self._representative_point()) -- cgit v1.2.3 From e761d8b42c178d3e9a940963234d4cd62c777f59 Mon Sep 17 00:00:00 2001 From: Kaalleen <36401965+kaalleen@users.noreply.github.com> Date: Tue, 22 Nov 2022 10:21:45 +0100 Subject: Convert to gradient blocks extension (#1844) --- lib/elements/gradient_fill.py | 79 +++++++++++++++++++++++++++++++++++++++ lib/extensions/__init__.py | 2 + lib/extensions/gradient_blocks.py | 69 ++++++++++++++++++++++++++++++++++ 3 files changed, 150 insertions(+) create mode 100644 lib/elements/gradient_fill.py create mode 100644 lib/extensions/gradient_blocks.py (limited to 'lib') diff --git a/lib/elements/gradient_fill.py b/lib/elements/gradient_fill.py new file mode 100644 index 00000000..5ac49c4e --- /dev/null +++ b/lib/elements/gradient_fill.py @@ -0,0 +1,79 @@ +from math import pi + +from inkex import DirectedLineSegment, Transform +from shapely import geometry as shgeo +from shapely.affinity import affine_transform, rotate +from shapely.ops import split + +from ..svg import get_correction_transform + + +def gradient_shapes_and_attributes(element, shape): + # e.g. url(#linearGradient872) -> linearGradient872 + color = element.color[5:-1] + xpath = f'.//svg:defs/svg:linearGradient[@id="{color}"]' + gradient = element.node.getroottree().getroot().findone(xpath) + gradient.apply_transform() + point1 = (float(gradient.get('x1')), float(gradient.get('y1'))) + point2 = (float(gradient.get('x2')), float(gradient.get('y2'))) + # get 90° angle to calculate the splitting angle + line = DirectedLineSegment(point1, point2) + angle = line.angle - (pi / 2) + # Ink/Stitch somehow turns the stitch angle + stitch_angle = angle * -1 + # create bbox polygon to calculate the length necessary to make sure that + # the gradient splitter lines will cut the entire design + bbox = element.node.bounding_box() + bbox_polygon = shgeo.Polygon([(bbox.left, bbox.top), (bbox.right, bbox.top), + (bbox.right, bbox.bottom), (bbox.left, bbox.bottom)]) + # gradient stops + offsets = gradient.stop_offsets + stop_styles = gradient.stop_styles + # now split the shape according to the gradient stops + polygons = [] + colors = [] + attributes = [] + previous_color = None + end_row_spacing = None + for i, offset in enumerate(offsets): + shape_rest = [] + split_point = shgeo.Point(line.point_at_ratio(float(offset))) + length = split_point.hausdorff_distance(bbox_polygon) + split_line = shgeo.LineString([(split_point.x - length - 2, split_point.y), + (split_point.x + length + 2, split_point.y)]) + split_line = rotate(split_line, angle, origin=split_point, use_radians=True) + transform = -Transform(get_correction_transform(element.node)) + transform = list(transform.to_hexad()) + split_line = affine_transform(split_line, transform) + offset_line = split_line.parallel_offset(1, 'right') + polygon = split(shape, split_line) + color = stop_styles[i]['stop-color'] + # does this gradient line split the shape + offset_outside_shape = len(polygon.geoms) == 1 + for poly in polygon.geoms: + if isinstance(poly, shgeo.Polygon) and element.shape_is_valid(poly): + if poly.intersects(offset_line): + if previous_color: + polygons.append(poly) + colors.append(previous_color) + attributes.append({'angle': stitch_angle, 'end_row_spacing': end_row_spacing, 'color': previous_color}) + polygons.append(poly) + attributes.append({'angle': stitch_angle + pi, 'end_row_spacing': end_row_spacing, 'color': color}) + else: + shape_rest.append(poly) + shape = shgeo.MultiPolygon(shape_rest) + previous_color = color + end_row_spacing = element.row_spacing * 2 + # add left over shape(s) + if shape: + if offset_outside_shape: + for s in shape.geoms: + polygons.append(s) + attributes.append({'color': stop_styles[-2]['stop-color'], 'angle': stitch_angle, 'end_row_spacing': end_row_spacing}) + stitch_angle += pi + else: + end_row_spacing = None + for s in shape.geoms: + polygons.append(s) + attributes.append({'color': stop_styles[-1]['stop-color'], 'angle': stitch_angle, 'end_row_spacing': end_row_spacing}) + return polygons, attributes diff --git a/lib/extensions/__init__.py b/lib/extensions/__init__.py index f1837c59..5c702ce8 100644 --- a/lib/extensions/__init__.py +++ b/lib/extensions/__init__.py @@ -21,6 +21,7 @@ from .embroider_settings import EmbroiderSettings from .flip import Flip from .generate_palette import GeneratePalette from .global_commands import GlobalCommands +from .gradient_blocks import GradientBlocks from .input import Input from .install import Install from .install_custom_palette import InstallCustomPalette @@ -79,6 +80,7 @@ __all__ = extensions = [StitchPlanPreview, RemoveEmbroiderySettings, Cleanup, BreakApart, + GradientBlocks, ApplyThreadlist, InstallCustomPalette, GeneratePalette, diff --git a/lib/extensions/gradient_blocks.py b/lib/extensions/gradient_blocks.py new file mode 100644 index 00000000..5159149f --- /dev/null +++ b/lib/extensions/gradient_blocks.py @@ -0,0 +1,69 @@ +# Authors: see git history +# +# Copyright (c) 2010 Authors +# Licensed under the GNU GPL version 3.0 or later. See the file LICENSE for details. + +from math import degrees + +from inkex import PathElement, errormsg + +from ..elements import FillStitch +from ..elements.gradient_fill import gradient_shapes_and_attributes +from ..i18n import _ +from ..svg import get_correction_transform +from ..svg.tags import INKSTITCH_ATTRIBS +from .base import InkstitchExtension + + +class GradientBlocks(InkstitchExtension): + ''' + This will break apart fill objects with a gradient fill into solid color blocks with end_row_spacing. + ''' + + def effect(self): + if not self.svg.selection: + errormsg(_("Please select at least one object with a gradient fill.")) + return + + if not self.get_elements(): + return + + elements = [element for element in self.elements if (isinstance(element, FillStitch) and self.has_gradient_color(element))] + if not elements: + errormsg(_("Please select at least one object with a gradient fill.")) + return + + for element in elements: + parent = element.node.getparent() + correction_transform = get_correction_transform(element.node) + style = element.node.style + index = parent.index(element.node) + fill_shapes, attributes = gradient_shapes_and_attributes(element, element.shape) + # reverse order so we can always insert with the same index number + fill_shapes.reverse() + attributes.reverse() + for i, shape in enumerate(fill_shapes): + style['fill'] = attributes[i]['color'] + end_row_spacing = attributes[i]['end_row_spacing'] or None + angle = degrees(attributes[i]['angle']) + d = "M " + " ".join([f'{x}, {y}' for x, y in list(shape.exterior.coords)]) + " Z" + block = PathElement(attrib={ + "id": self.uniqueId("path"), + "style": str(style), + "transform": correction_transform, + "d": d, + INKSTITCH_ATTRIBS['angle']: f'{angle: .2f}' + }) + if end_row_spacing: + block.set('inkstitch:end_row_spacing_mm', f'{end_row_spacing: .2f}') + block.set('inkstitch:underpath', False) + parent.insert(index, block) + parent.remove(element.node) + + def has_gradient_color(self, element): + return element.color.startswith('url') and "linearGradient" in element.color + + +if __name__ == '__main__': + e = GradientBlocks() + e.effect() -- cgit v1.2.3 From 43a31ba80ee844699a52341ff7d6ef6b881e6276 Mon Sep 17 00:00:00 2001 From: Claudine Peyrat <88194877+claudinepeyrat06@users.noreply.github.com> Date: Tue, 22 Nov 2022 10:46:44 +0100 Subject: Claudine/lettering with trims (#1866) * add trim after each letter allow to add a trim after each letter * add trim after letter, word or line rewriting everythng * style correction correcting all that is signaled by make style * corrections i don't understand why i add to modify get_command_pos in commands. If I don't i can not add a command at the end of a glyph that ends with a polyline (eg B from Fold) * replace checkbox with dropdown * rename variables in English * use same trim methods for auto_satin and non auto_satin * check if trim option is never strip lines of text Co-authored-by: Claudine Co-authored-by: Kaalleen Co-authored-by: Kaalleen <36401965+kaalleen@users.noreply.github.com> --- lib/commands.py | 8 ++++- lib/extensions/lettering.py | 31 ++++++++++-------- lib/lettering/font.py | 80 ++++++++++++++++++++++++++++++++++++++------- 3 files changed, 94 insertions(+), 25 deletions(-) (limited to 'lib') diff --git a/lib/commands.py b/lib/commands.py index a7affb6d..6280fc0c 100644 --- a/lib/commands.py +++ b/lib/commands.py @@ -347,7 +347,13 @@ def get_command_pos(element, index, total): # Put command symbols 30 pixels out from the shape, spaced evenly around it. # get a line running 30 pixels out from the shape - outline = element.shape.buffer(30).exterior + + if not isinstance(element.shape.buffer(30), shgeo.MultiPolygon): + outline = element.shape.buffer(30).exterior + else: + polygons = element.shape.buffer(30).geoms + polygon = polygons[len(polygons)-1] + outline = polygon.exterior # find the top center point on the outline and start there top_center = shgeo.Point(outline.centroid.x, outline.bounds[1]) diff --git a/lib/extensions/lettering.py b/lib/extensions/lettering.py index c870a764..40fd48af 100644 --- a/lib/extensions/lettering.py +++ b/lib/extensions/lettering.py @@ -71,8 +71,9 @@ class LetteringFrame(wx.Frame): self.back_and_forth_checkbox = wx.CheckBox(self, label=_("Stitch lines of text back and forth")) self.back_and_forth_checkbox.Bind(wx.EVT_CHECKBOX, lambda event: self.on_change("back_and_forth", event)) - self.trim_checkbox = wx.CheckBox(self, label=_("Add trims")) - self.trim_checkbox.Bind(wx.EVT_CHECKBOX, lambda event: self.on_change("trim", event)) + self.trim_option_choice = wx.Choice(self, choices=["Never", "after each line", "after each word", "after each letter"], + name=_("Add trim after")) + self.trim_option_choice.Bind(wx.EVT_CHOICE, lambda event: self.on_trim_option_change(event)) # text editor self.text_input_box = wx.StaticBox(self, wx.ID_ANY, label=_("Text")) @@ -105,7 +106,8 @@ class LetteringFrame(wx.Frame): "text": "", "back_and_forth": False, "font": None, - "scale": 100 + "scale": 100, + "trim_option": 0 }) if INKSTITCH_LETTERING in self.group.attrib: @@ -123,7 +125,7 @@ class LetteringFrame(wx.Frame): def apply_settings(self): """Make the settings in self.settings visible in the UI.""" self.back_and_forth_checkbox.SetValue(bool(self.settings.back_and_forth)) - self.trim_checkbox.SetValue(bool(self.settings.trim)) + self.trim_option_choice.SetSelection(self.settings.trim_option) self.set_initial_font(self.settings.font) self.text_editor.SetValue(self.settings.text) self.scale_spinner.SetValue(self.settings.scale) @@ -219,6 +221,10 @@ class LetteringFrame(wx.Frame): self.settings[attribute] = event.GetEventObject().GetValue() self.preview.update() + def on_trim_option_change(self, event=None): + self.settings.trim_option = self.trim_option_choice.GetCurrentSelection() + self.preview.update() + def on_font_changed(self, event=None): font = self.fonts.get(self.font_chooser.GetValue(), self.default_font) self.settings.font = font.marked_custom_font_id @@ -253,13 +259,6 @@ class LetteringFrame(wx.Frame): self.back_and_forth_checkbox.Disable() self.back_and_forth_checkbox.SetValue(False) - if font.auto_satin: - self.trim_checkbox.Enable() - self.trim_checkbox.SetValue(bool(self.settings.trim)) - else: - self.trim_checkbox.Disable() - self.trim_checkbox.SetValue(False) - self.update_preview() self.Layout() @@ -314,7 +313,9 @@ class LetteringFrame(wx.Frame): font = self.fonts.get(self.font_chooser.GetValue(), self.default_font) try: - font.render_text(self.settings.text, destination_group, back_and_forth=self.settings.back_and_forth, trim=self.settings.trim) + font.render_text(self.settings.text, destination_group, back_and_forth=self.settings.back_and_forth, + trim_option=self.settings.trim_option) + except FontError as e: if raise_error: inkex.errormsg(_("Error: Text cannot be applied to the document.\n%s") % e) @@ -400,7 +401,11 @@ class LetteringFrame(wx.Frame): # options left_option_sizer = wx.BoxSizer(wx.VERTICAL) left_option_sizer.Add(self.back_and_forth_checkbox, 1, wx.EXPAND | wx.LEFT | wx.TOP | wx.RIGHT, 5) - left_option_sizer.Add(self.trim_checkbox, 1, wx.EXPAND | wx.LEFT | wx.TOP | wx.RIGHT | wx.BOTTOM, 5) + + trim_option_sizer = wx.BoxSizer(wx.HORIZONTAL) + trim_option_sizer.Add(wx.StaticText(self, wx.ID_ANY, "Add trims"), 0, wx.LEFT | wx.ALIGN_CENTRE_VERTICAL, 5) + trim_option_sizer.Add(self.trim_option_choice, 1, wx.EXPAND | wx.LEFT | wx.TOP | wx.RIGHT | wx.BOTTOM, 5) + left_option_sizer.Add(trim_option_sizer, 0, wx.ALIGN_LEFT, 5) font_scale_sizer = wx.BoxSizer(wx.HORIZONTAL) font_scale_sizer.Add(wx.StaticText(self, wx.ID_ANY, "Scale"), 0, wx.LEFT | wx.ALIGN_CENTRE_VERTICAL, 0) diff --git a/lib/lettering/font.py b/lib/lettering/font.py index 328d2ba4..5a617da1 100644 --- a/lib/lettering/font.py +++ b/lib/lettering/font.py @@ -10,15 +10,16 @@ from random import randint import inkex -from ..commands import ensure_symbol -from ..elements import nodes_to_elements +from ..commands import add_commands, ensure_symbol +from ..elements import FillStitch, Stroke, nodes_to_elements from ..exceptions import InkstitchException from ..extensions.lettering_custom_font_dir import get_custom_font_dir from ..i18n import _, get_languages -from ..marker import MARKER, ensure_marker +from ..marker import MARKER, ensure_marker, has_marker from ..stitches.auto_satin import auto_satin -from ..svg.tags import (CONNECTION_END, CONNECTION_START, INKSCAPE_LABEL, - SVG_PATH_TAG, SVG_USE_TAG, XLINK_HREF) +from ..svg.tags import (CONNECTION_END, CONNECTION_START, EMBROIDERABLE_TAGS, + INKSCAPE_LABEL, SVG_GROUP_TAG, SVG_PATH_TAG, + SVG_USE_TAG, XLINK_HREF) from ..utils import Point from .font_variant import FontVariant @@ -180,7 +181,8 @@ class Font(object): def is_custom_font(self): return get_custom_font_dir() in self.path - def render_text(self, text, destination_group, variant=None, back_and_forth=True, trim=False): + def render_text(self, text, destination_group, variant=None, back_and_forth=True, trim_option=0): + """Render text into an SVG group element.""" self._load_variants() @@ -206,7 +208,7 @@ class Font(object): position.y += self.leading if self.auto_satin and len(destination_group) > 0: - self._apply_auto_satin(destination_group, trim) + self._apply_auto_satin(destination_group) # make sure font stroke styles have always a similar look for element in destination_group.iterdescendants(SVG_PATH_TAG): @@ -220,6 +222,8 @@ class Font(object): style += inkex.Style("stroke-width:0.5px") element.set('style', '%s' % style.to_str()) + # add trims + self._add_trims(destination_group, text, trim_option, back_and_forth) # make sure necessary marker and command symbols are in the defs section self._ensure_command_symbols(destination_group) self._ensure_marker_symbols(destination_group) @@ -309,6 +313,10 @@ class Font(object): self._update_commands(node, glyph) + # this is used to recognize a glyph layer later in the process + # because this is not unique it will be overwritten by inkscape when inserted into the document + node.set("id", "glyph") + return node def _update_commands(self, node, glyph): @@ -329,6 +337,58 @@ class Font(object): c.set(CONNECTION_END, "#%s" % new_element_id) c.set(CONNECTION_START, "#%s" % new_symbol_id) + def _add_trims(self, destination_group, text, trim_option, back_and_forth): + """ + trim_option == 0 --> no trims + trim_option == 1 --> trim at the end of each line + trim_option == 2 --> trim after each word + trim_option == 3 --> trim after each letter + """ + if trim_option == 0: + return + + # reverse every second line of text if back and forth is true and strip spaces + text = text.splitlines() + text = [t[::-1].strip() if i % 2 != 0 and back_and_forth else t.strip() for i, t in enumerate(text)] + text = "\n".join(text) + + i = -1 + space_indices = [i for i, t in enumerate(text) if t == " "] + line_break_indices = [i for i, t in enumerate(text) if t == "\n"] + for group in destination_group.iterdescendants(SVG_GROUP_TAG): + # make sure we are only looking at glyph groups + if group.get("id") != "glyph": + continue + + i += 1 + while i in space_indices + line_break_indices: + i += 1 + + # letter + if trim_option == 3: + self._process_trim(group) + # word + elif trim_option == 2 and i+1 in space_indices + line_break_indices: + self._process_trim(group) + # line + elif trim_option == 1 and i+1 in line_break_indices: + self._process_trim(group) + + def _process_trim(self, group): + # find the last path that does not carry a marker and add a trim there + for path_child in group.iterdescendants(EMBROIDERABLE_TAGS): + if not has_marker(path_child): + path = path_child + if path.get('style') and "fill" in path.get('style'): + element = FillStitch(path) + else: + element = Stroke(path) + + if element.shape: + element_id = "%s_%s" % (element.node.get('id'), randint(0, 9999)) + element.node.set("id", element_id) + add_commands(element, ['trim']) + def _ensure_command_symbols(self, group): # collect commands commands = set() @@ -349,16 +409,14 @@ class Font(object): for element in marked_elements: element.style['marker-start'] = "url(#inkstitch-%s-marker)" % marker - def _apply_auto_satin(self, group, trim): + def _apply_auto_satin(self, group): """Apply Auto-Satin to an SVG XML node tree with an svg:g at its root. The group's contents will be replaced with the results of the auto- satin operation. Any nested svg:g elements will be removed. """ - # TODO: trim option for non-auto-route - elements = nodes_to_elements(group.iterdescendants(SVG_PATH_TAG)) if elements: - auto_satin(elements, preserve_order=True, trim=trim) + auto_satin(elements, preserve_order=True, trim=False) -- cgit v1.2.3