svg2gcode 1.2.0__tar.gz → 2.1.0__tar.gz

{svg2gcode-1.2.0 → svg2gcode-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: svg2gcode
-Version: 1.2.0
+Version: 2.1.0
 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>
@@ -16,27 +16,48 @@ Project-URL: Home, https://github.com/johannesnoordanus/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) which should be installed <sup>(*)</sup>.
 
-Drawings and images can be composed using Inkscape (for example) and saved to a .svg file. This file can be converted to gcode by svg2gcode.
+Drawings and images can be composed using Inkscape (for example) and saved to a *.svg* file. This file can 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.
 
 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``` and ```gcode_speed``` can be set per object (they must be created: use **+**). Note that this overrides explicit or default commandline settings.
+Image attributes ```gcode_pixelsize```, ```gcode_maxpower```, ```gcode_speed```, ```gcode_noise``` and ```gcode_speedmoves``` can be set per object (they must be created: use **+**). Note that this overrides explicit or default commandline settings.
+
+Version 2.0.0 has important new 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.
+
+To summarize:
+
+Optimized gcode
+- draw pixels in one go until change of power
+- emit X/Y coordinates only when they change
+- emit linear move 'G1/G0' code minimally
+- does not emit zero power (or below cutoff) pixels
+
+General optimizations
+- laser head has defered 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*
+ 
+**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. 
 
-**Tip**: use commandline program grblhud (https://github.com/johannesnoordanus/grblhud) to have full control over gcode execution.  
 ### Install:
 ```
 > 
 > pip install svg2gcode
 ```
-<sup>(*)</sup> Note that library *svg_to_gcode* is included in this package. 
+<sup>(*)</sup> Note that this library is included. 
 ### Usage:
 See notes below.
 ```
 $ svg2gcode --help
-usage: svg2gcode.py [-h] [--showimage] [--pixelsize <default:0.1>] [--imagespeed <default:800>] [--cuttingspeed <default:1000>] [--imagepower <default:300>]
-                    [--cuttingpower <default:0.85>] [--maxlaserpower <default:1000>] [--rapidmove] [--xmaxtravel <default:300>] [--ymaxtravel <default:400>] [--fan] [-V]
-                    svg gcode
+usage: svg2gcode [-h] [--showimage] [--pixelsize <default:0.1>] [--imagespeed <default:800>]
+                 [--cuttingspeed <default:1000>] [--imagepower <default:300>] [--cuttingpower <default:850>]
+                 [--rapidmove <default:10>] [--noise <default:0>] [--constantburn] [--xmaxtravel <default:300>]
+                 [--ymaxtravel <default:400>] [--fan] [-V]
+                 svg gcode
 
 Convert svg to gcode for GRBL v1.1 compatible diode laser engravers.
 
@@ -54,16 +75,24 @@ options:
   --cuttingspeed <default:1000>
                         cutting speed in mm/min
   --imagepower <default:300>
-                        maximum laser power while drawing an image (as a rule of thumb set to 1/3 of the machine maximum)
+                        maximum laser power while drawing an image (as a rule of thumb set to 1/3 of the
+                        machine maximum for a 5W laser)
   --cuttingpower <default:850>
                         sets laser power of line drawings/cutting
-  --rapidmove           generate inbetween G0 moves
+  --rapidmove <default:10>
+                        generate G0 moves between shapes, for images: G0 moves when skipping more than 10mm
+                        (default), 0 is no G0 moves
+  --noise <default:0>   reduces image noise by not emitting pixels with power lower or equal than this setting
+  --constantburn        use constant burn mode M3 (a bit more dangerous!), instead of dynamic burn mode M4
+  --origin Xdelta Ydelta
+                        translate origin by (Xdelta,Ydelta) (default not set)
   --xmaxtravel <default:300>
                         machine x-axis lengh in mm
   --ymaxtravel <default:400>
                         machine y-axis lengh in mm
   --fan                 set machine fan on
   -V, --version         show version number and exit
+
 ```
 ### Notes:
   - example command to create two types of gcode file, one containing the drawings of the .svg, the other containing the images:      
@@ -77,7 +106,7 @@ options:
  - drawing objects - within the composer - must be converted to a```path```to be translated to a gcode sequence
  - also, image objects should **not** be converted to a ```path```
  - images must be linked or embedded using base64.
- - images can be in several formats (my tests included ```.png``` and  ```.jpg``` image files)
+ - images can be in several formats (my tests included *.png* and  *.jpg* image files)
 
 
 

svg2gcode-2.1.0/README.md

@@ -0,0 +1,98 @@
+# 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) which should be installed <sup>(*)</sup>.
+
+Drawings and images can be composed using Inkscape (for example) and saved to a *.svg* file. This file can 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.
+
+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``` and ```gcode_speedmoves``` can be set per object (they must be created: use **+**). Note that this overrides explicit or default commandline settings.
+
+Version 2.0.0 has important new 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.
+
+To summarize:
+
+Optimized gcode
+- draw pixels in one go until change of power
+- emit X/Y coordinates only when they change
+- emit linear move 'G1/G0' code minimally
+- does not emit zero power (or below cutoff) pixels
+
+General optimizations
+- laser head has defered 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*
+ 
+**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. 
+
+### Install:
+```
+> 
+> pip install svg2gcode
+```
+<sup>(*)</sup> Note that this library is included. 
+### Usage:
+See notes below.
+```
+$ svg2gcode --help
+usage: svg2gcode [-h] [--showimage] [--pixelsize <default:0.1>] [--imagespeed <default:800>]
+                 [--cuttingspeed <default:1000>] [--imagepower <default:300>] [--cuttingpower <default:850>]
+                 [--rapidmove <default:10>] [--noise <default:0>] [--constantburn] [--xmaxtravel <default:300>]
+                 [--ymaxtravel <default:400>] [--fan] [-V]
+                 svg gcode
+
+Convert svg to gcode for GRBL v1.1 compatible diode laser engravers.
+
+positional arguments:
+  svg                   svg file to be converted to gcode
+  gcode                 gcode output file
+
+options:
+  -h, --help            show this help message and exit
+  --showimage           show b&w converted image
+  --pixelsize <default:0.1>
+                        pixel size in mm (XY-axis): each image pixel is drawn this size
+  --imagespeed <default:800>
+                        image draw speed in mm/min
+  --cuttingspeed <default:1000>
+                        cutting speed in mm/min
+  --imagepower <default:300>
+                        maximum laser power while drawing an image (as a rule of thumb set to 1/3 of the
+                        machine maximum for a 5W laser)
+  --cuttingpower <default:850>
+                        sets laser power of line drawings/cutting
+  --rapidmove <default:10>
+                        generate G0 moves between shapes, for images: G0 moves when skipping more than 10mm
+                        (default), 0 is no G0 moves
+  --noise <default:0>   reduces image noise by not emitting pixels with power lower or equal than this setting
+  --constantburn        use constant burn mode M3 (a bit more dangerous!), instead of dynamic burn mode M4
+  --origin Xdelta Ydelta
+                        translate origin by (Xdelta,Ydelta) (default not set)
+  --xmaxtravel <default:300>
+                        machine x-axis lengh in mm
+  --ymaxtravel <default:400>
+                        machine y-axis lengh in mm
+  --fan                 set machine fan on
+  -V, --version         show version number and exit
+
+```
+### Notes:
+  - example command to create two types of gcode file, one containing the drawings of the .svg, the other containing the images:      
+```
+  > svg2gcode ambachtmanlogo.svg logo.gc
+  > ..
+  > ls *.gc 
+  > logo.gc             # all drawings
+  > logo_images.gc      # all images
+```   
+ - drawing objects - within the composer - must be converted to a```path```to be translated to a gcode sequence
+ - also, image objects should **not** be converted to a ```path```
+ - images must be linked or embedded using base64.
+ - images can be in several formats (my tests included *.png* and  *.jpg* image files)
+
+

svg2gcode-2.1.0/svg2gcode/README.md

@@ -0,0 +1,98 @@
+# 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) which should be installed <sup>(*)</sup>.
+
+Drawings and images can be composed using Inkscape (for example) and saved to a *.svg* file. This file can 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.
+
+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``` and ```gcode_speedmoves``` can be set per object (they must be created: use **+**). Note that this overrides explicit or default commandline settings.
+
+Version 2.0.0 has important new 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.
+
+To summarize:
+
+Optimized gcode
+- draw pixels in one go until change of power
+- emit X/Y coordinates only when they change
+- emit linear move 'G1/G0' code minimally
+- does not emit zero power (or below cutoff) pixels
+
+General optimizations
+- laser head has defered 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*
+ 
+**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. 
+
+### Install:
+```
+> 
+> pip install svg2gcode
+```
+<sup>(*)</sup> Note that this library is included. 
+### Usage:
+See notes below.
+```
+$ svg2gcode --help
+usage: svg2gcode [-h] [--showimage] [--pixelsize <default:0.1>] [--imagespeed <default:800>]
+                 [--cuttingspeed <default:1000>] [--imagepower <default:300>] [--cuttingpower <default:850>]
+                 [--rapidmove <default:10>] [--noise <default:0>] [--constantburn] [--xmaxtravel <default:300>]
+                 [--ymaxtravel <default:400>] [--fan] [-V]
+                 svg gcode
+
+Convert svg to gcode for GRBL v1.1 compatible diode laser engravers.
+
+positional arguments:
+  svg                   svg file to be converted to gcode
+  gcode                 gcode output file
+
+options:
+  -h, --help            show this help message and exit
+  --showimage           show b&w converted image
+  --pixelsize <default:0.1>
+                        pixel size in mm (XY-axis): each image pixel is drawn this size
+  --imagespeed <default:800>
+                        image draw speed in mm/min
+  --cuttingspeed <default:1000>
+                        cutting speed in mm/min
+  --imagepower <default:300>
+                        maximum laser power while drawing an image (as a rule of thumb set to 1/3 of the
+                        machine maximum for a 5W laser)
+  --cuttingpower <default:850>
+                        sets laser power of line drawings/cutting
+  --rapidmove <default:10>
+                        generate G0 moves between shapes, for images: G0 moves when skipping more than 10mm
+                        (default), 0 is no G0 moves
+  --noise <default:0>   reduces image noise by not emitting pixels with power lower or equal than this setting
+  --constantburn        use constant burn mode M3 (a bit more dangerous!), instead of dynamic burn mode M4
+  --origin Xdelta Ydelta
+                        translate origin by (Xdelta,Ydelta) (default not set)
+  --xmaxtravel <default:300>
+                        machine x-axis lengh in mm
+  --ymaxtravel <default:400>
+                        machine y-axis lengh in mm
+  --fan                 set machine fan on
+  -V, --version         show version number and exit
+
+```
+### Notes:
+  - example command to create two types of gcode file, one containing the drawings of the .svg, the other containing the images:      
+```
+  > svg2gcode ambachtmanlogo.svg logo.gc
+  > ..
+  > ls *.gc 
+  > logo.gc             # all drawings
+  > logo_images.gc      # all images
+```   
+ - drawing objects - within the composer - must be converted to a```path```to be translated to a gcode sequence
+ - also, image objects should **not** be converted to a ```path```
+ - images must be linked or embedded using base64.
+ - images can be in several formats (my tests included *.png* and  *.jpg* image files)
+
+

{svg2gcode-1.2.0 → svg2gcode-2.1.0}/svg2gcode/__init__.py

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

{svg2gcode-1.2.0 → svg2gcode-2.1.0}/svg2gcode/__main__.py

@@ -23,9 +23,10 @@ def svg2gcode(args) -> int:
         # For line drawings 'pass_depth' controls how far down the tool moves after every pass. Set it to 0 if your machine does not support Z axis movement.
         gcode_compiler = Compiler(interfaces.Gcode, params={'laser_power':args.cuttingpower,'movement_speed':args.cuttingspeed, 'pixel_size':args.pixelsize,
                         '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})
+                        'showimage':args.showimage, 'x_axis_maximum_travel':args.xmaxtravel,'y_axis_maximum_travel':args.ymaxtravel, 'image_noise':args.noise,
+                        'laser_mode':"constant" if args.constantburn else "dynamic" })
         # emit gcode for svg
-        gcode_compiler.compile_to_file(args.gcode, parse_file(args.svg), passes=1)
+        gcode_compiler.compile_to_file(args.gcode, parse_file(args.svg, delta_origin=args.origin), passes=1)
 
     except Exception as error:
         print(error)
@@ -45,6 +46,8 @@ def main() -> int:
     cuttingpower_default = 850
     xmaxtravel_default = 300
     ymaxtravel_default = 400
+    rapidmove_default = 10
+    noise_default = 0
 
     # Define command line argument interface
     parser = argparse.ArgumentParser(description='Convert svg to gcode for GRBL v1.1 compatible diode laser engravers.')
@@ -58,10 +61,16 @@ def main() -> int:
     parser.add_argument('--cuttingspeed', default=cuttingspeed_default, metavar="<default:" + str(cuttingspeed_default)+">",
         type=int, help='cutting speed in mm/min')
     parser.add_argument('--imagepower', default=imagepower_default, metavar="<default:" +str(imagepower_default)+ ">",
-        type=int, help="maximum laser power while drawing an image (as a rule of thumb set to 1/3 of the machine maximum)")
+        type=int, help="maximum laser power while drawing an image (as a rule of thumb set to 1/3 of the machine maximum for a 5W laser)")
     parser.add_argument('--cuttingpower', default=cuttingpower_default, metavar="<default:" +str(cuttingpower_default)+ ">",
         type=int, help="sets laser power of line drawings/cutting")
-    parser.add_argument('--rapidmove', action='store_true', default=True, help='generate inbetween G0 moves' )
+    parser.add_argument('--rapidmove', default=rapidmove_default, metavar="<default:" +str(rapidmove_default)+ ">",
+        type=int, help='generate G0 moves between shapes, for images: G0 moves when skipping more than 10mm (default), 0 is no G0 moves' )
+    parser.add_argument('--noise', default=noise_default, metavar="<default:" +str(noise_default)+ ">",
+        type=int, help='reduces image noise by not emitting pixels with power lower or equal than this setting')
+    parser.add_argument('--constantburn', action='store_true', default=False, help='use constant burn mode M3 (a bit more dangerous!), instead of dynamic burn mode M4')
+    parser.add_argument('--origin', default=None, nargs=2, metavar=('Xdelta', 'Ydelta'),
+        type=float, help="translate origin by (Xdelta,Ydelta) (default not set)")
     parser.add_argument('--xmaxtravel', default=xmaxtravel_default, metavar="<default:" +str(xmaxtravel_default)+ ">",
         type=int, help="machine x-axis lengh in mm")
     parser.add_argument('--ymaxtravel', default=ymaxtravel_default, metavar="<default:" +str(ymaxtravel_default)+ ">",

{svg2gcode-1.2.0 → svg2gcode-2.1.0}/svg2gcode/svg_to_gcode/__init__.py

@@ -24,11 +24,14 @@ SETTING 	= {
     "laser_mode",		# LASERMODE		set constant or dynamic laser power mode
     "maximum_image_laser_power",# positive integer      sets laser power (maximum) for image drawings (this is typically 1/3) of 'maximum_laser_power')
     "image_movement_speed",     # positive integer      sets movement speed when drawing an image (typically a lot less than the 'maximum_rate')
+    "image_noise",              # positive integer      reduces image noise by not emitting pixels lower or equal this setting')
     # Configuration
     "unit",			# UNITS			sets machine unit (milimeters, inches), this also defines the Feed (movement) parameter (mm/min or in/min)
     "distance_mode",		# DISTANCEMODE		sets machine distance mode ('absolute' from 0,0 or 'incremental' from current position)
-    "rapid_move",		# boolean		when false, do not use rapid move (G0) to go to the next line chain, use a 'slow' (G1) move with laser
-				# 			power off (S0) (note that the first move - to the start of the first line chain - is still a rapid move)
+    "rapid_move",		# positive integer	when 0, no rapid moves, > 0, G0 moves to the next line chain (otherwise a slow G1 S0 move is used).
+				# 			(note that the first move - to the start of the first line chain - is always a rapid move)
+                                #                       This setting is overloaded for images: a number 'n' > 0 means, do a rapid (G0) move when skipping
+                                #                       more than 'n'mm
     "pixel_size",               # float                 sets image pixel size (in mm)
     "showimage"                 # boolean               show image used for conversion to gcode
 }
@@ -50,12 +53,13 @@ DEFAULT_SETTING 	= {
     "movement_speed": 		None,		# MANDATORY
     "laser_power": 		1000,		# default set to 1
     "laser_mode": 		"dynamic",	# default set to dynamic (M4 safest mode, laser is off when not moving)
-    "maximum_image_laser_power":None,           # MANDATORY should be ("maximum_laser_power" - "minimum_laser_power" / 3)
+    "maximum_image_laser_power":None,           # MANDATORY should be ("maximum_laser_power" - "minimum_laser_power" / 3 for a 5W laser)
     "image_movement_speed":     None,           # MANDATORY
+    "image_noise":              0,              # default set to not reduces images noise')
     # Configuration
     "unit": 			"mm",		# default set to milimeters
     "distance_mode": 		"absolute",	# default set to absolute
-    "rapid_move":		True,		# default set to true
+    "rapid_move":		10,		# default set to true, for images do a rapid move when skipping more than 10mm
     "pixel_size":               0.1,            # laser kerf is mostly < 0.1mm
     "showimage":                False           # default image is not shown
 }
@@ -84,7 +88,7 @@ def check_setting(setting: dict[str,Any] =None) -> bool:
             raise ValueError(f"Unknown '{key}' value '{setting[key]}'. Please specify one of the following: {{True,False}}")
         if key in {"minimum_laser_power","maximum_laser_power","x_axis_maximum_rate","y_axis_maximum_rate", "movement_speed",
                    "x_axis_maximum_travel","y_axis_maximum_travel", "maximum_image_laser_power",
-                   "image_movement_speed","laser_power" } and (not isinstance(setting[key],int) or setting[key] < 0):
+                   "image_movement_speed","laser_power","rapid_move" } and (not isinstance(setting[key],int) or setting[key] < 0):
             raise ValueError(f"'{key}' has type {type(setting[key])} and value {setting[key]}, but should be of type {type(1)} and have a value >= 0")
         # Toolparameters
         if key in {"pass_depth","dwell_time"}:
@@ -98,8 +102,6 @@ def check_setting(setting: dict[str,Any] =None) -> bool:
             raise ValueError(f"Unknown '{key}' value '{setting[key]}'. Please specify one of the following: {UNITS}")
         if key == "distance_mode" and setting[key] not in DISTANCEMODE:
             raise ValueError(f"Unknown '{key}' value '{setting[key]}'. Please specify one of the following: {DISTANCEMODE}")
-        if key == "rapid_move" and setting[key] not in {True,False}:
-            raise ValueError(f"Unknown '{key}' value '{setting[key]}'. Please specify one of the following: {{True,False}}")
         if key in {"fan","showimage"} and setting[key] not in {True,False}:
             raise ValueError(f"Unknown '{key}' value '{setting[key]}'. Please specify one of the following: {{True,False}}")
         if key == "pixel_size" and setting[key] and (not isinstance(setting[key],(float)) or setting[key] <= 0):

{svg2gcode-1.2.0 → svg2gcode-2.1.0}/svg2gcode/svg_to_gcode/compiler/_compiler.py

@@ -126,7 +126,7 @@ class Compiler:
         Assembles the code in the header, body and footer.
         """
 
-        header_gc = ["M5","M8", "M4"]
+        header_gc = ["M5","M8", 'M3' if self.settings["laser_mode"] == "constant" else 'M4']
         # laser off, fan off, program stop
         footer_gc = ["M5","M9","M2"]
 
@@ -250,11 +250,17 @@ class Compiler:
 
         # convert image to new size
         if img is not None:
-            img = img.resize((int(float(img_attrib['width']) * 1/float(pixelsize)), int(float(img_attrib['height']) * 1/float(pixelsize))), Image.Resampling.LANCZOS)
+            # add alpha channel
+            img = img.convert("RGBA")
+
+            # create a white background and add it to the image
+            img_background = Image.new(mode = "RGBA", size = img.size, color = (255,255,255))
+            img = Image.alpha_composite(img_background, img)
+
+            # convert image to black&white (without alpha) and new size #reminder: 'img = img.convert("LA")'
+            img = img.resize((int(float(img_attrib['width']) * 1/float(pixelsize)),
+                            int(float(img_attrib['height']) * 1/float(pixelsize))), Image.Resampling.LANCZOS).convert("L")
 
-            # convert to B&W without alpha
-            #img = img.convert("LA")
-            img = img.convert("L")
             if self.settings['showimage']:
                 img.show()
 
@@ -263,6 +269,14 @@ class Compiler:
 
         return None
 
+    def distance(self, A: (float,float),B: (float,float)):
+        """
+        Does Pythagoras
+        """
+        # |Ax - Bx|^2 + |Ay - By|^2 = C^2
+        # distance = √C^2
+        return math.sqrt(abs(A[0] - B[0])**2 + abs(A[1] - B[1])**2)
+
     def image2gcode(self, img_attrib: dict[str, Any], img=None, transformation = None):
 
         invert_intensity = True
@@ -272,9 +286,12 @@ class Compiler:
         pixelsize = img_attrib['gcode_pixelsize'] if 'gcode_pixelsize' in img_attrib else self.settings["pixel_size"]
         maxpower = img_attrib['gcode_maxpower'] if 'gcode_maxpower' in img_attrib else self.settings["maximum_image_laser_power"]
         speed = img_attrib['gcode_speed'] if 'gcode_speed' in img_attrib else self.settings["image_movement_speed"]
+        noise = img_attrib['gcode_noise'] if 'gcode_noise' in img_attrib else self.settings["image_noise"]
+        speedmoves = img_attrib['gcode_speedmoves'] if 'gcode_speedmoves' in img_attrib else self.settings["rapid_move"]
 
         # set header for this image
-        self.gcode += [f"; image name: {img_attrib['id']}, pixelsize: {pixelsize}, speed: {speed}, maxpower: {maxpower}\n;"]
+        self.gcode += [f"; image name: {img_attrib['id']}, pixelsize: {pixelsize}, speed: {speed},\n"
+                       f';             maxpower: {maxpower}, speedmoves {speedmoves}, noise level {noise}\n;\n']
 
         # set X/Y-axis precision to number of digits after the decimal separator
         XY_prec = len(str(pixelsize).split('.')[1])
@@ -304,6 +321,9 @@ class Compiler:
         #
         left2right = True
 
+        # current location of laser head
+        head = (X,Y)
+
         # start print
         for line in img:
 
@@ -322,40 +342,63 @@ class Compiler:
             # Note also that drawing form left to right differs subtly from the reverse
 
             # draw this pixel line
-            #for count, bw in np.ndenumerate(line):
             for count, pixel in enumerate(line):
                 # power proportional to maximum laser power
                 laserpow = round((1.0 - float(pixel/255)) * maxpower) if invert_intensity else round(float(pixel/255) * maxpower)
-                # delay emit first pixel (so all same power pixels can be emitted in one sweep)
+
                 if count == 0:
+                    # delay emit first pixel (so all same power pixels can be emitted in one sweep)
                     prev_pow = laserpow
+                    # set last head loaction on start of the line
+                    lastloc = (X,Y)
 
                 # draw points until change of power
                 if laserpow != prev_pow or count == line.size-1:
-                    if transformation is not None:
-                        XYt = transformation.apply_affine_transformation(Vector(X, Y))
-                        code = f"X{round(XYt[0],XY_prec)}Y{round(XYt[1],XY_prec)}"
-                        code += f"S{prev_pow}"
+                    if prev_pow > noise:
+                        code = ""
+                        if lastloc:
+                            # head is not at correct location, go there
+
+                            # Apply affine transformation (if needed)
+                            # (Note that an affine transformation does not necessarily preserve angles between
+                            #  lines or distances between points!)
+                            XYlastloc = (lastloc[0], lastloc[1]) if transformation is None else \
+                                        transformation.apply_affine_transformation(Vector(lastloc[0], lastloc[1]))
+
+                            XYhead = (head[0], head[1]) if transformation is None else \
+                                     transformation.apply_affine_transformation(Vector(head[0], head[1]))
+
+                            if speedmoves and (self.distance(XYhead,XYlastloc) > speedmoves):
+                                # fast
+                                code = f"G0 X{round(XYlastloc[0],XY_prec)}Y{round(XYlastloc[1],XY_prec)}\nG1\n"
+                            else:
+                                # normal speed
+                                code = f"X{round(XYlastloc[0],XY_prec)}Y{round(XYlastloc[1],XY_prec)}S0\n"
+
+                        # emit point
+                        if transformation is not None:
+                            XYt = transformation.apply_affine_transformation(Vector(X, Y))
+                            code += f"X{round(XYt[0],XY_prec)}Y{round(XYt[1],XY_prec)}S{prev_pow}"
+                        else:
+                            code += f"X{X}S{prev_pow}"
+                        self.gcode += [code]
+
+                        # head at this location
+                        head = (X,Y)
+                        lastloc = None
                     else:
-                        code = f"X{X}"
-                        code += f"S{prev_pow}"
-                    self.gcode += [code]
+                        # didn't move head to location, save it
+                        lastloc = (X,Y)
 
                     if count == line.size-1:
                         continue
-                    # if laserpow != prev_pow
-                    prev_pow = laserpow
+                    prev_pow = laserpow # if laserpow != prev_pow
 
                 # next point
                 X = round(X + (pixelsize if left2right else -pixelsize), XY_prec)
 
-            # go to next scan line
+            # next scan line (defer head movement: lazy head)
             Y = round(Y + pixelsize, XY_prec)
-            if transformation is not None:
-                XYt = transformation.apply_affine_transformation(Vector(X, Y))
-                self.gcode += [f"X{round(XYt[0],XY_prec)}Y{round(XYt[1],XY_prec)}S0"]
-            else:
-                self.gcode += [f"Y{Y}S0"]
 
             # change print direction
             left2right = not left2right

{svg2gcode-1.2.0 → svg2gcode-2.1.0}/svg2gcode/svg_to_gcode/svg_parser/_parser_methods.py

@@ -19,7 +19,7 @@ def _has_style(element: ElementTree.Element, key: str, value: str) -> bool:
     return element.get(key) == value or (element.get("style") and f"{key}:{value}" in element.get("style"))
 
 
-def add_viewbox_transformation(transformation: Transformation, transform_origin, vwbox):
+def add_viewbox_transformation(transformation: Transformation, transform_origin, vwbox, origin):
     """
     Transform SVG coordinate system to a math-cartesion coordinate system and correct its origin.
     When viewBox is missing the 'height' value of the viewport is used.
@@ -50,16 +50,28 @@ def add_viewbox_transformation(transformation: Transformation, transform_origin,
         # viewBox "width" and "height" represent the dimensions of the 'svg'
         # (a rectangle - left upper at (vwbox['x'],vwbox['y']) - in user space)
 
+        # Set origin back at viewbox position after flip updown and add
+        # the user specified origin.
+        # When no user origin is specified, this translation is skipped,
+        # which effectively places the viewbox lower left (mind you after
+        # flipupdown) at (0,0) (so the canvas has positive coordinates only).
+
+        # (transformations are in reverse order see 'Note' below)
+        if origin is not None and ((vwbox["x"] + origin[0]) or (vwbox["y"]  + origin[1])):
+            up_transformation.add_translation(vwbox["x"] + origin[0],vwbox["y"] + origin[1])
+
         # Note: If A and B are the matrices of two linear transformations, then the effect of first applying A and then B
         # to a column vector x is given by B(Ax) == (BA)x
         # So, in the below case, transformation order is 'scale' first and 'translation' second.
+
+        # this effectively does a flip updown to set a carthesian coordinate system (origin at bottom left) gcode uses
         up_transformation.add_translation(0, vwbox["height"])       # Translation
         up_transformation.add_scale(1, -1)                          # T * Scale
         # applying it to a vector:                                  # T * S * Vector(x,y)
 
         # viewBox "x" and "y" represent the upper left corner of the document.
-        # when non zero, the upper left corner should be corrected to (0,0)
-        # (a laser or CNC machine has a positive workarea only, which should be as large as possible)
+        # when non zero, the upper left corner should be corrected to (0,0) for
+        # the above flip updown to work correctly
         if vwbox["x"] or vwbox["y"]:
             up_transformation.add_translation(-vwbox["x"],-vwbox["y"])
 
@@ -97,7 +109,7 @@ def get_viewBox(root: ElementTree.Element) -> {}:
 
 
 def parse_root(root: ElementTree.Element, transform_origin=True, viewbox=None, draw_hidden=False,
-               visible_root=True, root_transformation=None) -> List[Curve]:
+               visible_root=True, root_transformation=None, origin=None) -> List[Curve]:
 
     """
     Recursively parse an etree root's children into geometric curves.
@@ -109,6 +121,7 @@ def parse_root(root: ElementTree.Element, transform_origin=True, viewbox=None, d
     :param transform_origin: Whether or not to transform input coordinates from the svg coordinate system to standard
     cartesian system. Depends on viewBox height for calculations.
     :param draw_hidden: Whether or not to draw hidden elements based on their display, visibility and opacity attributes.
+    :param origin: translate origin to (origin[0],origin[1]); when None set viewbox upper left to (0,0)
     :param visible_root: Specifies whether or the root is visible. (Inheritance can be overridden)
     :param root_transformation: Specifies whether the root's transformation. (Transformations are inheritable)
     :return: A list of geometric curves describing the svg. Use the Compiler sub-module to compile them to gcode.
@@ -153,7 +166,7 @@ def parse_root(root: ElementTree.Element, transform_origin=True, viewbox=None, d
         if draw_hidden or visible:
             if element.tag == "{%s}path" % NAMESPACES["svg"]:
                 path = Path(element.attrib['d'],
-                               add_viewbox_transformation(transformation, transform_origin, viewbox))
+                               add_viewbox_transformation(transformation, transform_origin, viewbox, origin))
                 curves.extend(path.curves)
             else:
                 if element.tag == "{%s}image" % NAMESPACES["svg"]:
@@ -161,45 +174,47 @@ def parse_root(root: ElementTree.Element, transform_origin=True, viewbox=None, d
 
                     # instantiate curve (image)
                     ri = RasterImage(element.attrib, element.attrib["{%s}href" % NAMESPACES["xlink"]],
-                                add_viewbox_transformation(transformation, transform_origin, viewbox))
+                                add_viewbox_transformation(transformation, transform_origin, viewbox, origin))
                     curves.append(ri)
 
         # Continue the recursion
-        curves.extend(parse_root(element, transform_origin, viewbox, draw_hidden, visible, transformation))
+        curves.extend(parse_root(element, transform_origin, viewbox, draw_hidden, visible, transformation, origin))
 
     # ToDo implement shapes class
     return curves
 
 
-def parse_string(svg_string: str, transform_origin=True, viewbox=None, draw_hidden=False) -> List[Curve]:
+def parse_string(svg_string: str, transform_origin=True, viewbox=None, draw_hidden=False, delta_origin=None) -> List[Curve]:
     """
-        Recursively parse an svg string into geometric curves. (Wrapper for parse_root)
-
-        :param svg_string: The etree element who's children should be recursively parsed. The root will not be drawn.
-        :param viewbox: ViewBox of the SVG, used to transform it to a math-cartesion coordinate system and
-        correct its origin. When the viewBox is missing the viewport (of the root) is used. If the root
-        does not contain a viewBox or viewport, it must be either manually specified or transform must be False.
-        :param transform_origin: Whether or not to transform input coordinates from the svg coordinate system to standard cartesian
-         system. Depends on canvas_height for calculations.
-        :param draw_hidden: Whether or not to draw hidden elements based on their display, visibility and opacity attributes.
-        :return: A list of geometric curves describing the svg. Use the Compiler sub-module to compile them to gcode.
+    Recursively parse an svg string into geometric curves. (Wrapper for parse_root)
+
+    :param svg_string: The etree element who's children should be recursively parsed. The root will not be drawn.
+    :param viewbox: ViewBox of the SVG, used to transform it to a math-cartesion coordinate system and
+     correct its origin. When the viewBox is missing the viewport (of the root) is used. If the root
+     does not contain a viewBox or viewport, it must be either manually specified or transform must be False.
+    :param transform_origin: Whether or not to transform input coordinates from the svg coordinate system to standard cartesian
+     system. Depends on canvas_height for calculations.
+    :param draw_hidden: Whether or not to draw hidden elements based on their display, visibility and opacity attributes.
+    :pram origin: translate origin to (origin[0],origin[1]), when None set viewbox upper left to (0,0)
+    :return: A list of geometric curves describing the svg. Use the Compiler sub-module to compile them to gcode.
     """
     root = ElementTree.fromstring(svg_string)
-    return parse_root(root, transform_origin, viewbox, draw_hidden)
+    return parse_root(root, transform_origin, viewbox, draw_hidden, origin=delta_origin)
+
 
+def parse_file(file_path: str, transform_origin=True, viewbox=None, draw_hidden=False, delta_origin=None) -> List[Curve]:
+    """
+    Recursively parse an svg file into geometric curves. (Wrapper for parse_root)
 
-def parse_file(file_path: str, transform_origin=True, viewbox=None, draw_hidden=False) -> List[Curve]:
+    :param file_path: The etree element who's children should be recursively parsed. The root will not be drawn.
+    :param viewbox: ViewBox of the SVG, used to transform it to a math-cartesion coordinate system and
+     correct its origin. When the viewBox is missing the viewport (of the root) is used. If the root
+     does not contain a viewBox or viewport, it must be either manually specified or transform must be False.
+    :param transform_origin: Whether or not to transform input coordinates from the svg coordinate system to standard cartesian
+     system. Depends on canvas_height for calculations.
+    :param draw_hidden: Whether or not to draw hidden elements based on their display, visibility and opacity attributes.
+    :param origin: translate origin to (origin[0],origin[1]), when None set viewbox upper left to (0,0)
+    :return: A list of geometric curves describing the svg. Use the Compiler sub-module to compile them to gcode.
     """
-            Recursively parse an svg file into geometric curves. (Wrapper for parse_root)
-
-            :param file_path: The etree element who's children should be recursively parsed. The root will not be drawn.
-            :param viewbox: ViewBox of the SVG, used to transform it to a math-cartesion coordinate system and
-            correct its origin. When the viewBox is missing the viewport (of the root) is used. If the root
-            does not contain a viewBox or viewport, it must be either manually specified or transform must be False.
-            :param transform_origin: Whether or not to transform input coordinates from the svg coordinate system to standard cartesian
-             system. Depends on canvas_height for calculations.
-            :param draw_hidden: Whether or not to draw hidden elements based on their display, visibility and opacity attributes.
-            :return: A list of geometric curves describing the svg. Use the Compiler sub-module to compile them to gcode.
-        """
     root = ElementTree.parse(file_path).getroot()
-    return parse_root(root, transform_origin, viewbox, draw_hidden)
+    return parse_root(root, transform_origin, viewbox, draw_hidden, origin=delta_origin)

svg2gcode-1.2.0/README.md

@@ -1,69 +0,0 @@
-# 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) which should be installed <sup>(*)</sup>.
-
-Drawings and images can be composed using Inkscape (for example) and saved to a .svg file. This file can 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.
-
-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``` and ```gcode_speed``` can be set per object (they must be created: use **+**). Note that this overrides explicit or default commandline settings.
-
-**Tip**: use commandline program grblhud (https://github.com/johannesnoordanus/grblhud) to have full control over gcode execution.  
-### Install:
-```
-> 
-> pip install svg2gcode
-```
-<sup>(*)</sup> Note that library *svg_to_gcode* is included in this package. 
-### Usage:
-See notes below.
-```
-$ svg2gcode --help
-usage: svg2gcode.py [-h] [--showimage] [--pixelsize <default:0.1>] [--imagespeed <default:800>] [--cuttingspeed <default:1000>] [--imagepower <default:300>]
-                    [--cuttingpower <default:0.85>] [--maxlaserpower <default:1000>] [--rapidmove] [--xmaxtravel <default:300>] [--ymaxtravel <default:400>] [--fan] [-V]
-                    svg gcode
-
-Convert svg to gcode for GRBL v1.1 compatible diode laser engravers.
-
-positional arguments:
-  svg                   svg file to be converted to gcode
-  gcode                 gcode output file
-
-options:
-  -h, --help            show this help message and exit
-  --showimage           show b&w converted image
-  --pixelsize <default:0.1>
-                        pixel size in mm (XY-axis): each image pixel is drawn this size
-  --imagespeed <default:800>
-                        image draw speed in mm/min
-  --cuttingspeed <default:1000>
-                        cutting speed in mm/min
-  --imagepower <default:300>
-                        maximum laser power while drawing an image (as a rule of thumb set to 1/3 of the machine maximum)
-  --cuttingpower <default:850>
-                        sets laser power of line drawings/cutting
-  --rapidmove           generate inbetween G0 moves
-  --xmaxtravel <default:300>
-                        machine x-axis lengh in mm
-  --ymaxtravel <default:400>
-                        machine y-axis lengh in mm
-  --fan                 set machine fan on
-  -V, --version         show version number and exit
-```
-### Notes:
-  - example command to create two types of gcode file, one containing the drawings of the .svg, the other containing the images:      
-```
-  > svg2gcode ambachtmanlogo.svg logo.gc
-  > ..
-  > ls *.gc 
-  > logo.gc             # all drawings
-  > logo_images.gc      # all images
-```   
- - drawing objects - within the composer - must be converted to a```path```to be translated to a gcode sequence
- - also, image objects should **not** be converted to a ```path```
- - images must be linked or embedded using base64.
- - images can be in several formats (my tests included ```.png``` and  ```.jpg``` image files)
-
-

svg2gcode-1.2.0/svg2gcode/README.md

@@ -1,69 +0,0 @@
-# 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) which should be installed <sup>(*)</sup>.
-
-Drawings and images can be composed using Inkscape (for example) and saved to a .svg file. This file can 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.
-
-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``` and ```gcode_speed``` can be set per object (they must be created: use **+**). Note that this overrides explicit or default commandline settings.
-
-**Tip**: use commandline program grblhud (https://github.com/johannesnoordanus/grblhud) to have full control over gcode execution.  
-### Install:
-```
-> 
-> pip install svg2gcode
-```
-<sup>(*)</sup> Note that library *svg_to_gcode* is included in this package. 
-### Usage:
-See notes below.
-```
-$ svg2gcode --help
-usage: svg2gcode.py [-h] [--showimage] [--pixelsize <default:0.1>] [--imagespeed <default:800>] [--cuttingspeed <default:1000>] [--imagepower <default:300>]
-                    [--cuttingpower <default:0.85>] [--maxlaserpower <default:1000>] [--rapidmove] [--xmaxtravel <default:300>] [--ymaxtravel <default:400>] [--fan] [-V]
-                    svg gcode
-
-Convert svg to gcode for GRBL v1.1 compatible diode laser engravers.
-
-positional arguments:
-  svg                   svg file to be converted to gcode
-  gcode                 gcode output file
-
-options:
-  -h, --help            show this help message and exit
-  --showimage           show b&w converted image
-  --pixelsize <default:0.1>
-                        pixel size in mm (XY-axis): each image pixel is drawn this size
-  --imagespeed <default:800>
-                        image draw speed in mm/min
-  --cuttingspeed <default:1000>
-                        cutting speed in mm/min
-  --imagepower <default:300>
-                        maximum laser power while drawing an image (as a rule of thumb set to 1/3 of the machine maximum)
-  --cuttingpower <default:850>
-                        sets laser power of line drawings/cutting
-  --rapidmove           generate inbetween G0 moves
-  --xmaxtravel <default:300>
-                        machine x-axis lengh in mm
-  --ymaxtravel <default:400>
-                        machine y-axis lengh in mm
-  --fan                 set machine fan on
-  -V, --version         show version number and exit
-```
-### Notes:
-  - example command to create two types of gcode file, one containing the drawings of the .svg, the other containing the images:      
-```
-  > svg2gcode ambachtmanlogo.svg logo.gc
-  > ..
-  > ls *.gc 
-  > logo.gc             # all drawings
-  > logo_images.gc      # all images
-```   
- - drawing objects - within the composer - must be converted to a```path```to be translated to a gcode sequence
- - also, image objects should **not** be converted to a ```path```
- - images must be linked or embedded using base64.
- - images can be in several formats (my tests included ```.png``` and  ```.jpg``` image files)
-
-