svg2gcode 3.3.1__tar.gz → 3.3.4__tar.gz

{svg2gcode-3.3.1 → svg2gcode-3.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: svg2gcode
-Version: 3.3.1
+Version: 3.3.4
 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>
@@ -14,7 +14,7 @@ Project-URL: Home, https://github.com/johannesnoordanus/svg2gcode
 
 # svg2gcode
 
-*svg2gcode* is a *WYSIWYG* converter of Scalable Vector Graphic *(SVG)* drawings. It is based on library *SvgToGcode* (*fork*: *https://github.com/johannesnoordanus/SvgToGcode*)<sup>(*)</sup>.
+*svg2gcode* is a *WYSIWYG* converter of Scalable Vector Graphic *(SVG)* drawings. It is based on library *SvgToGcode* (*https://github.com/johannesnoordanus/SvgToGcode*)<sup>(*)</sup>.
 
 Drawings and images can be composed using Inkscape (or other *SVG* image software), saved to a *.svg* file and - *WYSIWYG* - converted to gcode.
 Color coding can be used to mark what part(s) of the drawing to cut, engrave or even ignore.
@@ -31,13 +31,16 @@ More info can be obtained by looking at the documentation and examples below and
 
 *svg2gcode* has three related programs: *image2gcode* mentioned above has similar capabilities but handles raster image files (like *png* and *jpg*) directly, *gcode2image* performs the inverse function and is capable of showing multiple writes (burns) to the same location and last *grblhud* which gives full control over gcode execution.
 
+<sup>(*)</sup> Note that an upgraded and corrected version of this library is included.
+
  -----
 
 Please consider supporting me, so I can make this application better and add new functionality to it: <http://paypal.me/johannesnoordanus/5,00>
 
 My next update will add *fill-rule* 'nonzero' (see information on *fill-rule* below).
 
-<sup>(*)</sup> Note that an upgraded and corrected version of this library is included. 
+ -----
+
 ### Supported SVG elements and attributes
 
 *SVG* *path* and *image* elements (specific: ```<svg:path ..>```tags and images```<svg:image ..>```tags) are supported. Other drawing objects must be converted to a *path* first to be able to translate them to a gcode sequence.
@@ -45,6 +48,25 @@ My next update will add *fill-rule* 'nonzero' (see information on *fill-rule* be
 Attributes *stroke* (color), *stroke-width*, *stroke_alpha*, *fill* (color), *fill-rule*, *fill_alpha* are supported.
 Currently only value *evenodd* of *fill-rule* is supported.
 
+### *WYSIWYG*
+
+As seen above, not all *svg* elements are directly supported, but they are after a *path* conversion within the composer (Inkscape: ```menu Path->Object/Stroke to Path```). Without a *path* conversion *svg2gcode* simply ignores all elements except *path* and *image*. Text (fonts) require another step after *selecting* all text and clicking menu ```Object to Path```. Clicking ```menu Object->Ungroup``` generates a separate *path* for each letter which contains all relevant attributes. (Otherwise Inkscape uses a group tag ```<g``` to set some attributes for all letters within the text that are not repeated for each individual letter.)
+
+Note that the latest version of *svg2gcode* (3.3.3) has support for ```<g``` tags (attribute inheritance) and is able to correctly convert text without ```Ungroup```.
+
+You can use *gcode2image* to check the conversion result:
+```
+> svg2gcode some.svg some.gc
+> gcode2image --showimage --flip --grid --showorigin some.gc some.png
+```
+The image shown should be the same as the one shown by the composer (Inkscape). This is also a good way to measure the conversion result. Note that ```--grid``` and ```--showorigin``` can give some inteference. To be sure run *gcode2image* without them.
+
+#### Notes:
+ - drawing objects - within the composer - must be converted to a```path```to be translated to a gcode sequence
+ - image objects should **not** be converted to a ```path```
+ - images must be linked or embedded using base64 (Inkscape default).
+ - images can be in several formats (my tests included *.png* and  *.jpg* image files)
+ - *SVG* source documents must be in unit 'mm' and set to ```1 'user unit' is 1 mm``` (Inkscape default)
 ### Important Commandline options
 
 Option ```--color_coded``` can be used to specify what part(s) of the drawing to cut, engrave or even ignore. 
@@ -90,7 +112,7 @@ Note that engraving is the default action, so if option *color_coded* isn't set
 
 This makes it possible to make a drawing where all path elements are drawn in their respective colors to make an engraving of the entire vector drawing.
 When you set the engrave action for a set of colors, only those colors will be engraved (having their respective colors), all other paths having no action set are ignored.
-Also, when a path has no stroke attribute (or it is set to none) the element cannot be engraved (because it has no color) so it is interpreted as a cut action.
+Also, when a path has no stroke attribute (or it is set to none) the element cannot be engraved (because it has no color) so it is ignored.
 
 Option ```--pathcut``` can be used to override all stroke attributes and force cutting of all *paths* of the *SVG*.
 Note that this option cannot be set at the same time as *--color_coded* above.
@@ -121,7 +143,6 @@ General optimizations
 - borders are drawn in parallel and in one go, following the *path* coordinates.
 - fill has support for alpha channel and 'fill-opacity'
  
-
 ### Install:
 ```
 > 
@@ -347,10 +368,3 @@ One containing the drawings of the .svg, the other containing the images:
 
 Default *svg2gcode* uses constant burn mode *M3*. This can be changed by setting option *--no-constantburn* which selects burn mode *M4*. Mode *M4* is not suitable for engravings because it automatically compensates (laser)power for speed. This conflicts with the specific gcode settings given by *image2gcode* (called by *svg2gcode*) for each pixel. In fact some experiments show that *M4* causes loss of quality and image deterioration when speed is increased. On white oak images had too much black and grey which did not go away for substantially higher speed. When switched back to constant burn (*M3*) mode, the same high speed gave excellent images having a sepia (licht yellow brown) color tone.
 
-### Notes:
- - drawing objects - within the composer - must be converted to a```path```to be translated to a gcode sequence
- - also, image objects should **not** be converted to a ```path```
- - images must be linked or embedded using base64.
- - images can be in several formats (my tests included *.png* and  *.jpg* image files)
- - SVG source documents must be in unit 'mm' (and set to 1 'user unit' is 1 mm) which is the default for Inkscape (check document settings and look at the 'scaling' parameter)
-

{svg2gcode-3.3.1 → svg2gcode-3.3.4}/README.md

@@ -1,6 +1,6 @@
 # svg2gcode
 
-*svg2gcode* is a *WYSIWYG* converter of Scalable Vector Graphic *(SVG)* drawings. It is based on library *SvgToGcode* (*fork*: *https://github.com/johannesnoordanus/SvgToGcode*)<sup>(*)</sup>.
+*svg2gcode* is a *WYSIWYG* converter of Scalable Vector Graphic *(SVG)* drawings. It is based on library *SvgToGcode* (*https://github.com/johannesnoordanus/SvgToGcode*)<sup>(*)</sup>.
 
 Drawings and images can be composed using Inkscape (or other *SVG* image software), saved to a *.svg* file and - *WYSIWYG* - converted to gcode.
 Color coding can be used to mark what part(s) of the drawing to cut, engrave or even ignore.
@@ -17,13 +17,16 @@ More info can be obtained by looking at the documentation and examples below and
 
 *svg2gcode* has three related programs: *image2gcode* mentioned above has similar capabilities but handles raster image files (like *png* and *jpg*) directly, *gcode2image* performs the inverse function and is capable of showing multiple writes (burns) to the same location and last *grblhud* which gives full control over gcode execution.
 
+<sup>(*)</sup> Note that an upgraded and corrected version of this library is included.
+
  -----
 
 Please consider supporting me, so I can make this application better and add new functionality to it: <http://paypal.me/johannesnoordanus/5,00>
 
 My next update will add *fill-rule* 'nonzero' (see information on *fill-rule* below).
 
-<sup>(*)</sup> Note that an upgraded and corrected version of this library is included. 
+ -----
+
 ### Supported SVG elements and attributes
 
 *SVG* *path* and *image* elements (specific: ```<svg:path ..>```tags and images```<svg:image ..>```tags) are supported. Other drawing objects must be converted to a *path* first to be able to translate them to a gcode sequence.
@@ -31,6 +34,25 @@ My next update will add *fill-rule* 'nonzero' (see information on *fill-rule* be
 Attributes *stroke* (color), *stroke-width*, *stroke_alpha*, *fill* (color), *fill-rule*, *fill_alpha* are supported.
 Currently only value *evenodd* of *fill-rule* is supported.
 
+### *WYSIWYG*
+
+As seen above, not all *svg* elements are directly supported, but they are after a *path* conversion within the composer (Inkscape: ```menu Path->Object/Stroke to Path```). Without a *path* conversion *svg2gcode* simply ignores all elements except *path* and *image*. Text (fonts) require another step after *selecting* all text and clicking menu ```Object to Path```. Clicking ```menu Object->Ungroup``` generates a separate *path* for each letter which contains all relevant attributes. (Otherwise Inkscape uses a group tag ```<g``` to set some attributes for all letters within the text that are not repeated for each individual letter.)
+
+Note that the latest version of *svg2gcode* (3.3.3) has support for ```<g``` tags (attribute inheritance) and is able to correctly convert text without ```Ungroup```.
+
+You can use *gcode2image* to check the conversion result:
+```
+> svg2gcode some.svg some.gc
+> gcode2image --showimage --flip --grid --showorigin some.gc some.png
+```
+The image shown should be the same as the one shown by the composer (Inkscape). This is also a good way to measure the conversion result. Note that ```--grid``` and ```--showorigin``` can give some inteference. To be sure run *gcode2image* without them.
+
+#### Notes:
+ - drawing objects - within the composer - must be converted to a```path```to be translated to a gcode sequence
+ - image objects should **not** be converted to a ```path```
+ - images must be linked or embedded using base64 (Inkscape default).
+ - images can be in several formats (my tests included *.png* and  *.jpg* image files)
+ - *SVG* source documents must be in unit 'mm' and set to ```1 'user unit' is 1 mm``` (Inkscape default)
 ### Important Commandline options
 
 Option ```--color_coded``` can be used to specify what part(s) of the drawing to cut, engrave or even ignore. 
@@ -76,7 +98,7 @@ Note that engraving is the default action, so if option *color_coded* isn't set
 
 This makes it possible to make a drawing where all path elements are drawn in their respective colors to make an engraving of the entire vector drawing.
 When you set the engrave action for a set of colors, only those colors will be engraved (having their respective colors), all other paths having no action set are ignored.
-Also, when a path has no stroke attribute (or it is set to none) the element cannot be engraved (because it has no color) so it is interpreted as a cut action.
+Also, when a path has no stroke attribute (or it is set to none) the element cannot be engraved (because it has no color) so it is ignored.
 
 Option ```--pathcut``` can be used to override all stroke attributes and force cutting of all *paths* of the *SVG*.
 Note that this option cannot be set at the same time as *--color_coded* above.
@@ -107,7 +129,6 @@ General optimizations
 - borders are drawn in parallel and in one go, following the *path* coordinates.
 - fill has support for alpha channel and 'fill-opacity'
  
-
 ### Install:
 ```
 > 
@@ -332,10 +353,3 @@ One containing the drawings of the .svg, the other containing the images:
 ### Burn mode M3/M4:
 
 Default *svg2gcode* uses constant burn mode *M3*. This can be changed by setting option *--no-constantburn* which selects burn mode *M4*. Mode *M4* is not suitable for engravings because it automatically compensates (laser)power for speed. This conflicts with the specific gcode settings given by *image2gcode* (called by *svg2gcode*) for each pixel. In fact some experiments show that *M4* causes loss of quality and image deterioration when speed is increased. On white oak images had too much black and grey which did not go away for substantially higher speed. When switched back to constant burn (*M3*) mode, the same high speed gave excellent images having a sepia (licht yellow brown) color tone.
-
-### Notes:
- - drawing objects - within the composer - must be converted to a```path```to be translated to a gcode sequence
- - also, image objects should **not** be converted to a ```path```
- - images must be linked or embedded using base64.
- - images can be in several formats (my tests included *.png* and  *.jpg* image files)
- - SVG source documents must be in unit 'mm' (and set to 1 'user unit' is 1 mm) which is the default for Inkscape (check document settings and look at the 'scaling' parameter)

{svg2gcode-3.3.1 → svg2gcode-3.3.4}/svg2gcode/__init__.py

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

{svg2gcode-3.3.1 → svg2gcode-3.3.4}/svg2gcode/svg_to_gcode/compiler/_compiler.py

@@ -19,6 +19,7 @@ from svg2gcode.svg_to_gcode import DEFAULT_SETTING
 from svg2gcode.svg_to_gcode import TOLERANCES, SETTING, check_setting
 
 from svg2gcode.svg_to_gcode import css_color
+from svg2gcode.svg_to_gcode.svg_parser import NAMESPACES, ElementTree_MY_PARENT
 
 from svg2gcode import __version__
 
@@ -66,6 +67,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 +81,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 +132,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 +146,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 +163,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 +186,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 +208,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 +239,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 +380,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 = ''
@@ -472,6 +482,25 @@ class Compiler:
         if 'gcode_pathcut' in curve.path_attrib:
             style['pathcut'] = curve.path_attrib['gcode_pathcut']
 
+        # check missing attributes, if any
+        if ElementTree_MY_PARENT in curve.path_attrib:
+            parent = curve.path_attrib[ElementTree_MY_PARENT]
+
+            # find first parent g (group) tag, if any
+            while parent and parent.tag != "{%s}g" % NAMESPACES["svg"]:
+                if ElementTree_MY_PARENT in parent.attrib:
+                    parent = parent.attrib[ElementTree_MY_PARENT]
+                else:
+                    parent = None
+            if parent:
+                # fill in missing attribues, if any
+                for key, value in style.items():
+                    if not value and key in ['fill', 'fill-rule', 'fill-opacity', 'stroke', 'stroke-width', 'stroke-opacity']:
+                        # get missing attribute (if any)
+                        if key in parent.attrib:
+                            attrib = parent.attrib[key]
+                            if attrib and attrib != 'none':
+                                style[key] = attrib
         return style
 
     def color_coded_paths(self, set_color_coded = False) -> ():
@@ -671,7 +700,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 +719,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 +779,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 +790,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 +806,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 ...
+                            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,7 +861,11 @@ 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)
 
-                self.body.extend([f"\n; fill path '{name_id}'"])
+                # 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]
@@ -836,8 +884,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
@@ -854,7 +902,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.1 → svg2gcode-3.3.4}/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

{svg2gcode-3.3.1 → svg2gcode-3.3.4}/svg2gcode/svg_to_gcode/svg_parser/__init__.py

@@ -8,4 +8,4 @@ specific maintenance notes:
 
 from svg2gcode.svg_to_gcode.svg_parser._transformation import Transformation
 from svg2gcode.svg_to_gcode.svg_parser._path import Path
-from svg2gcode.svg_to_gcode.svg_parser._parser_methods import parse_file, parse_string, parse_root
+from svg2gcode.svg_to_gcode.svg_parser._parser_methods import parse_file, parse_string, parse_root, NAMESPACES, ElementTree_MY_PARENT

{svg2gcode-3.3.1 → svg2gcode-3.3.4}/svg2gcode/svg_to_gcode/svg_parser/_parser_methods.py

@@ -11,6 +11,23 @@ from svg2gcode.svg_to_gcode.geometry import Curve, RasterImage
 NAMESPACES = {'svg': 'http://www.w3.org/2000/svg',
               'xlink':'http://www.w3.org/1999/xlink'}
 
+ElementTree_MY_PARENT = '__my_parent__'
+
+def addParentInfo(et):
+    for child in et:
+        child.attrib[ElementTree_MY_PARENT] = et
+        addParentInfo(child)
+
+def stripParentInfo(et):
+    for child in et:
+        child.attrib.pop(ElementTree_MY_PARENT, 'None')
+        stripParentInfo(child)
+
+def getParent(et):
+    if ElementTree_MY_PARENT in et.attrib:
+        return et.attrib[ElementTree_MY_PARENT]
+    else:
+        return None
 
 def _has_style(element: ElementTree.Element, key: str, value: str) -> bool:
     """
@@ -178,8 +195,7 @@ def parse_root(root: ElementTree.Element, transform_origin=True, viewbox=None, d
                                add_viewbox_transformation(transformation, transform_origin, viewbox, origin, scale, rotate))
 
                 curves.extend(path.curves)
-            else:
-                if element.tag == "{%s}image" % NAMESPACES["svg"]:
+            elif element.tag == "{%s}image" % NAMESPACES["svg"]:
                     # svg image
 
                     # instantiate curve (image)
@@ -209,6 +225,7 @@ def parse_string(svg_string: str, transform_origin=True, viewbox=None, draw_hidd
     :return: A list of geometric curves describing the svg. Use the Compiler sub-module to compile them to gcode.
     """
     root = ElementTree.fromstring(svg_string)
+    addParentInfo(root)
     return parse_root(root, transform_origin, viewbox, draw_hidden, origin=delta_origin, scale=scale_factor, rotate=rotate_deg)
 
 
@@ -227,4 +244,5 @@ def parse_file(file_path: str, transform_origin=True, viewbox=None, draw_hidden=
     :return: A list of geometric curves describing the svg. Use the Compiler sub-module to compile them to gcode.
     """
     root = ElementTree.parse(file_path).getroot()
+    addParentInfo(root)
     return parse_root(root, transform_origin, viewbox, draw_hidden, origin=delta_origin, scale=scale_factor, rotate=rotate_deg)