svg2gcode 3.3.0__tar.gz → 3.3.2__tar.gz

{svg2gcode-3.3.0 → svg2gcode-3.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: svg2gcode
-Version: 3.3.0
+Version: 3.3.2
 Summary: svg2gcode: convert an SVG (Scalable Vector Graphic) image to gcode.
 Keywords: scalable vector graphics,svg,image,laser cutter,laser engraving
 Author-email: Johannes Noordanus <mailjohannes.mailnoordanus@gmail.com>

{svg2gcode-3.3.0 → svg2gcode-3.3.2}/svg2gcode/__init__.py

@@ -1,4 +1,4 @@
 """
 svg2gcode: convert an SVG (Scalable Vector Graphic) image to gcode.
 """
-__version__ = "3.3.0"
+__version__ = "3.3.2"

{svg2gcode-3.3.0 → svg2gcode-3.3.2}/svg2gcode/svg_to_gcode/compiler/_compiler.py

@@ -66,6 +66,9 @@ class Compiler:
 
         self.interface.set_machine_parameters(self.settings)
 
+        # toggle
+        self.fan_on = self.settings['fan']
+
         if custom_header is None:
             custom_header = []
 
@@ -77,7 +80,7 @@ class Compiler:
                        self.interface.set_distance_mode(self.settings["distance_mode"])] + custom_header
         self.footer = custom_footer
 
-        # path object gcode
+        # path gcode
         self.body: list[str] = []
         # image gcode
         self.gcode: list[str] = []
@@ -128,12 +131,13 @@ class Compiler:
 
         :param passes: the number of passes that should be made. Every pass the machine moves_down (z-axis) by
         self.pass_depth and self.body is repeated.
-        :return returns the assembled code. self.header + [self.body, -self.pass_depth] * passes + self.footer
+        :return returns the assembled g-code. [self.body, -self.pass_depth] * passes
         """
         if len(self.body) == 0:
             logger.debug("Compile with an empty body (no curves).")
             return ''
 
+        fan_off = False
         gcode = []
         for i in range(passes):
             gcode += [f"; pass #{i+1}"]
@@ -141,13 +145,11 @@ class Compiler:
 
             if i < (passes - 1) and self.settings["pass_depth"] > 0:
                 # If it isn't the last pass, turn off the laser and move down
-                gcode.append(self.interface.laser_off())
+                gcode.append(self.interface.laser_off(fan_off))
                 gcode.append(self.interface.set_relative_coordinates())
                 gcode.append(self.interface.linear_move(z=-self.settings["pass_depth"]))
                 gcode.append(self.interface.set_distance_mode(self.settings["distance_mode"]))
 
-        gcode += [self.interface.laser_off()]
-
         # remove all ""
         gcode = filter(lambda command: len(command) > 0, gcode)
 
@@ -160,11 +162,12 @@ class Compiler:
         """
 
         # laser off, fan on, M3 or M4 burn mode
-        header_gc = ["M5","M8", 'M3' if self.settings["laser_mode"] == "constant" else 'M4']
-        # laser off, fan off
-        footer_gc = ["M5","M9"]
+        header_gc = ["M5"]
+        if self.settings['fan'] and self.settings["splitfile"]:
+            header_gc += ['M8']
+        header_gc += ['M3' if self.settings["laser_mode"] == "constant" else 'M4']
 
-        return '\n'.join(header_gc + self.gcode + footer_gc)
+        return '\n'.join(header_gc + self.gcode)
 
     def compile_to_file(self, file_name: str, svg_file_name: str, curves: list[Curve], passes=1):
         """
@@ -182,15 +185,17 @@ class Compiler:
         self.append_curves(curves)
 
         header = '\n'.join(self.header) + '\n'
+        footer = '\n'.join(self.footer) + '\n'
 
         if len(self.body) > 0:
             # write path objects
             with open(file_name, 'w') as file:
-                emit_program_end = self.interface.program_end() if (self.settings["splitfile"] or len(self.gcode) == 0) else ""
-                file.write(self.gcode_file_header() + header + self.compile(passes=passes) + '\n' + emit_program_end)
+                #emit_program_end = self.interface.program_end() if (self.settings["splitfile"] or len(self.gcode) == 0) else ""
+                program_end = footer if (self.settings["splitfile"] or len(self.gcode) == 0) else ""
+                file.write(self.gcode_file_header() + header + self.compile(passes=passes) + '\n' + program_end)
                 logger.info(f"Generated {file_name}")
         else:
-            logger.warn(f'No path (curve) data found, skipping "{file_name}"')
+            logger.warn(f'No path (curve) data found nothing added to "{file_name}"')
 
         image_file_name = file_name.rsplit('.',1)[0] + "_images." + file_name.rsplit('.',1)[1]
         if len(self.gcode) == 0:
@@ -202,13 +207,13 @@ class Compiler:
             if self.settings["splitfile"]:
                 # emit image objects to <filename>_images.<gcext>
                 with open(image_file_name, 'w') as file:
-                    file.write(self.gcode_file_header() + header +  self.compile_images() + '\n' + self.interface.program_end() + '\n')
+                    file.write(self.gcode_file_header() + header + self.compile_images() + '\n' + footer)
                     logger.info(f"Generated {image_file_name}")
             else:
                 # emit images objects in same file
                 open_mode = 'w' if len(self.body) == 0 else 'a+'
                 with open(file_name, open_mode) as file:
-                    file.write((self.gcode_file_header() if len(self.body) == 0 else "") + '\n' +  self.compile_images() + '\n' + self.interface.program_end() + '\n')
+                    file.write((self.gcode_file_header() if len(self.body) == 0 else "") + '\n' +  self.compile_images() + '\n' + footer)
                     logger.info(f"Added image(s) to {file_name}")
 
     def append_line_chain(self, line_chain: LineSegmentChain, step: float, color: int = None, speed: int = None):
@@ -233,20 +238,24 @@ class Compiler:
         laser_power = color if color is not None else self.settings["laser_power"]
         movement_speed = speed if speed is not None else self.settings["movement_speed"]
 
+        # do not turn fan off
+        fan_off = False
+
 	# Move to the next line_chain when the next line segment doesn't connect to the end of the previous one.
         if self.interface.position is None or abs(self.interface.position - start) > TOLERANCES["operation"]:
             if self.interface.position is None or self.settings["rapid_move"]:
                 # move to the next line_chain: set laser off, rapid move to start of chain,
                 # set movement (cutting) speed, set laser mode and power on
-                code += [self.interface.laser_off(), self.interface.rapid_move(start.x, start.y),
+                code += [self.interface.laser_off(fan_off), self.interface.rapid_move(start.x, start.y),
                         self.interface.set_movement_speed(movement_speed),
-                        self.interface.set_laser_mode(self.settings["laser_mode"]), self.interface.set_laser_power_value(laser_power)]
+                        self.interface.set_laser_mode(self.settings["laser_mode"]), self.interface.set_laser_power_value(laser_power,self.fan_on)]
             else:
                 # move to the next line_chain: set laser mode, set laser power to 0 (cutting is off),
                 # set movement speed, (no rapid) move to start of chain, set laser to power
-                code += [self.interface.set_laser_mode(self.settings["laser_mode"]), self.interface.set_laser_power_value(0),
+                code += [self.interface.set_laser_mode(self.settings["laser_mode"]), self.interface.set_laser_power_value(0,self.fan_on),
                         self.interface.set_movement_speed(movement_speed), self.interface.linear_move(start.x, start.y),
                         self.interface.set_laser_power_value(laser_power)]
+            self.fan_on = False
 
             self.boundingbox.update(start)
 
@@ -370,7 +379,7 @@ class Compiler:
         arguments["showoverscan"] = img_attrib['gcode_showoverscan'] if 'gcode_showoverscan' in img_attrib else self.settings["image_showoverscan"]
         arguments["offset"] = (float(img_attrib['x']), float(img_attrib['y']))
         arguments["name"] = img_attrib['id']
-        arguments["invert"] = img_attrib['invert'] if 'invert' in img_attrib else False
+        arguments["invert"] = img_attrib['invert'] if 'invert' in img_attrib else True
 
         # get image parameters
         params = ''
@@ -671,7 +680,10 @@ class Compiler:
                     # Invert b&w value and apply alpha channel - when available - to the inverted b&w value
                     # Library function image2gcode - as it is now - cannot invert a color value and then apply the alpha channel.
                     # Note that step 6 of '# Render svg fill attribute' below, sets option 'invert' of image2gcode to false to use fill_color directly.)
-                    fill_color = Image2gcode.linear_power(css_color.parse_css_color2bw8(style['fill']), self.settings["maximum_image_laser_power"])
+
+                    # invert (byte value)
+                    fill_color = Image2gcode.linear_power(css_color.parse_css_color2bw8(style['fill']), 255)
+
                     if style['fill-rule'] is not None:
                         fill_rule = style['fill-rule']
                         if fill_rule == "nonzero":
@@ -687,7 +699,7 @@ class Compiler:
                         fill_alpha = 1
                         if len(rgba) == 4:
                             fill_alpha = rgba[3]
-                    fill_color = fill_color * fill_alpha
+                    fill_color = round(fill_color * fill_alpha)
 
             return (stroke_width, stroke_color, stroke_alpha, fill_color, fill_alpha, fill_rule)
 
@@ -747,14 +759,6 @@ class Compiler:
                 stroke_width, stroke_color, stroke_alpha, fill_color, fill_alpha, fill_rule = get_style_info_of_line_chain(line_chain)
 
                 if len(stroke_color):
-                    # Get steps (offsets) for the lines that make the border
-                    steps = [0]
-                    if stroke_width:
-                        for delta in range(stroke_width):
-                            if delta:
-                                steps.append(round(delta * pixel_size, self.precision))
-                                if not (delta == stroke_width and stroke_width % 2 != 0):
-                                    steps.append(round(-delta * pixel_size, self.precision))
 
                     # Get stroke alpha channel (opacity)
                     # fill opacity attribute overrides rgba property
@@ -766,8 +770,8 @@ class Compiler:
 
                     # engrave values
                     # set inversed b&w value (and apply alpha channel, when available)
-                    inverse_bw = Image2gcode.linear_power(css_color.parse_css_color2bw8(stroke_color), \
-                                                          self.settings["maximum_image_laser_power"]) * stroke_alpha
+                    inverse_bw = round(Image2gcode.linear_power(css_color.parse_css_color2bw8(stroke_color),
+                                                          self.settings["maximum_image_laser_power"]) * stroke_alpha)
                     # set laser head movement speed
                     speed = self.settings["image_movement_speed"]
 
@@ -782,31 +786,51 @@ class Compiler:
                                 # color_coded set cut path for this stroke_color
                                 self.body.extend([f"\n; --color_coded cut path '{name_id}', color '{stroke_color}'"])
                                 render_pathwidth(line_chain, [0], None, None, boundingbox)
-                            else:
-                                # engrave path ...
-                                pathignore, pathcut, pathengrave = color_coded_paths()
+                            elif inverse_bw:
+                                # with path color, setengrave path ...
+                                pathignore, pathcut, pathengrave = self.color_coded_paths()
 
                                 # ... if color_coded did not set engrave (at all) or set engrave for this stroke_color
                                 if len(pathengrave) == 0 or engravepath:
+                                    # Get steps (offsets) for the lines that make the border
+                                    steps = [0]
+                                    if stroke_width:
+                                        for delta in range(stroke_width):
+                                            if delta:
+                                                steps.append(round(delta * pixel_size, self.precision))
+                                                if not (delta == stroke_width and stroke_width % 2 != 0):
+                                                    steps.append(round(-delta * pixel_size, self.precision))
+
                                     if len(pathengrave) == 0:
                                         self.body.extend([f"\n; --color_coded: engrave not set, path '{name_id}', color '{stroke_color}'"])
                                     else:
                                         self.body.extend([f"\n; --color_coded: engrave path '{name_id}', color '{stroke_color}'"])
                                     render_pathwidth(line_chain, steps, inverse_bw, speed, boundingbox)
                         else:
+                            # ignore path
                             self.body.extend([f"\n; --color_coded: ignore path '{name_id}', color '{stroke_color}'"])
 
-                    else:
-                        # color_coded isn't set: engrave path
+                    elif inverse_bw:
+                        # Get steps (offsets) for the lines that make the border
+                        steps = [0]
+                        if stroke_width:
+                            for delta in range(stroke_width):
+                                if delta:
+                                    steps.append(round(delta * pixel_size, self.precision))
+                                    if not (delta == stroke_width and stroke_width % 2 != 0):
+                                        steps.append(round(-delta * pixel_size, self.precision))
+
+                        # color_coded isn't set: with path color engrave path
                         self.body.extend([f"\n; engrave path '{name_id}', color '{stroke_color}'"])
                         render_pathwidth(line_chain, steps, inverse_bw, speed, boundingbox)
                 else:
-                    # line stroke isn't set: cut path
-                    self.body.extend([f"\n; no stroke color: cut path '{name_id}'"])
-                    render_pathwidth(line_chain, [0], None, None, boundingbox)
+                    # line stroke isn't set: ignore path
+                    self.body.extend([f"\n; no stroke color set: ignore path '{name_id}'"])
+                    #render_pathwidth(line_chain, [0], None, None, boundingbox)
 
             # Render svg 'fill' attribute
-            if not self.settings["nofill"] and fill_color is not None and boundingbox.get() is not None:
+            #if not self.settings["nofill"] and fill_color is not None and boundingbox.get() is not None:
+            if not self.settings["nofill"] and fill_color is not None:
                 # fill a path
                 # this is done in 6 steps:
                 # step 1: create two raster images matching the bbox
@@ -817,6 +841,12 @@ class Compiler:
                 # step 5: filter stray pixels (to remove noise from the action above)
                 # step 6: generate gcode from image_fill (by execution function image2gcode)
 
+                # update boundingbox for this 'name_id'
+                for line_chain in path_curves[name_id]:
+                    for line in line_chain:
+                        boundingbox.update(line.start)
+                        boundingbox.update(line.end)
+
                 # get bounding box info from the path border
                 lowerleft = boundingbox.get()[0]
                 upperright = boundingbox.get()[1]
@@ -834,8 +864,8 @@ class Compiler:
 
                 # step 1: create two raster images matching the bbox
                 # init
-                image_mark = np.full([img_height + 2, img_width + scan_error], 255, dtype=np.uint8)
-                image_fill = np.full([img_height + 2, img_width + scan_error], 0, dtype=np.uint8)
+                image_mark = np.full([img_height + 4, img_width + scan_error + 2], 255, dtype=np.uint8)
+                image_fill = np.full([img_height + 4, img_width + scan_error + 2], 0, dtype=np.uint8)
 
                 # step 2: add marker lines just inside the line chains of the path
                 # - determine the inside of the line chain
@@ -852,7 +882,7 @@ class Compiler:
                     # delta line chain is inside or outside the base line chain, but when we compare
                     # the bbox sizes we know.
                     # Note that this method can be used to determine if a line chain is drawn clockwise
-                    # or anti-clockwise because a posive delta offset should be 'outside' the line chain
+                    # or anti-clockwise because a positive delta offset should be 'outside' the line chain
                     # in this case (depending on the definition/calculation of the delta function).
                     # we can use this to implement the other svg fill rule: 'nonzero'.
                     bbox = Boundingbox()

{svg2gcode-3.3.0 → svg2gcode-3.3.2}/svg2gcode/svg_to_gcode/compiler/interfaces/_gcode.py

@@ -154,22 +154,22 @@ class Gcode(Interface):
 
         return command + ''
 
-    def laser_off(self):
+    def laser_off(self, fan_off = True):
         self._laser_mode = 'M5'
         self._laser_mode_changed = True
-        new_mode = "M5" + ("\nM9" if self._machine_params['fan'] else '') # laser off, (fan off when available)
+        new_mode = "M5" + ("\nM9" if self._machine_params['fan'] and fan_off else '') # laser off, (fan off when available)
         return f"{new_mode}"
 
-    def set_laser_power(self, power):
+    def set_laser_power(self, power, fan_on = True):
         print("laser power!")
         if power < 0 or power > 1:
             raise ValueError(f"{power} is out of bounds. Laser power must be given between 0 and 1. "
                              f"The interface will scale it correctly.")
 
 	# set power for next linear move
-        return self.set_laser_power_value(int(linear_map(self._machine_params['minimum_laser_power'], self._machine_params['maximum_laser_power'], power)))
+        return self.set_laser_power_value(int(linear_map(self._machine_params['minimum_laser_power'], self._machine_params['maximum_laser_power'], power)), fan_on)
 
-    def set_laser_power_value(self, machine_value) -> str:
+    def set_laser_power_value(self, machine_value, fan_on = True) -> str:
         """
         Set laser power directly - in target machine values - not as a fraction.
         """
@@ -177,10 +177,10 @@ class Gcode(Interface):
         self._next_laser_power = machine_value
 
         # (fan on when available), laser_on
-        new_mode = ("\nM8" if self._machine_params['fan'] else '') + ("\n" + self._laser_mode if self._laser_mode_changed else '')
+        new_mode = ("\nM8" if self._machine_params['fan'] and fan_on else '') + ("\n" + self._laser_mode if self._laser_mode_changed else '')
         self._laser_mode_changed = False
 	# return laser mode (M3 constant laser power or M4 dynamic laser power) when laser mode changed
-        return f"; Cut at F{self._next_speed} {self._unit}/min, power S{machine_value}{new_mode}"
+        return f"; F{self._next_speed} {self._unit}/min, power S{machine_value}{new_mode}"
 
     def set_laser_mode(self, mode):
 	# set constant/dynamic laser power mode