add fast_visualise function and FastDirectStitch

also fixed directions, and set default running stitch length

Author: Simul-Eqn

src/turtlethread/base_turtle.py

@@ -250,7 +250,7 @@ def right(self, angle):
         >>> turtle.heading()
         337.0
         """
-        self._rotate(-angle)
+        self._rotate(angle)
 
     def left(self, angle):
         """Turn turtle left by angle units.
@@ -271,7 +271,7 @@ def left(self, angle):
         >>> turtle.heading()
         67.0
         """
-        self._rotate(angle)
+        self._rotate(-angle)
 
     def pos(self):
         """Return the turtle's current location (x,y), as a Vec2D-vector.

src/turtlethread/fills.py

@@ -132,7 +132,7 @@ def _fill_at_angle(self, turtle, points, angle, simulate=False):
             prev_line = None
             jump = False
             for i in range(start_idx, len(scanned_lines) - 1): # For each scanned line
-                with turtle.direct_stitch():
+                with turtle.fast_direct_stitch():
                     if len(scanned_lines[i]) >= 2: # If there are at least 2 coordinates, there needs to be a stitch between them!
                         no_fill_in_current_iteration_flag = False # Something was filled this iteration! For while loop to continue
                         stitch_rot = (

src/turtlethread/stitches.py

@@ -49,6 +49,20 @@ def to_pyembroidery(self) -> pyembroidery.EmbPattern:
 
         return pattern
 
+    def get_pyembroidery_of(self, stitch_group_idx): 
+        """Get the PyEmbroidery pattern with the stitch commands of the i-th stitch group"""
+        pattern = pyembroidery.EmbPattern()
+        stitch_group = self.stitch_groups[stitch_group_idx]
+        if (not isinstance(stitch_group, JumpStitch)) and stitch_group.color is not None: 
+            pattern += stitch_group.color 
+
+        scaled_stitch_commands = (
+            (x * self.scale, y * self.scale, cmd) for x, y, cmd in stitch_group.get_stitch_commands()
+        )
+        pattern.stitches.extend(scaled_stitch_commands)
+
+        return pattern
+
     def get_stitch_command(self) -> list[tuple[float, float, StitchCommand]]:
         """Get stitch commands for PyEmbroidery.
 
@@ -60,6 +74,7 @@ def get_stitch_command(self) -> list[tuple[float, float, StitchCommand]]:
 
 
 class StitchGroup(ABC):
+    speedup=0 
     """Object representing one contiguous set of commands for the embroidery machine.
 
     Stitch groups are used to convert the Turtle commands into embroidery machine commands. For example, if you want to
@@ -579,6 +594,7 @@ class SatinStitch(ZigzagStitch):
     """Stitch group for satin stitches.
     A satin stitch is simply a zigzag stitch with a tight density. This creates a solid fill.
     We use 0.3mm for the density."""
+    speedup=1
 
     def __init__(self, start_pos: Vec2D, color: str, stitch_width: int | float, center: bool = True) -> None:
         super().__init__(start_pos=start_pos, color=color, stitch_width=stitch_width, stitch_length=3, center=center)
@@ -754,4 +770,9 @@ def _get_stitch_commands(self) -> list[tuple[float, float, StitchCommand]]:
         for pos1, pos2 in itertools.pairwise(self._positions):
             stitch_commands.extend(self._iter_stitches_between_positions(pos1, pos2))
 
-        return stitch_commands
+        return stitch_commands
+
+
+class FastDirectStitch(DirectStitch):
+    """A variation of direct stitch that will be fast when using fast_visualise """
+    speedup = 2 

src/turtlethread/turtle.py

@@ -9,7 +9,7 @@
 from . import fills
 from .base_turtle import TNavigator, Vec2D
 from .pattern_info import show_info
-from .visualise import visualise_pattern
+from .visualise import visualise_pattern, fast_visualise
 
 USE_SPHINX_GALLERY = False
 
@@ -182,7 +182,7 @@ def circle(self, radius, extent=None, steps=None):
 
         super().circle(radius=radius, extent=extent, steps=steps)
 
-    def start_running_stitch(self, stitch_length):
+    def start_running_stitch(self, stitch_length=30):
         """Set the stitch mode to running stitch (not recommended, use ``running_stitch``-context instead).
 
         With a running stitch, we get stitches with a constant distance between each stitch.
@@ -290,6 +290,9 @@ def start_z_stitch(
 
     def start_direct_stitch(self):
         self.set_stitch_type(stitches.DirectStitch(self.pos()))
+    
+    def start_fast_direct_stitch(self):
+        self.set_stitch_type(stitches.FastDirectStitch(self.pos()))
 
     def cleanup_stitch_type(self):
         """Cleanup after switching stitch type."""
@@ -331,7 +334,7 @@ def use_stitch_group(self, stitch_group):
 
         self.cleanup_stitch_type()
 
-    def running_stitch(self, stitch_length):
+    def running_stitch(self, stitch_length=30):
         """Set the stitch mode to running stitch and cleanup afterwards.
 
         With a running stitch, we get stitches with a constant distance between each stitch.
@@ -444,6 +447,9 @@ def z_stitch(
 
     def direct_stitch(self):
         return self.use_stitch_group(stitches.DirectStitch(self.pos(), self.curr_color))
+    
+    def fast_direct_stitch(self):
+        return self.use_stitch_group(stitches.FastDirectStitch(self.pos(), self.curr_color))
 
     @property
     def _position(self):
@@ -523,6 +529,46 @@ def visualise(self, turtle=None, width=800, height=800, scale=1, speed=6, trace_
             print(e)
             # Errors when you close the window! Yikes
             pass
+    
+    def fast_visualise(self, turtle=None, width=800, height=800, scale=1, speed=6, trace_jump=False, skip=False, check_density=True, done=True, bye=True):
+        """A fast version of the visualise() function, though it has undergone less testing.
+
+        Parameters
+        ----------
+        pattern : pyembroidery.EmbPattern
+            Embroidery pattern to visualise
+        turtle : turtle.Turtle (optional)
+            Python turtle object to use for drawing. If not specified, then the default turtle
+            is used.
+        width : int
+            Canvas width
+        height : int
+            Canvas height
+        scale : int
+            Factor the embroidery length's are scaled by.
+        speed : int
+            Speed that the turtle object moves at.
+        trace_jump : bool
+            If True, then draw a grey line connecting the origin and destination of jumps.
+        skip : bool
+            If True, then skip the drawing animation and jump to the completed visualisation.
+        check_density : bool
+            If True, then check the density of the embroidery pattern. Recommended but slow.
+        done : bool
+            If True, then ``turtle.done()`` will be called after drawing.
+        bye : bool
+            If True, then ``turtle.bye()`` will be called after drawing.
+        """
+        try:
+            fast_visualise(
+                self,
+                turtle=turtle, width=width, height=height, scale=scale, speed=speed, trace_jump=trace_jump, skip=skip, 
+                check_density=check_density, done=done, bye=bye
+            )
+        except Exception as e:
+            print(e)
+            # Errors when you close the window! Yikes
+            pass
 
     def show_info(self):
         """Display information about this turtle's embroidery pattern."""