meerk40t 0.9.7051__py2.py3-none-any.whl → 0.9.7900__py2.py3-none-any.whl

meerk40t/tools/geomstr.py

@@ -199,13 +199,17 @@ def stitcheable_nodes(data, tolerance) -> list:
     if tolerance == 0:
         tolerance = 1e-6
     for idx1, (nodeidx1, g1) in enumerate(geoms):
+        fp1 = g1.first_point
+        lp1 = g1.last_point
+        if fp1 is None or lp1 is None:
+            continue
         for idx2 in range(idx1 + 1, len(geoms)):
             nodeidx2 = geoms[idx2][0]
             g2 = geoms[idx2][1]
-            fp1 = g1.first_point
             fp2 = g2.first_point
-            lp1 = g1.last_point
             lp2 = g2.last_point
+            if fp2 is None or lp2 is None:
+                continue
             if (
                 abs(lp1 - lp2) <= tolerance
                 or abs(lp1 - fp2) <= tolerance
@@ -251,11 +255,16 @@ def stitch_geometries(geometry_list: list, tolerance: float = 0.0) -> list:
         while geometries:
             candidate = geometries.pop(0)
             stitched = False
+            cand_fp = candidate.first_point
+            cand_lp = candidate.last_point
+            if cand_fp is None or cand_lp is None:
+                stitched_geometries.append(candidate)
+                continue
             for i, target in enumerate(stitched_geometries):
-                cand_fp = candidate.first_point
-                cand_lp = candidate.last_point
                 targ_fp = target.first_point
                 targ_lp = target.last_point
+                if targ_fp is None or targ_lp is None:
+                    continue
                 if abs(targ_lp - cand_fp) <= tolerance:
                     # Just append g1 to g2
                     if abs(targ_lp - cand_fp) > 0:
@@ -496,7 +505,7 @@ class Simplifier:
 
     def by_ratio(self, r):
         if r <= 0 or r > 1:
-            raise ValueError("Ratio must be 0<r<=1. Got {}".format(r))
+            raise ValueError(f"Ratio must be 0<r<=1. Got {r}")
 
         return self.by_number(r * len(self.thresholds))
 
@@ -531,7 +540,7 @@ class Clip:
                 x3 < y3,
             )
         ).all(axis=2)
-        splits = [list() for _ in range(len(subject))]
+        splits = [[] for _ in range(len(subject))]
         for s0, s1 in sorted(np.argwhere(checks), key=lambda e: e[0], reverse=True):
             splits[s0].extend(
                 [t for t, _ in subject.intersections(int(s0), clip.segments[s1])]
@@ -546,7 +555,7 @@ class Clip:
         @param clip:
         @return:
         """
-        splits = [list() for _ in range(len(subject))]
+        splits = [[] for _ in range(len(subject))]
         for s0 in range(len(subject)):
             for s1 in range(len(clip)):
                 for t0, t1 in subject.intersections(int(s0), clip.segments[s1]):
@@ -774,12 +783,12 @@ class Pattern:
         # Scale once, translate often
         m = Matrix.scale(cw, ch)
         geom = self.geomstr.as_transformed(m)
-        for col in range(start_value_x, cols + end_value_x, 1):
+        for col in range(start_value_x, cols + end_value_x):
             x_offset = col * (cw + 2 * px)
             x = top_left_x + x_offset
 
             top_left_y = y0
-            for row in range(start_value_y, rows + end_value_y, 1):
+            for row in range(start_value_y, rows + end_value_y):
                 y_offset = row * (ch + 2 * py)
                 if col % 2:
                     y_offset += (ch + 2 * py) / 2
@@ -942,9 +951,9 @@ class BeamTable:
             event = events[i]
             pt, adds, removes, sorts = event
             try:
-                next, _, _, _ = events[i + 1]
+                next_idx, _, _, _ = events[i + 1]
             except IndexError:
-                next = complex(float("inf"), float("inf"))
+                next_idx = complex(float("inf"), float("inf"))
 
             for index in removes:
                 try:
@@ -978,7 +987,7 @@ class BeamTable:
                     # was removed
                     pass
             i += 1
-            if pt == next:
+            if pt == next_idx:
                 continue
             if len(actives) > largest_actives:
                 largest_actives = len(actives)
@@ -1041,11 +1050,11 @@ class BeamTable:
             pt, index, swap = event
 
             try:
-                next, _, _ = events[i + 1]
-                scanline = (pt + next) / 2
+                next_idx, _, _ = events[i + 1]
+                scanline = (pt + next_idx) / 2
             except IndexError:
-                next = complex(float("inf"), float("inf"))
-                scanline = next
+                next_idx = complex(float("inf"), float("inf"))
+                scanline = next_idx
 
             if swap is not None:
                 s1 = actives.index(swap[0])
@@ -1058,7 +1067,7 @@ class BeamTable:
                 remove_index = actives.index(~index)
                 del actives[remove_index]
 
-            if pt != next:
+            if pt != next_idx:
                 if len(actives) > largest_actives:
                     largest_actives = len(actives)
                 # actives.sort(key=y_ints)
@@ -1125,9 +1134,9 @@ class BeamTable:
         starts = np.ravel(np.real(from_vals) + y_start * 1j)
         ends = np.ravel(np.real(to_vals) + y_end * 1j)
 
-        filter = np.dstack((starts != ends, ~np.isnan(starts))).all(axis=2)[0]
-        starts = starts[filter]
-        ends = ends[filter]
+        filtered = np.dstack((starts != ends, ~np.isnan(starts))).all(axis=2)[0]
+        starts = starts[filtered]
+        ends = ends[filtered]
         count = starts.shape[0]
         segments = np.dstack(
             (starts, [0] * count, [TYPE_LINE] * count, [0] * count, ends)
@@ -1575,7 +1584,7 @@ class Geomstr:
     """
 
     def __init__(self, segments=None):
-        self._settings = dict()
+        self._settings = {}
         if segments is not None:
             if isinstance(segments, Geomstr):
                 self._settings.update(segments._settings)
@@ -2261,13 +2270,13 @@ class Geomstr:
         @param end_pos:
         @param start_pos:
         """
-        segments = list()
+        segments = []
         for point in self.as_contiguous_points(start_pos=start_pos, end_pos=end_pos):
             if isinstance(point, tuple):
                 point, settings = point
                 if segments:
                     yield segments, settings
-                    segments = list()
+                    segments = []
             else:
                 segments.append(point)
 
@@ -2331,12 +2340,12 @@ class Geomstr:
         @param distance:
         @return:
         """
-        segments = list()
+        segments = []
         for point in self.as_equal_interpolated_points(distance=distance):
             if point is None:
                 if segments:
                     yield segments
-                    segments = list()
+                    segments = []
             else:
                 segments.append(point)
         if segments:
@@ -2445,12 +2454,12 @@ class Geomstr:
         @param interpolate:
         @return:
         """
-        segments = list()
+        segments = []
         for point in self.as_interpolated_points(interpolate=interpolate):
             if point is None:
                 if segments:
                     yield segments
-                    segments = list()
+                    segments = []
             else:
                 segments.append(point)
         if segments:
@@ -2871,7 +2880,7 @@ class Geomstr:
 
         p_start = point_at_t(current_t)
 
-        for i in range(0, slices):
+        for i in range(slices):
             next_t = current_t + t_slice
             mid_t = (next_t + current_t) / 2
 
@@ -2932,7 +2941,7 @@ class Geomstr:
 
         p_start = point_at_t(current_t)
 
-        for i in range(0, slices):
+        for i in range(slices):
             next_t = current_t + t_slice
             if i == slices - 1:
                 next_t = end_t
@@ -3035,7 +3044,7 @@ class Geomstr:
         c = Clip(other)
         polycut = c.polycut(self, breaks=True)
 
-        geoms = list()
+        geoms = []
         g = Geomstr()
         geoms.append(g)
         for e in polycut.segments[: self.index]:
@@ -4009,10 +4018,9 @@ class Geomstr:
             return
         if segtype2 in NON_GEOMETRY_TYPES:
             return
-        if segtype1 == TYPE_LINE:
-            if segtype2 == TYPE_LINE:
-                yield from self._line_line_intersections(line1, line2)
-                return
+        if segtype1 == TYPE_LINE and segtype2 == TYPE_LINE:
+            yield from self._line_line_intersections(line1, line2)
+            return
         #     if oinfo.real == TYPE_QUAD:
         #         yield from self._line_quad_intersections(line1, line2)
         #         return
@@ -5227,22 +5235,34 @@ class Geomstr:
     def as_contiguous(self):
         """
         Generate individual subpaths of contiguous segments
+        Attention: this will not yield meta segments, like TYPE_NOP and others
 
         @return:
         """
-        last = 0
+        new_segments = []
         for idx, seg in enumerate(self.segments[: self.index]):
             segtype = self._segtype(seg)
+            if segtype in META_TYPES:
+                # Skip meta segments
+                continue
             if segtype == TYPE_END:
-                yield Geomstr(self.segments[last:idx])
-                last = idx + 1
-            elif idx > 0:
-                # are the start and endpositions different?
-                if self.segments[idx, 0] != self.segments[idx - 1, -1]:
-                    yield Geomstr(self.segments[last:idx])
-                    last = idx
-        if last != self.index:
-            yield Geomstr(self.segments[last : self.index])
+                if len(new_segments) > 0:
+                    yield Geomstr(new_segments)
+                new_segments.clear()
+            else:
+                if len(new_segments) == 0:
+                    new_segments.append(seg)
+                elif seg[0] != new_segments[-1][-1]:
+                    # If the start of the current segment is not the end of the last segment
+                    yield Geomstr(new_segments)
+                    new_segments.clear()
+                    new_segments.append(seg)
+                else:
+                    # If the start of the current segment is the end of the last segment
+                    new_segments.append(seg)
+        if len(new_segments) > 0:
+            # If there are still segments left, yield them
+            yield Geomstr(new_segments)
 
     def ensure_proper_subpaths(self):
         """
@@ -5489,7 +5509,7 @@ class Geomstr:
         """
         infos = self.segments[: self.index, 2]
         q = np.where(np.real(infos).astype(int) & 0b1001)[0]
-        for mid in range(0, len(q)):
+        for mid in range(len(q)):
             idxs = q[mid:]
             p1 = idxs[0]
             pen_downs = self.segments[idxs, 0]
@@ -5676,8 +5696,8 @@ class Geomstr:
         if lines is None:
             lines = self.segments[: self.index]
         if function_dict is None:
-            function_dict = dict()
-        default_dict = dict()
+            function_dict = {}
+        default_dict = {}
         defining_function = 0
         function_start = 0
         for index, line in enumerate(lines):
@@ -5735,7 +5755,7 @@ class Geomstr:
         final = Geomstr()
         for subgeom in geom.as_subpaths():
             newgeom = Geomstr()
-            points = list()
+            points = []
             closed = subgeom.is_closed()
 
             def processpts():

meerk40t/tools/rasterplotter.py

@@ -467,11 +467,6 @@ class RasterPlotter:
                 return int(round(self.offset_x)), int(round(self.offset_y))
             else:
                 return self.offset_x, self.offset_y
-        if self.use_integers:
-            if self.use_integers:
-                return int(round(self.offset_x)), int(round(self.offset_y))
-            else:
-                return self.offset_x, self.offset_y
         if self.use_integers:
             return (
                 int(round(self.offset_x + self.final_x * self.step_x)),

meerk40t/tools/ttfparser.py

@@ -15,6 +15,33 @@ USE_MY_METRICS = 1 << 9
 OVERLAP_COMPOUND = 1 << 10
 
 
+def flagname(flag):
+    if flag & ON_CURVE_POINT:
+        return "ON_CURVE_POINT"
+    elif flag & ARG_1_AND_2_ARE_WORDS:
+        return "ARG_1_AND_2_ARE_WORDS"
+    elif flag & ARGS_ARE_XY_VALUES:
+        return "ARGS_ARE_XY_VALUES"
+    elif flag & ROUND_XY_TO_GRID:
+        return "ROUND_XY_TO_GRID"
+    elif flag & WE_HAVE_A_SCALE:
+        return "WE_HAVE_A_SCALE"
+    elif flag & MORE_COMPONENTS:
+        return "MORE_COMPONENTS"
+    elif flag & WE_HAVE_AN_X_AND_Y_SCALE:
+        return "WE_HAVE_AN_X_AND_Y_SCALE"
+    elif flag & WE_HAVE_A_TWO_BY_TWO:
+        return "WE_HAVE_A_TWO_BY_TWO"
+    elif flag & WE_HAVE_INSTRUCTIONS:
+        return "WE_HAVE_INSTRUCTIONS"
+    elif flag & USE_MY_METRICS:
+        return "USE_MY_METRICS"
+    elif flag & OVERLAP_COMPOUND:
+        return "OVERLAP_COMPOUND"
+    else:
+        return f"UNKNOWN_FLAG_{flag}"
+
+
 class TTFParsingError(ValueError):
     """Parsing error"""
 
@@ -76,7 +103,7 @@ class TrueTypeFont:
             self.parse_cmap()
             self.parse_name()
         except Exception as e:
-            print (f"TTF init for {filename} crashed: {e}")
+            print(f"TTF init for {filename} crashed: {e}")
             raise TTFParsingError("Error while parsing data") from e
         self.glyph_data = list(self.parse_glyf())
         self._line_information = []
@@ -209,24 +236,16 @@ class TrueTypeFont:
                         curr = contour[-1]
                         next = contour[0]
                         if curr[2] & ON_CURVE_POINT:
-                            if self.active:
-                                path.move(
-                                    (offset_x + curr[0]) * scale,
-                                    (offset_y + curr[1]) * scale,
-                                )
+                            start_x = (offset_x + curr[0]) * scale
+                            start_y = (offset_y + curr[1]) * scale
+                        elif next[2] & ON_CURVE_POINT:
+                            start_x = (offset_x + next[0]) * scale
+                            start_y = (offset_y + next[1]) * scale
                         else:
-                            if next[2] & ON_CURVE_POINT:
-                                if self.active:
-                                    path.move(
-                                        (offset_x + next[0]) * scale,
-                                        (offset_y + next[1]) * scale,
-                                    )
-                            else:
-                                if self.active:
-                                    path.move(
-                                        (offset_x + (curr[0] + next[0]) / 2) * scale,
-                                        (offset_y + (curr[1] + next[1]) / 2) * scale,
-                                    )
+                            start_x = (offset_x + (curr[0] + next[0]) / 2) * scale
+                            start_y = (offset_y + (curr[1] + next[1]) / 2) * scale
+                        if self.active:
+                            path.move(start_x, start_y)
                         for i in range(len(contour)):
                             prev = curr
                             curr = next
@@ -242,9 +261,10 @@ class TrueTypeFont:
                             else:
                                 next2 = next
                                 if not next[2] & ON_CURVE_POINT:
-                                    next2 = (curr[0] + next[0]) / 2, (
-                                        curr[1] + next[1]
-                                    ) / 2
+                                    next2 = (
+                                        (curr[0] + next[0]) / 2,
+                                        (curr[1] + next[1]) / 2,
+                                    )
                                 if self.active:
                                     path.quad(
                                         None,
@@ -321,10 +341,7 @@ class TrueTypeFont:
                                 )
                     self._raw_tables[tag] = data
             except Exception as e:
-                raise TTFParsingError(
-                    f"invalid format: {e}"
-                ) from e
-
+                raise TTFParsingError(f"invalid format: {e}") from e
 
     def parse_head(self):
         data = self._raw_tables[b"head"]
@@ -576,71 +593,127 @@ class TrueTypeFont:
             yield from self._parse_compound_glyph(data)
 
     def _parse_compound_glyph(self, data):
+        """
+        Parses a compound glyph, which can consist of multiple components.
+        Each component can have its own transformation matrix applied to it.
+        The transformation matrix can include scaling, translation, and rotation.
+        The flags indicate how the arguments are interpreted, whether they are
+        absolute coordinates or relative offsets, and whether the glyph is
+        transformed by a scale, x and y scale, or a two-by-two matrix.
+        The glyphs are returned as a list of contours, where each contour is a
+        list of points. Each point is a tuple of (x, y, flag), where
+        x and y are the coordinates of the point, and flag indicates whether
+        the point is an on-curve point or a control point.
+
+        The flags used in the compound glyphs are defined as follows:
+        - ON_CURVE_POINT: Indicates that the point is an on-curve point.
+        - ARG_1_AND_2_ARE_WORDS: Indicates that the first two arguments are
+          16-bit signed integers instead of 8-bit unsigned integers.
+        - ARGS_ARE_XY_VALUES: Indicates that the arguments are interpreted as
+          x and y coordinates instead of relative offsets.
+        - ROUND_XY_TO_GRID: Indicates that the x and y coordinates should be
+          rounded to the nearest grid point.
+        - WE_HAVE_A_SCALE: Indicates that the glyph is transformed by a single
+          scale factor applied to both x and y coordinates.
+        - MORE_COMPONENTS: Indicates that there are more components in the
+          compound glyph. This flag is used to indicate that the glyph has
+          additional components that need to be processed.
+        - WE_HAVE_AN_X_AND_Y_SCALE: Indicates that the glyph is transformed by
+          separate scale factors for x and y coordinates.
+        - WE_HAVE_A_TWO_BY_TWO: Indicates that the glyph is transformed by a
+          two-by-two matrix, which allows for more complex transformations
+          including rotation and shearing.
+        - WE_HAVE_INSTRUCTIONS: Indicates that the glyph has instructions that
+          modify the rendering of the glyph. These instructions can include
+          additional transformations or adjustments to the glyph's shape.
+        - USE_MY_METRICS: Indicates that the glyph should use its own metrics
+          instead of the metrics defined in the font's horizontal metrics table.
+        - OVERLAP_COMPOUND: Indicates that the components of the compound glyph
+          may overlap. This flag is used to indicate that the components of the
+          compound glyph may overlap, which can affect how the glyph is rendered.
+
+        """
         flags = MORE_COMPONENTS
-        s = 1 << 14
+        scale_factor = 1 << 14  # Fixed point scale factor (16384)
+
+        # Collect all contours from all components
+        all_contours = []
+
         while flags & MORE_COMPONENTS:
-            a, b, c, d, e, f = (
-                1.0,
-                0.0,
-                0.0,
-                1.0,
-                0.0,
-                0.0,
-            )
-            dest, src = -1, -1
+            # Initialize transformation matrix as identity
+            # Matrix format: [xx, xy, yx, yy, dx, dy]
+            # Represents: [x'] = [xx xy] [x] + [dx]
+            #             [y']   [yx yy] [y]   [dy]
+            transform_xx, transform_xy, transform_yx, transform_yy = 1.0, 0.0, 0.0, 1.0
+            transform_dx, transform_dy = 0.0, 0.0
+
+            # Read component header
             flags, glyph_index = struct.unpack(">HH", data.read(4))
-            if flags & ARGS_ARE_XY_VALUES:
-                if flags & ARG_1_AND_2_ARE_WORDS:
-                    args1, args2 = struct.unpack(">hh", data.read(4))
-                else:
-                    args1, args2 = struct.unpack(">bb", data.read(2))
-                e, f = args1 / s, args2 / s
+
+            # Read arguments (either offsets or point indices)
+            if flags & ARG_1_AND_2_ARE_WORDS:
+                # 16-bit arguments
+                arg1, arg2 = struct.unpack(">hh", data.read(4))
             else:
-                if flags & ARG_1_AND_2_ARE_WORDS:
-                    args1, args2 = struct.unpack(">HH", data.read(4))
+                # 8-bit arguments
+                if flags & ARGS_ARE_XY_VALUES:
+                    # Signed bytes for offsets
+                    arg1, arg2 = struct.unpack(">bb", data.read(2))
                 else:
-                    args1, args2 = struct.unpack(">BB", data.read(2))
-                dest, src = args1, args2
+                    # Unsigned bytes for point indices
+                    arg1, arg2 = struct.unpack(">BB", data.read(2))
+
+            # Interpret arguments
+            if flags & ARGS_ARE_XY_VALUES:
+                # Arguments are x,y offsets
+                transform_dx, transform_dy = float(arg1), float(arg2)
+            else:
+                # Arguments are point indices for point matching
+                dest_point_index, src_point_index = arg1, arg2
+                # Point matching not fully implemented - would need to find
+                # matching points in already processed contours and source glyph
+                transform_dx, transform_dy = 0.0, 0.0
+
+            # Read transformation matrix components
             if flags & WE_HAVE_A_SCALE:
-                a = struct.unpack(">h", data.read(2))[0] / s
-                d = a
+                # Single scale factor for both x and y
+                scale = struct.unpack(">h", data.read(2))[0] / scale_factor
+                transform_xx = transform_yy = scale
             elif flags & WE_HAVE_AN_X_AND_Y_SCALE:
-                a, d = struct.unpack(">hh", data.read(4))
-                a, d = a / s, d / s
+                # Separate scale factors for x and y
+                scale_x, scale_y = struct.unpack(">hh", data.read(4))
+                transform_xx = scale_x / scale_factor
+                transform_yy = scale_y / scale_factor
             elif flags & WE_HAVE_A_TWO_BY_TWO:
-                a, b, c, d = struct.unpack(">hhhh", data.read(8))
-                a, b, c, d = a / s, b / s, c / s, d / s
-            original = data.tell()
-            m = max(abs(a), abs(b))
-            if abs(abs(a) - abs(c)) < 33.0 / s:
-                m *= 2
-            n = max(abs(c), abs(d))
-            if abs(abs(b) - abs(c)) < 33.0 / s:
-                n *= 2
-            contours = list(self._parse_glyph_index(glyph_index))
-            if src != -1 and dest != -1:
-                pass  # Not properly supported.
-            if flags & ROUND_XY_TO_GRID:
-                for contour in contours:
-                    yield [
-                        (
-                            round(m * (x * a / m + y * b / m + e)),
-                            round(n * (x * c / n + y * d / n + f)),
-                            flag,
-                        )
-                        for x, y, flag in contour
-                    ]
-            else:
-                for contour in contours:
-                    yield [
-                        (
-                            m * (x * a / m + y * b / m + e),
-                            n * (x * c / n + y * d / n + f),
-                            flag,
-                        )
-                        for x, y, flag in contour
-                    ]
-            data.seek(original)
+                # Full 2x2 transformation matrix
+                xx, xy, yx, yy = struct.unpack(">hhhh", data.read(8))
+                transform_xx = xx / scale_factor
+                transform_xy = xy / scale_factor
+                transform_yx = yx / scale_factor
+                transform_yy = yy / scale_factor
+
+            # Get the component glyph's contours
+            component_contours = list(self._parse_glyph_index(glyph_index))
+
+            # Apply transformation to each contour
+            for contour in component_contours:
+                transformed_contour = []
+                for x, y, flag in contour:
+                    # Apply 2D transformation matrix
+                    new_x = transform_xx * x + transform_xy * y + transform_dx
+                    new_y = transform_yx * x + transform_yy * y + transform_dy
+
+                    # Round to grid if requested
+                    if flags & ROUND_XY_TO_GRID:
+                        new_x = round(new_x)
+                        new_y = round(new_y)
+
+                    transformed_contour.append((new_x, new_y, flag))
+
+                # Add transformed contour to our collection
+                all_contours.append(transformed_contour)
+        # Yield all collected contours
+        yield from all_contours
 
     def _parse_simple_glyph(self, num_contours, data):
         end_pts = struct.unpack(f">{num_contours}H", data.read(2 * num_contours))

{meerk40t-0.9.7051.dist-info → meerk40t-0.9.7900.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: meerk40t
-Version: 0.9.7051
+Version: 0.9.7900
 Summary: MeerK40t LaserCutter Software
 Home-page: https://github.com/meerk40t/meerk40t
 Author: Tatarize