svg2gcode 3.3.6__tar.gz → 4.0.1__tar.gz

svg2gcode-4.0.1/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 Johannes Noordanus
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

svg2gcode-3.3.6/README.md → svg2gcode-4.0.1/PKG-INFO

@@ -1,8 +1,55 @@
+Metadata-Version: 2.5
+Name: svg2gcode
+Version: 4.0.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>
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-Expression: MIT
+License-File: LICENSE
+Requires-Dist: numpy >= 2.5.3
+Requires-Dist: Pillow >= 12.2.0
+Requires-Dist: image2gcode >= 2.9.17
+Project-URL: Home, https://github.com/johannesnoordanus/svg2gcode
+Import-Name: svg2gcode
+
 # svg2gcode
 
-*svg2gcode* is a *WYSIWYG* converter of Scalable Vector Graphic *(SVG)* drawings. It is based on library *SvgToGcode* (*https://github.com/johannesnoordanus/SvgToGcode*)<sup>(*)</sup>.
+### svg2gcode <small>is a *WYSIWYG* converter of Scalable Vector Graphic *(.svg)* drawings.</small>
+
+It is based on library *SvgToGcode* (*https://github.com/johannesnoordanus/SvgToGcode*)<sup>(1)</sup>.
+### Version 4.0 is out now!
+**svg2gcode 4.0** has a vastly improved *stroke* and *fill* and is even easier to control.
+Lines with a certain width are now drawn almost perfectly in a vector like manner. 
+*fill* is also a vector (line) fill now. 
+Both types of fill *evenodd* and *nonzero* are supported and use a complete new render engine that directly renders to gcode.
+
+It is very easy to convert text to gcode now, just create a *.svg* file using Inkscape for example, type in some text and convert it via ```object to path``` to a path.
+Save this file in say *letters.svg* and type the following: <sup>(2)</sup>
+```
+> svg2gcode --color_coded "allothercolors = engrave" letters.svg letters.gc
+```
+This will generate a gcode file *letters.gc* which produces an exact copy of the text on your laser engraver.<br>
+Option *--color_coded* is enhanced and accepts apart from *color* names, ```#hex```, ```rgb```, ```rgba```, ```hsl``` and ```hsla``` color codes.
+
+As can be seen above a special 'color' ```allothercolors``` is added, which means what you think it means. So we can now name all colors we do not explicitly mention in the option to be able to *'ignore', 'cut' or 'engrave'* all other colors.<br>
+More info on *--color_coded* and other program options and can be found below.
+
+Fan control has also improved, it is now possible - apart from setting it on or off globally - to have fan on for ```engraving``` or ```cut``` only.
+
+I put a lot of work into this program to get it right, but it might be that you encounter errors in which case you can contact me or put in an issue at *https://github.com/johannesnoordanus/svg2gcode*. You can also do a feature request in the same manner.
+
+Have fun using it.
+
+Johannes
+
+<sup>(2)</sup> It is also possible to leave out option *--color-coded* because engraving is the default.
+
+ -----
+### General description
 
-Drawings and images can be composed using Inkscape (or other *SVG* image software), saved to a *.svg* file and - *WYSIWYG* - converted to gcode.
+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.
 
 Raster elements within a *SVG* drawing are converted pixel perfect, vector elements are drawn at the specified resolution.
@@ -17,13 +64,12 @@ 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.
+<sup>(1)</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).
+If you find this application useful, please consider donating, so I can continue maintaining and enhancing it.<br>
+<http://paypal.me/johannesnoordanus/5,00>
 
  -----
 
@@ -32,11 +78,16 @@ My next update will add *fill-rule* 'nonzero' (see information on *fill-rule* be
 *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.
+*fill-rule* is currently fully supported and accepts values *evenodd* and *nonzero* of which the latter is default.
+With option ```svg2gcode --fillrule "evenodd|nonzero"``` you can set your own preference from the commandline. 
 
 ### *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``` <sup>(**)</sup> 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.) 
+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*. 
+
+Depending on your preference text (fonts) require another step in Inkscape after *selecting* all text and clicking menu ```Object to Path```. Clicking menu```Object->Ungroup``` <sup>(3)</sup> 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.)
+
+If you *Ungroup* each character is rendered separately to gcode and this means that *stroke* and *fill* is done per character. Version 4.0 of *svg2gcode* has no problem rendering - do *stroke* and *fill* - for all text combined but note that it is a different situation.
 
 You can use *gcode2image* to check the conversion result:
 ```
@@ -47,27 +98,37 @@ The image shown should be the same as the one shown by the composer (Inkscape).
 
 #### Contour & fill
 
-Inkscape translates a contour of a raster image to an outline and fill. So, if you create a contour via (select bitmap first) ```Path->Trace Bitmap...``` slide the ```Treshold``` of the Trace Bitmap menu to almost 1 (0,995) to make the entire bitmap image black (this is a bit *trial and error*, use ```Update preview``` to get the highest slider value before the whole images is black).
+Inkscape translates a contour of a raster image to an outline and fill. So, if you create a contour using Inkscape via (select bitmap first) ```Path->Trace Bitmap...``` slide the ```Treshold``` of the Trace Bitmap menu to almost 1 (0,995) to make the entire bitmap image black (this is a bit *trial and error*, use ```Update preview``` to get the highest slider value before the whole images is black), the style attribute will look like:
 
-You can look at the result xml tree via Inkscapes ```XML editor``` which now shows a path for the outline of the raster image and a style attribue like this:
 ```
 style           fill:#000000;stroke-width:0.172652
 ```
+
+You see this in the ```.svg``` file or the xml tree via Inkscapes ```XML editor``` which now shows a path for the outline of the raster image and a style attribute.
+
 To cut this outline, you can set the *fill* attribute to *none* (via the ```XML editor``` or menu ```Fill and Stroke```) and set a specific *stroke* color, for example *red*. The following command generates gcode to cut the outline.
 ```
 > svg2gcode --color_coded "red = cut" contour.svg contour.gc
+
+```
+You can also engrave the whole bitmap image by setting a specific fill color (via menu ```Fill and Stroke```); in this case there is no need to use option ```color_coded``` because engraving is the default. But remember that is it possible to ignore (or engrave or cut) all other colors by using the special keyword ```allothercolors```.
+
+For example if you have the following:
+
+```
+svg2gcode --showimage --fillrule evenodd --color_coded "#0F0F0F = engrave, green = cut, allothercolors = ignore" some.svg some.gc
 ```
-You can also engrave the whole bitmap image by setting a specific fill color (via menu ```Fill and Stroke```) (in this case there is no need to use option ```color_coded```)
+Lines having color code *#0F0F0F* will be engraved and line having color name 'green' will be cut, while all other colors you might have in your drawing will be ignored.
 
 #### 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 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)
+ - vector graphics (*.svg*) source documents must be in unit 'mm' and set to ```1 'user unit' is 1 mm``` (Inkscape default)
 
-<sup>(**)</sup> Note that the latest version of *svg2gcode* (3.3.4) has support for ```<g``` tags (attribute inheritance) and is able to correctly convert text without ```Ungroup```.
+<sup>(3)</sup> Note that the latest version of *svg2gcode* (4.0.0) has support for ```<g``` tags (attribute inheritance) and is able to correctly convert text without ```Ungroup```.
 
 ### Important Commandline options
 
@@ -77,7 +138,7 @@ 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:
+The corresponding gcode (*.gc*) file contains lines like below to indicated which 'black path' is skipped:
 ```
 ;    svg2gcode 3.2.8 (2024-07-28 11:39:27)
 ;    arguments:
@@ -130,7 +191,7 @@ Note that these attributes override explicit or default commandline settings.
 
 ### gcode optimizations
 
-Optimized gcode
+Optimized gcode for images
 - draw pixels in one go until change of power
 - emit X/Y coordinates only when they change
 - emit linear move 'G1/G0' code minimally
@@ -138,7 +199,7 @@ Optimized gcode
 
 General optimizations
 - laser head has deferred and sparse moves.
-(XY locations are virtual, head does not always follow)
+  (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)
 - default --constantburn mode *gcode M3*
@@ -159,12 +220,11 @@ Some linux distributions use a managed environment in which you cannot install p
 ### Usage:
 ```
 > svg2gcode --help
-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
+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 | --no-constantburn] [--origin delta-x delta-y] [--scale factor-x factor-y] [--rotate <default:0>] [--splitfile] [--pathcut] [--nofill] [--fillrule <default:"nonzero">]
+                     [--xmaxtravel <default:300>] [--ymaxtravel <default:400>] [--color_coded <default:"">] [--fan <default:"off">] [-V]
+                     svg gcode
 
 Convert svg to gcode for GRBL v1.1 compatible diode laser engravers.
 
@@ -207,13 +267,17 @@ options:
   --splitfile           split gcode output of SVG path and image objects
   --pathcut             alway cut SVG path objects! (use laser power set with option --cuttingpower)
   --nofill              ignore SVG fill attribute
+  --fillrule <default:"nonzero">
+                        set fill rule to [nonzero|evenodd]
   --xmaxtravel <default:300>
                         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
+                        set action for path with specific stroke color "[[color|allothercolors] = [cut|engrave|ignore] *]*", example: --color_coded "black = ignore purple = cut blue = engrave allothercolors
+                        = ignore"
+  --fan <default:"off">
+                        set fan [on|off|on_engrave|on_cut]
   -V, --version         show version number and exit
 ```
 
@@ -367,3 +431,4 @@ 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.
 
+

svg2gcode-3.3.6/PKG-INFO → svg2gcode-4.0.1/README.md

@@ -1,22 +1,39 @@
-Metadata-Version: 2.1
-Name: svg2gcode
-Version: 3.3.6
-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>
-Requires-Python: >=3.11
-Description-Content-Type: text/markdown
-Classifier: License :: OSI Approved :: MIT License
-Requires-Dist: numpy >= 1.24.3
-Requires-Dist: Pillow >= 9.5.0
-Requires-Dist: image2gcode >= 2.9.8
-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* (*https://github.com/johannesnoordanus/SvgToGcode*)<sup>(*)</sup>.
+### svg2gcode <small>is a *WYSIWYG* converter of Scalable Vector Graphic *(.svg)* drawings.</small>
+
+It is based on library *SvgToGcode* (*https://github.com/johannesnoordanus/SvgToGcode*)<sup>(1)</sup>.
+### Version 4.0 is out now!
+**svg2gcode 4.0** has a vastly improved *stroke* and *fill* and is even easier to control.
+Lines with a certain width are now drawn almost perfectly in a vector like manner. 
+*fill* is also a vector (line) fill now. 
+Both types of fill *evenodd* and *nonzero* are supported and use a complete new render engine that directly renders to gcode.
+
+It is very easy to convert text to gcode now, just create a *.svg* file using Inkscape for example, type in some text and convert it via ```object to path``` to a path.
+Save this file in say *letters.svg* and type the following: <sup>(2)</sup>
+```
+> svg2gcode --color_coded "allothercolors = engrave" letters.svg letters.gc
+```
+This will generate a gcode file *letters.gc* which produces an exact copy of the text on your laser engraver.<br>
+Option *--color_coded* is enhanced and accepts apart from *color* names, ```#hex```, ```rgb```, ```rgba```, ```hsl``` and ```hsla``` color codes.
+
+As can be seen above a special 'color' ```allothercolors``` is added, which means what you think it means. So we can now name all colors we do not explicitly mention in the option to be able to *'ignore', 'cut' or 'engrave'* all other colors.<br>
+More info on *--color_coded* and other program options and can be found below.
+
+Fan control has also improved, it is now possible - apart from setting it on or off globally - to have fan on for ```engraving``` or ```cut``` only.
+
+I put a lot of work into this program to get it right, but it might be that you encounter errors in which case you can contact me or put in an issue at *https://github.com/johannesnoordanus/svg2gcode*. You can also do a feature request in the same manner.
+
+Have fun using it.
+
+Johannes
+
+<sup>(2)</sup> It is also possible to leave out option *--color-coded* because engraving is the default.
+
+ -----
+### General description
 
-Drawings and images can be composed using Inkscape (or other *SVG* image software), saved to a *.svg* file and - *WYSIWYG* - converted to gcode.
+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.
 
 Raster elements within a *SVG* drawing are converted pixel perfect, vector elements are drawn at the specified resolution.
@@ -31,13 +48,12 @@ 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.
+<sup>(1)</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).
+If you find this application useful, please consider donating, so I can continue maintaining and enhancing it.<br>
+<http://paypal.me/johannesnoordanus/5,00>
 
  -----
 
@@ -46,11 +62,16 @@ My next update will add *fill-rule* 'nonzero' (see information on *fill-rule* be
 *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.
+*fill-rule* is currently fully supported and accepts values *evenodd* and *nonzero* of which the latter is default.
+With option ```svg2gcode --fillrule "evenodd|nonzero"``` you can set your own preference from the commandline. 
 
 ### *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``` <sup>(**)</sup> 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.) 
+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*. 
+
+Depending on your preference text (fonts) require another step in Inkscape after *selecting* all text and clicking menu ```Object to Path```. Clicking menu```Object->Ungroup``` <sup>(3)</sup> 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.)
+
+If you *Ungroup* each character is rendered separately to gcode and this means that *stroke* and *fill* is done per character. Version 4.0 of *svg2gcode* has no problem rendering - do *stroke* and *fill* - for all text combined but note that it is a different situation.
 
 You can use *gcode2image* to check the conversion result:
 ```
@@ -61,27 +82,37 @@ The image shown should be the same as the one shown by the composer (Inkscape).
 
 #### Contour & fill
 
-Inkscape translates a contour of a raster image to an outline and fill. So, if you create a contour via (select bitmap first) ```Path->Trace Bitmap...``` slide the ```Treshold``` of the Trace Bitmap menu to almost 1 (0,995) to make the entire bitmap image black (this is a bit *trial and error*, use ```Update preview``` to get the highest slider value before the whole images is black).
+Inkscape translates a contour of a raster image to an outline and fill. So, if you create a contour using Inkscape via (select bitmap first) ```Path->Trace Bitmap...``` slide the ```Treshold``` of the Trace Bitmap menu to almost 1 (0,995) to make the entire bitmap image black (this is a bit *trial and error*, use ```Update preview``` to get the highest slider value before the whole images is black), the style attribute will look like:
 
-You can look at the result xml tree via Inkscapes ```XML editor``` which now shows a path for the outline of the raster image and a style attribue like this:
 ```
 style           fill:#000000;stroke-width:0.172652
 ```
+
+You see this in the ```.svg``` file or the xml tree via Inkscapes ```XML editor``` which now shows a path for the outline of the raster image and a style attribute.
+
 To cut this outline, you can set the *fill* attribute to *none* (via the ```XML editor``` or menu ```Fill and Stroke```) and set a specific *stroke* color, for example *red*. The following command generates gcode to cut the outline.
 ```
 > svg2gcode --color_coded "red = cut" contour.svg contour.gc
+
+```
+You can also engrave the whole bitmap image by setting a specific fill color (via menu ```Fill and Stroke```); in this case there is no need to use option ```color_coded``` because engraving is the default. But remember that is it possible to ignore (or engrave or cut) all other colors by using the special keyword ```allothercolors```.
+
+For example if you have the following:
+
+```
+svg2gcode --showimage --fillrule evenodd --color_coded "#0F0F0F = engrave, green = cut, allothercolors = ignore" some.svg some.gc
 ```
-You can also engrave the whole bitmap image by setting a specific fill color (via menu ```Fill and Stroke```) (in this case there is no need to use option ```color_coded```)
+Lines having color code *#0F0F0F* will be engraved and line having color name 'green' will be cut, while all other colors you might have in your drawing will be ignored.
 
 #### 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 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)
+ - vector graphics (*.svg*) source documents must be in unit 'mm' and set to ```1 'user unit' is 1 mm``` (Inkscape default)
 
-<sup>(**)</sup> Note that the latest version of *svg2gcode* (3.3.4) has support for ```<g``` tags (attribute inheritance) and is able to correctly convert text without ```Ungroup```.
+<sup>(3)</sup> Note that the latest version of *svg2gcode* (4.0.0) has support for ```<g``` tags (attribute inheritance) and is able to correctly convert text without ```Ungroup```.
 
 ### Important Commandline options
 
@@ -91,7 +122,7 @@ 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:
+The corresponding gcode (*.gc*) file contains lines like below to indicated which 'black path' is skipped:
 ```
 ;    svg2gcode 3.2.8 (2024-07-28 11:39:27)
 ;    arguments:
@@ -144,7 +175,7 @@ Note that these attributes override explicit or default commandline settings.
 
 ### gcode optimizations
 
-Optimized gcode
+Optimized gcode for images
 - draw pixels in one go until change of power
 - emit X/Y coordinates only when they change
 - emit linear move 'G1/G0' code minimally
@@ -152,7 +183,7 @@ Optimized gcode
 
 General optimizations
 - laser head has deferred and sparse moves.
-(XY locations are virtual, head does not always follow)
+  (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)
 - default --constantburn mode *gcode M3*
@@ -173,12 +204,11 @@ Some linux distributions use a managed environment in which you cannot install p
 ### Usage:
 ```
 > svg2gcode --help
-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
+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 | --no-constantburn] [--origin delta-x delta-y] [--scale factor-x factor-y] [--rotate <default:0>] [--splitfile] [--pathcut] [--nofill] [--fillrule <default:"nonzero">]
+                     [--xmaxtravel <default:300>] [--ymaxtravel <default:400>] [--color_coded <default:"">] [--fan <default:"off">] [-V]
+                     svg gcode
 
 Convert svg to gcode for GRBL v1.1 compatible diode laser engravers.
 
@@ -221,13 +251,17 @@ options:
   --splitfile           split gcode output of SVG path and image objects
   --pathcut             alway cut SVG path objects! (use laser power set with option --cuttingpower)
   --nofill              ignore SVG fill attribute
+  --fillrule <default:"nonzero">
+                        set fill rule to [nonzero|evenodd]
   --xmaxtravel <default:300>
                         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
+                        set action for path with specific stroke color "[[color|allothercolors] = [cut|engrave|ignore] *]*", example: --color_coded "black = ignore purple = cut blue = engrave allothercolors
+                        = ignore"
+  --fan <default:"off">
+                        set fan [on|off|on_engrave|on_cut]
   -V, --version         show version number and exit
 ```
 
@@ -381,4 +415,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.
 
-

{svg2gcode-3.3.6 → svg2gcode-4.0.1}/pyproject.toml

@@ -1,20 +1,20 @@
 [build-system]
-requires = ["flit_core >=3.2,<4"]
+requires = ["flit_core >=3.11,<5"]
 build-backend = "flit_core.buildapi"
 
 [project]
 name = "svg2gcode"
 authors = [{name = "Johannes Noordanus", email = "mailjohannes.mailnoordanus@gmail.com"}]
 readme = "README.md"
-license = {file = "LICENSE"}
-classifiers = ["License :: OSI Approved :: MIT License"]
+license = "MIT"
+license-files = ["LICENSE"]
 dynamic = ["version", "description"]
 
 keywords = ["scalable vector graphics", "svg", "image", "laser cutter", "laser engraving"]
 dependencies = [
-    "numpy >= 1.24.3",
-    "Pillow >= 9.5.0",
-    "image2gcode >= 2.9.8",
+    "numpy >= 2.5.3",
+    "Pillow >= 12.2.0",
+    "image2gcode >= 2.9.17",
 ]
 requires-python = ">=3.11"
 

{svg2gcode-3.3.6 → svg2gcode-4.0.1}/svg2gcode/__init__.py

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

{svg2gcode-3.3.6 → svg2gcode-4.0.1}/svg2gcode/__main__.py

@@ -5,6 +5,8 @@ svg2gcode: convert an image to gcode.
 import os
 import sys
 import re
+import logging
+import warnings
 try:
     import tomllib
 except ImportError:
@@ -21,6 +23,14 @@ from svg2gcode.svg_to_gcode import css_color
 
 config_file = os.path.expanduser('~/.config/svg2gcode.toml')
 
+# Set logging global disable flag
+##logging.disable(logging.CRITICAL + 1)
+
+# Set warnings disable flag (use python option -W to enable warnings)
+if not sys.warnoptions:
+    warnings.simplefilter("ignore")
+
+
 # Notes:
 # - drawing objects (when using Inkscape for example) must be converted to a 'path' to be translated in a gcode sequence
 # - images objects should NOT be converted a 'path'
@@ -37,25 +47,11 @@ 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, 'fillrule':args.fillrule, '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")
@@ -109,8 +105,10 @@ def main() -> int:
         "pass_depth_default": 0,
         "passes_default": 1,
         "rotate_default": 0,
+        "fillrule_default": "nonzero",
         "colorcoded_default": "",
         "constantburn_default": True,
+        "fan_default": "off"
     }
 
     if os.path.exists(config_file):
@@ -156,14 +154,17 @@ def main() -> int:
     parser.add_argument('--splitfile', action='store_true', default=False, help='split gcode output of SVG path and image objects' )
     parser.add_argument('--pathcut', action='store_true', default=False, help='alway cut SVG path objects! (use laser power set with option --cuttingpower)' )
     parser.add_argument('--nofill', action='store_true', default=False, help='ignore SVG fill attribute' )
+    parser.add_argument('--fillrule', action = 'store', default=cfg["fillrule_default"], metavar="<default:\"" + str(cfg["fillrule_default"])+ "\">",
+         type = str, help = 'set fill rule to [nonzero|evenodd]')
     parser.add_argument('--xmaxtravel', default=cfg["xmaxtravel_default"], metavar="<default:" +str(cfg["xmaxtravel_default"])+ ">",
         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('--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|allothercolors] = [cut|engrave|ignore] *]*"'
+                            ', example: --color_coded "black = ignore purple = cut blue = engrave allothercolors = ignore"' )
+    parser.add_argument('--fan', action = 'store', default=cfg["fan_default"], metavar="<default:\"" + str(cfg["fan_default"])+ "\">",
+         type = str, help = 'set fan [on|on_engrave|on_cut]')
     parser.add_argument('-V', '--version', action='version', version='%(prog)s ' + __version__, help="show version number and exit")
 
     args = parser.parse_args()
@@ -173,25 +174,37 @@ def main() -> int:
             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(",", "|"))
+            # check color_coded argument validity (1)
 
-            # make a color list
-            colors = colors.split("|")
+            # do a full match to validate the syntax
+            cc = re.sub(",", '', args.color_coded)
+            fm = re.fullmatch("( *[^ ]* *= *(cut|engrave|ignore))+", cc)
+            if not fm:
+                print(f"syntax error in argument: '--color_coded {args.color_coded}', argument should be similar to: "
+                      f"'--color_coded \"black = ignore purple = cut blue = engrave\"'")
+                return 1
+
+            cc = fm.group(0)
 
-            # 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]
+            # check color_coded argument validity (2)
+            pathignore, pathcut, pathengrave = Compiler.color_coded(cc)
 
-            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).")
+            # a path color should be in one set only
+            for i in pathignore:
+                if i in pathcut or i in pathengrave:
+                    print(f"error in argument: '--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"error in argument: '--color_coded \"{args.color_coded}\"' has a path color '{i}' set in multiple categories (cut|engrave|ignore).")
+                    return 1
+
+            # check validity of color argument, either "allothercolors" or a valid color value e.g. one of '#hex', 'rgb(', 'rgba(', 'hsl(' and 'hsla(' color schemes.
+            for i in pathignore + pathcut + pathengrave:
+                if not (i == "allothercolors" or css_color.parse_css_color(i, fallback = False, warning = False)):
+                    print(f"error in argument: '--color_coded \"{args.color_coded}\"':")
+                    print(f"- invalid color '{i}', color must be of scheme '#hex', 'rgb', 'rgba', 'hsl', 'hsla' or set to 'allothercolors'.")
                     return 1
 
         if args.origin is not None and args.selfcenter:
@@ -199,12 +212,13 @@ def main() -> int:
             return 1
 
         return svg2gcode(args)
+
     except KeyboardInterrupt:
-        print(f"svg2gcode aborted!")
+        print("svg2gcode aborted!")
+        return 1
     except Exception as error:
         print(error)
-
-    return 1
+        return 1
 
 if __name__ == '__main__':
     sys.exit(main())