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

meerk40t/dxf/plugin.py

@@ -1,35 +1,47 @@
-def plugin(kernel, lifecycle=None):
-    if lifecycle == "invalidate":
-        try:
-            import ezdxf  # pylint: disable=unused-import
-        except ImportError:
-            print("DXF plugin could not load because ezdxf is not installed.")
-            return True
-        try:
-            # Includes ezdxf and all required imports therein
-            from meerk40t.dxf.dxf_io import DxfLoader
-        except ImportError:
-            print(
-                "DXF plugin could not load because, though ezdxf is installed, the version isn't supported."
-            )
-            return True
-    elif lifecycle == "register":
-        from meerk40t.dxf.dxf_io import DxfLoader
-
-        kernel.register("load/DxfLoader", DxfLoader)
-        _ = kernel.translation
-        choices = [
-            {
-                "attr": "dxf_center",
-                "object": kernel.elements,
-                "default": True,
-                "type": bool,
-                "label": _("DXF Center and Fit"),
-                "tip": _(
-                    "Fit (scale down if necessary) and center a DXF file within the bed"
-                ),
-                "page": "Input/Output",
-                "section": "Input",
-            },
-        ]
-        kernel.register_choices("preferences", choices)
+def plugin(kernel, lifecycle=None):
+    if lifecycle == "invalidate":
+        try:
+            import ezdxf  # pylint: disable=unused-import
+        except ImportError:
+            print("DXF plugin could not load because ezdxf is not installed.")
+            return True
+        try:
+            # Includes ezdxf and all required imports therein
+            from meerk40t.dxf.dxf_io import DxfLoader
+        except ImportError:
+            print(
+                "DXF plugin could not load because, though ezdxf is installed, the version isn't supported."
+            )
+            return True
+    elif lifecycle == "register":
+        from meerk40t.dxf.dxf_io import DxfLoader
+
+        kernel.register("load/DxfLoader", DxfLoader)
+        _ = kernel.translation
+        choices = [
+            {
+                "attr": "dxf_center",
+                "object": kernel.elements,
+                "default": True,
+                "type": bool,
+                "label": _("DXF Center and Fit"),
+                "tip": _(
+                    "Fit (scale down if necessary) and center a DXF file within the bed"
+                ),
+                "page": "Input/Output",
+                "section": "Input",
+            },
+            {
+                "attr": "dxf_try_unsupported",
+                "object": kernel.elements,
+                "default": True,
+                "type": bool,
+                "label": _("DXF: Try to read 3D-polylines"),
+                "tip": _(
+                    "Tries to use dxf 3D-polylines, disable it if the file contains meshes or other 3D data"
+                ),
+                "page": "Input/Output",
+                "section": "Input",
+            },
+        ]
+        kernel.register_choices("preferences", choices)

meerk40t/external_plugins.py

@@ -1,79 +1,79 @@
-"""
-These are external plugins. They are dynamically found by entry points. This file is replaced with the build file during
-builds, since compiled versions do not have access to entry points. External plugins therefore must be hard-coded for
-builds. See the external_plugin_build.py file for regular built plugins.
-"""
-
-MEERK40T_ENTRYPOINT = "meerk40t.extension"
-
-
-def plugins_pre_38():
-    """
-    Import plugins using pkg_resources. pkg_resources was deprecated in 3.10 and removed in 3.12
-    @return:
-    """
-    import pkg_resources
-
-    for entry_point in pkg_resources.iter_entry_points(MEERK40T_ENTRYPOINT):
-        try:
-            plugin = entry_point.load()
-        except pkg_resources.DistributionNotFound:
-            pass
-        except pkg_resources.VersionConflict as e:
-            print(
-                "Cannot install plugin - '{entrypoint}' due to version conflict.".format(
-                    entrypoint=str(entry_point)
-                )
-            )
-            print(e)
-        else:
-            yield plugin
-
-
-def plugins_importlib():
-    """
-    Import entry points with importlib.
-
-    @return:
-    """
-    from importlib.metadata import entry_points
-
-    entry_points = entry_points()
-
-    try:
-        ep = entry_points.select(group=MEERK40T_ENTRYPOINT)
-    except AttributeError:
-        ep = entry_points.get(MEERK40T_ENTRYPOINT)
-
-    if ep is None:
-        return []
-
-    for entry_point in ep:
-        try:
-            yield entry_point.load()
-        except ImportError as e:
-            print(
-                "Cannot install plugin - '{entrypoint}'.".format(
-                    entrypoint=str(entry_point.value)
-                )
-            )
-            print(e)
-
-
-def plugin(kernel, lifecycle):
-    import sys
-
-    if lifecycle == "plugins":
-        if getattr(sys, "frozen", False):
-            return
-        if kernel.args.no_plugins:
-            return
-
-        try:
-            return list(plugins_importlib())
-        except ImportError:
-            return list(plugins_pre_38())
-
-    if lifecycle == "invalidate":
-        # Do not maintain plugin.
-        return True
+"""
+These are external plugins. They are dynamically found by entry points. This file is replaced with the build file during
+builds, since compiled versions do not have access to entry points. External plugins therefore must be hard-coded for
+builds. See the external_plugin_build.py file for regular built plugins.
+"""
+
+MEERK40T_ENTRYPOINT = "meerk40t.extension"
+
+
+def plugins_pre_38():
+    """
+    Import plugins using pkg_resources. pkg_resources was deprecated in 3.10 and removed in 3.12
+    @return:
+    """
+    import pkg_resources
+
+    for entry_point in pkg_resources.iter_entry_points(MEERK40T_ENTRYPOINT):
+        try:
+            ep_plugin = entry_point.load()
+        except pkg_resources.DistributionNotFound:
+            pass
+        except pkg_resources.VersionConflict as e:
+            print(
+                "Cannot install plugin - '{entrypoint}' due to version conflict.".format(
+                    entrypoint=str(entry_point)
+                )
+            )
+            print(e)
+        else:
+            yield ep_plugin
+
+
+def plugins_importlib():
+    """
+    Import entry points with importlib.
+
+    @return:
+    """
+    from importlib.metadata import entry_points
+
+    entry_points = entry_points()
+
+    try:
+        ep = entry_points.select(group=MEERK40T_ENTRYPOINT)
+    except AttributeError:
+        ep = entry_points.get(MEERK40T_ENTRYPOINT)
+
+    if ep is None:
+        return []
+
+    for entry_point in ep:
+        try:
+            yield entry_point.load()
+        except ImportError as e:
+            print(
+                "Cannot install plugin - '{entrypoint}'.".format(
+                    entrypoint=str(entry_point.value)
+                )
+            )
+            print(e)
+
+
+def plugin(kernel, lifecycle):
+    import sys
+
+    if lifecycle == "plugins":
+        if getattr(sys, "frozen", False):
+            return
+        if kernel.args.no_plugins:
+            return
+
+        try:
+            return list(plugins_importlib())
+        except ImportError:
+            return list(plugins_pre_38())
+
+    if lifecycle == "invalidate":
+        # Do not maintain plugin.
+        return True

meerk40t/external_plugins_build.py

@@ -1,28 +1,28 @@
-"""
-This file is used in builds to replace the dynamic plugins file. This file should not be included anywhere. It should
-be swapped during a full build so that entry_points get switched for hard-linked references. This ensures that builds
-can contain a list of useful desired plugins.
-
-If you have written such a plugin, raise an issue to have it reviewed and included into the builds.
-"""
-
-
-def plugin(kernel, lifecycle):
-    if lifecycle == "plugins":
-        if kernel.args.no_plugins:
-            # If no plugins was requested, we do not load these plugins.
-            return
-
-        plugins = list()
-
-        """
-        This loads Jpirnay's meerk40t-barcodes plugin.
-
-        https://github.com/meerk40t/meerk40t-barcodes
-        """
-
-        from barcodes.main import plugin as barplugin
-
-        plugins.append(barplugin)
-
-        return plugins
+"""
+This file is used in builds to replace the dynamic plugins file. This file should not be included anywhere. It should
+be swapped during a full build so that entry_points get switched for hard-linked references. This ensures that builds
+can contain a list of useful desired plugins.
+
+If you have written such a plugin, raise an issue to have it reviewed and included into the builds.
+"""
+
+
+def plugin(kernel, lifecycle):
+    if lifecycle == "plugins":
+        if kernel.args.no_plugins:
+            # If no plugins was requested, we do not load these plugins.
+            return
+
+        plugins = list()
+
+        """
+        This loads Jpirnay's meerk40t-barcodes plugin.
+
+        https://github.com/meerk40t/meerk40t-barcodes
+        """
+
+        from barcodes.main import plugin as barplugin
+
+        plugins.append(barplugin)
+
+        return plugins

meerk40t/extra/cag.py

@@ -1,116 +1,112 @@
-from meerk40t.svgelements import Color, Path, Polygon
-
-
-def plugin(kernel, lifecycle):
-    if lifecycle == "invalidate":
-        try:
-            import numpy as np  # pylint: disable=unused-import
-        except ImportError:
-            return True
-    elif lifecycle == "register":
-        from ..core.elements.elements import linearize_path
-        from ..tools import polybool as pb
-
-        _ = kernel.translation
-        context = kernel.root
-
-        @context.console_option(
-            "keep", "k", type=bool, action="store_true", help="keep original elements"
-        )
-        @context.console_command(
-            ("intersection", "xor", "union", "difference"),
-            input_type="elements",
-            output_type="elements",
-            help=_("Constructive Additive Geometry: Add"),
-        )
-        def cag(command, channel, _, keep=False, data=None, **kwargs):
-            if len(data) < 2:
-                channel(
-                    _(
-                        "Not enough items selected to apply constructive geometric function"
-                    )
-                )
-                return "elements", []
-
-            elements = context.elements
-            solution_path = Path(
-                stroke=elements.default_stroke,
-                stroke_width=elements.default_strokewidth,
-                fill=elements.default_fill,
-            )
-
-            # reorder elements
-            data.sort(key=lambda n: n.emphasized_time)
-
-            node = None
-            segment_list = []
-            for i in range(len(data)):
-                node = data[i]
-                try:
-                    path = node.as_path()
-                except AttributeError:
-                    return "elements", data
-                c = linearize_path(path)
-                try:
-                    c = pb.Polygon(c)
-                    c = pb.segments(c)
-                    segment_list.append(c)
-                except pb.PolyBoolException:
-                    channel(_("Polybool could not solve."))
-            if len(segment_list) == 0:
-                return "elements", data
-            if not keep:
-                for node in data:
-                    node.remove_node()
-            segs = segment_list[0]
-            for s in segment_list[1:]:
-                combined = pb.combine(segs, s)
-                if command == "intersection":
-                    segs = pb.selectIntersect(combined)
-                elif command == "xor":
-                    segs = pb.selectXor(combined)
-                elif command == "union":
-                    segs = pb.selectUnion(combined)
-                else:
-                    # difference
-                    segs = pb.selectDifference(combined)
-
-            last_polygon = pb.polygon(segs)
-            for se in last_polygon.regions:
-                r = Polygon(*[(p.x, p.y) for p in se])
-                if solution_path is None:
-                    solution_path = Path(r)
-                else:
-                    solution_path += Path(r)
-            if solution_path:
-                if node is None:
-                    new_node = elements.elem_branch.add(
-                        path=solution_path,
-                        type="elem path",
-                    )
-                else:
-                    try:
-                        stroke = node.stroke if node is not None else None
-                    except AttributeError:
-                        stroke = Color("blue")
-                    try:
-                        fill = node.fill if node is not None else None
-                    except AttributeError:
-                        fill = None
-                    try:
-                        stroke_width = node.stroke_width if node is not None else None
-                    except AttributeError:
-                        stroke_width = elements.default_strokewidth
-                    new_node = elements.elem_branch.add(
-                        path=solution_path,
-                        type="elem path",
-                        stroke=stroke,
-                        fill=fill,
-                        stroke_width=stroke_width,
-                    )
-                context.signal("refresh_scene", "Scene")
-                elements.classify([new_node])
-                return "elements", [node]
-            else:
-                channel(_("No solution found (empty path)"))
-                return "elements", []
+from meerk40t.svgelements import Color, Path, Polygon
+
+
+def plugin(kernel, lifecycle):
+    if lifecycle == "invalidate":
+        try:
+            import numpy as np  # pylint: disable=unused-import
+        except ImportError:
+            return True
+    elif lifecycle == "register":
+        from ..core.elements.elements import linearize_path
+        from ..tools import polybool as pb
+
+        _ = kernel.translation
+        context = kernel.root
+
+        @context.console_option(
+            "keep", "k", type=bool, action="store_true", help="keep original elements"
+        )
+        @context.console_command(
+            ("intersection", "xor", "union", "difference"),
+            input_type="elements",
+            output_type="elements",
+            help=_("Constructive Additive Geometry: Add"),
+        )
+        def cag(command, channel, _, keep=False, data=None, **kwargs):
+            if len(data) < 2:
+                channel(
+                    _(
+                        "Not enough items selected to apply constructive geometric function"
+                    )
+                )
+                return "elements", []
+
+            elements = context.elements
+            solution_path = Path(
+                stroke=elements.default_stroke,
+                stroke_width=elements.default_strokewidth,
+                fill=elements.default_fill,
+            )
+
+            # reorder elements
+            data.sort(key=lambda n: n.emphasized_time)
+
+            last_fill = None
+            last_stroke = None
+            last_stroke_width = None
+            segment_list = []
+            for i, node in enumerate(data):
+                try:
+                    path = abs(node.as_path())
+                except AttributeError:
+                    return "elements", data
+                if last_fill is None and hasattr(node, "fill"):
+                    last_fill = node.fill
+                if last_stroke is None and hasattr(node, "stroke"):
+                    last_stroke = node.stroke
+                    last_stroke_width = node.stroke_width
+                c = linearize_path(path)
+                try:
+                    c = pb.Polygon(c)
+                    c = pb.segments(c)
+                    segment_list.append(c)
+                except pb.PolyBoolException:
+                    channel(_("Polybool could not solve."))
+            if not segment_list:
+                return "elements", data
+            segs = segment_list[0]
+            for s in segment_list[1:]:
+                try:
+                    combined = pb.combine(segs, s)
+                    if command == "intersection":
+                        segs = pb.selectIntersect(combined)
+                    elif command == "xor":
+                        segs = pb.selectXor(combined)
+                    elif command == "union":
+                        segs = pb.selectUnion(combined)
+                    else:
+                        # difference
+                        segs = pb.selectDifference(combined)
+                except pb.PolyBoolException:
+                    channel(_("Polybool could not solve."))
+
+            last_polygon = pb.polygon(segs)
+            for se in last_polygon.regions:
+                r = Polygon(*[(p.x, p.y) for p in se])
+                if solution_path is None:
+                    solution_path = Path(r)
+                else:
+                    solution_path += Path(r)
+            if solution_path:
+                with elements.undoscope("Constructive Additive Geometry: Add"):
+                    if not keep:
+                        for node in data:
+                            node.remove_node()
+                    stroke = last_stroke if last_stroke is not None else Color("blue")
+                    fill = last_fill
+                    stroke_width = last_stroke_width if last_stroke_width is not None else elements.default_strokewidth
+                    new_node = elements.elem_branch.add(
+                        path=solution_path,
+                        type="elem path",
+                        stroke=stroke,
+                        fill=fill,
+                        stroke_width=stroke_width,
+                    )
+                    context.signal("refresh_scene", "Scene")
+                    if elements.classify_new:
+                        elements.classify([new_node])
+                return "elements", [node]
+            else:
+                channel(_("No solution found (empty path)"))
+                return "elements", []