meerk40t 0.9.2000__py2.py3-none-any.whl → 0.9.3001__py2.py3-none-any.whl

{meerk40t-0.9.2000.dist-info → meerk40t-0.9.3001.dist-info}/entry_points.txt

@@ -1,3 +1,2 @@
 [console_scripts]
 meerk40t = meerk40t.main:run
-

test/test_core_elements.py

@@ -70,17 +70,10 @@ class TestElements(unittest.TestCase):
             kernel_root = kernel.get_context("/")
             kernel_root("circle 1in 1in 1in\n")
             for node in kernel_root.elements.elems():
-                shape = node.shape
-                self.assertEqual(
-                    shape,
-                    Circle(
-                        center=(1000 * UNITS_PER_MIL, 1000 * UNITS_PER_MIL),
-                        r=1000 * UNITS_PER_MIL,
-                        stroke_width=shape.stroke_width,
-                        fill=shape.fill,
-                        stroke=shape.stroke,
-                    ),
-                )
+                self.assertEqual(node.cx, 1000 * UNITS_PER_MIL)
+                self.assertEqual(node.cy, 1000 * UNITS_PER_MIL)
+                self.assertEqual(node.rx, 1000 * UNITS_PER_MIL)
+                self.assertEqual(node.ry, 1000 * UNITS_PER_MIL)
                 self.assertEqual(node.stroke, "blue")
         finally:
             kernel.shutdown()
@@ -96,19 +89,10 @@ class TestElements(unittest.TestCase):
             kernel_root = kernel.get_context("/")
             kernel_root("rect 1in 1in 1in 1in stroke red fill blue\n")
             for node in kernel_root.elements.elems():
-                shape = node.shape
-                self.assertEqual(
-                    shape,
-                    Rect(
-                        1000 * UNITS_PER_MIL,
-                        1000 * UNITS_PER_MIL,
-                        1000 * UNITS_PER_MIL,
-                        1000 * UNITS_PER_MIL,
-                        stroke_width=shape.stroke_width,
-                        fill=shape.fill,
-                        stroke=shape.stroke,
-                    ),
-                )
+                self.assertEqual(node.x, 1000 * UNITS_PER_MIL)
+                self.assertEqual(node.y, 1000 * UNITS_PER_MIL)
+                self.assertEqual(node.width, 1000 * UNITS_PER_MIL)
+                self.assertEqual(node.height, 1000 * UNITS_PER_MIL)
                 self.assertEqual(node.stroke, "red")
                 self.assertEqual(node.fill, "blue")
         finally:

test/test_file_svg.py

@@ -86,3 +86,91 @@ class TestFileSVG(unittest.TestCase):
             self.assertIsInstance(node_copy.speed, float)
         finally:
             kernel.shutdown()
+
+    def test_load_092_operations(self):
+        """
+        test to ensure that `meerk40t:operation` types load.
+        """
+        file1 = "test-ops.svg"
+        self.addCleanup(os.remove, file1)
+        with open(file1, "w") as f:
+            f.write(
+                """
+            <svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:ev="http://www.w3.org/2001/xml-events" xmlns:meerk40t="https://github.com/meerk40t/meerk40t/wiki/Namespace" width="400.0mm" height="430.0mm" viewBox="0 0 1032047 1109450">
+            <meerk40t:operation type="op raster" lock="False" speed="150.0" dpi="500" color="black" frequency="30.0" stopop="False" allowed_attributes="[]" power="1000" dwell_time="50.0" id="meerk40t:3" />
+            <meerk40t:operation type="op engrave" label="Engrave (100%, 20mm/s)" lock="False" id="E1" speed="20" power="1000" allowed_attributes="['stroke']" color="#0000ff00" dangerous="False" output="True" dwell_time="50.0" references="meerk40t:6" />
+            <meerk40t:operation type="op cut" label="Cut (100%, 1mm/s)" lock="False" speed="1.0" color="#ff000000" frequency="30.0" kerf="0" allowed_attributes="['stroke']" power="1000" dwell_time="50.0" id="C1" />
+            <ellipse cx="550118.9389283657" cy="363374.1254904113" rx="96436.11909338088" ry="96436.11909338088" stroke_scale="False" type="elem ellipse" id="meerk40t:6" lock="False" mkparam="('circle', 0, 550118.9389283657, 363374.1254904113, 0, 618309.5726906088, 295183.49172816816)" vector-effect="non-scaling-stroke" fill-rule="evenodd" stroke="#0000ff" stroke-width="1000.0" fill="none" />
+            </svg>"""
+            )
+
+        kernel = bootstrap.bootstrap()
+        try:
+            ob = kernel.elements.op_branch
+            kernel.console("operation* delete\n")
+            kernel.console("element* delete\n")
+            kernel.console(f"load {file1}\n")
+            self.assertEqual(len(list(ob.flat(types="op raster"))), 1)
+            self.assertEqual(len(list(ob.flat(types="op engrave"))), 1)
+            self.assertEqual(len(list(ob.flat(types="op cut"))), 1)
+        finally:
+            kernel.shutdown()
+
+    def test_load_hatch_op(self):
+        """
+        test to ensure that `meerk40t:operation` op hatch loading.
+        """
+        file1 = "test-hatch.svg"
+        self.addCleanup(os.remove, file1)
+        with open(file1, "w") as f:
+            f.write(
+                """
+            <svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:ev="http://www.w3.org/2001/xml-events" xmlns:meerk40t="https://github.com/meerk40t/meerk40t/wiki/Namespace" width="400.0mm" height="430.0mm" viewBox="0 0 1032047 1109450">
+            <meerk40t:operation type="op hatch" label="Engrave (100%, 20mm/s)" lock="False" id="E1" speed="20" power="1000" allowed_attributes="['stroke']" color="#0000ff00" dangerous="False" output="True" dwell_time="50.0" references="meerk40t:6" />
+            </svg>"""
+            )
+
+        kernel = bootstrap.bootstrap()
+        try:
+            ob = kernel.elements.op_branch
+            kernel.console("operation* delete\n")
+            kernel.console("element* delete\n")
+            kernel.console(f"load {file1}\n")
+            self.assertEqual(len(list(ob.flat(types="op raster"))), 0)
+            self.assertEqual(len(list(ob.flat(types="op engrave"))), 1)
+            self.assertEqual(len(list(ob.flat(types="op cut"))), 0)
+            self.assertEqual(len(list(ob.flat(types="effect hatch"))), 1)
+        finally:
+            kernel.shutdown()
+
+    def test_load_wobble(self):
+        """
+        test to ensure that `meerk40t:operation` types load.
+        """
+        file1 = "test-wobble.svg"
+        self.addCleanup(os.remove, file1)
+        with open(file1, "w") as f:
+            f.write(
+                """
+            <svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:ev="http://www.w3.org/2001/xml-events" xmlns:meerk40t="https://github.com/meerk40t/meerk40t/wiki/Namespace" width="400.0mm" height="430.0mm" viewBox="0 0 1032047 1109450">
+            <g type="op engrave" label="Engrave (100%, 20mm/s)" lock="False" id="E1" speed="20" power="1000" allowed_attributes="['stroke']" color="#0000ff00" dangerous="False" output="True" dwell_time="50.0" references="meerk40t:6">
+            <g type="effect wobble" lock="False" output="True" />
+            </g>
+            <ellipse cx="550118.9389283657" cy="363374.1254904113" rx="96436.11909338088" ry="96436.11909338088" stroke_scale="False" type="elem ellipse" id="meerk40t:6" lock="False" mkparam="('circle', 0, 550118.9389283657, 363374.1254904113, 0, 618309.5726906088, 295183.49172816816)" vector-effect="non-scaling-stroke" fill-rule="evenodd" stroke="#0000ff" stroke-width="1000.0" fill="none" />
+            </svg>"""
+            )
+
+        kernel = bootstrap.bootstrap()
+        try:
+            ob = kernel.elements.op_branch
+            kernel.console("operation* delete\n")
+            kernel.console("element* delete\n")
+            kernel.console(f"load {file1}\n")
+            self.assertEqual(len(list(ob.flat(types="op raster"))), 0)
+            engrave = list(ob.flat(types="op engrave"))
+            self.assertEqual(len(engrave), 1)
+            self.assertEqual(len(list(ob.flat(types="op cut"))), 0)
+            self.assertEqual(len(list(ob.flat(types="effect wobble"))), 1)
+            self.assertEqual(len(list(engrave[0].flat(types="effect wobble"))), 1)
+        finally:
+            kernel.shutdown()

test/test_fill.py

@@ -79,13 +79,13 @@ class TestFill(unittest.TestCase):
             kernel.console("rect 0 0 1in 1in\n")
             kernel.console("operation* delete\n")
             kernel.console("hatch\n")
-            hatch = list(kernel.elements.ops())[0]
-
+            hatch_op = list(kernel.elements.ops())[0]
             rect = list(kernel.elements.elems())[0]
-            hatch.add_reference(rect)
 
-            hatch_copy = copy(hatch)
-            hatch_copy.copy_children_as_real(hatch)
+            # Add rect refences into hatch.
+            hatch_op.children[0].add_reference(rect)
+
+            hatch_copy = hatch_op.copy_with_reified_tree()
 
             hatch_effect = hatch_copy.children[0]
             shape = hatch_effect.as_geometry()
@@ -108,13 +108,13 @@ class TestFill(unittest.TestCase):
 
             ops = list(kernel.elements.ops())
             hatch = ops[0]
+            hatch_effect = hatch.children[0]
             rect0 = list(kernel.elements.elems())[0]
-            hatch.add_reference(rect0)
+            hatch_effect.add_reference(rect0)
             rect1 = list(kernel.elements.elems())[1]
-            hatch.add_reference(rect1)
+            hatch_effect.add_reference(rect1)
 
-            hatch_copy = copy(hatch)
-            hatch_copy.copy_children_as_real(hatch)
+            hatch_copy = hatch.copy_with_reified_tree()
 
             hatch_effect = hatch_copy.children[0]
             shape0 = hatch_effect.as_geometry()

test/test_geomstr.py

@@ -8,9 +8,12 @@ from math import tau
 import numpy as np
 
 from meerk40t.fill.fills import scanline_fill
+from meerk40t.fill.patterns import set_diamond1, set_line
 from meerk40t.svgelements import Arc, CubicBezier, Line, Matrix, QuadraticBezier
 from meerk40t.tools.geomstr import (
     TYPE_LINE,
+    TYPE_POINT,
+    BeamTable,
     Clip,
     Geomstr,
     MergeGraph,
@@ -49,6 +52,39 @@ def draw(segments, min_x, min_y, max_x, max_y, buffer=0, filename="test.png"):
     im.save(filename)
 
 
+def draw_geom(segments, min_x, min_y, max_x, max_y, buffer=0, filename="test.png"):
+    from PIL import Image, ImageDraw
+
+    min_x -= buffer
+    min_y -= buffer
+    max_x += buffer
+    max_y += buffer
+    im = Image.new("RGBA", (int(max_x - min_x) + 1, int(max_y - min_y) + 1), "white")
+
+    draw = ImageDraw.Draw(im)
+    for line in segments.segments[: segments.index]:
+        if line[2].real == TYPE_POINT:
+            f = line[0]
+            draw.ellipse(
+                (
+                    f.real - 3 - min_x,
+                    f.imag - 3 - min_y,
+                    f.real + 3 - min_x,
+                    f.imag + 3 - min_y,
+                ),
+                fill="#FF0000",
+            )
+        elif line[2].real == TYPE_LINE:
+            # Draw raw segments.
+            f = line[0]
+            t = line[-1]
+            draw.line(
+                ((f.real - min_x, f.imag - min_y), (t.real - min_x, t.imag - min_y)),
+                fill="#000000",
+            )
+    im.save(filename)
+
+
 def random_point(i=100):
     return complex(random.random() * i, random.random() * i)
 
@@ -341,6 +377,42 @@ class TestGeomstr(unittest.TestCase):
         # print(p.segments)
         # draw(p.segments, w, h)
 
+    def test_geomstr_y_intercepts(self):
+        """
+        Draws, 5 perfectly horizontal lines. Queries the y_intercepts
+        @return:
+        """
+        g = Geomstr()
+        g.line(complex(0, 20), complex(100, 20))
+        g.line(complex(0, 40), complex(100, 40))
+        g.line(complex(0, 80), complex(100, 80))
+        g.line(complex(0, 60), complex(100, 60))
+        g.line(complex(0, 100), complex(100, 100))
+        q = g.y_intercept([0, 1, 2, 3, 4], 10)
+        self.assertEqual(q[0], 20.0)
+        self.assertEqual(q[1], 40.0)
+        self.assertEqual(q[2], 80.0)
+        self.assertEqual(q[3], 60.0)
+        self.assertEqual(q[4], 100.0)
+
+    def test_geomstr_x_intercepts(self):
+        """
+        Draws, 5 perfectly vertical lines. Queries the x_intercepts
+        @return:
+        """
+        g = Geomstr()
+        g.line(complex(20, 0), complex(20, 100))
+        g.line(complex(40, 0), complex(40, 100))
+        g.line(complex(80, 0), complex(80, 100))
+        g.line(complex(60, 0), complex(60, 100))
+        g.line(complex(100, 0), complex(100, 100))
+        q = g.x_intercept([0, 1, 2, 3, 4], 10)
+        self.assertEqual(q[0], 20.0)
+        self.assertEqual(q[1], 40.0)
+        self.assertEqual(q[2], 80.0)
+        self.assertEqual(q[3], 60.0)
+        self.assertEqual(q[4], 100.0)
+
     def test_geomstr_classmethods(self):
         """
         Test various classmethods for making defined geomstr shapes.
@@ -776,8 +848,6 @@ class TestGeomstr(unittest.TestCase):
         print(results)
 
     def test_pattern_generation(self):
-        from meerk40t.fill.patternfill import set_diamond1
-
         f = set_diamond1
         p = Pattern()
         p.create_from_pattern(f)
@@ -794,8 +864,6 @@ class TestGeomstr(unittest.TestCase):
             # self.assertTrue((array == array2).all())
 
     def test_pattern_generation_counts(self):
-        from meerk40t.fill.patternfill import set_diamond1
-
         f = set_diamond1
         p = Pattern()
         p.create_from_pattern(f)
@@ -812,8 +880,6 @@ class TestGeomstr(unittest.TestCase):
         print("finished.")
 
     def test_pattern_clip(self):
-        from meerk40t.fill.patternfill import set_diamond1
-
         t = time.time()
         f = set_diamond1
         p = Pattern()
@@ -1009,9 +1075,24 @@ class TestGeomstr(unittest.TestCase):
         except ZeroDivisionError:
             pass
 
-    def test_point_in_polygon(self):
-        from meerk40t.fill.patternfill import set_diamond1
+        # q = BeamTable(poly.geomstr)
+        # q.compute_beam_brute()
+        # t = time.time()
+        # r = q.points_in_polygon(points)
+        # t2 = time.time() - t
+        # i = 0
+        # for p1, p2 in zip(r, mask):
+        #     i += 1
+        #     if bool(p1) != bool(p2):
+        #         print(f"{i} {points[i]}")
+        # self.assertEqual(bool(p1), bool(p2))
+
+    def test_render(self):
+        rect = Geomstr.rect(x=300, y=200, width=500, height=500, rx=50, ry=50)
+        image = rect.segmented().render()
+        image.save("render-test.png")
 
+    def test_point_in_polygon(self):
         t1 = 0
         t2 = 0
         f = set_diamond1
@@ -1047,6 +1128,96 @@ class TestGeomstr(unittest.TestCase):
         except ZeroDivisionError:
             print(f"{t2} vs {t1}")
 
+    def test_intersections_near(self):
+        for r1 in np.linspace(0, 100, 5):
+            r2 = r1 + 0.0001
+            circle1 = Geomstr.circle(cx=0, cy=0, r=r1)
+            circle2 = Geomstr.circle(cx=0, cy=0, r=r2)
+            circle1.rotate(r1)
+            for j in range(circle1.index):
+                for k in range(circle2.index):
+                    c = list(
+                        circle1.intersections(circle1.segments[j], circle2.segments[k])
+                    )
+                    print(r1, r2)
+                    self.assertFalse(c)
+
+    def test_livinghinge_whiskers2(self):
+        clip = Geomstr.ellipse(
+            rx=96436.11909338088,
+            ry=96436.11909338088,
+            cx=550118.9389283657,
+            cy=363374.1254904113,
+        )
+        subject = Geomstr()
+        subject.line(5.82716822e05 + 343372.64182036j, 6.48483387e05 + 343372.64182036j)
+        q = Clip(clip)
+        subject = q.polycut(subject)
+        subject = q.inside(subject)
+
+        m = Geomstr()
+        m.append(clip)
+        m.append(subject)
+        m.uscale(0.002)
+        draw(list(m.as_interpolated_points()), *m.bbox(), filename="whiskers.png")
+
+    def test_livinghinge_whiskers(self):
+        """
+        Test for Whiskers bug. The given clip and exactly the right settings could allow a line to not clip correctly
+
+        We use a previously failing set of settings and make sure that the midpoints and both ends are always on the
+        same side of the polygon.
+        @return:
+        """
+        clip = Geomstr.ellipse(
+            rx=96436.11909338088,
+            ry=96436.11909338088,
+            cx=550118.9389283657,
+            cy=363374.1254904113,
+        )
+        p = Pattern()
+        p.create_from_pattern(set_line, 0, 0, outershape=clip)
+        p.set_cell_padding(-11377.615848868112, -257.2803475393701)
+        p.set_cell_dims(65766.56560039372, 5593.051033464568)
+        p.extend_pattern = True
+        subject = Geomstr()
+        q = Clip(clip)
+        self.path = Geomstr()
+        for s in list(p.generate(*q.bounds)):
+            subject.append(s)
+
+        subject = q.polycut(subject)
+        subject = q.inside(subject)
+
+        m = Geomstr()
+        m.append(clip)
+        m.append(subject)
+        m.uscale(0.002)
+        draw(list(m.as_interpolated_points()), *m.bbox())
+
+        c = Geomstr()
+        # Pip currently only works with line segments
+        for sp in clip.as_subpaths():
+            for segs in sp.as_interpolated_segments(interpolate=100):
+                c.polyline(segs)
+                c.end()
+        sb = Scanbeam(c)
+
+        mid_points = subject.position(slice(subject.index), 0.5)
+        r = np.where(sb.points_in_polygon(mid_points))
+
+        s = np.where(
+            sb.points_in_polygon(subject.position(slice(subject.index), 0.05))
+        )[0]
+
+        e = np.where(
+            sb.points_in_polygon(subject.position(slice(subject.index), 0.95))
+        )[0]
+
+        for q in r[0]:
+            self.assertIn(q, s)
+            self.assertIn(q, e)
+
     def test_point_towards_numpy(self):
         p1 = complex(0, 100)
         p2 = complex(50, 22)
@@ -1253,6 +1424,85 @@ class TestGeomstr(unittest.TestCase):
             filename="box.png",
         )
 
+    def test_geom_max_aabb(self):
+        g = Geomstr.rect(0, 0, 200, 200)
+        nx, ny, mx, my = g.aabb()
+        print(nx)
+
+    def test_static_beam_horizontal_bowtie(self):
+        """
+        0: down-right
+        1: right side
+        2: down-left
+        3: left side
+        30    21
+        |\   /|
+        | \ / |
+        | / \ |
+        |/   \|
+        @return:
+        """
+        bowtie = Geomstr.lines(
+            complex(0, 0),
+            complex(100, 100),
+            complex(100, 0),
+            complex(0, 100),
+            complex(0, 0),
+        )
+        sb = BeamTable(bowtie)
+        result = sb.actives_at(25)
+        actives = bowtie.x_intercept(result, 25)
+
+        for x, y in zip(result, (0, 2)):
+            self.assertEqual(x, y)
+
+    def test_static_beam_vertical_bowtie(self):
+        """
+       0   3
+        --------
+        \     /
+         \   /
+          \/
+          /\
+         /  \
+        /    \
+        ------
+        2   1
+        @return:
+        """
+        bowtie = Geomstr.lines(
+            complex(0, 0),
+            complex(100, 100),
+            complex(0, 100),
+            complex(100, 0),
+            complex(0, 0),
+        )
+        sb = BeamTable(bowtie)
+        result = sb.actives_at(complex(25, 0))
+        actives = bowtie.x_intercept(result, 25)
+
+        for x, y in zip(result, (3, 0, 2, 1)):
+            self.assertEqual(x, y)
+
+    def test_scan_table_random(self):
+        for c in range(1):
+            print("\n\n\n\n\n")
+            g = Geomstr()
+            for i in range(25):
+                random_segment(
+                    g, i=1000, arc=False, point=False, quad=False, cubic=False
+                )
+            t = time.time()
+            sb = BeamTable(g)
+            sb.compute_beam_brute()
+            intersections = sb.intersections
+            print(f"Time: {time.time() - t}")
+            try:
+                g.append(intersections)
+                draw_geom(g, *g.bbox(), filename="scantable.png")
+            except PermissionError:
+                pass
+
     # def test_geomstr_hatch(self):
     #     gs = Geomstr.svg(
     #         "M 207770.064517,235321.124952 C 206605.069353,234992.732685 205977.289179,234250.951228 205980.879932,233207.034699 C 205983.217733,232527.380908 206063.501616,232426.095743 206731.813533,232259.66605 L 207288.352862,232121.071081 L 207207.998708,232804.759538 C 207106.904585,233664.912764 207367.871267,234231.469286 207960.295387,234437.989447 C 208960.760372,234786.753419 209959.046638,234459.536445 210380.398871,233644.731075 C 210672.441667,233079.98258 210772.793626,231736.144349 210569.029382,231118.732625 C 210379.268508,230543.75153 209783.667018,230128.095713 209148.499972,230127.379646 C 208627.98084,230126.79283 208274.720902,230294.472682 207747.763851,230792.258962 C 207377.90966,231141.639128 207320.755956,231155.543097 206798.920578,231023.087178 C 206328.09633,230903.579262 206253.35266,230839.656219 206307.510015,230602.818034 C 206382.366365,230275.460062 207158.299204,225839.458855 207158.299204,225738.863735 C 207158.299204,225701.269015 208426.401454,225670.509699 209976.304204,225670.509699 C 211869.528049,225670.509699 212794.309204,225715.990496 212794.309204,225809.099369 C 212794.309204,225885.323687 212726.683921,226357.175687 212644.030798,226857.659369 L 212493.752392,227767.629699 L 210171.516354,227767.629699 L 207849.280317,227767.629699 L 207771.086662,228324.677199 C 207728.080152,228631.053324 207654.900983,229067.454479 207608.466287,229294.457543 L 207524.039566,229707.190387 L 208182.568319,229381.288158 C 209664.399179,228647.938278 211467.922971,228893.537762 212548.92912,229975.888551 C 214130.813964,231559.741067 213569.470754,234195.253882 211455.779825,235108.237047 C 210589.985852,235482.206254 208723.891068,235589.992389 207770.064517,235321.124952 L 207770.064517,235321.124952Z"

test/test_kernel.py

@@ -21,6 +21,7 @@ class TestKernel(unittest.TestCase):
                 if command in (
                     "quit",
                     "shutdown",
+                    "restart",
                     "interrupt",
                     "+laser",
                     "-laser",
@@ -88,6 +89,9 @@ class TestKernel(unittest.TestCase):
                     func_dict = dict(func.func_dict)
                     print(f"Executing: {func.name}")
                     func(n, **func_dict)
+                    if n.parent is None:
+                        # This function removed the element. Put it back in the tree.
+                        kernel.elements.elem_branch.add_node(n)
         finally:
             kernel.console("elements\n")
             kernel.shutdown()

test/test_tools_rasterplotter.py

@@ -0,0 +1,29 @@
+import time
+import unittest
+
+import numpy as np
+from PIL import Image, ImageDraw
+
+from meerk40t.tools.rasterplotter import RasterPlotter
+
+
+class TestRasterPlotter(unittest.TestCase):
+    def test_rasterplotter_largecircle(self):
+        """
+        Tests the speed of rasterplotter for large circle.
+
+        :return:
+        """
+        image = Image.new("RGBA", (2560, 2560), "white")
+        draw = ImageDraw.Draw(image)
+        draw.ellipse((0, 0, 2560, 2560), "black")
+        image = image.convert("L")
+        img = np.array(image)
+        # img = image.load()
+        plotter = RasterPlotter(img, 2560, 2560)
+        t = time.time()
+        i = 0
+        for x, y, on in plotter.plot():
+            i += 0
+        print(i)
+        print(f"\nTime taken to finish process {time.time() - t}\n")

meerk40t/extra/embroider.py

@@ -1,56 +0,0 @@
-from meerk40t.core.units import Length
-from meerk40t.svgelements import Angle, Matrix, Path, Polyline
-from meerk40t.tools.pathtools import EulerianFill
-
-
-def plugin(kernel, lifecycle):
-    if lifecycle == "register":
-        _ = kernel.translation
-        context = kernel.root
-
-        @context.console_option(
-            "angle", "a", type=Angle.parse, default="0deg", help=_("Angle of the fill")
-        )
-        @context.console_option(
-            "distance",
-            "d",
-            type=Length,
-            default="0.5mm",
-            help=_("Length between rungs"),
-        )
-        @context.console_command("embroider", help=_("embroider <angle> <distance>"))
-        def embroider(command, channel, _, angle=None, distance=None, **kwargs):
-            elements = context.elements
-            channel(_("Embroidery Filling"))
-            efill = EulerianFill(float(distance))
-            for node in elements.elems(emphasized=True):
-                try:
-                    path = Path(node.shape)
-                except AttributeError:
-                    try:
-                        path = Path(node.path)
-                    except AttributeError:
-                        continue
-                if angle is not None:
-                    path *= Matrix.rotate(angle)
-                pts = [abs(path).point(i / 100.0, error=1e-4) for i in range(101)]
-                efill += pts
-
-            points = efill.get_fill()
-
-            for s in split(points):
-                result = Path(Polyline(s, stroke="black"))
-                if angle is not None:
-                    result *= Matrix.rotate(-angle)
-                node = elements.elem_branch.add(path=result, type="elem path")
-                elements.classify([node])
-
-
-def split(points):
-    pos = 0
-    for i, pts in enumerate(points):
-        if pts is None:
-            yield points[pos : i - 1]
-            pos = i + 1
-    if pos != len(points):
-        yield points[pos : len(points)]