PyPI - svg2gcode - Versions diffs - 3.2.8__tar.gz → 3.3.1__tar.gz - Mend

svg2gcode 3.2.8tar.gz → 3.3.1tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (34) hide show

{svg2gcode-3.2.8 → svg2gcode-3.3.1}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: svg2gcode
-Version: 3.2.8
+Version: 3.3.1
 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,46 +14,97 @@ Project-URL: Home, https://github.com/johannesnoordanus/svg2gcode
 # svg2gcode
-A commandline steering program that enables laser cutting of svg drawings```<svg:path ..>```tags and combined engraving of svg images```<svg:image ..>```tags.
-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* (*fork*: *https://github.com/johannesnoordanus/SvgToGcode*)<sup>(*)</sup>.
-Drawings and images can be composed using Inkscape (or other SVG image software) and saved to a *.svg* file. This file can then be converted to gcode by *svg2gcode*.
-Gcode produced in this way has the advantage that drawings and images have the same - relative - position and orientation as can be seen on the composer window.
-This makes combined cutting and engraving as easy as orientating the (wood) slab once.
+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.
-SVG *path* and *image* objects are supported. Note that other drawing object must be converted to a *path* to be able to translate them to a gcode sequence.
-Recently (version 3.0.0 and higher) support for *stroke* color and *stroke-width* attributes of SVG *path* objects is added.
-This means that it is possible to make laser engravings of text (fonts) and other drawing objects having a border with a specific color.
-It is even possible to use alpha channel for these drawing objects now.
+Raster elements within a *SVG* drawing are converted pixel perfect, vector elements are drawn at the specified resolution.
+Vector elements are converted including line width, fill and color, but note that colors (including alpha-channel) are converted to black and white.
+(This is because laser engravings resemble black and white images.)
+This means that it is possible to make laser engravings of text (fonts) and other drawing elements or even the entire vector drawing.
-Controlling laser power, pixel size and other settings can be done via commandline parameters (see below) or within Inkscape using the XMLeditor.
-Image attributes ```gcode_pixelsize```, ```gcode_maxpower```, ```gcode_speed```, ```gcode_noise```, ```gcode_speedmoves```, ```gcode_overscan``` and ```gcode_showoverscan``` can be set per object.
-(Image attributes can be added within the XMLeditor (Inkscape) by using the **+**).
-Note that image attributes override explicit or default commandline settings.
+You have full control of placing (locating) of the gcode end result. You can for example translate, scale, rotate and have the origin at the image center.
+*svg2gcode* produces highly optimised and accurate *gcode*. *gcode* file length is relatively short (because codes and coordinates are emitted sparsely) and laser drawing is sped up by speed moves and skipping of all empty parts.
-You have full control of placing (locating) of the result gcode via options *--origin*, <i>--rotate</i> and *--scale*.
-Option *--selfcenter* can be used to set the origin at the center of the image.
-Note that gcode file headers contain compile information like the boundingbox and boundingbox center coordinates.
+More info can be obtained by looking at the documentation and examples below and the documentation of *image2gcode* (for example about calibration of laser engravers).
-Version 2.0.0 and higher have important speed optimizations. Engravings run significantly faster and skip from one image zone to the other at maximum speed.
-See options ```--speedmoves``` and ```--noise``` for example.
+*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.
-Version 3.0.0 and higher have support for 'stroke' (color) and 'stroke-width' attributes, this means that cutting a path works a bit different now.
-When the *stroke* attribute of a *path* is nonexistent or set to none, the path will be laser burned with the value set by option *--cuttingpower*.
+ -----
-Version 3.1.0 and higher have support for 'fill' (color) and 'fill-rule' attributes. Currently only fill rule 'evenodd' is supported.
+Please consider supporting me, so I can make this application better and add new functionality to it: <http://paypal.me/johannesnoordanus/5,00>
-Also, *svg2gcode* option ```--pathcut``` can be used to override all stroke attributes and force cutting of all *paths* of the SVG.
-Option ```--nofill``` (not set by default) is added to disable path fills.
+My next update will add *fill-rule* 'nonzero' (see information on *fill-rule* below).
-More info can be obtained by looking at the examples below and from program *image2gcode* and its documentation (for example about callibrating laser engravers).
-Please consider supporting me, so I can make this application better and add new functionality to it: <http://paypal.me/johannesnoordanus/5,00>
+<sup>(*)</sup> Note that an upgraded and corrected version of this library is included.
+### Supported SVG elements and attributes
-My next update will add fill-rule 'nonzero'.
+*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.
+Attributes *stroke* (color), *stroke-width*, *stroke_alpha*, *fill* (color), *fill-rule*, *fill_alpha* are supported.
+Currently only value *evenodd* of *fill-rule* is supported.
-To summarize:
+### Important Commandline options
+Option ```--color_coded``` can be used to specify what part(s) of the drawing to cut, engrave or even ignore.
+For example:
+```
+> svg2gcode --color_coded "black = ignore red = cut blue = engrave" paws.svg paws.gc
+```
+As a consequence all 'black' path elements will be ignored and will not appear after conversion, all red paths will be cut and all blue paths will be engraved (having color blue).
+The corresponding gcode file contains lines like below to indicated which 'black path' is skipped:
+```
+;    svg2gcode 3.2.8 (2024-07-28 11:39:27)
+;    arguments:
+;      laser_power: 850,
+;      movement_speed: 1000,
+...
+;      image_showoverscan: False,
+;      color_coded: black = ignore red = cut blue = engrave
+;    Boundingbox: (X0.8,Y0.0:X5.1,Y4.3)
+;    boundingbox center: (X2.951648,Y2.148172)
+;    GRBL 1.1, unit=mm, absolute coordinates
+; Machine settings:
+;    rapid movement,
+...
+;    XY plane,
+;    cutter compensation off,
+;    coordinate system 1,
+;    move 'unit'/min
+G0 G17 G40 G54 G94
+G21
+G90
+; pass #1
+; --color_coded: ignore path 'path304-9-2-9-41-7', color '#000000'
+```
+Note that it doesn't matter if a specific color action is set but no corresponding path exits.
+Note that multiple collors can be set per 'action':
+```
+> svg2gcode --color_coded "black = ignore red = cut green = ignore blue = engrave orange = engrave yellow = cut" paws.svg paws.gc
+```
+Note that engraving is the default action, so if option *color_coded* isn't set or *color_coded* has no engrave color set, all paths having no other action set will be engraved (but see below).
+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.
+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.
+Option ```--nofill``` makes it possible to disable all path fills.
+Options ```--origin --rotate --scale --selfcenter``` can be used to locate and transform the gcode image.
+Option ```--speedmoves``` makes it possible to run engravings significantly faster and skip from one image zone to the other at maximum speed.
+Option ```--noise``` suppresses stray pixels
+Controlling laser power, pixel size and other settings can be done via commandline parameters but also via the following attributes (which can be set within the *.svg* file directly or within Inkscape using the XMLeditor):
+```gcode_pixelsize```, ```gcode_maxpower```, ```gcode_speed```, ```gcode_noise```, ```gcode_speedmoves```, ```gcode_overscan``` and ```gcode_showoverscan``` can be set per vector element. (Image attributes can be added within the XMLeditor (Inkscape) by using the **+**).
+Note that these attributes override explicit or default commandline settings.
+### gcode optimizations
 Optimized gcode
 - draw pixels in one go until change of power
@@ -62,18 +113,14 @@ Optimized gcode
 - does not emit zero power (or below cutoff) pixels
 General optimizations
-- laser head has defered and sparse moves.
+- laser head has deferred and sparse moves.
 (XY locations are virtual, head does not always follow)
 - moves at high speed (G0) over 10mm (default) or more zero pixels
 - low burn levels (stray pixels) can be suppressed (default off)
-- option *--constantburn* selects constant burn mode *M3* (for cutting and engraving) instead of default dynamic burn mode *M4*
+- default --constantburn mode *gcode M3*
 - borders are drawn in parallel and in one go, following the *path* coordinates.
 - fill has support for alpha channel and 'fill-opacity'
-**Tip**: use commandline program *grblhud* *(https://github.com/johannesnoordanus/grblhud)* to have full control over gcode execution,
-also, program *image2gcode* has similar capabilities but handles raster images files (like *png* and *jpg*) directly.
-**Tip2**: another program *LaserWeb* (not made by me) is quite capable and has an excelent 3D gcode visualizer, it is able to calculate 3D paths for CNC machines, including the bit diameter.
 ### Install:
 ```
@@ -86,14 +133,14 @@ Some linux distributions use a managed environment in which you cannot install p
 > pipx install svg2gcode
 ```
-<sup>(*)</sup> Note that an upgraded and corrected version of this library is included.
 ### Usage:
 ```
 > svg2gcode --help
-usage: svg2gcode [-h] [--showimage] [--selfcenter] [--pixelsize <default:0.1>] [--imagespeed <default:800>] [--cuttingspeed <default:1000>] [--imagepower <default:300>]
-                    [--poweroffset <default:0>] [--cuttingpower <default:850>] [--passes <default:1>] [--pass_depth <default:0>] [--rapidmove <default:10>] [--noise <default:0>]
-                    [--overscan <default:0>] [--showoverscan] [--constantburn] [--origin delta-x delta-y] [--scale factor-x factor-y] [--rotate <default:0>] [--splitfile] [--pathcut]
-                    [--xmaxtravel <default:300>] [--ymaxtravel <default:400>] [--fan] [-V]
+usage: runsvg2gcode [-h] [--showimage] [--selfcenter] [--pixelsize <default:0.1>] [--imagespeed <default:800>] [--cuttingspeed <default:1000>] [--imagepower <default:300>]
+                    [--poweroffset <default:0>] [--cuttingpower <default:850>] [--passes <default:1>] [--pass_depth <default:0>] [--rapidmove <default:10>]
+                    [--noise <default:0>] [--overscan <default:0>] [--showoverscan] [--constantburn | --no-constantburn] [--origin delta-x delta-y] [--scale factor-x factor-y]
+                    [--rotate <default:0>] [--splitfile] [--pathcut] [--nofill] [--xmaxtravel <default:300>] [--ymaxtravel <default:400>] [--color_coded <default:"">] [--fan]
+                    [-V]
                     svg gcode
 Convert svg to gcode for GRBL v1.1 compatible diode laser engravers.
@@ -127,7 +174,8 @@ options:
   --overscan <default:0>
                         overscan image lines to avoid incorrect power levels for pixels at left and right borders, number in pixels, default off
   --showoverscan        show overscan pixels (note that this is visible and part of the gcode emitted!)
-  --constantburn        set constant burn mode M3 (default set to dynamic burn mode M4); this enhances engraving quality
+  --constantburn, --no-constantburn
+                        default constant burn mode (M3)
   --origin delta-x delta-y
                         translate origin by vector (delta-x,delta-y) in mm (default not set, option --selfcenter cannot be used at the same time)
   --scale factor-x factor-y
@@ -140,6 +188,8 @@ options:
                         machine x-axis lengh in mm
   --ymaxtravel <default:400>
                         machine y-axis lengh in mm
+  --color_coded <default:"">
+                        set action for path with specific stroke color "[color = [cut|engrave|ignore] *]*", example: --color_coded "black = ignore purple = cut blue = engrave"
   --fan                 set machine fan on
   -V, --version         show version number and exit
 ```
@@ -151,8 +201,9 @@ You can also store svg2gcode settings in configuration file `~/.config/svg2gcode
 xmaxtravel= 400
 ymaxtravel= 400
 imagespeed = 6000
+color_coded = "black = ignore purple = cut blue = engrave"
 ```
-It can be used with any parameter which takes a value, and alows to persist your laser settings.
+It can be used with any parameter which takes a value, and allows to persist your laser settings.
 You can create this configuration file using an editor like vi or nano.
 An alternative (quick) way to do that is to enter:
 ```
@@ -160,6 +211,7 @@ $ mkdir ~/.config
 $ echo "xmaxtravel= 400
 ymaxtravel= 400
 imagespeed = 6000
+color_coded = \"black = ignore purple = cut blue = engrave\"
 " > ~/.config/svg2gcode.toml
 ```
 (but use your own settings!)
@@ -251,7 +303,7 @@ or add 'gcode-pathcut' to the style string:
 ```
 (Note that this makes it possible to selectively cut path objects within the SVG.)
-or add *svg2gcode* option *--pathcut* to override all path stroke attributes within the SVG document
+or add *svg2gcode* option *--pathcut* to override all path stroke attributes within the SVG document or use option *--color_coded* and set a cut action for the stroke color.
 Run *svg2gcode* (with same options) again.
 Now the gcode after conversion will look like this:
@@ -280,6 +332,7 @@ Don't worry if your lasercutter has no Z-axis, because this parameter will be ig
 If you have a CNC machine (which does have a Z-axis) you can mill in depth (so to speak), but you can also add - or switch to - a laser head and use the gcode to be able to really laser cut deeper!
 #### Create two types of gcode file
 One containing the drawings of the .svg, the other containing the images:
 ```
@@ -292,7 +345,7 @@ One containing the drawings of the .svg, the other containing the images:
 ### Burn mode M3/M4:
-Default *svg2gcode* uses dynamic burn mode *M4*. This can be changed by setting option *--constantburn* which selects burn mode *M3*. 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.
+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

{svg2gcode-3.2.8 → svg2gcode-3.3.1}/README.md RENAMED Viewed

@@ -1,45 +1,96 @@
 # svg2gcode
-A commandline steering program that enables laser cutting of svg drawings```<svg:path ..>```tags and combined engraving of svg images```<svg:image ..>```tags.
-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* (*fork*: *https://github.com/johannesnoordanus/SvgToGcode*)<sup>(*)</sup>.
-Drawings and images can be composed using Inkscape (or other SVG image software) and saved to a *.svg* file. This file can then be converted to gcode by *svg2gcode*.
-Gcode produced in this way has the advantage that drawings and images have the same - relative - position and orientation as can be seen on the composer window.
-This makes combined cutting and engraving as easy as orientating the (wood) slab once.
+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.
-SVG *path* and *image* objects are supported. Note that other drawing object must be converted to a *path* to be able to translate them to a gcode sequence.
-Recently (version 3.0.0 and higher) support for *stroke* color and *stroke-width* attributes of SVG *path* objects is added.
-This means that it is possible to make laser engravings of text (fonts) and other drawing objects having a border with a specific color.
-It is even possible to use alpha channel for these drawing objects now.
+Raster elements within a *SVG* drawing are converted pixel perfect, vector elements are drawn at the specified resolution.
+Vector elements are converted including line width, fill and color, but note that colors (including alpha-channel) are converted to black and white.
+(This is because laser engravings resemble black and white images.)
+This means that it is possible to make laser engravings of text (fonts) and other drawing elements or even the entire vector drawing.
-Controlling laser power, pixel size and other settings can be done via commandline parameters (see below) or within Inkscape using the XMLeditor.
-Image attributes ```gcode_pixelsize```, ```gcode_maxpower```, ```gcode_speed```, ```gcode_noise```, ```gcode_speedmoves```, ```gcode_overscan``` and ```gcode_showoverscan``` can be set per object.
-(Image attributes can be added within the XMLeditor (Inkscape) by using the **+**).
-Note that image attributes override explicit or default commandline settings.
+You have full control of placing (locating) of the gcode end result. You can for example translate, scale, rotate and have the origin at the image center.
+*svg2gcode* produces highly optimised and accurate *gcode*. *gcode* file length is relatively short (because codes and coordinates are emitted sparsely) and laser drawing is sped up by speed moves and skipping of all empty parts.
-You have full control of placing (locating) of the result gcode via options *--origin*, <i>--rotate</i> and *--scale*.
-Option *--selfcenter* can be used to set the origin at the center of the image.
-Note that gcode file headers contain compile information like the boundingbox and boundingbox center coordinates.
+More info can be obtained by looking at the documentation and examples below and the documentation of *image2gcode* (for example about calibration of laser engravers).
-Version 2.0.0 and higher have important speed optimizations. Engravings run significantly faster and skip from one image zone to the other at maximum speed.
-See options ```--speedmoves``` and ```--noise``` for example.
+*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.
-Version 3.0.0 and higher have support for 'stroke' (color) and 'stroke-width' attributes, this means that cutting a path works a bit different now.
-When the *stroke* attribute of a *path* is nonexistent or set to none, the path will be laser burned with the value set by option *--cuttingpower*.
+ -----
-Version 3.1.0 and higher have support for 'fill' (color) and 'fill-rule' attributes. Currently only fill rule 'evenodd' is supported.
+Please consider supporting me, so I can make this application better and add new functionality to it: <http://paypal.me/johannesnoordanus/5,00>
-Also, *svg2gcode* option ```--pathcut``` can be used to override all stroke attributes and force cutting of all *paths* of the SVG.
-Option ```--nofill``` (not set by default) is added to disable path fills.
+My next update will add *fill-rule* 'nonzero' (see information on *fill-rule* below).
-More info can be obtained by looking at the examples below and from program *image2gcode* and its documentation (for example about callibrating laser engravers).
-Please consider supporting me, so I can make this application better and add new functionality to it: <http://paypal.me/johannesnoordanus/5,00>
+<sup>(*)</sup> Note that an upgraded and corrected version of this library is included.
+### Supported SVG elements and attributes
-My next update will add fill-rule 'nonzero'.
+*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.
+Attributes *stroke* (color), *stroke-width*, *stroke_alpha*, *fill* (color), *fill-rule*, *fill_alpha* are supported.
+Currently only value *evenodd* of *fill-rule* is supported.
-To summarize:
+### Important Commandline options
+Option ```--color_coded``` can be used to specify what part(s) of the drawing to cut, engrave or even ignore.
+For example:
+```
+> svg2gcode --color_coded "black = ignore red = cut blue = engrave" paws.svg paws.gc
+```
+As a consequence all 'black' path elements will be ignored and will not appear after conversion, all red paths will be cut and all blue paths will be engraved (having color blue).
+The corresponding gcode file contains lines like below to indicated which 'black path' is skipped:
+```
+;    svg2gcode 3.2.8 (2024-07-28 11:39:27)
+;    arguments:
+;      laser_power: 850,
+;      movement_speed: 1000,
+...
+;      image_showoverscan: False,
+;      color_coded: black = ignore red = cut blue = engrave
+;    Boundingbox: (X0.8,Y0.0:X5.1,Y4.3)
+;    boundingbox center: (X2.951648,Y2.148172)
+;    GRBL 1.1, unit=mm, absolute coordinates
+; Machine settings:
+;    rapid movement,
+...
+;    XY plane,
+;    cutter compensation off,
+;    coordinate system 1,
+;    move 'unit'/min
+G0 G17 G40 G54 G94
+G21
+G90
+; pass #1
+; --color_coded: ignore path 'path304-9-2-9-41-7', color '#000000'
+```
+Note that it doesn't matter if a specific color action is set but no corresponding path exits.
+Note that multiple collors can be set per 'action':
+```
+> svg2gcode --color_coded "black = ignore red = cut green = ignore blue = engrave orange = engrave yellow = cut" paws.svg paws.gc
+```
+Note that engraving is the default action, so if option *color_coded* isn't set or *color_coded* has no engrave color set, all paths having no other action set will be engraved (but see below).
+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.
+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.
+Option ```--nofill``` makes it possible to disable all path fills.
+Options ```--origin --rotate --scale --selfcenter``` can be used to locate and transform the gcode image.
+Option ```--speedmoves``` makes it possible to run engravings significantly faster and skip from one image zone to the other at maximum speed.
+Option ```--noise``` suppresses stray pixels
+Controlling laser power, pixel size and other settings can be done via commandline parameters but also via the following attributes (which can be set within the *.svg* file directly or within Inkscape using the XMLeditor):
+```gcode_pixelsize```, ```gcode_maxpower```, ```gcode_speed```, ```gcode_noise```, ```gcode_speedmoves```, ```gcode_overscan``` and ```gcode_showoverscan``` can be set per vector element. (Image attributes can be added within the XMLeditor (Inkscape) by using the **+**).
+Note that these attributes override explicit or default commandline settings.
+### gcode optimizations
 Optimized gcode
 - draw pixels in one go until change of power
@@ -48,18 +99,14 @@ Optimized gcode
 - does not emit zero power (or below cutoff) pixels
 General optimizations
-- laser head has defered and sparse moves.
+- laser head has deferred and sparse moves.
 (XY locations are virtual, head does not always follow)
 - moves at high speed (G0) over 10mm (default) or more zero pixels
 - low burn levels (stray pixels) can be suppressed (default off)
-- option *--constantburn* selects constant burn mode *M3* (for cutting and engraving) instead of default dynamic burn mode *M4*
+- default --constantburn mode *gcode M3*
 - borders are drawn in parallel and in one go, following the *path* coordinates.
 - fill has support for alpha channel and 'fill-opacity'
-**Tip**: use commandline program *grblhud* *(https://github.com/johannesnoordanus/grblhud)* to have full control over gcode execution,
-also, program *image2gcode* has similar capabilities but handles raster images files (like *png* and *jpg*) directly.
-**Tip2**: another program *LaserWeb* (not made by me) is quite capable and has an excelent 3D gcode visualizer, it is able to calculate 3D paths for CNC machines, including the bit diameter.
 ### Install:
 ```
@@ -72,14 +119,14 @@ Some linux distributions use a managed environment in which you cannot install p
 > pipx install svg2gcode
 ```
-<sup>(*)</sup> Note that an upgraded and corrected version of this library is included.
 ### Usage:
 ```
 > svg2gcode --help
-usage: svg2gcode [-h] [--showimage] [--selfcenter] [--pixelsize <default:0.1>] [--imagespeed <default:800>] [--cuttingspeed <default:1000>] [--imagepower <default:300>]
-                    [--poweroffset <default:0>] [--cuttingpower <default:850>] [--passes <default:1>] [--pass_depth <default:0>] [--rapidmove <default:10>] [--noise <default:0>]
-                    [--overscan <default:0>] [--showoverscan] [--constantburn] [--origin delta-x delta-y] [--scale factor-x factor-y] [--rotate <default:0>] [--splitfile] [--pathcut]
-                    [--xmaxtravel <default:300>] [--ymaxtravel <default:400>] [--fan] [-V]
+usage: runsvg2gcode [-h] [--showimage] [--selfcenter] [--pixelsize <default:0.1>] [--imagespeed <default:800>] [--cuttingspeed <default:1000>] [--imagepower <default:300>]
+                    [--poweroffset <default:0>] [--cuttingpower <default:850>] [--passes <default:1>] [--pass_depth <default:0>] [--rapidmove <default:10>]
+                    [--noise <default:0>] [--overscan <default:0>] [--showoverscan] [--constantburn | --no-constantburn] [--origin delta-x delta-y] [--scale factor-x factor-y]
+                    [--rotate <default:0>] [--splitfile] [--pathcut] [--nofill] [--xmaxtravel <default:300>] [--ymaxtravel <default:400>] [--color_coded <default:"">] [--fan]
+                    [-V]
                     svg gcode
 Convert svg to gcode for GRBL v1.1 compatible diode laser engravers.
@@ -113,7 +160,8 @@ options:
   --overscan <default:0>
                         overscan image lines to avoid incorrect power levels for pixels at left and right borders, number in pixels, default off
   --showoverscan        show overscan pixels (note that this is visible and part of the gcode emitted!)
-  --constantburn        set constant burn mode M3 (default set to dynamic burn mode M4); this enhances engraving quality
+  --constantburn, --no-constantburn
+                        default constant burn mode (M3)
   --origin delta-x delta-y
                         translate origin by vector (delta-x,delta-y) in mm (default not set, option --selfcenter cannot be used at the same time)
   --scale factor-x factor-y
@@ -126,6 +174,8 @@ options:
                         machine x-axis lengh in mm
   --ymaxtravel <default:400>
                         machine y-axis lengh in mm
+  --color_coded <default:"">
+                        set action for path with specific stroke color "[color = [cut|engrave|ignore] *]*", example: --color_coded "black = ignore purple = cut blue = engrave"
   --fan                 set machine fan on
   -V, --version         show version number and exit
 ```
@@ -137,8 +187,9 @@ You can also store svg2gcode settings in configuration file `~/.config/svg2gcode
 xmaxtravel= 400
 ymaxtravel= 400
 imagespeed = 6000
+color_coded = "black = ignore purple = cut blue = engrave"
 ```
-It can be used with any parameter which takes a value, and alows to persist your laser settings.
+It can be used with any parameter which takes a value, and allows to persist your laser settings.
 You can create this configuration file using an editor like vi or nano.
 An alternative (quick) way to do that is to enter:
 ```
@@ -146,6 +197,7 @@ $ mkdir ~/.config
 $ echo "xmaxtravel= 400
 ymaxtravel= 400
 imagespeed = 6000
+color_coded = \"black = ignore purple = cut blue = engrave\"
 " > ~/.config/svg2gcode.toml
 ```
 (but use your own settings!)
@@ -237,7 +289,7 @@ or add 'gcode-pathcut' to the style string:
 ```
 (Note that this makes it possible to selectively cut path objects within the SVG.)
-or add *svg2gcode* option *--pathcut* to override all path stroke attributes within the SVG document
+or add *svg2gcode* option *--pathcut* to override all path stroke attributes within the SVG document or use option *--color_coded* and set a cut action for the stroke color.
 Run *svg2gcode* (with same options) again.
 Now the gcode after conversion will look like this:
@@ -266,6 +318,7 @@ Don't worry if your lasercutter has no Z-axis, because this parameter will be ig
 If you have a CNC machine (which does have a Z-axis) you can mill in depth (so to speak), but you can also add - or switch to - a laser head and use the gcode to be able to really laser cut deeper!
 #### Create two types of gcode file
 One containing the drawings of the .svg, the other containing the images:
 ```
@@ -278,7 +331,7 @@ One containing the drawings of the .svg, the other containing the images:
 ### Burn mode M3/M4:
-Default *svg2gcode* uses dynamic burn mode *M4*. This can be changed by setting option *--constantburn* which selects burn mode *M3*. 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.
+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

{svg2gcode-3.2.8 → svg2gcode-3.3.1}/svg2gcode/__init__.py RENAMED Viewed

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

{svg2gcode-3.2.8 → svg2gcode-3.3.1}/svg2gcode/__main__.py RENAMED Viewed

@@ -4,6 +4,7 @@ svg2gcode: convert an image to gcode.
 import os
 import sys
+import re
 try:
     import tomllib
 except ImportError:
@@ -16,6 +17,7 @@ from svg2gcode.svg_to_gcode.svg_parser import parse_file
 from svg2gcode.svg_to_gcode.compiler import Compiler, interfaces
 from svg2gcode import __version__
+from svg2gcode.svg_to_gcode import css_color
 config_file = os.path.expanduser('~/.config/svg2gcode.toml')
@@ -35,10 +37,25 @@ def svg2gcode(args) -> int:
                'maximum_image_laser_power':args.imagepower, 'image_movement_speed':args.imagespeed, 'fan':args.fan,'rapid_move':args.rapidmove,
                'showimage':args.showimage, 'x_axis_maximum_travel':args.xmaxtravel,'y_axis_maximum_travel':args.ymaxtravel, 'image_noise':args.noise,
                'pass_depth':args.pass_depth, 'laser_mode':"constant" if args.constantburn else "dynamic", 'splitfile':args.splitfile, 'pathcut':args.pathcut,
-               'nofill':args.nofill, 'image_poweroffset':args.poweroffset, 'image_overscan':args.overscan, 'image_showoverscan':args.showoverscan})
+               'nofill':args.nofill, 'image_poweroffset':args.poweroffset, 'image_overscan':args.overscan, 'image_showoverscan':args.showoverscan,
+               'color_coded': args.color_coded,})
     compiler = init_compiler(args)
+    if args.color_coded != "":
+        # check color_coded argument validity (2)
+        pathignore, pathcut, pathengrave = compiler.color_coded_paths(True)
+        # a path color should be in one set only
+        for i in pathignore:
+            if i in pathcut or i in pathengrave:
+                print(f"argument error: '--color_coded \"{args.color_coded}\"' has a path color '{i}' set in multiple categories (cut|engrave|ignore) .")
+                return 1
+        for i in pathcut:
+            if i in pathengrave:
+                print(f"argument error: '--color_coded \"{args.color_coded}\"' has a path color '{i}' set in multiple categories (cut|engrave|ignore) .")
+                return 1
     # emit gcode for svg
     if args.selfcenter:
         print("pass 1")
@@ -92,6 +109,8 @@ def main() -> int:
         "pass_depth_default": 0,
         "passes_default": 1,
         "rotate_default": 0,
+        "colorcoded_default": "",
+        "constantburn_default": True,
     }
     if os.path.exists(config_file):
@@ -127,7 +146,7 @@ def main() -> int:
     parser.add_argument('--overscan', default=cfg["overscan_default"], metavar="<default:" +str(cfg["overscan_default"])+ ">",
         type=int, help="overscan image lines to avoid incorrect power levels for pixels at left and right borders, number in pixels, default off")
     parser.add_argument('--showoverscan', action='store_true', default=False, help='show overscan pixels (note that this is visible and part of the gcode emitted!)' )
-    parser.add_argument('--constantburn', action='store_true', default=False, help='set constant burn mode M3 (default is dynamic burn mode M4); this enhances engraving quality')
+    parser.add_argument('--constantburn', action=argparse.BooleanOptionalAction, default=cfg["constantburn_default"], help='default constant burn mode (M3)')
     parser.add_argument('--origin', default=None, nargs=2, metavar=('delta-x', 'delta-y'),
         type=float, help="translate origin by vector (delta-x,delta-y) in mm (default not set, option --selfcenter cannot be used at the same time)")
     parser.add_argument('--scale', default=None, nargs=2, metavar=('factor-x', 'factor-y'),
@@ -141,12 +160,40 @@ def main() -> int:
         type=int, help="machine x-axis lengh in mm")
     parser.add_argument('--ymaxtravel', default=cfg["ymaxtravel_default"], metavar="<default:" +str(cfg["ymaxtravel_default"])+ ">",
         type=int, help="machine y-axis lengh in mm")
+    parser.add_argument( '--color_coded', action = 'store', default=cfg["colorcoded_default"], metavar="<default:\"" + str(cfg["colorcoded_default"])+ "\">",
+         type = str, help = 'set action for path with specific stroke color "[color = [cut|engrave|ignore] *]*"'
+                            ', example: --color_coded "black = ignore purple = cut blue = engrave"' )
     parser.add_argument('--fan', action='store_true', default=False, help='set machine fan on' )
     parser.add_argument('-V', '--version', action='version', version='%(prog)s ' + __version__, help="show version number and exit")
     args = parser.parse_args()
     try:
+        if args.color_coded != "":
+            if args.pathcut:
+                print("options --color_coded and --pathcut cannot be used at the same time, program abort")
+                return 1
+            # check argument validity (1)
+            # category names
+            category = ["cut", "engrave", "ignore"]
+            # get css color names
+            colors = str([*css_color.css_color_keywords])
+            colors = re.sub("(,|\[|\]|\'| )", '', colors.replace(",", "|"))
+            # make a color list
+            colors = colors.split("|")
+            # get all names from color_coded
+            names_regex = "[a-zA-Z]+"
+            match = re.findall(names_regex, args.color_coded)
+            names = [i for i in match]
+            for name in names:
+                if not (name in colors or name in category):
+                    print(f"argument error: '--color_coded {args.color_coded}' has a name '{name}' that does not correspond to a css color or category (cut|engrave|ignore).")
+                    return 1
         if args.origin is not None and args.selfcenter:
             print("options --selfcenter and --origin cannot be used at the same time, program abort")
             return 1

{svg2gcode-3.2.8 → svg2gcode-3.3.1}/svg2gcode/svg_to_gcode/__init__.py RENAMED Viewed

@@ -40,7 +40,8 @@ SETTING 	= {
     "showimage",                # boolean               show image used for conversion to gcode
     "splitfile",                # boolean               return SVG path objects to <filename>.<gcext> and SVG image objects to <filename>_images.<gcext>
     "pathcut",                  # boolean               always cut SVG path objects! use laser_power setting
-    "nofill"                    # boolean               ignore SVG fill attribute
+    "nofill",                   # boolean               ignore SVG fill attribute
+    "color_coded"               # string                color of path determines whether it is a cut or engrave
 }
 # Set defaults 'minimum_laser_power', 'pass_depth', 'dwell_time', 'laser_power', 'laser_mode', 'unit', 'distance_mode'
@@ -74,7 +75,8 @@ DEFAULT_SETTING 	= {
     "showimage":                False,          # default image is not shown
     "splitfile":                False,          # SVG path and image objects are emitted to one file: <filename>.<gcext>
     "pathcut":                  False,          # always cut SVG path objects! use laser_power setting
-    "nofill":                   False           # ignore SVG fill attribute
+    "nofill":                   False,          # ignore SVG fill attribute
+    "color_coded":              str             # color of path determines whether it is a cut or engrave
 }
 def check_setting(setting: dict[str,Any] =None) -> bool:

{svg2gcode-3.2.8 → svg2gcode-3.3.1}/svg2gcode/svg_to_gcode/compiler/_compiler.py RENAMED Viewed

@@ -58,8 +58,9 @@ class Compiler:
         # save params
         self.params = params
-	      # get default settings and update
+	# get default settings
         self.settings = copy.deepcopy(DEFAULT_SETTING)
+        # and update
         for key in params.keys():
             self.settings[key] = params[key]
@@ -108,12 +109,13 @@ class Compiler:
             else:
                 params += f";      {k}: {v}"
-        center = self.boundingbox.center()
         gcode += [ f";    svg2gcode {__version__} ({str(datetime.now()).split('.')[0]})",
-                   f";    arguments: \n{params}",
-                   f";    {self.boundingbox}",
-                   f";    boundingbox center: (X{center[0]:.{0 if center[0].is_integer() else self.precision}f},"
-                   f"Y{center[1]:.{0 if center[1].is_integer() else self.precision}f})" ]
+                   f";    arguments: \n{params}",]
+        if self.boundingbox.get():
+            center = self.boundingbox.center()
+            gcode += [ f";    {self.boundingbox}",
+                       f";    boundingbox center: (X{center[0]:.{0 if center[0].is_integer() else self.precision}f},"
+                       f"Y{center[1]:.{0 if center[1].is_integer() else self.precision}f})" ]
         gcode += [ f";    GRBL 1.1, unit={self.settings['unit']}, {self.settings['distance_mode']} coordinates" ]
@@ -209,10 +211,15 @@ class Compiler:
                     file.write((self.gcode_file_header() if len(self.body) == 0 else "") + '\n' +  self.compile_images() + '\n' + self.interface.program_end() + '\n')
                     logger.info(f"Added image(s) to {file_name}")
-    def append_line_chain(self, line_chain: LineSegmentChain, step: float, color: int = None):
+    def append_line_chain(self, line_chain: LineSegmentChain, step: float, color: int = None, speed: int = None):
         """
-        Draws a LineSegmentChain by calling interface.linear_move() for each segment. The resulting code is appended to
-        self.body
+        Draws a LineSegmentChain (path) by calling interface.linear_move() for each segment.
+        The resulting code is appended to self.body
+        :param line_chain: path to draw.
+        :param step: path offset (indicates that this path is offset to another path).
+        :param color: laser intensity, 'laser_power' when set to 'None'.
+        :param speed: laser head movement speed, 'movement_speed' when set to 'None'.
         """
         if line_chain.chain_size() == 0:
@@ -224,6 +231,7 @@ class Compiler:
         # set laser power to color value when svg attribute 'stroke' (color) is set
         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"]
 	# 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"]:
@@ -231,13 +239,13 @@ class Compiler:
                 # 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),
-                        self.interface.set_movement_speed(self.settings["movement_speed"]),
+                        self.interface.set_movement_speed(movement_speed),
                         self.interface.set_laser_mode(self.settings["laser_mode"]), self.interface.set_laser_power_value(laser_power)]
             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),
-                        self.interface.set_movement_speed(self.settings["movement_speed"]), self.interface.linear_move(start.x, start.y),
+                        self.interface.set_movement_speed(movement_speed), self.interface.linear_move(start.x, start.y),
                         self.interface.set_laser_power_value(laser_power)]
             self.boundingbox.update(start)
@@ -398,7 +406,9 @@ class Compiler:
             if 'fill' in style_str:
                 fill = re.search('fill:[^;]+;',style_str)
                 if fill:
-                    style['fill'] = fill.group(0)[5:-1]
+                    fill_str = fill.group(0)[5:-1]
+                    if fill_str != 'none':
+                        style['fill'] = fill_str
             # parse fill-rule
             if 'fill-rule' in style_str:
                 fill_rule = re.search('fill-rule:#(evenodd|nonzero)',style_str)
@@ -413,7 +423,9 @@ class Compiler:
             if 'stroke' in style_str:
                 stroke = re.search('stroke:[^;]+;',style_str)
                 if stroke:
-                    style['stroke'] = stroke.group(0)[7:-1]
+                    stroke_str = stroke.group(0)[7:-1]
+                    if stroke_str != 'none':
+                        style['stroke'] = stroke_str
             # parse stroke-width
             if 'stroke-width' in style_str:
                 stroke_width = re.search('stroke-width:(\d*\.)?\d+',style_str)
@@ -435,7 +447,8 @@ class Compiler:
         # parse fill attribute
         if 'fill' in curve.path_attrib:
-            style['fill'] = curve.path_attrib['fill']
+            if curve.path_attrib['fill'] != 'none':
+                style['fill'] = curve.path_attrib['fill']
         if 'fill-rule' in curve.path_attrib:
             style['fill-rule'] = curve.path_attrib['fill-rule']
         # parse fill-opacity
@@ -445,7 +458,9 @@ class Compiler:
                 style['fill-opacity'] = re.search('(\d*\.)?\d+', fill_opacity.group(0)).group(0)
         # parse stroke attribute
         if 'stroke' in curve.path_attrib:
-            style['stroke'] = curve.path_attrib['stroke']
+            stroke_str = curve.path_attrib['stroke']
+            if stroke_str != 'none':
+                style['stroke'] = stroke_str
         # parse stroke-width attribute
         if 'stroke-width' in curve.path_attrib:
             style['stroke-width'] = curve.path_attrib['stroke-width']
@@ -459,6 +474,87 @@ class Compiler:
         return style
+    def color_coded_paths(self, set_color_coded = False) -> ():
+        """
+        Get color_coded info
+        Return string tuple (pathignore, pathcut, pathengrave)
+        """
+        pathignore = None
+        pathcut = None
+        pathengrave = None
+        if self.settings["color_coded"]:
+            color_code = self.settings["color_coded"]
+            # get css color names
+            colors = str([*css_color.css_color_keywords])
+            colors = re.sub("(,|\[|\]|\'| )", '', colors.replace(",", "|"))
+            # get ignore (do not draw) colors
+            colors_ignore_regex = "((" + colors + ") *= *ignore)+"
+            match = re.findall(colors_ignore_regex, color_code)
+            pathignore = [i[1] for i in match]
+            # get cut colors
+            colors_cut_regex = "((" + colors + ") *= *cut)+"
+            match = re.findall(colors_cut_regex, color_code)
+            pathcut = [i[1] for i in match]
+            # get engrave colors
+            colors_engrave_regex = "((" + colors + ") *= *engrave)+"
+            match = re.findall(colors_engrave_regex, color_code)
+            pathengrave = [i[1] for i in match]
+            if set_color_coded:
+                cced = ""
+                for i in pathignore:
+                    cced += f"{i} = ignore "
+                for i in pathcut:
+                    cced += f"{i} = cut "
+                for i in pathengrave:
+                    cced += f"{i} = engrave "
+                # set color_coded option string to the actual version
+                self.settings["color_coded"] = cced
+                self.params["color_coded"] = cced
+        return (pathignore, pathcut, pathengrave)
+    def parse_color_coded(self, stroke_color: str = None) -> ():
+        """
+        Parse option --color_coded
+        Return tuple (ignorepath, cutpath, engravepath)
+        """
+        if self.settings["color_coded"]:
+            ignorepath = False
+            cutpath = False
+            engravepath = False
+            # Get colo_coded info
+            pathignore, pathcut, pathengrave = self.color_coded_paths();
+            for color in pathignore:
+                if css_color.rgb24equal(css_color.parse_css_color(stroke_color), css_color.css_color_keywords[color]["decimal"]):
+                    # stroke color is ignored (no path is drawn)
+                    ignorepath = True
+                    break
+            if not ignorepath:
+                # cut path if option --color_coded is selected and stroke_color == "red"
+                for color in pathcut:
+                    if css_color.rgb24equal(css_color.parse_css_color(stroke_color), css_color.css_color_keywords[color]["decimal"]):
+                        cutpath = True
+                        break
+                if not cutpath:
+                    for color in pathengrave:
+                        if css_color.rgb24equal(css_color.parse_css_color(stroke_color), css_color.css_color_keywords[color]["decimal"]):
+                            engravepath = True
+                            break
+        return (ignorepath, cutpath, engravepath)
     def append_curves(self, curves: list[Curve]):
         """
         Draws curves.
@@ -518,6 +614,84 @@ class Compiler:
                 pixel = 1/self.settings["pixel_size"]
                 draw(img, (int(p1[0]*pixel),int(p1[1]*pixel)),(int(p2[0]*pixel),int(p2[1]*pixel)), gray)
+        def render_pathwidth(line_chain: LineSegmentChain, steps: list[float], color: int = None, speed: int = None, boundingbox = None):
+            """
+            Render - generate gcode for - a path of certain 'width'.
+            """
+            # A path can be an 'engraving' or a 'cut'.
+            for step in steps:      # step 'width'
+                if step:
+                    # calculate delta chain
+                    delta_chain = LineSegmentChain.delta_chain(line_chain, step)
+                    # Note that append_line_chain generates a path cut when inverse_bw and speed are set to None.
+                    self.append_line_chain(delta_chain, step, color, speed)
+                    # update boundingbox of this 'name_id'
+                    for line in delta_chain:
+                        boundingbox.update(line.start)
+                        boundingbox.update(line.end)
+                else:
+                    # Note that append_line_chain generates a path cut when inverse_bw and speed are set to None.
+                    self.append_line_chain(line_chain, 0, color, speed)
+                    # update boundingbox of this 'name_id'
+                    for line in line_chain:
+                        boundingbox.update(line.start)
+                        boundingbox.update(line.end)
+        def get_style_info_of_line_chain(line_chain: LineSegmentChain) -> ():
+            """
+            Get style info of line_chain.
+            Returns tuple (stroke_width, stroke_color, stroke_alpha, fill_color, fill_alpha, fill_rule)
+            """
+            # defaults
+            stroke_width = 0
+            stroke_color = ""
+            stroke_alpha = None
+            fill_color = None
+            fill_alpha = None
+            fill_rule = None
+            # get style info for this line chain
+            first_line_of_chain = line_chain.get(0)
+            style = self.parse_style_attribute(first_line_of_chain)
+            if style:
+                if not (style['pathcut'] == 'true' or self.settings["pathcut"]) \
+                    and style['stroke'] is not None and style['stroke'] != "none":
+                    stroke_color = style['stroke']
+                    if style['stroke-opacity'] is not None:
+                        # fill opacity attribute overrides rgba property
+                        stroke_alpha = float(style['stroke-opacity'])
+                        if not (stroke_alpha >=0 and stroke_alpha <= 1):
+                            logger.warn(f"Opacity value '{stroke_alpha}' should be in range [0.0..1.0]!")
+                if style['stroke-width'] is not None and style['stroke-width'] != "none":
+                    width = float(style['stroke-width'])
+                    stroke_width = math.ceil(round(width/pixel_size, self.precision)/2)
+                if style['fill'] is not None and style['fill'] != 'none':
+                    # 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"])
+                    if style['fill-rule'] is not None:
+                        fill_rule = style['fill-rule']
+                        if fill_rule == "nonzero":
+                            logger.warn(f"fill-rule 'nonzero' of object '{name_id}' is currently unsupported!")
+                    if style['fill-opacity'] is not None:
+                        # fill opacity attribute overrides rgba property
+                        fill_alpha = float(style['fill-opacity'])
+                        if not (fill_alpha >=0 and fill_alpha <= 1):
+                            logger.warn(f"Opacity value '{fill_alpha}' should be in range [0.0..1.0]!")
+                            fill_alpha = 1
+                    else:
+                        rgba = css_color.parse_css_color(style['fill'])
+                        fill_alpha = 1
+                        if len(rgba) == 4:
+                            fill_alpha = rgba[3]
+                    fill_color = fill_color * fill_alpha
+            return (stroke_width, stroke_color, stroke_alpha, fill_color, fill_alpha, fill_rule)
         path_curves = {}
         pixel_size = float(self.settings["pixel_size"])
@@ -556,71 +730,33 @@ class Compiler:
                     # add line segments to curves having this id
                     path_curves[curve_name_id].append(line_chain)
-        # default stroke width is one line (thickness)
-        stroke_width = pixel_size
         # emit all paths (organized by name id)
         for name_id in path_curves:
             steps = []
             fill_color = None
+            fill_alpha = None
             fill_rule = None
             # set a boundingbox per 'name_id'
             boundingbox = Boundingbox()
+            # Render svg 'stroke' attribute
             for line_chain in path_curves[name_id]:
+                # get style info
+                stroke_width, stroke_color, stroke_alpha, fill_color, fill_alpha, fill_rule = get_style_info_of_line_chain(line_chain)
-                # default stroke width is one line (thickness)
-                width = 0
-                stroke_color = ""
-                stroke_alpha = None
-                # get style info for this line chain (of object 'name_id')
-                first_line_of_chain = line_chain.get(0)
-                style = self.parse_style_attribute(first_line_of_chain)
-                if style:
-                    if not (style['pathcut'] == 'true' or self.settings["pathcut"]) \
-                        and style['stroke'] is not None and style['stroke'] != "none":
-                        stroke_color = style['stroke']
-                        if style['stroke-opacity'] is not None:
-                            # fill opacity attribute overrides rgba property
-                            stroke_alpha = float(style['stroke-opacity'])
-                            if not (stroke_alpha >=0 and stroke_alpha <= 1):
-                                logger.warn(f"Opacity value '{stroke_alpha}' should be in range [0.0..1.0]!")
-                    if style['stroke-width'] is not None and style['stroke-width'] != "none":
-                        stroke_width = float(style['stroke-width'])
-                        width = math.ceil(round(stroke_width/pixel_size, self.precision)/2)
-                    if style['fill'] is not None:
-                        # 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 sets option 'invert' to false to be able to use the value below directly.
-                        fill_color = Image2gcode.linear_power(css_color.parse_css_color2bw8(style['fill']), self.settings["maximum_image_laser_power"])
-                        if style['fill-rule'] is not None:
-                            fill_rule = style['fill-rule']
-                            if fill_rule == "nonzero":
-                                logger.warn(f"fill-rule 'nonzero' of object '{name_id}' is currently unsupported!")
-                        if style['fill-opacity'] is not None:
-                            # fill opacity attribute overrides rgba property
-                            fill_alpha = float(style['fill-opacity'])
-                            if not (fill_alpha >=0 and fill_alpha <= 1):
-                                logger.warn(f"Opacity value '{fill_alpha}' should be in range [0.0..1.0]!")
-                                fill_alpha = 1
-                        else:
-                            rgba = css_color.parse_css_color(style['fill'])
-                            fill_alpha = 1
-                            if len(rgba) == 4:
-                                fill_alpha = rgba[3]
-                        fill_color = fill_color * fill_alpha
-                # Get steps (offsets) for the lines that make the border
-                steps = [0]
-                if len(stroke_color) and width:
-                    for delta in range(width):
-                        if delta:
-                            steps.append(round(delta * pixel_size, self.precision))
-                            if not (delta == width and width % 2 != 0):
-                                steps.append(round(-delta * pixel_size, self.precision))
-                # Get stroke alpha channel (opacity)
                 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
                     if stroke_alpha is None:
                         stroke_alpha = 1
@@ -628,30 +764,49 @@ class Compiler:
                         if len(rgba) == 4:
                             stroke_alpha = rgba[3]
-                # Render svg stroke (of size 'width')
-                # (draw smooth border outlines in gcode)
-                # Note the update of the boundingbox.
-                self.body.extend([f"\n; border: '{name_id}'"])
-                for step in steps:
-                    if step:
-                        delta_chain = LineSegmentChain.delta_chain(line_chain, step)
-                        # apply alpha channel - when available - to inverted b&w value
-                        inverse_bw = Image2gcode.linear_power(css_color.parse_css_color2bw8(stroke_color), self.settings["maximum_image_laser_power"]) * stroke_alpha
-                        self.append_line_chain(delta_chain, step, inverse_bw)
-                        # update 'name_id' boundingbox
-                        for line in delta_chain:
-                            boundingbox.update(line.start)
-                            boundingbox.update(line.end)
+                    # 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
+                    # set laser head movement speed
+                    speed = self.settings["image_movement_speed"]
+                    # handle option color_coded
+                    if self.settings["color_coded"]:
+                        # get color_coded info
+                        ignorepath, cutpath, engravepath = self.parse_color_coded(stroke_color)
+                        if not ignorepath:
+                            if cutpath:
+                                # 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 = 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:
+                                    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:
+                            self.body.extend([f"\n; --color_coded: ignore path '{name_id}', color '{stroke_color}'"])
                     else:
-                        # apply alpha channel - when available - to inverted b&w value
-                        inverse_bw = Image2gcode.linear_power(css_color.parse_css_color2bw8(stroke_color), self.settings["maximum_image_laser_power"]) * stroke_alpha if len(stroke_color) else None
-                        self.append_line_chain(line_chain, step, inverse_bw)
-                        # update 'name_id' boundingbox
-                        for line in line_chain:
-                            boundingbox.update(line.start)
-                            boundingbox.update(line.end)
-            if not self.settings["nofill"] and fill_color is not None:
+                        # color_coded isn't set: 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)
+            # Render svg 'fill' attribute
+            if not self.settings["nofill"] and fill_color is not None and boundingbox.get() is not None:
                 # fill a path
                 # this is done in 6 steps:
                 # step 1: create two raster images matching the bbox
@@ -660,7 +815,9 @@ class Compiler:
                 #         (fill rule 'nonzero' to be implemented later on see note below)
                 # step 4: draw white borders to erase fill overlap
                 # step 5: filter stray pixels (to remove noise from the action above)
-                # step 6: generate gcode from image_fill
+                # step 6: generate gcode from image_fill (by execution function image2gcode)
+                self.body.extend([f"\n; fill path '{name_id}'"])
                 # get bounding box info from the path border
                 lowerleft = boundingbox.get()[0]
@@ -754,11 +911,11 @@ class Compiler:
                 #               for markers (border,inside border) and apply rule
                 #               'evenodd' to fill when an even number of borders
                 #               is crossed, untill odd
-                # Note that the image 'image_fill' is filled not 'image_mark' to make sure marks stay in place.
+                # Note that image 'image_fill' is filled (not 'image_mark') to make sure marks stay in place.
                 # Note that the fill algorithm can be adapted to support direct rendering of gcode (instead of rendering via 'image_fill' and
                 # function 'image2gcode', converting a raster image to gcode). This reduces the number of steps needed: steps 4, 5 and 6 can
-                # be left out. It does need a few adaptions in the previous steps, namely drawing the line chain border (color '10') in full width
+                # be left out. It does need a few adaptations in the previous steps, namely drawing the line chain border (color '10') in full width
                 # (instead of 1 pixel) and draw the 'inside' line (color 128) one pixel further. In addition to this uncomment the '## direct gcode'
                 # lines of step 3 to activate gcode rendering.
@@ -914,7 +1071,6 @@ class Compiler:
                 ## direct gcode: ignore this step
                 # start gcode fill
-                self.body.extend([f"\n;fill '{name_id}'"])
                 self.image2gcode(img_attrib, image_fill)
     def check_axis_maximum_travel(self):
@@ -929,9 +1085,10 @@ class Compiler:
         :return true when box is in machine area bounds, false otherwise
         """
-        if self.settings["distance_mode"] == "absolute" and self.check_axis_maximum_travel():
+        if self.settings["distance_mode"] == "absolute" and self.check_axis_maximum_travel() and self.boundingbox.get():
             machine_max = Vector(self.settings["x_axis_maximum_travel"],self.settings["y_axis_maximum_travel"])
             bbox = self.boundingbox.get()
             # bbox[0] == lowerleft, bbox[1] == uperright, bbox[0/1][0] == x, bbox[0/1][1] == y
             #      lower left x and y >= 0 and upperright x and y <= resp. machine max x and y
             return (bbox[0][0] >= 0 and bbox[0][1] >=0

{svg2gcode-3.2.8 → svg2gcode-3.3.1}/svg2gcode/svg_to_gcode/css_color.py RENAMED Viewed

@@ -253,8 +253,8 @@ def parse_css_color(color: str) -> [int,int,int,float]:
                     rgbcolor = [int(rgbcolor[0] * 255), int(rgbcolor[1] * 255), int(rgbcolor[2] * 255), a]
     if not rgbcolor:
-        logger.warn(f"Not a valid css color: '{color}', color set to 'black'!")
-        rgbcolor = css_color_keywords['black']["decimal"]
+        logger.warn(f"Not a valid css color: '{color}', color set to 'white'!")
+        rgbcolor = css_color_keywords['white']["decimal"]
     return rgbcolor
@@ -274,6 +274,12 @@ def rgb24tobw8(rgb24: [int,int,int,float]) -> int:
     """
     return int(rgb24[0] * 0.299 + rgb24[1] * 0.587 + rgb24[2] * 0.114) & 0xff
+def rgb24equal(rgb24, rgb24_2) -> bool:
+    """
+        compare two 24 bit rgb (color) values
+    """
+    return (rgb24[0] == rgb24_2[0]) and (rgb24[1] == rgb24_2[1]) and (rgb24[2] == rgb24_2[2])
 def parse_css_color2bw8(color: str) -> int:
     """
     parse css color string to 8 bit b&w value