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

test/test_element_degenerate_points.py

@@ -1,43 +0,0 @@
-import os
-import unittest
-from test import bootstrap
-
-from meerk40t.core.elements.element_types import elem_nodes
-from meerk40t.core.node.elem_point import PointNode
-
-
-class TestShapePoints(unittest.TestCase):
-    def test_shapes_are_points(self):
-        """
-        Test the ability shapes to convert to points if they meet criteria set in 0.7.x
-
-        :return:
-        """
-        file1 = "text.svg"
-        self.addCleanup(os.remove, file1)
-        kernel = bootstrap.bootstrap()
-        try:
-            kernel_root = kernel.get_context("/")
-            elements = kernel_root.elements
-            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="110.0mm" height="110.0mm" viewBox="0 0 416 416" xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape">
-<element type="elem point" x="36.65648536929456" y="77.38541766211871" id="meerk40t:24" stroke_width="1000.0" lock="False" stroke="#0000ff" stroke-width="none" fill="none" />
-<path d="M36.65648536929456,77.38541766211871" id="degenerate_dot" lock="True" stroke="#0000ff"/>
-<path d="M36.65648536929456,77.38541766211871Z" id="degenerate_dot_z" lock="True" stroke="#0000ff"/>
-<path d="M0,0Z" transform="translate(36.65648536929456,77.38541766211871)" lock="True" stroke="#0000ff"/>
-<polygon points="36.65648536929456,77.38541766211871" lock="False" stroke="#0000ff"/>
-<polyline points="36.65648536929456,77.38541766211871" lock="False" stroke="#0000ff"/>
-<line x1="36.65648536929456" y1="77.38541766211871" x2="36.65648536929456" y2="77.38541766211871" lock="False" stroke="cornflower blue"/>
-                </svg>"""
-                )
-            elements.load(file1)
-            results = list(elements.elem_branch.flat(types=elem_nodes))
-            self.assertEqual(len(results), 7)
-            for i in range(1, len(results)):
-                self.assertEqual(results[i - 1].bbox(), results[i].bbox())
-            for n in results:
-                self.assertEqual(n.type, "elem point")
-                self.assertEqual(type(n), PointNode)
-        finally:
-            kernel.shutdown()

test/test_elements_classify.py

@@ -1,97 +0,0 @@
-import unittest
-from random import Random
-from test import bootstrap
-
-from meerk40t.core.elements.element_types import elem_nodes, op_nodes
-
-
-class TestElementClassification(unittest.TestCase):
-    def test_element_classification(self):
-        """
-        Random Test of classifications
-
-        :return:
-        """
-        random = Random()
-        kernel = bootstrap.bootstrap()
-        root = kernel.get_context("/")
-        # root("channel print classify\n")
-
-        def random_units():
-            r = random.randint(0, 4)
-            if r == 0:
-                return "px"
-            if r == 1:
-                return ""
-            if r == 2:
-                return "in"
-            if r == 3:
-                return "mm"
-            if r == 4:
-                return "cm"
-            print(r)
-            raise ValueError()
-
-        def random_color():
-            r = random.randint(0, 4)
-            if r == 0:
-                return f"#{random.randint(0,255):02X}{random.randint(0,255):02X}{random.randint(0,255):02X}"
-            elif r == 1:
-                return f"#{random.randint(0, 16):X}{random.randint(0, 16):X}{random.randint(0, 16):X}"
-            else:
-                operations = list(root.elements.op_branch.flat(types=op_nodes))
-                if not operations:
-                    return "cornflower blue"
-                random_op = operations[random.randint(0, len(operations) - 1)]
-                try:
-                    return random_op.color.hexrgb
-                except AttributeError:
-                    # Some already extant operations exist some don't have colors like console
-                    return "cornflower blue"
-
-        def random_x():
-            return f"{random.random() * 10}{random_units()}"
-
-        random_y = random_x
-        random_radius = random_x
-
-        def add_random_element():
-            r = random.randint(0, 1)
-
-            if r == 0:
-                root(
-                    f"circle {random_x()} {random_y()} {random_radius()} stroke {random_color()} fill {random_color()}\n"
-                )
-            if r == 1:
-                root(
-                    f"line {random_x()} {random_y()} {random_x()} {random_y()} stroke {random_color()} fill {random_color()}\n"
-                )
-
-        def add_random_operation():
-            r = random.randint(0, 6)
-            if r == 0:
-                root(f"cut -c {random_color()}\n")
-            if r == 1:
-                root(f"raster -c {random_color()}\n")
-            if r == 2:
-                root(f"engrave -c {random_color()}\n")
-            if r == 3:
-                root(f"hatch -c {random_color()}\n")
-            if r == 4:
-                root(f"imageop -c {random_color()}\n")
-            if r == 5:
-                root(f"dots -c {random_color()}\n")
-            if r == 6:
-                root(f"engrave -c {random_color()}\n")
-
-        try:
-            for i in range(10):
-                add_random_operation()
-            for i in range(100):
-                add_random_element()
-            root("element* classify\n")
-
-            results = list(root.elements.elem_branch.flat(types=elem_nodes))
-            self.assertEqual(len(results), 100)
-        finally:
-            kernel.shutdown()

test/test_elements_penbox.py

@@ -1,22 +0,0 @@
-import unittest
-from test import bootstrap
-
-
-class TestPenbox(unittest.TestCase):
-    def test_penbox(self):
-        """
-        Test penbox code
-
-        :return:
-        """
-        kernel = bootstrap.bootstrap()
-        try:
-            kernel_root = kernel.get_context("/")
-            kernel_root("penbox testpasses add 5 set 0-4 hatch_angle 0-90\n")
-            self.assertEqual(len(kernel_root.penbox.pens["testpasses"]), 5)
-            self.assertEqual(
-                kernel_root.elements.penbox.pens["testpasses"][-1]["hatch_angle"], 90
-            )
-
-        finally:
-            kernel.shutdown()

test/test_file_svg.py

@@ -1,176 +0,0 @@
-import os
-import unittest
-from test import bootstrap
-
-from meerk40t.core.node.op_engrave import EngraveOpNode
-from meerk40t.core.units import Length
-
-
-class TestFileSVG(unittest.TestCase):
-    def test_load_save_svg(self):
-        """
-        test svg saving and loading of various files.
-        """
-        file1 = "test.svg"
-        self.addCleanup(os.remove, file1)
-
-        kernel = bootstrap.bootstrap()
-        try:
-            kernel.console("operation* delete\n")
-            node = EngraveOpNode(
-                id="E1",
-                label="My label",
-                color="green",
-                lock=True,
-                allowed_attributes=["number_of_unicorns"],
-                stroke="green",
-                fill="gray",
-                stroke_width=7,
-                dancing_bear=0.2,
-            )
-            kernel.elements.op_branch.add_node(node)
-            kernel.console(f"rect 2cm 2cm 1cm 1cm engrave -s 15\n")
-            kernel.console(f"save {file1}\n")
-            kernel.console("element* delete\n")
-            kernel.console("operation* delete\n")
-            kernel.console(f"load {file1}\n")
-            f = list(kernel.elements.elem_branch.flat(types="elem rect"))[0]
-            self.assertEqual(f.width, float(Length("1cm")))
-
-            ns = list(kernel.elements.op_branch.flat(types="op engrave"))
-            node_copy = ns[0]
-            for attr in (
-                "id",
-                "label",
-                "color",
-                "lock",
-                "allowed_attributes",
-                "stroke",
-                "fill",
-                "stroke_width",
-                "stroke_scaled",
-            ):
-                if hasattr(node, attr):
-                    self.assertEqual(getattr(node_copy, attr), getattr(node, attr))
-            self.assertEqual(node_copy.settings["dancing_bear"], 0.2)
-            for item in node.settings:
-                self.assertEqual(node.settings[item], node_copy.settings[item])
-            print(f)
-
-        finally:
-            kernel.shutdown()
-
-    def test_load_save_svg_int_id(self):
-        """
-        tests that the validation of id prevents integer value.
-        """
-        file1 = "test.svg"
-        self.addCleanup(os.remove, file1)
-
-        kernel = bootstrap.bootstrap()
-        try:
-            kernel.console("operation* delete\n")
-            node = EngraveOpNode(id="1", label="1", speed=39.8)
-            kernel.elements.op_branch.add_node(node)
-            kernel.console(f"save {file1}\n")
-            kernel.console("operation* delete\n")
-            kernel.console(f"load {file1}\n")
-            node_copy = list(kernel.elements.op_branch.flat(types="op engrave"))[0]
-            self.assertEqual(node_copy.id, node.id)
-            self.assertIsInstance(node_copy.id, str)
-
-            self.assertEqual(node_copy.label, node.label)
-            self.assertIsInstance(node_copy.label, str)
-
-            self.assertEqual(node_copy.speed, node.speed)
-            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

@@ -1,155 +0,0 @@
-import unittest
-from copy import copy
-from test import bootstrap
-
-from meerk40t.core.cutplan import CutPlan
-from meerk40t.fill.fills import eulerian_fill, scanline_fill
-from meerk40t.svgelements import Matrix, Rect
-
-
-def draw(fill, w, h, filename="test.png"):
-    from PIL import Image, ImageDraw
-
-    im = Image.new("RGBA", (w, h), "white")
-    draw = ImageDraw.Draw(im)
-    last_x = None
-    last_y = None
-    for x, y in fill:
-        if last_x is not None:
-            draw.line((last_x, last_y, x, y), fill="black")
-        last_x, last_y = x, y
-    im.save(filename)
-
-
-class TestFill(unittest.TestCase):
-    """Tests the functionality of fills."""
-
-    def test_fill_euler(self):
-        w = 10000
-        h = 10000
-        paths = (
-            complex(w * 0.05, h * 0.05),
-            complex(w * 0.95, h * 0.05),
-            complex(w * 0.95, h * 0.95),
-            complex(w * 0.05, h * 0.95),
-            complex(w * 0.05, h * 0.05),
-            None,
-            complex(w * 0.25, h * 0.25),
-            complex(w * 0.75, h * 0.25),
-            complex(w * 0.75, h * 0.75),
-            complex(w * 0.25, h * 0.75),
-            complex(w * 0.25, h * 0.25),
-        )
-
-        fill = list(eulerian_fill(settings={}, outlines=paths, matrix=None))
-        self.assertEqual(len(fill), 13)
-        for x, y in fill:
-            self.assertIn(x, (500, 2500, 7500, 9500))
-
-    def test_fill_euler_scale(self):
-        w = 1000
-        h = 1000
-        paths = (
-            complex(w * 0.05, h * 0.05),
-            complex(w * 0.95, h * 0.05),
-            complex(w * 0.95, h * 0.95),
-            complex(w * 0.05, h * 0.95),
-            complex(w * 0.05, h * 0.05),
-            None,
-            complex(w * 0.25, h * 0.25),
-            complex(w * 0.75, h * 0.25),
-            complex(w * 0.75, h * 0.75),
-            complex(w * 0.25, h * 0.75),
-            complex(w * 0.25, h * 0.25),
-        )
-        matrix = Matrix.scale(0.005)
-        fill = list(eulerian_fill(settings={}, outlines=paths, matrix=matrix))
-        self.assertEqual(len(fill), 327)
-        for x, y in fill:
-            self.assertIn(x, (50, 250, 750, 950))
-
-        # draw(fill, w, h)
-
-    def test_fill_hatch(self):
-        """
-        Tests hatch generation by manually executing the regular planning steps.
-        """
-        kernel = bootstrap.bootstrap()
-        try:
-            kernel.console("rect 0 0 1in 1in\n")
-            kernel.console("operation* delete\n")
-            kernel.console("hatch\n")
-            hatch_op = list(kernel.elements.ops())[0]
-            rect = list(kernel.elements.elems())[0]
-
-            # 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()
-            self.assertEqual(len(shape), 50)
-            print(shape)
-        finally:
-            kernel.shutdown()
-
-    def test_fill_hatch_2rect(self):
-        """
-        Test the hatch with manual steps, counting lines in two rectangles.
-        """
-
-        kernel = bootstrap.bootstrap()
-        try:
-            kernel.console("rect 0 0 1in 1in\n")
-            kernel.console("rect 3in 0 1in 1in\n")
-            kernel.console("operation* delete\n")
-            kernel.console("hatch\n")
-
-            ops = list(kernel.elements.ops())
-            hatch = ops[0]
-            hatch_effect = hatch.children[0]
-            rect0 = list(kernel.elements.elems())[0]
-            hatch_effect.add_reference(rect0)
-            rect1 = list(kernel.elements.elems())[1]
-            hatch_effect.add_reference(rect1)
-
-            hatch_copy = hatch.copy_with_reified_tree()
-
-            hatch_effect = hatch_copy.children[0]
-            shape0 = hatch_effect.as_geometry()
-            self.assertEqual(len(shape0), 100)
-        finally:
-            kernel.shutdown()
-
-    def test_fill_scanline(self):
-        w = 10000
-        h = 10000
-        paths = (
-            complex(w * 0.05, h * 0.05),
-            complex(w * 0.95, h * 0.05),
-            complex(w * 0.95, h * 0.95),
-            complex(w * 0.05, h * 0.95),
-            complex(w * 0.05, h * 0.05),
-            None,
-            complex(w * 0.25, h * 0.25),
-            complex(w * 0.75, h * 0.25),
-            complex(w * 0.75, h * 0.75),
-            complex(w * 0.25, h * 0.75),
-            complex(w * 0.25, h * 0.25),
-        )
-
-        fill = list(scanline_fill(settings={}, outlines=paths, matrix=None))
-        for p in fill:
-            if p is None:
-                continue
-            x, y = p
-            self.assertIn(x, (500, 2500, 7500, 9500))
-
-    def test_fill_kernel_registered(self):
-        kernel = bootstrap.bootstrap()
-        try:
-            eulerian_fill_k = kernel.lookup("hatch/eulerian")
-            self.assertIs(eulerian_fill_k, eulerian_fill)
-        finally:
-            kernel.shutdown()