meerk40t 0.9.7020__py2.py3-none-any.whl → 0.9.7030__py2.py3-none-any.whl

meerk40t/extra/param_functions.py

@@ -435,7 +435,7 @@ def plugin(kernel, lifecycle):
         @self.console_argument("inversions", nargs="*", type=int)
         @context.console_command(
             "ffractal",
-            help=_("ffractal iterations"),
+            help=_("fractal iterations"),
             output_type="geometry",
             hidden=True,
         )

meerk40t/extra/potrace.py

@@ -48,21 +48,25 @@ potracer:   https://github.com/tatarize/potrace
 
 def plugin(kernel, lifecycle=None):
     if lifecycle == "invalidate":
+        invalid = False
+        return invalid
+
+    if lifecycle == "register":
+        _ = kernel.translation
+        import numpy
+        valid = False
         try:
-            import numpy
             import potrace
-            if not hasattr(potrace, "Bitmap"):
+            if hasattr(potrace, "Bitmap"):
+                valid = True
+            else:
                 # This is a strange variant, that we do not support!
                 print ("The version of potrace that is installed on your machine is incompatible. Please report this to the developers.")
-                return True
         except ImportError:
-            # print("Potrace plugin could not load because potracer/pypotrace is not installed.")
-            return True
-
-    if lifecycle == "register":
-        _ = kernel.translation
-        import numpy
-        import potrace
+            valid = False
+        
+        if not valid:
+            from . import mk_potrace as potrace
 
         def make_vector(
             image,

meerk40t/grbl/interpreter.py

@@ -12,7 +12,7 @@ from meerk40t.kernel import Module
 class GRBLInterpreter(Module):
     def __init__(self, service, path):
         Module.__init__(self, service, path)
-        self.emulator = GRBLEmulator(self, service.space.display.matrix())
+        self.emulator = GRBLEmulator(self, service.space.display.matrix)
         self._attached_device = None
 
     def __repr__(self):

meerk40t/gui/about.py

@@ -1770,6 +1770,8 @@ class ComponentPanel(ScrolledPanel):
 
         def get_potrace():
             entry = ["potracer", "", "", "https://pypi.org/project/potracer/"]
+            status = _("Present (slow)")
+            info = "0.05 (internal)"
             try:
                 import potrace
 
@@ -1780,14 +1782,10 @@ class ComponentPanel(ScrolledPanel):
                     entry[0] = "pypotrace"
                     entry[3] = "https://pypi.org/project/pypotrace/"
                     info = potrace.potracelib_version()
-                else:
-                    status = _("Present (slow)")
-                    info = "??"
                 if not hasattr(potrace, "Bitmap"):
                     status = _("Faulty, please report")
             except ImportError:
-                info = "??"
-                status = _("Missing")
+                pass
             entry[1] = info
             entry[2] = status
             self.content.append(entry)

meerk40t/gui/basicops.py

@@ -459,21 +459,21 @@ class BasicOpPanel(wx.Panel):
         self.context.themes.set_window_colors(header)
         header.SetMinSize(dip_size(self, 20, -1))
         header.SetMaxSize(dip_size(self, 20, -1))
-        header.SetToolTip(_("Active"))
+        header.SetToolTip(_("A: Active = toggle whether the elements assigned to this operation will be burned or not"))
         info_sizer.Add(header, 1, wx.ALIGN_CENTER_VERTICAL, 0)
 
         header = wxStaticText(self.op_panel, wx.ID_ANY, label="S")
         self.context.themes.set_window_colors(header)
         header.SetMinSize(dip_size(self, 20, -1))
         header.SetMaxSize(dip_size(self, 20, -1))
-        header.SetToolTip(_("Show"))
+        header.SetToolTip(_("S: Show = if inactive then you can suppress the drawing of the assigned elements"))
         info_sizer.Add(header, 1, wx.ALIGN_CENTER_VERTICAL, 0)
 
         header = wxStaticText(self.op_panel, wx.ID_ANY, label="C")
         self.context.themes.set_window_colors(header)
         header.SetMinSize(dip_size(self, 20, -1))
         header.SetMaxSize(dip_size(self, 20, -1))
-        header.SetToolTip(_("Coolant"))
+        header.SetToolTip(_("C: Coolant = determines whether coolant remains / will be turned on / turned off at start of this operation"))
         info_sizer.Add(header, 1, wx.ALIGN_CENTER_VERTICAL, 0)
 
         unit = " [%]" if self.use_percent else ""

meerk40t/gui/choicepropertypanel.py

@@ -1117,10 +1117,7 @@ class ChoicePropertyPanel(ScrolledPanel):
                     control.SetValue(bool((data >> b) & 1))
                     if mask:
                         control.Enable(bool((mask_bits >> b) & 1))
-                    control.Bind(
-                        wx.EVT_CHECKBOX,
-                        on_checkbox_check(attr, control, obj, b, additional_signal),
-                    )
+                    control.Bind(wx.EVT_CHECKBOX, on_checkbox_bitcheck(attr, control, obj, b, additional_signal), )
 
                     # mask bit
                     if mask:

meerk40t/gui/gui_mixins.py

@@ -584,7 +584,10 @@ class Warnings:
                             image_node = node.node if hasattr(node, "node") else node
                             if getattr(image_node, "hidden", False):
                                 continue
-                            opdpi = op.dpi if useop else image_node.dpi
+                            if hasattr(image_node, "dpi"):
+                                opdpi = op.dpi if useop else image_node.dpi
+                            else:
+                                opdpi = op.dpi
                             step_x, step_y = self.context.device.view.dpi_to_steps(opdpi)
                             step_x *= self.context.device.view.native_scale_x
                             step_y *= self.context.device.view.native_scale_y

meerk40t/gui/spoolerpanel.py

@@ -673,15 +673,6 @@ class SpoolerPanel(wx.Panel):
 
         return routine
 
-    def pane_show(self, *args):
-        self.shown = True
-        self.context.schedule(self.timerjob)
-        self.refresh_spooler_list()
-
-    def pane_hide(self, *args):
-        self.context.unschedule(self.timerjob)
-        self.shown = False
-
     @staticmethod
     def _name_str(named_obj):
         try:
@@ -1171,10 +1162,16 @@ class SpoolerPanel(wx.Panel):
             self.on_device_update(None)
 
     def pane_show(self):
+        self.shown = True
         self.list_job_history.load_column_widths()
         self.list_job_spool.load_column_widths()
+        self.context.schedule(self.timerjob)
+        self.refresh_spooler_list()
 
     def pane_hide(self):
+        self.context.unschedule(self.timerjob)
+        self.shown = False
+
         self.list_job_history.save_column_widths()
         self.list_job_spool.save_column_widths()
 

meerk40t/gui/themes.py

@@ -31,6 +31,9 @@ def color_distance(c1:wx.Colour, c2:wx.Colour) -> bool:
     # print (f"Distance from {c1.GetAsString()} to {c2.GetAsString()} = {sqrt(sq_dist)}")
     return sqrt(sq_dist)
 
+def inverted_color(c1:wx.Colour) -> wx.Colour:
+    return wx.Colour(255-c1.red, 255-c1.green, 255-c1.blue, c1.alpha)
+
 def is_a_bright_color(c1):
     return color_distance(c1, wx.BLACK) > color_distance(c1, wx.WHITE)
 
@@ -132,6 +135,10 @@ class Themes(Service):
         tp["inactive_fg"] = wx.SystemSettings.GetColour(wx.SYS_COLOUR_INACTIVECAPTIONTEXT)
         # for key, col in tp.items():
         #     print (f'tp["{key}"] = wx.Colour({col.red}, {col.green}, {col.blue}, {col.alpha})')
+        for p1, p2 in (("label_bg", "label_fg"), ("button_bg", "button_fg"), ("text_bg", "text_fg"), ("list_bg", "list_fg")):
+            inv_col = inverted_color(tp[p2])
+            if color_distance(tp[p2], tp[p1]) < color_distance(inv_col, tp[p1]):
+                tp[p2] = inv_col
         if system() != "Darwin":
             # Alas, Darwin does not properly support overloading of colors...
             if not self.dark and is_a_dark_color(tp["win_bg"]):
@@ -166,7 +173,6 @@ class Themes(Service):
                 tp["highlight"] = wx.Colour(0, 0, 255)
                 tp["inactive_bg"] = wx.Colour(46, 46, 46)
                 tp["inactive_fg"] = base_fg
-
         tp["pause_bg"] = (
             wx.Colour(87, 87, 0) if self._dark else wx.Colour(200, 200, 0)
         )

meerk40t/gui/wxmeerk40t.py

@@ -24,6 +24,7 @@ from meerk40t.gui.wxmscene import SceneWindow
 from meerk40t.gui.wxutils import TextCtrl, wxButton, wxStaticText
 from meerk40t.kernel import CommandSyntaxError, Module, get_safe_path
 from meerk40t.kernel.kernel import Job
+from meerk40t.core.units import Length
 
 from ..main import APPLICATION_NAME, APPLICATION_VERSION
 from ..tools.kerftest import KerfTool
@@ -835,6 +836,31 @@ class wxMeerK40t(wx.App, Module):
                 dialog.cancel_it()
             dialog.Destroy()
 
+        @kernel.console_argument("info", type=str, help=_("Unit to translate"))
+        @kernel.console_command("unit", help=_("Translate units"))
+        def show_unit_info(command, channel, _, info=None, **kwargs):
+            if info is None:
+                channel(_("You need to provide a value to translate"))
+            device = kernel.root.device
+            try:
+                valuex = Length(info, relative_length=device.view.width, digits=4)
+            except ValueError:
+                channel(f"Invalid value: '{info}'")
+                return
+            channel(f"{info} translates to:")
+            channel(f"tat          :  {float(valuex):.4f}")
+            channel(f"mil          :  {valuex.mil}")
+            channel(f"um           :  {valuex.um}")
+            channel(f"nm           :  {valuex.nm}")
+            channel(f"mm           :  {valuex.mm}")
+            channel(f"cm           :  {valuex.cm}")
+            channel(f"Pixels       :  {valuex.pixels}")
+            channel(f"Point        :  {valuex.pt}")
+            channel(f"spx (screen) :  {valuex.spx}")
+            channel(f"inch         :  {valuex.inches}")
+            channel(f"Device units :  {float(valuex) / device.view.native_scale_x:.4f}")
+            
+
     def module_open(self, *args, **kwargs):
         context = self.context
         kernel = context.kernel

meerk40t/gui/wxmscene.py

@@ -868,6 +868,99 @@ class MeerK40tScenePanel(wx.Panel):
                 else:
                     channel(_("Target needs to be one of primary, secondary, circular"))
 
+        # Establishes magnet commands
+        @context.console_argument(
+            "action", type=str, help=_("Action: clear or set / delete with coordinate")
+        )
+        @context.console_argument(
+            "axis", type=str, help=_("Axis (X or Y)")
+        )
+        @context.console_argument("pos", type=str, help=_("Position for magnetline"))
+        @context.console_command(
+            "magnet",
+            help=_("magnet <action> <axis> <position>"),
+            input_type="scene",
+        )
+        def magnet_set(
+            command,
+            channel,
+            _,
+            action=None,
+            axis=None,
+            pos=None,
+            **kwarg,
+        ):
+            def info(opt_msg):
+                channel(
+                    _("You need to provide the intended action:") + "\n" +
+                    _("clear x - clear y : will clear all magnets on the given axis") + "\n" +
+                    _("set x <pos> - set y <pos>: will set a magnet line on the given axis") + "\n" +
+                    _("delete x <pos> - delete y <pos>: will delete the magnet line on the given axis")
+                )
+                if opt_msg:
+                    channel(opt_msg)
+
+            if action is None or axis is None or axis.upper() not in ("X", "Y"):
+                info("")
+                return
+            action = action.lower()
+            axis = axis.upper()
+            value = None
+            if pos:
+                try:
+                    rel_len = self.context.device.view.width if axis == "X" else self.context.device.view.height
+                    value = float(Length(pos, relative_length=rel_len))
+                except ValueError:
+                    info (f"Invalid length: {pos}")
+                    return
+
+            if action != "clear" and value is None:
+                info(_("You need to provide a position"))
+                return
+
+            if action == "clear":
+                if axis == "X":
+                    count = len(self.magnet_x)
+                    self.magnet_x.clear()
+                else:
+                    count = len(self.magnet_y)
+                    self.magnet_y.clear()
+                self.save_magnets()
+                self.context.signal("refresh_scene", "Scene")
+                channel (_("Deleted {count} magnet lines on axis {axis}").format(axis=axis, count=count))
+            elif action == "set":
+                done = False
+                if axis == "X":
+                    if not value in self.magnet_x:
+                        done = True
+                        self.magnet_x.append(value)
+                else:
+                    if not value in self.magnet_y:
+                        done = True
+                        self.magnet_y.append(value)
+                self.save_magnets()
+                self.context.signal("refresh_scene", "Scene")
+                if done:
+                    channel(_("Magnetline appended at {pos} on axis {axis}").format(pos=pos, axis=axis))
+                else:
+                    channel(_("Magnetline was already present"))
+            elif action.startswith("del"):
+                done = False
+                if axis == "X":
+                    if value in self.magnet_x:
+                        done = True
+                        self.magnet_x.remove(value)
+                else:
+                    if value in self.magnet_y:
+                        done = True
+                        self.magnet_y.remove(value)
+                self.save_magnets()
+                self.context.signal("refresh_scene", "Scene")
+                if done:
+                    channel(_("Magnetline removed at {pos} on axis {axis}").format(pos=pos, axis=axis))
+                else:
+                    channel(_("Magnetline was not existing"))
+
     def toggle_ref_obj(self):
         for e in self.scene.context.elements.flat(types=elem_nodes, emphasized=True):
             if self.reference_object == e:

meerk40t/image/imagetools.py

@@ -1495,7 +1495,7 @@ def plugin(kernel, lifecycle=None):
     )
     @context.console_command(
         "linecut",
-        help=_("Cuts and image with a line"),
+        help=_("Cuts an image with a line"),
         input_type="image",
         output_type="image",
         hidden=True,

meerk40t/kernel/kernel.py

@@ -254,15 +254,21 @@ class Kernel(Settings):
                 kwargs_repr = [f"{k}={v}" for k, v in kwargs.items()]
                 signature = ", ".join(args_repr + kwargs_repr)
                 start = f"Calling {str(obj)}.{func.__name__}({signature})"
-                debug_file.write(start + "\n")
+                try:
+                    debug_file.write(start + "\n")
+                except (ValueError, OSError):
+                    pass
                 print(start)
                 t = time.time()
                 value = func(*args, **kwargs)
                 t = time.time() - t
                 finish = f"    {func.__name__} returned {value} after {t * 1000}ms"
                 print(finish)
-                debug_file.write(finish + "\n")
-                debug_file.flush()
+                try:
+                    debug_file.write(finish + "\n")
+                    debug_file.flush()
+                except (ValueError, OSError):
+                    pass
                 return value
 
             return wrapper_debug
@@ -1236,7 +1242,7 @@ class Kernel(Settings):
 
                     line = await loop.run_in_executor(None, sys.stdin.readline)
                     line = line.strip()
-                    if line in ("quit", "shutdown", "restart"):
+                    if line in ("quit", "shutdown", "exit", "restart"):
                         self._quit = True
                         if line == "restart":
                             self._restart = True

meerk40t/kernel/settings.py

@@ -54,6 +54,8 @@ class Settings:
             FileNotFoundError,
         ):
             return
+        except UnicodeDecodeError as e:
+            print ("The config file contained unsupported characters, please share the file with the dev team")
         except (configparser.DuplicateOptionError, configparser.DuplicateSectionError) as e:
             print (f"We had a duplication error in the config, try to recover from {e}")
         for section in parser.sections():

meerk40t/lihuiyu/device.py

@@ -6,14 +6,16 @@ the given device type.
 """
 
 from hashlib import md5
+import platform
+
 import meerk40t.constants as mkconst
 from meerk40t.core.laserjob import LaserJob
 from meerk40t.core.spoolers import Spooler
 from meerk40t.core.view import View
 from meerk40t.kernel import CommandSyntaxError, Service, signal_listener
 
-from ..core.units import UNITS_PER_MIL, Length
-from ..device.mixins import Status
+from meerk40t.core.units import UNITS_PER_MIL, Length
+from meerk40t.device.mixins import Status
 from .controller import LihuiyuController
 from .driver import LihuiyuDriver
 from .tcp_connection import TCPOutput
@@ -514,7 +516,10 @@ class LihuiyuDevice(Service, Status):
         self.setting(str, "serial", None)
         self.setting(bool, "serial_enable", False)
 
-        self.setting(int, "port", 1022)
+        # Linux prevents ports below 1024 to be used in an non-root context
+        def_port = 1022 if platform.system() == "Windows" else "1025"
+
+        self.setting(int, "port", def_port)
         self.setting(str, "address", "localhost")
 
         self.driver = LihuiyuDriver(self)
@@ -978,6 +983,7 @@ class LihuiyuDevice(Service, Status):
                 server = self.open_as("module/TCPServer", server_name, port=port)
                 if quit:
                     self.close(server_name)
+                    channel(_("TCP Server for lihuiyu has been closed"))
                     return
                 channel(_("TCP Server for lihuiyu on port: {port}").format(port=port))
                 if verbose:

meerk40t/main.py

@@ -11,7 +11,7 @@ import os.path
 import sys
 
 APPLICATION_NAME = "MeerK40t"
-APPLICATION_VERSION = "0.9.7020"
+APPLICATION_VERSION = "0.9.7030"
 
 if not getattr(sys, "frozen", False):
     # If .git directory does not exist we are running from a package like pypi
@@ -151,6 +151,9 @@ parser.add_argument(
     action="store_true",
     help="start window maximized",
 )
+parser.add_argument(
+    "-d", "--daemon", action="store_true", help="keep MeerK40t in background"
+)
 
 
 def run():
@@ -220,12 +223,26 @@ def _exe(restarted, args):
     kernel.add_plugin(internal_plugins)
     kernel.add_plugin(external_plugins)
     auto = hasattr(kernel.args, "auto") and kernel.args.auto
+    command = hasattr(kernel.args, "execute") and kernel.args.execute
     console = hasattr(kernel.args, "console") and kernel.args.console
+    daemon = hasattr(kernel.args, "daemon") and kernel.args.daemon
+    server_mode = False
+    if command:
+        for c in command:
+            server_mode = server_mode or any(substring in c for substring in ("lhyserver", "grblserver", "ruidacontrol", "grblcontrol", "webserver"))
+    nogui = (
+        (hasattr(kernel.args, "gui_suppress") and kernel.args.gui_suppress) or
+        (hasattr(kernel.args, "no_gui") and kernel.args.no_gui) 
+    )
     for idx, attrib in enumerate(("mktablength", "mktabpositions")):
         kernel.register(f"registered_mk_svg_parameters/tabs{idx}", attrib)
 
-    if auto and not console:
-        kernel(partial=True)
-    else:
-        kernel()
+    require_partial_mode = False
+    if (
+        (not console or nogui) and
+        (auto or daemon or server_mode)
+    ):
+        require_partial_mode = True
+    # print (f"Auto: {auto}, Command: {command}, Console: {console}, daemon: {daemon}, nogui:{nogui}, Server: {server_mode} -> {require_partial_mode}")
+    kernel(partial=require_partial_mode)
     return hasattr(kernel, "restart") and kernel.restart

meerk40t/ruida/gui/gui.py

@@ -48,7 +48,7 @@ def plugin(service, lifecycle):
 
         from meerk40t.ruida.gui.ruidaconfig import RuidaConfiguration
         from meerk40t.ruida.gui.ruidacontroller import RuidaController
-        from meerk40t.ruida.gui.ruidaoperationproperties import RuidaOperationPanel
+        # from meerk40t.ruida.gui.ruidaoperationproperties import RuidaOperationPanel
 
         service.register("window/Controller", RuidaController)
         service.register("window/Configuration", RuidaConfiguration)
@@ -56,11 +56,11 @@ def plugin(service, lifecycle):
         service.register("winpath/Controller", service)
         service.register("winpath/Configuration", service)
 
-        service.register("property/RasterOpNode/Ruida", RuidaOperationPanel)
-        service.register("property/CutOpNode/Ruida", RuidaOperationPanel)
-        service.register("property/EngraveOpNode/Ruida", RuidaOperationPanel)
-        service.register("property/ImageOpNode/Ruida", RuidaOperationPanel)
-        service.register("property/DotsOpNode/Ruida", RuidaOperationPanel)
+        # service.register("property/RasterOpNode/Ruida", RuidaOperationPanel)
+        # service.register("property/CutOpNode/Ruida", RuidaOperationPanel)
+        # service.register("property/EngraveOpNode/Ruida", RuidaOperationPanel)
+        # service.register("property/ImageOpNode/Ruida", RuidaOperationPanel)
+        # service.register("property/DotsOpNode/Ruida", RuidaOperationPanel)
 
         service.add_service_delegate(RuidaGui(service))
 

meerk40t/ruida/gui/ruidaoperationproperties.py

@@ -17,16 +17,7 @@ class RuidaOperationPanel(ScrolledPanel):
         self.parent = args[0]
         self.operation = node
 
-        choices = [
-            {
-                "attr": "air_assist",
-                "object": node,
-                "default": True,
-                "type": bool,
-                "label": _("Air Assist"),
-                "tip": _("Trigger the per element air assist"),
-            },
-        ]
+        choices = []
 
         self.panel = ChoicePropertyPanel(
             self, wx.ID_ANY, context=self.context, choices=choices, scrolling=False

meerk40t/ruida/rdjob.py

@@ -1376,13 +1376,13 @@ class RDJob:
         part = current_settings.get("part", 0)
         speed = current_settings.get("speed", 0)
         power = current_settings.get("power", 0) / 10.0
-        air = current_settings.get("air_assist", True)
+        air = current_settings.get("coolant", 0)
         self.layer_end()
         self.layer_number_part(part)
         self.laser_device_0()
-        if air:
+        if air == 1:
             self.air_assist_on()
-        else:
+        elif air==2:
             self.air_assist_off()
         self.speed_laser_1(speed)
         self.laser_on_delay(0)

meerk40t/tools/geomstr.py

@@ -179,6 +179,94 @@ def remove(s, i):
     """
     s[i:-1] = s[i + 1 :]
 
+def stitch_geometries(geometry_list:list, tolerance:float=0.0) -> list:
+    action_list = list(geometry_list)
+    result_list = []
+    start_points = []
+    end_points = []
+    anychanges = True
+    were_stitches = False
+    iteration_loop = 0
+    while anychanges:
+        iteration_loop += 1
+        # print (f"Loop {iteration_loop}")
+        anychanges = False
+        for g1 in action_list:
+            if g1 is None:
+                continue
+            fp1 = g1.first_point
+            lp1 = g1.last_point
+            if fp1 is None or lp1 is None:
+                continue
+            was_stitched = False
+            for idx, g2 in enumerate(result_list):
+                fp2 = start_points[idx]
+                lp2 = end_points[idx]
+                # end - start: append
+                # end - end : append reverse
+                # start - start: insert reverse
+                # start - end: insert
+                dist_e_s = abs(lp2 - fp1)
+                dist_e_e = abs(lp2 - lp1)
+                dist_s_s = abs(fp2 - fp1)
+                dist_s_e = abs(fp2 - lp1)
+                # print (f"test #{idx} ({fp1.real:.2f},{fp1.imag:.2f})->({lp1.real:.2f},{lp1.imag:.2f}) versus ({fp2.real:.2f},{fp2.imag:.2f})->({lp2.real:.2f},{lp2.imag:.2f})")
+                # print (f"Gaps: e -> s: {dist_e_s:.3f}, e -> e: {dist_e_e:.3f}, s -> s: {dist_s_s:.3f},s -> e: {dist_s_e:.3f},")
+                if dist_e_s <= tolerance:
+                    # append
+                    if dist_e_s > 0:
+                        g2.line(lp2, fp1)
+                    g2.append(g1, end=False)
+                    was_stitched = True
+                elif dist_e_e <= tolerance:
+                    # append reverse
+                    g1.reverse()
+                    if dist_e_e > 0:
+                        g2.line(lp2, lp1)
+                    g2.append(g1, end=False)
+                    was_stitched = True
+                elif dist_s_s <= tolerance:
+                    # insert reverse
+                    g1.reverse()
+                    if dist_s_s > 0:
+                        g1.line(fp1, fp2)
+                    g2.insert(0, g1.segments[:g1.index])
+                    was_stitched = True
+                elif dist_s_e <= tolerance:
+                    # insert
+                    if dist_s_e > 0:
+                        g1.line(lp1, fp2)
+                    g2.insert(0, g1.segments[:g1.index])
+                    was_stitched = True
+                if was_stitched:
+                    # print ("stitched")
+                    # g2.debug_me()
+                    anychanges = True
+                    start_points[idx] = g2.first_point
+                    end_points[idx] = g2.last_point
+                    result_list[idx] = g2
+                    were_stitches = True
+                    break
+
+            if not was_stitched:
+                # print ("Unchanged")
+                result_list.append(g1)
+                start_points.append(fp1)
+                end_points.append(lp1)
+        if anychanges:
+            action_list = list(result_list)
+            result_list.clear()
+            start_points.clear()
+            end_points.clear()
+    if were_stitches:
+        for g1 in result_list:
+            fp1 = g1.first_point
+            lp1 = g1.last_point
+            dist_e_s = abs(lp1 - fp1)
+            if 0 < dist_e_s <= tolerance:
+                g1.line(lp1, fp1)
+        return result_list
+    return None
 
 class Simplifier:
     # Copyright (c) 2014 Elliot Hallmark

{meerk40t-0.9.7020.dist-info → meerk40t-0.9.7030.dist-info}/METADATA

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