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

meerk40t/balormk/livelightjob.py

@@ -6,6 +6,8 @@ when the elements change. It will show the updated job.
 
 This job works as a spoolerjob. Implementing all the regular calls for being a spooled job.
 """
+
+import threading
 import time
 from math import isinf
 
@@ -13,6 +15,7 @@ import numpy as np
 
 from meerk40t.core.node.node import Node
 from meerk40t.core.units import UNITS_PER_PIXEL, Length
+from meerk40t.kernel.jobs import Job
 from meerk40t.svgelements import Matrix
 from meerk40t.tools.geomstr import Geomstr
 
@@ -25,50 +28,60 @@ class LiveLightJob:
         geometry=None,
         travel_speed=None,
         jump_delay=None,
-        quantization=50,
+        quantization=100,
         listen=True,
         raw=False,
     ):
         self.service = service
+        self.quantization = quantization
+        self.mode = mode
+        self.listen = listen
+        self.raw = raw
+        self._geometry = geometry
+        self._travel_speed = travel_speed
+        self._jump_delay = jump_delay
+
+        # Kernel Job definition
+        self.redlight_lock = threading.RLock()
+        self.redlight_job = Job(
+            self.jobevent,
+            interval=0.1,
+            job_name=f"redlight_{self.mode}_{time.perf_counter():3f}",
+            run_main=False,
+        )
+
+        # Spooler-Job mirroring
         self.stopped = False
         self.started = False
-        self.changed = False
-        self._last_bounds = None
         self.priority = -1
         self.time_submitted = time.time()
         self.time_started = time.time()
         self.runtime = 0
 
-        self.quantization = quantization
-        self.mode = mode
+        # Update logic
+        self._connection = None
+        self.update_method = None
+        self.changed = False
         self.points = None
-        self.source = "elements"
-        if self.mode == "full":
-            self.label = "Live Full Light Job"
-            self._mode_light = self._full
-        elif self.mode == "bounds":
-            self.label = "Live Selection Light Job"
-            self._mode_light = self._bounds
-        elif self.mode == "crosshair":
-            self.label = "Simple Crosshairs"
-            self._mode_light = self._crosshairs
-        # elif self.mode == "regmarks":
-        #     self.label = "Live Regmark Light Job"
-        #     self._mode_light = self._regmarks
-        elif self.mode == "hull":
-            self.label = "Live Hull Light Job"
-            self._mode_light = self._hull
-        elif self.mode == "geometry":
-            self.label = "Element Light Job"
-            self._mode_light = self._static
-        else:
+        self.bounded = False
+
+        methods = {
+            "full": ("Full Light Job", self.update_full),
+            "hull": ("Hull Light Job", self.update_hull),
+            "bounds": ("Selection Light job", self.update_bounds),
+            "crosshair": ("Simple Crosshairs", self.update_crosshair),
+            "geometry": ("Element Light Job", self.update_geometry),
+        }
+        if self.mode not in methods:
             raise ValueError("Invalid mode.")
+        self.label, self.update_method = methods[self.mode]
+        if self.listen:
+            self.label = f"Live {self.label}"
 
-        self.listen = listen
-        self.raw = raw
-        self._geometry = geometry
-        self._travel_speed = travel_speed
-        self._jump_delay = jump_delay
+        # Caching of geometry to be drawn
+        self.changed = True
+        self._last_bounds = None
+        self.source = "elements"
 
     @property
     def status(self):
@@ -82,182 +95,224 @@ class LiveLightJob:
     def is_running(self):
         return not self.stopped
 
-    def execute(self, driver):
-        """
-        Spooler job execute.
+    def stop(self):
+        """Stop the spooler job.
 
-        @param driver: driver-like object
-        @return:
+        This function sets the 'stopped' flag to True, effectively
+        terminating the job's execution.
         """
-        if self.stopped:
-            return True
-        if self.listen:
-            self.service.listen("emphasized", self.on_emphasis_changed)
-            self.service.listen("modified_by_tool", self.on_emphasis_changed)
-            self.service.listen("updating", self.on_emphasis_changed)
-            self.service.listen("view;realized", self.on_emphasis_changed)
-        self.time_started = time.time()
-        self.started = True
-        connection = driver.connection
-        connection.rapid_mode()
-        connection.light_mode()
-        while self.process(connection):
-            # Calls process while execute() is running.
-            if self.stopped:
-                break
-        connection.abort()
         self.stopped = True
-        self.runtime += time.time() - self.time_started
-        if self.listen:
-            self.service.unlisten("emphasized", self.on_emphasis_changed)
-            self.service.unlisten("modified_by_tool", self.on_emphasis_changed)
-            self.service.unlisten("updating", self.on_emphasis_changed)
-            self.service.unlisten("view;realized", self.on_emphasis_changed)
-        self.service.signal("light_simulate", False)
-        if self.service.redlight_preferred:
-            connection.light_on()
-            connection.write_port()
-        else:
-            connection.light_off()
-            connection.write_port()
-        return True
 
-    def set_travel_speed(self, update_speed):
-        self._travel_speed = update_speed
+    def elapsed_time(self):
+        """Calculate the elapsed time of the job.
 
-    def stop(self):
-        """
-        Called in order to kill the spooler-job.
-        @return:
-        """
-        self.stopped = True
+        Returns the runtime if available, otherwise calculates the
+        elapsed time since the job started.
 
-    def elapsed_time(self):
-        """
-        How long is this job already running...
+        Returns:
+            float: The elapsed time in seconds.
         """
         result = 0
         if self.runtime != 0:
             result = self.runtime
-        else:
-            if self.is_running():
-                result = time.time() - self.time_started
+        elif self.is_running():
+            result = time.time() - self.time_started
         return result
 
     def estimate_time(self):
-        """
-        Estimate how long this spooler job will require to complete.
-        @return:
+        """Estimate the remaining time for the job to complete.
+
+        For this specific job, the estimation is always 0 as it's
+        a continuous live process.
+
+        Returns:
+            int: 0, representing no estimated time.
         """
         return 0
 
-    def update(self):
-        self.changed = True
-        self.points = None
+    def set_travel_speed(self, update_speed):
+        self._travel_speed = update_speed
 
-    def on_emphasis_changed(self, *args):
-        """
-        During execute the emphasis signal will call this function.
+    def execute(self, driver):
+        """Execute the spooler job.
 
-        @param args:
-        @return:
-        """
-        self.update()
+        This function runs the main loop of the job, continuously
+        updating and tracing the redlight until stopped.
 
-    def process(self, con):
-        """
-        Called repeatedly by `execute()`
-        @param con:
-        @return:
+        Args:
+            driver: The driver-like object providing the connection.
+
+        Returns:
+            bool: True when the job completes (after being stopped).
         """
         if self.stopped:
-            return False
-        if self.listen:
-            # Watch for changes.
-            bounds = self.service.elements.selected_area()
-            if bounds is None or isinf(bounds[0]):
-                bounds = Node.union_bounds(
-                    list(self.service.elements.regmarks(emphasized=True))
-                )
-            if bounds is None or isinf(bounds[0]):
-                bounds = Node.union_bounds(list(self.service.elements.elems()))
-            if self._last_bounds is not None and bounds != self._last_bounds:
-                # Emphasis did not change but the bounds did. We dragged something.
-                self.changed = True
-                self.points = None
-            self._last_bounds = bounds
+            return True
+        self.pre_job(driver)
+        while not self.stopped:
+            time.sleep(0.05)
+        self.post_job(driver)
+        return True
 
-        if self.changed:
-            # The emphasis selection has changed.
-            self.changed = False
+    def jobevent(self):
+        """Handle redlight job events.
+
+        This function is called periodically by the redlight job.
+        It updates the redlight path if necessary and then traces
+        the path with the laser.
+        """
+
+        def init_red(con):
             con.abort()
             first_x, first_y = con.get_last_xy()
             con.light_off()
             con.write_port()
             con.goto_xy(first_x, first_y, distance=0xFFFF)
+            if self._travel_speed is not None:
+                con._light_speed = self._travel_speed
+                con._dark_speed = self._travel_speed
+                con._goto_speed = self._travel_speed
+            else:
+                con._light_speed = self.service.redlight_speed
+                con._dark_speed = self.service.redlight_speed
+                con._goto_speed = self.service.redlight_speed
             con.light_mode()
 
-        if self._travel_speed is not None:
-            con._light_speed = self._travel_speed
-            con._dark_speed = self._travel_speed
-            con._goto_speed = self._travel_speed
-        else:
-            con._light_speed = self.service.redlight_speed
-            con._dark_speed = self.service.redlight_speed
-            con._goto_speed = self.service.redlight_speed
+        if self.stopped or self._connection is None:
+            return
+        con = self._connection
+        if self.changed:
+            # print ("Something changed")
+            with self.redlight_lock:
+                if self.update_method is not None:
+                    self.update_method()
+                # print (f"We are having now {len(self.points)} points")
+                self.changed = False
+            init_red(con)
+
+        # Now draw the stuff
+        self.trace_redlight(con)
+
+    def trace_redlight(self, con):
+        """Trace the redlight path.
+
+        This function iterates through the calculated redlight points
+        and sends commands to the controller to move the laser
+        accordingly, turning the laser on and off to trace the path.
+
+        Args:
+            con: The connection to the laser controller.
+        """
         con.light_mode()
-        # Calls light based on the set mode.
-        return self._mode_light(con)
+        delay_dark = self.service.delay_jump_long
+        delay_between = self.service.delay_jump_short
+        move = True
+        for i, e in enumerate(self.points):
+            if self.stopped or self.changed:
+                # Abort due to stoppage or change, no sense to continue
+                return
+            if e is None:
+                move = True
+                continue
+            x, y = e.real, e.imag
+            if np.isnan(x) or np.isnan(y):
+                move = True
+                continue
+            x = int(x)
+            y = int(y)
+            if x < 0 or x > 0xFFFF or y < 0 or y > 0xFFFF:
+                # Our bounds are not in frame.
+                if self.bounded:
+                    # We required them in frame.
+                    continue
+                # Fix them.
+                x &= 0xFFFF
+                y &= 0xFFFF
+            if move:
+                con.dark(x, y, long=delay_dark, short=delay_dark)
+                move = False
+                continue
+            con.light(x, y, long=delay_between, short=delay_between)
+        con.light_off()
+        con.write_port()
+
+    def setup_listen(self, start):
+        """Set up or tear down listeners for element changes.
 
-    # def _regmarks(self, con):
-    #     """
-    #     Mode light regmarks gets the elements for regmarks. Sends to light elements.
+        Args:
+            start (bool): True to start listening, False to stop.
+        """
+        if not self.listen:
+            return
+        for method in ("emphasized", "modified_by_tool", "updating", "view;realized"):
+            if start:
+                self.service.listen(method, self.on_emphasis_changed)
+            else:
+                self.service.unlisten(method, self.on_emphasis_changed)
 
-    #     @param con: connection
-    #     @return:
-    #     """
-    #     elements = list(self.service.elements.regmarks(emphasized=True))
-    #     if len(elements) == 0:
-    #         elements = list(self.service.elements.regmarks())
-    #     return self._light_elements(con, elements)
+    def pre_job(self, driver):
+        """Perform pre-job setup.
 
-    def _gather_source(self):
-        self.source = "elements"
-        elements = list(self.service.elements.elems(emphasized=True))
-        if len(elements) == 0:
-            elements = list(self.service.elements.regmarks(emphasized=True))
-            self.source = "regmarks"
-        if len(elements) == 0:
-            elements = list(self.service.elements.elems())
-        return elements
+        This function is called before the job starts executing.
+        It sets up listeners, initializes the connection, and
+        schedules the redlight job.
 
-    def _full(self, con):
-        """
-        Mode light full gets the elements from the emphasized primary elements. Sends to light elements.
-        @param con: connection
-        @return:
+        Args:
+            driver: The driver-like object.
         """
-        # Full was requested.
-        elements = self._gather_source()
-        return self._light_elements(con, elements)
+        self.setup_listen(True)
+        self.time_started = time.time()
+        self.started = True
+        self._connection = driver.connection
+        self._connection.rapid_mode()
+        self._connection.light_mode()
+        self.update()
+        self.service.kernel.schedule(self.redlight_job)
 
-    def _hull(self, con):
-        """
-        Mode light hull gets the convex hull. Sends to light hull.
+    def post_job(self, driver):
+        """Perform post-job cleanup.
+
+        This function is called after the job finishes executing.
+        It stops listening, cancels the redlight job, and resets
+        the connection.
 
-        @param con: connection
-        @return:
+        Args:
+            driver: The driver-like object.
         """
-        elements = self._gather_source()
-        return self._light_hull(con, elements)
+        self.stopped = True
+        self.runtime += time.time() - self.time_started
+        self.redlight_job.cancel()
+        self.service.kernel.unschedule(self.redlight_job)
+        self.setup_listen(False)
+        if self._connection is not None:
+            self._connection.abort()
+            if self.service.redlight_preferred:
+                self._connection.light_on()
+            else:
+                self._connection.light_off()
+            self._connection.write_port()
+            self._connection = None
+            self.service.signal("light_simulate", False)
 
-    def _crosshairs(self, con, margin=5000):
+    def update(self):
+        """Mark the redlight path as changed.
+
+        This function sets the 'changed' flag to True, indicating
+        that the redlight path needs to be recalculated.
         """
-        Mode light crosshairs draws crosshairs. Sends to light geometry.
+        with self.redlight_lock:
+            self.changed = True
+
+    def on_emphasis_changed(self, *args):
+        """Handle emphasis changes.
 
-        @param con: connection
-        @return:
+        This function is called when the emphasis of elements changes.
+        It triggers an update of the redlight path.
         """
+        self.update()
+
+    def update_crosshair(self):
+        """Update the redlight path to display crosshairs. Fallback case when nohing can be displayed"""
+        margin = 5000
         geometry = Geomstr.lines(
             (0x8000, 0x8000),
             (0x8000 - margin, 0x8000),
@@ -269,52 +324,97 @@ class LiveLightJob:
             (0x8000, 0x8000 + margin),
             (0x8000, 0x8000),
         )
-        rotate = self._redlight_adjust_matrix()
-        geometry.transform(rotate)
+        self.prepare_redlight_point(geometry, False, "crosshair")
 
-        return self._light_geometry(con, geometry)
-
-    def _static(self, con):
+    def update_geometry(self):
+        """Update the redlight path based on the provided geometry. Static, won't be changed."""
+        if self._geometry is None:
+            self.update_crosshair()
+            return
         geometry = Geomstr(self._geometry)
-        rotate = self._redlight_adjust_matrix()
-        if not self.raw:
-            geometry.transform(self.service.view.matrix)
-        geometry.transform(rotate)
-        return self._light_geometry(con, geometry)
+        self.prepare_redlight_point(geometry, not self.raw, "geometry")
 
-    def _bounds(self, con):
-        """
-        Light the bound's geometry. Sends to light geometry.
+    def _update_common(self, method, source):
+        elems = self._gather_source()
+        if len(elems) == 0:
+            self.update_crosshair()
+            return
+        geometry = method(elems)
+        if geometry is None:
+            self.update_crosshair()
+            return
 
-        @param con:
-        @return:
-        """
-        bounds = self._last_bounds
-        if not bounds:
-            # If no bounds give crosshairs.
-            return self._crosshairs(con)
-        xmin, ymin, xmax, ymax = bounds
-        geometry = Geomstr.lines(
-            (xmin, ymin),
-            (xmax, ymin),
-            (xmax, ymax),
-            (xmin, ymax),
-            (xmin, ymin),
-        )
-        rotate = self._redlight_adjust_matrix()
-        if not self.raw:
-            geometry.transform(self.service.view.matrix)
-        geometry.transform(rotate)
-        return self._light_geometry(con, geometry, bounded=True)
+        self.prepare_redlight_point(geometry, True, source)
+
+    def update_bounds(self):
+        """Update the redlight path to outline the bounds of selected elements."""
+
+        def create_bounds_geometry(elemlist):
+            bounds = Node.union_bounds(elemlist)
+            if bounds is None or isinf(bounds[0]):
+                return None
+            xmin, ymin, xmax, ymax = bounds
+            return Geomstr.lines(
+                (xmin, ymin),
+                (xmax, ymin),
+                (xmax, ymax),
+                (xmin, ymax),
+                (xmin, ymin),
+            )
+
+        self._update_common(create_bounds_geometry, "bounds")
+
+    def update_hull(self):
+        """Update the redlight path to trace the convex hull of selected elements."""
+
+        def create_hull_geometry(elemlist):
+            geometry = Geomstr()
+            for node in elemlist:
+                try:
+                    e = None
+                    if hasattr(node, "convex_hull"):
+                        e = node.convex_hull()
+                    if e is None:
+                        e = node.as_geometry()
+                except AttributeError:
+                    continue
+                geometry.append(e)
+            # If not empty return hull
+            return None if geometry.index == 0 else Geomstr.hull(geometry, distance=500)
+
+        self._update_common(create_hull_geometry, "hull")
+
+    def update_full(self):
+        """Update the redlight path to trace the full geometry of selected elements."""
+
+        def create_full_geometry(elemlist):
+            geometry = Geomstr()
+            for node in elemlist:
+                try:
+                    e = None
+                    if e is None and hasattr(node, "convex_hull"):
+                        e = node.convex_hull()
+                    if e is None and hasattr(node, "as_geometry"):
+                        e = node.as_geometry()
+                    if e is None and hasattr(node, "bounds"):
+                        nx, ny, mx, my = node.bounds
+                        e = Geomstr.rect(nx, ny, mx - nx, my - ny)
+                except AttributeError:
+                    continue
+                geometry.append(e)
+            return None if geometry.index == 0 else geometry
+
+        self._update_common(create_full_geometry, "full")
 
     def _redlight_adjust_matrix(self):
-        """
-        Calculate the redlight adjustment matrix which is the product of the redlight offset values and the
-        redlight rotation value.
+        """Calculate the redlight adjustment matrix.
 
-        @return:
-        """
+        The matrix is calculated based on the redlight offset and
+        rotation values.
 
+        Returns:
+            Matrix: The redlight adjustment matrix.
+        """
         x_offset = float(
             Length(
                 self.service.redlight_offset_x,
@@ -336,131 +436,48 @@ class LiveLightJob:
         redlight_adjust_matrix.post_translate(x_offset, y_offset)
         return redlight_adjust_matrix
 
-    def _light_geometry(self, con, geometry, bounded=False):
-        """
-        Light the current geometry.
+    def prepare_redlight_point(self, draw_geometry, adjust, source):
+        """Prepare the redlight points for tracing.
 
-        We abort quickly if self.stopped or self.changed is set.
+        This function takes the draw geometry, applies transformations
+        if necessary, and interpolates the geometry to generate a
+        list of points for the redlight to trace.
 
-        @param con: connection
-        @param geometry: geometry to light
-        @param bounded: Require the geometry to be properly bounded.
-        @return: True if we should continue, False if we should not.
+        Args:
+            draw_geometry (Geomstr): The geometry to trace.
+            adjust (bool): Whether to apply view transformations.
+            source (str): The source of the geometry.
         """
-        delay_dark = self.service.delay_jump_long
-        delay_between = self.service.delay_jump_short
-
-        points = list(geometry.as_equal_interpolated_points(distance=self.quantization))
-        move = True
-        for i, e in enumerate(points):
-            if self.stopped:
-                # Abort due to stoppage.
-                return False
-            if self.changed:
-                # Abort due to change.
-                return True
-            if e is None:
-                move = True
-                continue
-            x, y = e.real, e.imag
-            if np.isnan(x) or np.isnan(y):
-                move = True
-                continue
-            x = int(x)
-            y = int(y)
-            if (0 > x or x > 0xFFFF) or (0 > y or y > 0xFFFF):
-                # Our bounds are not in frame.
-                if bounded:
-                    # We required them in frame.
-                    return self._crosshairs(con)
-                else:
-                    # Fix them.
-                    x = x & 0xFFFF
-                    y = y & 0xFFFF
-            if move:
-                con.dark(x, y, long=delay_dark, short=delay_dark)
-                move = False
-                continue
-            con.light(x, y, long=delay_between, short=delay_between)
-        if con.light_off():
-            con.list_write_port()
-        return True
-
-    def _light_elements(self, con, elements):
-        """
-        Light the given elements. The elements should be a node list with `as_geometry()` objects
-        @param con:
-        @param elements:
-        @return:
-        """
-        geometry = Geomstr()
-        for n in elements:
-            e = None
-            if hasattr(n, "convex_hull"):
-                e = n.convex_hull()
-            if e is None and hasattr(n, "as_geometry"):
-                e = n.as_geometry()
-
-            if e is not None:
-                geometry.append(e)
-            else:
-                if hasattr(n, "as_image"):
-                    nx, ny, mx, my = n.bounds
-                    geometry.append(Geomstr.rect(nx, ny, mx - nx, my - ny))
-        if not geometry:
-            # There are no elements, return a default crosshair.
-            return self._crosshairs(con)
-
-        redlight_matrix = self._redlight_adjust_matrix()
-        if self.stopped:
-            return False
-
-        if self.changed:
-            return True
-
-        # Move to device space.
-        if not self.raw:
+        # draw_geometry.debug_me()
+        geometry = Geomstr(draw_geometry)
+        # print (f"Entered with {geometry.bbox()} ({geometry.index} segments [{source}])")
+        if adjust:
             geometry.transform(self.service.view.matrix)
+            # print (f"Adjusted to {geometry.bbox()}")
+        rotate = self._redlight_adjust_matrix()
+        geometry.transform(rotate)
+        self.points = list(
+            geometry.as_equal_interpolated_points(
+                distance=self.quantization, expand_lines=True
+            )
+        )
+        # print (f"Interpolation delivered: {len(self.points)} segments")
 
-        # Add redlight adjustments within device space.
-        geometry.transform(redlight_matrix)
-
-        self._light_geometry(con, geometry)
-        if con.light_off():
-            con.list_write_port()
-        return True
+    def _gather_source(self):
+        """Gather the source elements for redlight tracing.
 
-    def _light_hull(self, con, elements):
-        """
-        Light the given elements convex hull.
+        This function determines the source elements based on emphasis
+        and returns them as a list.
 
-        @param con:
-        @param elements:
-        @return:
+        Returns:
+            list: A list of source elements.
         """
+        self.source = "elements"
+        elements = list(self.service.elements.elems(emphasized=True))
         if not elements:
-            # There are no elements, return a default crosshair.
-            return self._crosshairs(con)
-        if self.points is None:
-            # Convert elements to geomstr
-            geometry = Geomstr()
-            for node in elements:
-                try:
-                    e = None
-                    if hasattr(node, "convex_hull"):
-                        e = node.convex_hull()
-                    if e is None:
-                        e = node.as_geometry()
-                except AttributeError:
-                    continue
-                geometry.append(e)
-
-            # Convert to hull.
-            hull = Geomstr.hull(geometry, distance=500)
-            if not self.raw:
-                hull.transform(self.service.view.matrix)
-            hull.transform(self._redlight_adjust_matrix())
-            self.points = hull
-
-        # Light geometry.
-        return self._light_geometry(con, self.points)
+            elements = list(self.service.elements.regmarks(emphasized=True))
+            self.source = "regmarks"
+        # if not elements:
+        #     elements = list(self.service.elements.elems())
+        #     self.source = "elements"
+        return elements