svg2gcode 3.3.2__tar.gz → 3.3.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: svg2gcode
-Version: 3.3.2
+Version: 3.3.5
 Summary: svg2gcode: convert an SVG (Scalable Vector Graphic) image to gcode.
 Keywords: scalable vector graphics,svg,image,laser cutter,laser engraving
 Author-email: Johannes Noordanus <mailjohannes.mailnoordanus@gmail.com>
@@ -14,7 +14,7 @@ Project-URL: Home, https://github.com/johannesnoordanus/svg2gcode
 
 # svg2gcode
 
-*svg2gcode* is a *WYSIWYG* converter of Scalable Vector Graphic *(SVG)* drawings. It is based on library *SvgToGcode* (*fork*: *https://github.com/johannesnoordanus/SvgToGcode*)<sup>(*)</sup>.
+*svg2gcode* is a *WYSIWYG* converter of Scalable Vector Graphic *(SVG)* drawings. It is based on library *SvgToGcode* (*https://github.com/johannesnoordanus/SvgToGcode*)<sup>(*)</sup>.
 
 Drawings and images can be composed using Inkscape (or other *SVG* image software), saved to a *.svg* file and - *WYSIWYG* - converted to gcode.
 Color coding can be used to mark what part(s) of the drawing to cut, engrave or even ignore.
@@ -31,13 +31,16 @@ More info can be obtained by looking at the documentation and examples below and
 
 *svg2gcode* has three related programs: *image2gcode* mentioned above has similar capabilities but handles raster image files (like *png* and *jpg*) directly, *gcode2image* performs the inverse function and is capable of showing multiple writes (burns) to the same location and last *grblhud* which gives full control over gcode execution.
 
+<sup>(*)</sup> Note that an upgraded and corrected version of this library is included.
+
  -----
 
 Please consider supporting me, so I can make this application better and add new functionality to it: <http://paypal.me/johannesnoordanus/5,00>
 
 My next update will add *fill-rule* 'nonzero' (see information on *fill-rule* below).
 
-<sup>(*)</sup> Note that an upgraded and corrected version of this library is included. 
+ -----
+
 ### Supported SVG elements and attributes
 
 *SVG* *path* and *image* elements (specific: ```<svg:path ..>```tags and images```<svg:image ..>```tags) are supported. Other drawing objects must be converted to a *path* first to be able to translate them to a gcode sequence.
@@ -45,6 +48,41 @@ My next update will add *fill-rule* 'nonzero' (see information on *fill-rule* be
 Attributes *stroke* (color), *stroke-width*, *stroke_alpha*, *fill* (color), *fill-rule*, *fill_alpha* are supported.
 Currently only value *evenodd* of *fill-rule* is supported.
 
+### *WYSIWYG*
+
+As seen above, not all *svg* elements are directly supported, but they are after a *path* conversion within the composer (Inkscape: ```menu Path->Object/Stroke to Path```). Without a *path* conversion *svg2gcode* simply ignores all elements except *path* and *image*. Text (fonts) require another step after *selecting* all text and clicking menu ```Object to Path```. Clicking menu```Object->Ungroup``` <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.) 
+
+You can use *gcode2image* to check the conversion result:
+```
+> svg2gcode some.svg some.gc
+> gcode2image --showimage --flip --grid --showorigin some.gc some.png
+```
+The image shown should be the same as the one shown by the composer (Inkscape). This is also a good way to measure the conversion result. Note that ```--grid``` and ```--showorigin``` can give some inteference. To be sure run *gcode2image* without them.
+
+#### 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).
+
+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
+```
+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```)
+
+#### Notes
+
+ - drawing objects - within the composer - must be converted to a```path```to be translated to a gcode sequence
+ - image objects should **not** be converted to a ```path```
+ - images must be linked or embedded using base64 (Inkscape default).
+ - images can be in several formats (my tests included *.png* and  *.jpg* image files)
+ - *SVG* source documents must be in unit 'mm' and set to ```1 'user unit' is 1 mm``` (Inkscape default)
+
+<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```.
+
 ### Important Commandline options
 
 Option ```--color_coded``` can be used to specify what part(s) of the drawing to cut, engrave or even ignore. 
@@ -90,7 +128,7 @@ Note that engraving is the default action, so if option *color_coded* isn't set
 
 This makes it possible to make a drawing where all path elements are drawn in their respective colors to make an engraving of the entire vector drawing.
 When you set the engrave action for a set of colors, only those colors will be engraved (having their respective colors), all other paths having no action set are ignored.
-Also, when a path has no stroke attribute (or it is set to none) the element cannot be engraved (because it has no color) so it is interpreted as a cut action.
+Also, when a path has no stroke attribute (or it is set to none) the element cannot be engraved (because it has no color) so it is ignored.
 
 Option ```--pathcut``` can be used to override all stroke attributes and force cutting of all *paths* of the *SVG*.
 Note that this option cannot be set at the same time as *--color_coded* above.
@@ -121,7 +159,6 @@ General optimizations
 - borders are drawn in parallel and in one go, following the *path* coordinates.
 - fill has support for alpha channel and 'fill-opacity'
  
-
 ### Install:
 ```
 > 
@@ -293,11 +330,8 @@ Note: to get options and defaults:
     > svg2gcode --help
 ```
 #### How do we cut these lines?
-Change the *style* attribute line - within file *line_hoek.svg* - to the following:
-```
-    style="fill:none;stroke:none;stroke-width:.1"
-```
-or add 'gcode-pathcut' to the style string: 
+
+Add 'gcode-pathcut' to the style string: 
 ```
     style="fill:none;stroke:red;stroke-width:.1;gcode-pathcut:true"
 ```
@@ -347,10 +381,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.
 
-### Notes:
- - drawing objects - within the composer - must be converted to a```path```to be translated to a gcode sequence
- - also, image objects should **not** be converted to a ```path```
- - images must be linked or embedded using base64.
- - images can be in several formats (my tests included *.png* and  *.jpg* image files)
- - SVG source documents must be in unit 'mm' (and set to 1 'user unit' is 1 mm) which is the default for Inkscape (check document settings and look at the 'scaling' parameter)
 

{svg2gcode-3.3.2 → svg2gcode-3.3.5}/README.md

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

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

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

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

@@ -19,6 +19,7 @@ from svg2gcode.svg_to_gcode import DEFAULT_SETTING
 from svg2gcode.svg_to_gcode import TOLERANCES, SETTING, check_setting
 
 from svg2gcode.svg_to_gcode import css_color
+from svg2gcode.svg_to_gcode.svg_parser import NAMESPACES, ElementTree_MY_PARENT
 
 from svg2gcode import __version__
 
@@ -481,6 +482,25 @@ class Compiler:
         if 'gcode_pathcut' in curve.path_attrib:
             style['pathcut'] = curve.path_attrib['gcode_pathcut']
 
+        # check missing attributes, if any
+        if ElementTree_MY_PARENT in curve.path_attrib:
+            parent = curve.path_attrib[ElementTree_MY_PARENT]
+
+            # find first parent g (group) tag, if any
+            while parent and parent.tag != "{%s}g" % NAMESPACES["svg"]:
+                if ElementTree_MY_PARENT in parent.attrib:
+                    parent = parent.attrib[ElementTree_MY_PARENT]
+                else:
+                    parent = None
+            if parent:
+                # fill in missing attribues, if any
+                for key, value in style.items():
+                    if not value and key in ['fill', 'fill-rule', 'fill-opacity', 'stroke', 'stroke-width', 'stroke-opacity']:
+                        # get missing attribute (if any)
+                        if key in parent.attrib:
+                            attrib = parent.attrib[key]
+                            if attrib and attrib != 'none':
+                                style[key] = attrib
         return style
 
     def color_coded_paths(self, set_color_coded = False) -> ():

{svg2gcode-3.3.2 → svg2gcode-3.3.5}/svg2gcode/svg_to_gcode/svg_parser/__init__.py

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

{svg2gcode-3.3.2 → svg2gcode-3.3.5}/svg2gcode/svg_to_gcode/svg_parser/_parser_methods.py

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