svg2gcode 3.0.3__tar.gz → 3.2.1__tar.gz

{svg2gcode-3.0.3 → svg2gcode-3.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: svg2gcode
-Version: 3.0.3
+Version: 3.2.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>
@@ -9,7 +9,7 @@ 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.6
+Requires-Dist: image2gcode >= 2.9.8
 Project-URL: Home, https://github.com/johannesnoordanus/svg2gcode
 
 # svg2gcode
@@ -41,12 +41,16 @@ See options ```--speedmoves``` and ```--noise``` for example.
 Version 3.0.0 and higher have support for 'stroke' (color) and 'stroke-width' attributes, this means that cutting a path works a bit different now. 
 When the *stroke* attribute of a *path* is nonexistent or set to none, the path will be laser burned with the value set by option *--cuttingpower*.
 
+Version 3.1.0 and higher have support for 'fill' (color) and 'fill-rule' attributes. Currently only fill rule 'evenodd' is supported.
+
 Also, *svg2gcode* option ```--pathcut``` can be used to override all stroke attributes and force cutting of all *paths* of the SVG.
-But, see the examples below.
+Option ```--nofill``` (not set by default) is added to disable path fills.
 
+More info can be obtained by looking at the examples below and from program *image2gcode* and its documentation (for example about callibrating laser engravers).  
+ 
 Please consider supporting me, so I can make this application better and add new functionality to it: <http://paypal.me/johannesnoordanus/5,00>
 
-My next update will be a major one, I'll add support for the *fill* attribute of SVG objects.
+My next update will add fill-rule 'nonzero'.
 
 
 To summarize:
@@ -64,6 +68,7 @@ General optimizations
 - 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*
 - borders are drawn in parallel and in one go, following the *path* coordinates.
+- fill has support for alpha channel and 'fill-opacity'
  
 **Tip**: use commandline program *grblhud* *(https://github.com/johannesnoordanus/grblhud)* to have full control over gcode execution,
 also, program *image2gcode* has similar capabilities but handles raster images files (like *png* and *jpg*) directly. 
@@ -124,6 +129,7 @@ options:
   --rotate <default:0>  number of degrees to rotate
   --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
   --xmaxtravel <default:300>
                         machine x-axis lengh in mm
   --ymaxtravel <default:400>

{svg2gcode-3.0.3 → svg2gcode-3.2.1}/README.md

@@ -27,12 +27,16 @@ See options ```--speedmoves``` and ```--noise``` for example.
 Version 3.0.0 and higher have support for 'stroke' (color) and 'stroke-width' attributes, this means that cutting a path works a bit different now. 
 When the *stroke* attribute of a *path* is nonexistent or set to none, the path will be laser burned with the value set by option *--cuttingpower*.
 
+Version 3.1.0 and higher have support for 'fill' (color) and 'fill-rule' attributes. Currently only fill rule 'evenodd' is supported.
+
 Also, *svg2gcode* option ```--pathcut``` can be used to override all stroke attributes and force cutting of all *paths* of the SVG.
-But, see the examples below.
+Option ```--nofill``` (not set by default) is added to disable path fills.
 
+More info can be obtained by looking at the examples below and from program *image2gcode* and its documentation (for example about callibrating laser engravers).  
+ 
 Please consider supporting me, so I can make this application better and add new functionality to it: <http://paypal.me/johannesnoordanus/5,00>
 
-My next update will be a major one, I'll add support for the *fill* attribute of SVG objects.
+My next update will add fill-rule 'nonzero'.
 
 
 To summarize:
@@ -50,6 +54,7 @@ General optimizations
 - 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*
 - borders are drawn in parallel and in one go, following the *path* coordinates.
+- fill has support for alpha channel and 'fill-opacity'
  
 **Tip**: use commandline program *grblhud* *(https://github.com/johannesnoordanus/grblhud)* to have full control over gcode execution,
 also, program *image2gcode* has similar capabilities but handles raster images files (like *png* and *jpg*) directly. 
@@ -110,6 +115,7 @@ options:
   --rotate <default:0>  number of degrees to rotate
   --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
   --xmaxtravel <default:300>
                         machine x-axis lengh in mm
   --ymaxtravel <default:400>

{svg2gcode-3.0.3 → svg2gcode-3.2.1}/pyproject.toml

@@ -14,7 +14,7 @@ keywords = ["scalable vector graphics", "svg", "image", "laser cutter", "laser e
 dependencies = [
     "numpy >= 1.24.3",
     "Pillow >= 9.5.0",
-    "image2gcode >= 2.9.6",
+    "image2gcode >= 2.9.8",
 ]
 requires-python = ">=3.7"
 

{svg2gcode-3.0.3 → svg2gcode-3.2.1}/svg2gcode/__init__.py

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

{svg2gcode-3.0.3 → svg2gcode-3.2.1}/svg2gcode/__main__.py

@@ -37,7 +37,7 @@ 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,
-               'image_poweroffset':args.poweroffset, 'image_overscan':args.overscan, 'image_showoverscan':args.showoverscan})
+               'nofill':args.nofill, 'image_poweroffset':args.poweroffset, 'image_overscan':args.overscan, 'image_showoverscan':args.showoverscan})
 
     compiler = init_compiler(args)
 
@@ -138,6 +138,7 @@ def main() -> int:
         type=int, help="number of degrees to rotate")
     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('--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"])+ ">",
@@ -147,18 +148,18 @@ def main() -> int:
 
     args = parser.parse_args()
 
-    try:
-        if args.origin is not None and args.selfcenter:
-            print("options --selfcenter and --origin cannot be used at the same time, program abort")
-            return 1
-
-        return svg2gcode(args)
-    except KeyboardInterrupt:
-        print(f"svg2gcode aborted!")
-    except Exception as error:
-        print(error)
-
-    return 1
+##    try:
+    if args.origin is not None and args.selfcenter:
+        print("options --selfcenter and --origin cannot be used at the same time, program abort")
+        return 1
+
+    return svg2gcode(args)
+####    except KeyboardInterrupt:
+##        print(f"svg2gcode aborted!")
+##    except Exception as error:
+##        print(error)
+##
+##    return 1
 
 if __name__ == '__main__':
     sys.exit(main())

{svg2gcode-3.0.3 → svg2gcode-3.2.1}/svg2gcode/svg_to_gcode/__init__.py

@@ -39,7 +39,8 @@ SETTING 	= {
     "pixel_size",               # float                 sets image pixel size (in mm)
     "showimage",                # boolean               show image used for conversion to gcode
     "splitfile",                # boolean               return SVG path objects to <filename>.<gcext> and SVG image objects to <filename>_images.<gcext>
-    "pathcut"                   # boolean               always cut SVG path objects! use laser_power setting
+    "pathcut",                  # boolean               always cut SVG path objects! use laser_power setting
+    "nofill"                    # boolean               ignore SVG fill attribute
 }
 
 # Set defaults 'minimum_laser_power', 'pass_depth', 'dwell_time', 'laser_power', 'laser_mode', 'unit', 'distance_mode'
@@ -71,8 +72,9 @@ DEFAULT_SETTING 	= {
     "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
-    "splitfile":                False,           # SVG path and image objects are emitted to one file: <filename>.<gcext>
-    "pathcut":                  False           # always cut SVG path objects! use laser_power setting
+    "splitfile":                False,          # SVG path and image objects are emitted to one file: <filename>.<gcext>
+    "pathcut":                  False,          # always cut SVG path objects! use laser_power setting
+    "nofill":                   False           # ignore SVG fill attribute
 }
 
 def check_setting(setting: dict[str,Any] =None) -> bool:
@@ -114,7 +116,7 @@ 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 in {"fan","showimage","splitfile","pathcut","image_showoverscan"} and setting[key] not in {True,False}:
+        if key in {"fan","showimage","splitfile","pathcut","nofill","image_showoverscan"} 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):
             raise TypeError(f"'{key}' is of type '{type(setting[key])}' but should be of type {type(1.0)} and have a value > 0.0")

{svg2gcode-3.0.3 → svg2gcode-3.2.1}/svg2gcode/svg_to_gcode/compiler/_compiler.py

@@ -8,6 +8,8 @@ from io import BytesIO
 from typing import Any
 
 import base64
+from PIL import Image
+from skimage.draw import line as drawline
 import numpy as np
 
 from svg2gcode.svg_to_gcode.compiler.interfaces import Interface
@@ -210,64 +212,6 @@ class Compiler:
                     file.write((self.gcode_file_header() if len(self.body) == 0 else "") + '\n' +  self.compile_images() + '\n' + self.interface.program_end() + '\n')
                     logger.info(f"Added image(s) to {file_name}")
 
-    def orthogonal_offset(self, offset: float, line: Line) -> Line:
-
-        def offset_direction(line: Line) -> (int,int):
-            d_x = (line.end.x - line.start.x)
-            d_y = (line.end.y - line.start.y)
-            direction = (0,0)
-
-            if d_x > 0 and d_y > 0:
-                direction = (-1,1)
-            elif d_x > 0 and d_y == 0:
-                direction = (0,1)
-            elif d_x < 0 and d_y == 0:
-                direction = (0,-1)
-            elif d_x < 0 and d_y < 0:
-                direction = (1,-1)
-            elif d_x == 0 and d_y < 0:
-                direction = (1,0)
-            elif d_x == 0 and d_y > 0:
-                direction = (-1,0)
-            elif d_x > 0 and d_y < 0:
-                direction = (1,1)
-            elif d_x < 0 and d_y > 0:
-                direction = (-1,-1)
-
-            return direction
-
-        delta_sign = offset_direction(line)
-
-        # calculate ortogonal line vector((0,0),(delta_x,delta_y)) of 'offset' length:
-        # (1)  y = 1/slope * x
-        #
-        # of length offset:
-        # (2)  x^2 + y^2                = offset^2     (Pythagoras)
-        # (3)  x^2 + (1/slope * x)^2    = offset^2
-        # (4)  (1 + (1/slope)^2) * x^2  = offset^2
-        # (5)  x^2 = offset^2 / (1 + (1/slope)^2)
-
-        if line.slope == 0:
-            # vertical line
-            delta_x = 0
-            delta_y = delta_sign[1] * offset
-        elif line.slope == 1:
-            # horizontal line
-            delta_x = delta_sign[0] * offset
-            delta_y = 0
-        else:
-            # slope
-            inv_slope = abs((1/line.slope))
-            delta_x = round(math.sqrt((offset ** 2) / (1 + inv_slope ** 2)), self.precision)
-            delta_y = round(inv_slope * delta_x, self.precision)
-
-            # set right direction
-            delta_x = delta_sign[0] * (-1 if (offset < 0) else 1) * delta_x
-            delta_y = delta_sign[1] * (-1 if (offset < 0) else 1) * delta_y
-
-        # add delta vector to line start and end vectors
-        return Line(line.start + Vector(delta_x, delta_y), line.end + Vector(delta_x, delta_y), "offset")
-
     def append_line_chain(self, line_chain: LineSegmentChain, step: float, color: int = None):
         """
         Draws a LineSegmentChain by calling interface.linear_move() for each segment. The resulting code is appended to
@@ -400,42 +344,10 @@ class Compiler:
 
         return None
 
-    def distance(self, A: (float,float),B: (float,float)):
-        """
-        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 line_intersection(self, l1: Line, l2:Line) -> Vector:
-        """
-        Line intersection (https://en.wikipedia.org/wiki/Line–line_intersection)
-        """
-        x1, y1 = l1.start
-        x2, y2 = l1.end
-        x3, y3 = l2.start
-        x4, y4 = l2.end
-
-        # denomintor
-        d = round((x1 - x2)*(y3 - y4) - (y1 - y2)*(x3 - x4), self.precision)
-
-        # Note that the cutoff below is needed to eliminate line artifacts (spikes) of the render result.
-        # This is due to calculation (precision) errors resulting in the y coordinate of the intersection to
-        # be off by a factor (2,3, 10?). It might be that the rounding applied here is not correct, or/and
-        # that the equations are inherently sensitive to rounding errors at certain inputs.
-        # TODO: analize this
-        if abs(d) < 0.01:
-            # no intersection
-            return None
-
-        return Vector( round(((x1*y2 - y1*x2) * (x3 - x4) - (x1 - x2) * (x3*y4 - y3*x4))/d, self.precision),
-                       round(((x1*y2 - y1*x2) * (y3 - y4) - (y1  - y2) * (x3*y4 - y3*x4))/d, self.precision) )
-
-    def image2gcode(self, img_attrib: dict[str, Any], img=None, transformation = None):
+    def image2gcode(self, img_attrib: dict[str, Any], img=None, transformation = None, power = None):
 
         # create image conversion object
-        convert = Image2gcode(transformation = transformation.apply_affine_transformation if transformation is not None else None)
+        convert = Image2gcode(transformation = transformation.apply_affine_transformation if transformation is not None else None, power = power)
 
         #
         # set arguments
@@ -453,6 +365,7 @@ class Compiler:
         arguments["showoverscan"] = img_attrib['gcode_showoverscan'] if 'gcode_showoverscan' in img_attrib else self.settings["image_showoverscan"]
         arguments["offset"] = (float(img_attrib['x']), float(img_attrib['y']))
         arguments["name"] = img_attrib['id']
+        arguments["noinvert"] = img_attrib['noinvert'] if 'noinvert' in img_attrib else False
 
         # get image parameters
         params = ''
@@ -477,7 +390,7 @@ class Compiler:
         for example "fill:#F4CF84;fill-rule:evenodd;stroke:#D07735;"
         """
 
-        style = {'fill' : None, 'fill-rule': None, 'stroke': None, 'stroke-width': None, 'pathcut': None}
+        style = {'fill' : None, 'fill-rule': None, 'fill-opacity': None, 'stroke': None, 'stroke-width': None, 'pathcut': None}
 
         # parse style attribute
 
@@ -494,6 +407,11 @@ class Compiler:
                 fill_rule = re.search('fill-rule:#(evenodd|nonzero)',style_str)
                 if fill_rule:
                     style['fill-rule'] = re.search('(evenodd|nonzero)', fill_rule.group(0)).group(0)
+            # parse fill-opacity
+            if 'fill-opacity' in style_str:
+                fill_opacity = re.search('fill-opacity:(\d*\.)?\d+',style_str)
+                if fill_opacity:
+                    style['fill-opacity'] = re.search('(\d*\.)?\d+', fill_opacity.group(0)).group(0)
             # parse stroke
             if 'stroke' in style_str:
                 stroke = re.search('stroke:[^;]+;',style_str)
@@ -518,13 +436,17 @@ class Compiler:
             style['fill'] = curve.path_attrib['fill']
         if 'fill-rule' in curve.path_attrib:
             style['fill-rule'] = curve.path_attrib['fill-rule']
+        # parse fill-opacity
+        if 'fill-opacity' in curve.path_attrib:
+            fill_opacity = re.search('fill-opacity:(\d*\.)?\d+',curve.path_attrib)
+            if fill_opacity:
+                style['fill-opacity'] = re.search('(\d*\.)?\d+', fill_opacity.group(0)).group(0)
         # parse stroke attribute
         if 'stroke' in curve.path_attrib:
             style['stroke'] = curve.path_attrib['stroke']
         # parse stroke-width attribute
         if 'stroke-width' in curve.path_attrib:
             style['stroke-width'] = curve.path_attrib['stroke-width']
-
         # parse gcode_pathcut attribute
         if 'gcode_pathcut' in curve.path_attrib:
             style['pathcut'] = curve.path_attrib['gcode_pathcut']
@@ -535,7 +457,17 @@ class Compiler:
         """
         Draws curves.
         """
+
+        def draw_line(img: np.array, p1: (int,int), p2: (int,int), gray: int):
+            """
+            Draws a line.
+            """
+            pixel = 1/self.settings["pixel_size"]
+            yy, xx = drawline(int(p1[1]*pixel),int(p1[0]*pixel),int(p2[1]*pixel),int(p2[0]*pixel))
+            img[yy,xx] = gray
+
         path_curves = {}
+        pixel_size = float(self.settings["pixel_size"])
 
         for curve in curves:
             if isinstance(curve, RasterImage):
@@ -554,7 +486,7 @@ class Compiler:
 
                 curve_name_id = ""
                 # parse id
-                if curve.path_attrib:
+                if curve.path_attrib and 'id' in curve.path_attrib:
                     curve_name_id = curve.path_attrib['id']
 
                 if curve_name_id not in path_curves:
@@ -572,19 +504,24 @@ class Compiler:
                     # add line segments to curves having this id
                     path_curves[curve_name_id].append(line_chain)
 
+        # default stroke width is one line (thickness)
+        stroke_width = pixel_size
+
         # emit all paths (organized by name id)
         for name_id in path_curves:
-            # for all line chains
+            steps = []
+            fill_color = None
+            fill_rule = None
+            # set a boundingbox per 'name_id'
+            boundingbox = Boundingbox()
             for line_chain in path_curves[name_id]:
 
-                pixel_size = float(self.settings["pixel_size"])
                 # default stroke width is one line (thickness)
-                stroke_width = pixel_size
-
-                first_line_of_chain = line_chain.get(0)
-
                 width = 0
                 stroke_color = ""
+
+                # get style info for this line chain (of object 'name_id')
+                first_line_of_chain = line_chain.get(0)
                 style = self.parse_style_attribute(first_line_of_chain)
                 if style:
                     if not (style['pathcut'] == 'true' or self.settings["pathcut"]) \
@@ -592,62 +529,319 @@ class Compiler:
                         stroke_color = style['stroke']
                     if style['stroke-width'] is not None and style['stroke-width'] != "none":
                         stroke_width = float(style['stroke-width'])
-                        width = int(round(stroke_width/pixel_size, self.precision))
-
+                        width = math.ceil(round(stroke_width/pixel_size, self.precision)/2)
+                    if style['fill'] is not None:
+                        # Invert b&w value (beforehand) and apply alpha channel - when available - to inverted b&w value
+                        # Note that step 6 sets option 'noinvert' to be able to use the value below directly.
+                        fill_color = Image2gcode.linear_power(css_color.parse_css_color2bw8(style['fill']), self.settings["maximum_image_laser_power"])
+                        if style['fill-rule'] is not None:
+                            fill_rule = style['fill-rule']
+                            if fill_rule == "nonzero":
+                                logger.warn(f"fill-rule 'nonzero' of object '{name_id}' is currently unsupported!")
+                        if style['fill-opacity'] is not None:
+                            alpha = float(style['fill-opacity'])
+                            if not (alpha >=0 and alpha <= 1):
+                                logger.warn(f"Opacity value '{alpha}' should be in range [0.0..1.0]!")
+                                alpha = 1
+                        else:
+                            rgba = css_color.parse_css_color(style['fill'])
+                            alpha = 1
+                            if len(rgba) == 4:
+                                alpha = rgba[3]
+                        fill_color = fill_color * alpha
+
+                # get steps (offsets) for the lines that make the border
                 steps = [0]
                 if len(stroke_color) and width:
                     for delta in range(width):
                         if delta:
                             steps.append(round(delta * pixel_size, self.precision))
-                            if not (delta + 1 == width and width % 2 == 0):
+                            if not (delta == width and width % 2 != 0):
                                 steps.append(round(-delta * pixel_size, self.precision))
 
+                # Get alpha channel (opacity)
+                alpha = 1
+                if len(stroke_color):
+                    rgba = css_color.parse_css_color(stroke_color)
+                    if len(rgba) == 4:
+                        alpha = rgba[3]
+
+                # render svg stroke (of size width)
+                # (draw smooth border outlines in gcode)
+                # Note the update of the boundingbox.
+                self.body.extend([f"\n; border: '{name_id}'"])
                 for step in steps:
                     if step:
-                        delta_chain = LineSegmentChain()
-
-                        for line in line_chain:
-                            line_delta = self.orthogonal_offset(step, line)
-
-                            if delta_chain.chain_size():
-                                # calculate intersection of previous line and current line
-                                intersect = self.line_intersection(delta_chain.get(-1), line_delta)
-                                large = 200
-                                if intersect is not None:
-                                    # set prev_line.end to intersect
-                                    prev_line = delta_chain.get(-1)
-                                    prev_line.end = intersect
-                                    delta_chain.set(-1, prev_line)
-
-                                    # set line_delta start to intersect
-                                    line_delta.start = intersect
-                                else:
-                                    # connect line, to prevent ValueErrors from delta_chain.append() below
-                                    line_delta.start = delta_chain.get(-1).end
-
-                            delta_chain.append(line_delta)
-
-                        # check if line chain is a loop
-                        if line_chain.get(0).start == line_chain.get(-1).end:
-                            # fix delta chain
-                            intersect = self.line_intersection(delta_chain.get(0), delta_chain.get(-1))
-                            if intersect is not None:
-                                # update start of loop
-                                start_loop = delta_chain.get(0)
-                                start_loop.start = intersect
-                                delta_chain.set(0, start_loop)
-
-                                # update end of loop
-                                end_loop = delta_chain.get(-1)
-                                end_loop.end = intersect
-                                delta_chain.set(-1, end_loop)
-
-                        # linear_power(self, pixel: UInt8, maxpower: int, offset: int = 0, invert: bool = True) -> int
-                        inverse_bw = Image2gcode.linear_power(css_color.parse_css_color2bw8(stroke_color), self.settings["maximum_image_laser_power"])
+                        delta_chain = LineSegmentChain.delta_chain(line_chain, step)
+                        # apply alpha channel - when available - to inverted b&w value
+                        inverse_bw = Image2gcode.linear_power(css_color.parse_css_color2bw8(stroke_color), self.settings["maximum_image_laser_power"]) * alpha
                         self.append_line_chain(delta_chain, step, inverse_bw)
+                        # update 'name_id' boundingbox
+                        for line in delta_chain:
+                            boundingbox.update(line.start)
+                            boundingbox.update(line.end)
                     else:
-                        inverse_bw = Image2gcode.linear_power(css_color.parse_css_color2bw8(stroke_color), self.settings["maximum_image_laser_power"]) if len(stroke_color) else None
+                        # apply alpha channel - when available - to inverted b&w value
+                        inverse_bw = Image2gcode.linear_power(css_color.parse_css_color2bw8(stroke_color), self.settings["maximum_image_laser_power"]) * alpha if len(stroke_color) else None
                         self.append_line_chain(line_chain, step, inverse_bw)
+                        # update 'name_id' boundingbox
+                        for line in line_chain:
+                            boundingbox.update(line.start)
+                            boundingbox.update(line.end)
+
+            if not self.settings["nofill"] and fill_color is not None:
+                # fill a path
+                # this is done in 6 steps:
+                # step 1: create two raster images matching the bbox
+                # step 2: add marker lines just inside the line chains of the path
+                # step 3: scan the marker image lines and and apply 'evenodd' fill
+                #         (fill rule 'nonzero' to be implemented later on see note below)
+                # step 4: draw white borders to erase fill overlap
+                # step 5: filter stray pixels (to remove noise from the action above)
+                # step 6: generate gcode from image_fill
+
+                # get bounding box info from the path border
+                lowerleft = boundingbox.get()[0]
+                upperright = boundingbox.get()[1]
+
+                # normalize origin to (0.0)
+                vdXY = Vector(-lowerleft.x, -lowerleft.y)
+                dXY = (-lowerleft.x, -lowerleft.y)
+
+                # get raster image dimensions
+                img_height = math.ceil((upperright.y - lowerleft.y)/pixel_size)
+                img_width = math.ceil((upperright.x - lowerleft.x)/pixel_size)
+
+                # default scan error (step 3 below)
+                scan_error = 4
+
+                # step 1: create two raster images matching the bbox
+                # init
+                image_mark = np.full([img_height + 2, img_width + scan_error], 255, dtype=np.uint8)
+                image_fill = np.full([img_height + 2, img_width + scan_error], 0, dtype=np.uint8)
+
+                # step 2: add marker lines just inside the line chains of the path
+                # - determine the inside of the line chain
+                # - draw marker lines
+                for line_chain in path_curves[name_id]:
+                    # Note that a svg object with a specific name_id can have multiple line_chains that
+                    # together, define one shape (circumference). When this the case the boundingbox
+                    # inside/outside method below is not fullproof. This can be solved to stitch together
+                    # the line chain parts (TODO)
+
+                    # - determine the inside of the line chain
+                    # Compare the bbox of the line chain with that of a delta line chain a
+                    # fixed distance (offset) from the base line chain. Initially we do not know if the
+                    # delta line chain is inside or outside the base line chain, but when we compare
+                    # the bbox sizes we know.
+                    # Note that this method can be used to determine if a line chain is drawn clockwise
+                    # or anti-clockwise because a posive delta offset should be 'outside' the line chain
+                    # in this case (depending on the definition/calculation of the delta function).
+                    # we can use this to implement the other svg fill rule: 'nonzero'.
+                    bbox = Boundingbox()
+                    for line in line_chain:
+                        bbox.update(line.start + vdXY)
+                        bbox.update(line.end + vdXY)
+                    bbox_size = bbox.size()
+
+                    bbox = Boundingbox()
+                    delta_chain = LineSegmentChain.delta_chain(line_chain, pixel_size * 2)
+                    for line in delta_chain:
+                        bbox.update(line.start + vdXY)
+                        bbox.update(line.end + vdXY)
+                    bbox_deltasize =  bbox.size()
+
+                    # compare bboxes and set inside offset
+                    inside = 1
+                    if bbox_deltasize > bbox_size:
+                        inside = -1
+
+                    # Note that some tuning is going on here.
+                    # This can be remedied in several ways:
+                    # - use draw lines that have a thickness?
+                    # - use a higher resolution (pixel grid) to reduce the 'rounding' errors
+                    offsets = [inside * .5 * pixel_size, inside * pixel_size, inside * 1.5 * pixel_size, inside * 2 * pixel_size]
+                    # Note that the system sometimes returns line_chains having 1 point and thus having no size, this is 'solved'
+                    # below, but should not happen (TODO). It is also assumed that line_chain parts that define one shape have
+                    # similar sizes (TODO).
+                    if bbox_size > 1 and bbox_size < 50:
+                        # small area, less margin for error
+                        scan_error = 1
+                        del offsets[-2:]
+
+                    ## direct gcode: update this, see step 3 note
+                    # draw border lines of a specific marker color within line chain
+                    # Note that the marker values are just a choice and only have to be consistent
+                    # with the algorithm used (step 3)
+                    if bbox_size > 1:
+                        for offset in offsets:
+                            # make a line chain just one pixel inside the base (step 0) line chain
+                            delta_chain = LineSegmentChain.delta_chain(line_chain, offset)
+                            for line in delta_chain:
+                                draw_line(image_mark, line.start + vdXY, line.end + vdXY, 128)
+
+                    # draw the line chain border using another marker color
+                    for line in line_chain:
+                        draw_line(image_mark, line.start + vdXY, line.end + vdXY, 10)
+
+                # step 3: scan the marker image lines and and apply 'evenodd' fill
+                #         (fill rule 'nonzero' to be implemented later on)
+                #    for each line (y):
+                #        for each point (x) on the line:
+                #           scan from left to right or reverse:
+                #               for markers (border,inside border) and apply rule
+                #               'evenodd' to fill when an even number of borders
+                #               is crossed, untill odd
+                # Note that the image 'image_fill' is filled not 'image_mark' to make sure marks stay in place.
+
+                # Note that the fill algorithm can be adapted to support direct rendering of gcode (instead of rendering via 'image_fill' and
+                # function 'image2gcode', converting a raster image to gcode). This reduces the number of steps needed: steps 4, 5 and 6 can
+                # be left out. It does need a few adaptions in the previous steps, namely drawing the line chain border (color '10') in full width
+                # (instead of 1 pixel) and draw the 'inside' line (color 128) one pixel further. In addition to this uncomment the '## direct gcode'
+                # lines of step 3 to activate gcode rendering.
+
+                ## direct gcode
+                ## code = [f"\n; fill '{name_id}'"]
+                ## code += [self.interface.set_laser_power_value(Image2gcode.linear_power(fill_color, self.settings["maximum_image_laser_power"]))]
+
+                go_right = True
+                # start scanning to the right
+                for y in range(image_mark.shape[0]):
+                    evenodd = 0
+
+                    if go_right:
+                        # scan to the right
+                        x = 0
+                        start = None
+                        while x < image_mark.shape[1]:
+                            if image_mark[y,x] == 10 :
+                                # found a border
+                                x_b = x
+                                ## direct gcode
+                                ## update line below, to be able to skip empty (value 255) pixels
+                                # scan border, possibly having multiple pixels.
+                                while x_b < image_mark.shape[1] and image_mark[y,x_b] == 10:
+                                    x_b += 1
+
+                                xscan_b = x - 1
+                                while xscan_b > 0 and xscan_b > (x - scan_error) and (image_mark[y,xscan_b] != 10 and image_mark[y,xscan_b] != 128):
+                                    xscan_b -= 1
+                                xscan_a = x_b
+                                while xscan_a < image_mark.shape[1] and xscan_a < (x_b + scan_error) and (image_mark[y,xscan_a] != 10 and image_mark[y,xscan_a] != 128):
+                                    xscan_a += 1
+
+                                if xscan_b >= 0 and image_mark[y,xscan_b] == 128:
+                                    # found border
+                                    if evenodd % 2 == 0:
+                                        start = (x * pixel_size, y * pixel_size)
+                                        ## direct gcode
+                                        ## code += [self.interface.rapid_move(start[0] - dXY[0], start[1] - dXY[1])]
+                                    else:
+                                        draw_line(image_fill, start + dXY, (x * pixel_size, y * pixel_size) + dXY, fill_color)
+                                        ## direct gcode
+                                        ## code += [self.interface.linear_move(x * pixel_size - dXY[0], y * pixel_size - dXY[1])]
+                                    evenodd = evenodd + 1
+                                if xscan_a < image_mark.shape[1] and image_mark[y,xscan_a] == 128:
+                                    # found border
+                                    if evenodd % 2 == 0:
+                                        start = (x * pixel_size, y * pixel_size)
+                                        ## direct gcode
+                                        ## code += [self.interface.rapid_move(start[0] - dXY[0], start[1] - dXY[1])]
+                                    else:
+                                        draw_line(image_fill, start + dXY, (x_b * pixel_size, y * pixel_size) + dXY, fill_color)
+                                        ## direct gcode
+                                        ## code += [self.interface.linear_move(x_b * pixel_size - dXY[0], y * pixel_size - dXY[1])]
+                                    evenodd = evenodd + 1
+                                if x_b > x:
+                                    x = x_b - 1
+                            x += 1
+                    else:
+                        # scan to the left
+                        start = None
+                        x = image_mark.shape[1] - 1
+                        while x >= 0:
+                            if image_mark[y,x] == 10:
+                                # found a border
+                                ## direct gcode
+                                ## update line below, to be able to skip empty (value 255) pixels
+                                # scan border, possibly having multiple pixels.
+                                x_b = x
+                                while x_b >= 0 and image_mark[y,x_b] == 10:
+                                    x_b -= 1
+
+                                xscan_b = x_b
+                                while xscan_b > 0 and xscan_b > (x_b - scan_error) and (image_mark[y,xscan_b] != 10 and image_mark[y,xscan_b] != 128):
+                                     xscan_b -= 1
+                                xscan_a = x + 1
+                                while xscan_a < image_mark.shape[1] and xscan_a < (x + scan_error) and (image_mark[y,xscan_a] != 10 and image_mark[y,xscan_a] != 128):
+                                    xscan_a += 1
+
+                                if xscan_a < image_mark.shape[1] and image_mark[y,xscan_a] == 128:
+                                    # found border
+                                    if evenodd % 2 == 0:
+                                        start = (x * pixel_size, y * pixel_size)
+                                        ## direct gcode
+                                        ## code += [self.interface.rapid_move(start[0] - dXY[0], start[1] - dXY[1])]
+                                    else:
+                                        draw_line(image_fill, start + dXY, (x * pixel_size, y * pixel_size) + dXY, fill_color)
+                                        ## direct gcode
+                                        ## code += [self.interface.linear_move(x * pixel_size - dXY[0], y * pixel_size - dXY[1])]
+                                    evenodd = evenodd + 1
+                                if xscan_b >= 0 and image_mark[y,xscan_b] == 128:
+                                    # found border
+                                    if evenodd % 2 == 0:
+                                        start = (x * pixel_size, y * pixel_size)
+                                        ## direct gcode
+                                        ## code += [self.interface.rapid_move(start[0] - dXY[0], start[1] - dXY[1])]
+                                    else:
+                                        draw_line(image_fill, start + dXY, (x_b * pixel_size, y * pixel_size) + dXY, fill_color)
+                                        ## direct gcode
+                                        ## code += [self.interface.linear_move(x_b * pixel_size - dXY[0], y * pixel_size - dXY[1])]
+                                    evenodd = evenodd + 1
+                                if x_b < x:
+                                    x = x_b + 1
+                            x -= 1
+
+                    # switch scan direction
+                    go_right = not go_right
+
+                ## direct gcode
+                ## self.body.extend(code)
+
+                ## direct gcode: ignore this step
+                # step 4: draw white borders to erase fill overlap
+                for line_chain in path_curves[name_id]:
+                    for step in steps:
+                        if step:
+                            delta_chain = LineSegmentChain.delta_chain(line_chain, step)
+                            for line in delta_chain:
+                                draw_line(image_fill, line.start + vdXY, line.end + vdXY, 0)
+                        else:
+                            for line in line_chain:
+                                draw_line(image_fill, line.start + vdXY, line.end + vdXY, 0)
+
+                ## direct gcode: ignore this step
+                # step 5: filter stray pixels (to remove noise from the action above)
+                for y in range(image_fill.shape[0]):
+                    for x in range(image_fill.shape[1]):
+                        if image_fill[y,x] != 0:
+                            if x > 1 and x < (image_fill.shape[1] - 1) and y > 1 and y < (image_fill.shape[0] - 1):
+                                if image_fill[y,x+1] == 0 and image_fill[y,x-1] == 0 and image_fill[y+1,x] == 0 and image_fill[y-1,x] == 0:
+                                    image_fill[y,x] = 0
+
+                ## direct gcode: ignore this step
+                # step 6: generate gcode from image_fill
+                img_attrib = {}
+                img_attrib['id'] = name_id
+                #img_attrib['gcode_speedmoves'] = 0
+                img_attrib['x'] = -dXY[0]
+                img_attrib['y'] = -dXY[1]
+                img_attrib['noinvert'] = True
+
+                ## direct gcode: ignore this step
+                # start gcode fill
+                self.body.extend([f"\n;fill '{name_id}'"])
+                self.image2gcode(img_attrib, image_fill)
 
     def check_axis_maximum_travel(self):
         return self.settings["x_axis_maximum_travel"] is not None and self.settings["y_axis_maximum_travel"] is not None

{svg2gcode-3.0.3 → svg2gcode-3.2.1}/svg2gcode/svg_to_gcode/css_color.py

@@ -192,7 +192,7 @@ def hex2rgb(hexcolor: str) -> [int,int,int]:
 
     return [r,g,b]
 
-def parse_css_color(color: str) -> [int,int,int]:
+def parse_css_color(color: str) -> [int,int,int,float]:
     """
         parse css color to rgb
         (definition from  https://www.w3.org/TR/css-color-3/)
@@ -229,7 +229,8 @@ def parse_css_color(color: str) -> [int,int,int]:
                 else:
                     b = int(rgb[commas_pos[1]+1:])
 
-                rgbcolor = [r * a, g * a, b * a]
+                #rgbcolor = [r * a, g * a, b * a]
+                rgbcolor = [r,g,b,a]
 
             else:
                 hsla = re.search(f"hsl(a)?\([0-9]+,[0-9]+,[0-9]+(,{float_re})?", color)
@@ -249,7 +250,7 @@ def parse_css_color(color: str) -> [int,int,int]:
                         l = int(hsl[commas_pos[1]+1:])
 
                     rgbcolor = hsl2rgb(h, s, l)
-                    rgbcolor = [int(rgbcolor[0] * 255 * a), int(rgbcolor[1] * 255 * a), int(rgbcolor[2] * 255 * a)]
+                    rgbcolor = [int(rgbcolor[0] * 255), int(rgbcolor[1] * 255), int(rgbcolor[2] * 255), a]
 
     if not rgbcolor:
         logger.warn(f"Not a valid css color: '{color}', color set to 'black'!")
@@ -267,7 +268,7 @@ def rgb24tobw24(rgb24: int) -> int:
     bnw = int(r * 0.299 + g * 0.587 + b * 0.114) & 0xff;
     return (bnw << 16) | (bnw << 8) | bnw;
 
-def rgb24tobw8(rgb24: [int,int,int]) -> int:
+def rgb24tobw8(rgb24: [int,int,int,float]) -> int:
     """
         convert a 24 bit rgb (color) value to 8 bit grayscale
     """

{svg2gcode-3.0.3 → svg2gcode-3.2.1}/svg2gcode/svg_to_gcode/formulas.py

@@ -11,7 +11,7 @@ from svg2gcode.svg_to_gcode import TOLERANCES
 def tolerance_constrain(value, maximum, minimum, tolerance=TOLERANCES["operation"]):
     """
     Constrain a value between if it surpasses a limit and is within operational tolerance of the limit. Else return the
-    value. Useful if you want to correct for flatting point errors but still want to raise an exception if the value is
+    value. Useful if you want to correct for floating point errors but still want to raise an exception if the value is
     out-of-bounds for a different reason.
     """
 
@@ -49,6 +49,11 @@ def line_intersect(p1, c1, p2, c2):
     return (((c1_c - p1_c) * p1 - (c1 - p1) * p1_c) * (c2 - p2) - ((c2_c - p2_c) * p2 - (c2 - p2) * p2_c) * (
             c1 - p1)) / ((c2 - p2) * (c1_c - p1_c) - (c1 - p1) * (c2_c - p2_c))
 
+def line_length(A: (float,float),B: (float,float)):
+    """ Pythagoras """
+    # |Ax - Bx|^2 + |Ay - By|^2 = C^2
+    # distance = √C^2
+    return math.sqrt((A[0] - B[0])**2 + (A[1] - B[1])**2)
 
 def is_on_mid_perpendicular(z, a, b):
     """Check if a point z is on the line which is perpendicular to ab and passes through the segment's midpoint"""

{svg2gcode-3.0.3 → svg2gcode-3.2.1}/svg2gcode/svg_to_gcode/geometry/_elliptical_arc.py

@@ -8,12 +8,12 @@ from svg2gcode.svg_to_gcode.geometry import Curve
 class EllipticalArc(Curve):
     """The EllipticalArc class inherits from the abstract Curve class and describes an elliptical arc."""
 
-    __slots__ = 'center', 'radii', 'rotation', 'start_angle', 'sweep_angle', 'end_angle', 'transformation'
+    __slots__ = 'center', 'radii', 'rotation', 'start_angle', 'sweep_angle', 'end_angle', 'transformation', 'path_attrib'
 
     # ToDo apply transformation beforehand (in Path) for consistency with other geometric objects. If you (the reader)
     #  know how to easily apply an affine transformation to an ellipse feel free to make a pull request.
     def __init__(self, center: Vector, radii: Vector, rotation: float, start_angle: float, sweep_angle: float,
-                 transformation: None):
+                 transformation: None, path_attrib = None):
 
         # Assign and verify arguments
         self.center = center
@@ -22,6 +22,7 @@ class EllipticalArc(Curve):
         self.start_angle = start_angle
         self.sweep_angle = sweep_angle
         self.transformation = transformation
+        self.path_attrib = path_attrib
 
         # Calculate missing data
         self.end_angle = start_angle + sweep_angle
@@ -32,7 +33,8 @@ class EllipticalArc(Curve):
 
     def __repr__(self):
         return f"EllipticalArc(start: {self.start}, end: {self.end}, center: {self.center}, radii: {self.radii}," \
-               f" rotation: {self.rotation}, start_angle: {self.start_angle}, sweep_angle: {self.sweep_angle})"
+               f" rotation: {self.rotation}, start_angle: {self.start_angle}, sweep_angle: {self.sweep_angle}," \
+               f" transformation: {self.transformation}, attrib: {self.path_attrib})"
 
     def point(self, t):
         angle = formulas.linear_map(self.start_angle, self.end_angle, t)

svg2gcode-3.2.1/svg2gcode/svg_to_gcode/geometry/_line.py

@@ -0,0 +1,111 @@
+
+import math
+
+from svg2gcode.svg_to_gcode.geometry import Vector
+from svg2gcode.svg_to_gcode.geometry import Curve
+from svg2gcode.svg_to_gcode import formulas
+
+
+# A line segment
+class Line(Curve):
+    """The Line class inherits from the abstract Curve class and describes a straight line segment."""
+
+    __slots__ = 'slope', 'offset', 'path_attrib'
+
+    def __init__(self, start, end, path_attrib = None):
+        self.start = start
+        self.end = end
+
+        self.slope = formulas.line_slope(start, end)
+        self.offset = formulas.line_offset(start, end)
+        self.path_attrib = path_attrib
+
+    def __repr__(self):
+        return f"Line(start:{self.start}, end:{self.end}, slope:{self.slope}, offset:{self.offset}, attrib:{self.path_attrib})"
+
+    def length(self):
+        #return abs(self.start - self.end)
+        return formulas.line_length(self.start,self.end)
+
+    def point(self, t):
+        x = self.start.x + t * (self.end.x - self.start.x)
+        y = self.slope * x + self.offset
+
+        return Vector(x, y)
+
+    def derivative(self, t):
+        return self.slope
+
+    @staticmethod
+    def offset_line(offset: float, line, precision = 6) -> (Vector,Vector):
+        """
+        Offset a line perpendicular to the given line.
+        """
+        def perpendicular(line) -> (int,int):
+            """
+            Get sign of vector perpendicular to the given line,
+            pointing outwards for a clockwise rotation.
+            Return (sign x, sign y)
+            """
+            d_x = line.end.x - line.start.x
+            d_y = line.end.y - line.start.y
+            # normalize to values 0 or 1 (with sign)
+            d_x = 0 if d_x == 0 else d_x/abs(d_x)
+            d_y = 0 if d_y == 0 else d_y/abs(d_y)
+            return (-d_y, d_x)
+
+        delta_sign = perpendicular(line)
+
+        if line.slope == 0:
+            # vertical line
+            delta_x = 0
+            delta_y = delta_sign[1] * offset
+        elif line.slope == 1:
+            # horizontal line
+            delta_x = delta_sign[0] * offset
+            delta_y = 0
+        else:
+            # calculate orthogonal line of 'offset' length:
+            #
+            # (1)  y = 1/slope * x                          (line formula   )
+            # (2)  x^2 + y^2                = offset^2      (Pythagoras     )
+            # (3)  x^2 + (1/slope * x)^2    = offset^2      (substitue 'y'  )
+            # (4)  (1 + (1/slope)^2) * x^2  = offset^2      (reorder        )
+            # (5)  x^2 = offset^2 / (1 + (1/slope)^2)       (get 'x'        )
+            # slope
+            inv_slope = abs((1/line.slope))
+            delta_x = round(math.sqrt((offset ** 2) / (1 + inv_slope ** 2)), precision)
+            delta_y = round(inv_slope * delta_x, precision)
+
+            # normalize offset
+            offset = 0 if offset == 0 else offset/abs(offset)
+            delta_x = delta_sign[0] * offset * delta_x
+            delta_y = delta_sign[1] * offset * delta_y
+
+        # add delta vector to line start and end vectors
+        return Line(line.start + Vector(delta_x, delta_y), line.end + Vector(delta_x, delta_y))
+
+    @staticmethod
+    def line_intersection(l1, l2, precision = 6) -> Vector:
+        """
+        Line intersection (https://en.wikipedia.org/wiki/Line–line_intersection)
+        Return intersection point or None when lines do not intersect.
+
+        """
+        x1, y1 = l1.start
+        x2, y2 = l1.end
+        x3, y3 = l2.start
+        x4, y4 = l2.end
+
+        # denomintor
+        #d = round((x1 - x2)*(y3 - y4) - (y1 - y2)*(x3 - x4), self.precision)
+        d = (x1 - x2)*(y3 - y4) - (y1 - y2)*(x3 - x4)
+
+        # Note that the cutoff below is needed to eliminate propagation of rounding errors.
+        # The equations below are inherently sensitive to rounding errors at certain inputs.
+        if abs(d) < 10**-precision:
+            # no intersection
+            return None
+
+        return Vector( round(((x1*y2 - y1*x2) * (x3 - x4) - (x1 - x2) * (x3*y4 - y3*x4))/d, precision),
+                       round(((x1*y2 - y1*x2) * (y3 - y4) - (y1  - y2) * (x3*y4 - y3*x4))/d, precision) )

{svg2gcode-3.0.3 → svg2gcode-3.2.1}/svg2gcode/svg_to_gcode/geometry/_line_segment_chain.py

@@ -28,6 +28,65 @@ class LineSegmentChain(Chain):
 
         self._curves.append(line2)
 
+    @staticmethod
+    def clockwise(line_chain, delta: float = .1) -> bool:
+        """
+        Return true when line chain rotates clockwise using sample delta
+
+        """
+        # bbox_line_chain = bbox(line_chain)
+        # bbox_delta_chain = bbox(delta_chain(line_chain, delta))
+        # if bbox_delta_chain > bbox_line_chain:
+        #       return true
+        # return false
+        pass
+
+    @staticmethod
+    def delta_chain(line_chain, offset: float) -> "LineSegmentChain":
+        """
+        Return a line chain offset to the given chain. If the chain rotates clockwise a positive offset
+        results in a delta chain outwards of (enclosing) the given line chain.
+
+        """
+        delta_chain = LineSegmentChain()
+
+        for line in line_chain:
+            line_delta = Line.offset_line(offset, line)
+
+            if delta_chain.chain_size():
+                # calculate intersection of previous line and current line
+                intersect = Line.line_intersection(delta_chain.get(-1), line_delta)
+                if intersect is not None:
+                    # set prev_line.end to intersect
+                    prev_line = delta_chain.get(-1)
+                    prev_line.end = intersect
+                    delta_chain.set(-1, prev_line)
+
+                    # set line_delta start to intersect
+                    line_delta.start = intersect
+                else:
+                    # connect line, to prevent ValueErrors from delta_chain.append() below
+                    line_delta.start = delta_chain.get(-1).end
+
+            delta_chain.append(line_delta)
+
+        # check if line chain is a loop
+        if line_chain.get(0).start == line_chain.get(-1).end:
+            # fix delta chain
+            intersect = Line.line_intersection(delta_chain.get(0), delta_chain.get(-1))
+            if intersect is not None:
+                # update start of loop
+                start_loop = delta_chain.get(0)
+                start_loop.start = intersect
+                delta_chain.set(0, start_loop)
+
+                # update end of loop
+                end_loop = delta_chain.get(-1)
+                end_loop.end = intersect
+                delta_chain.set(-1, end_loop)
+
+        return delta_chain
+
     @staticmethod
     def line_segment_approximation(shape, increment_growth=11 / 10, error_cap=None, error_floor=None)\
             -> "LineSegmentChain":

{svg2gcode-3.0.3 → svg2gcode-3.2.1}/svg2gcode/svg_to_gcode/svg_parser/_path.py

@@ -261,7 +261,7 @@ class Path:
             radii, center, start_angle, sweep_angle = formulas.endpoint_to_center_parameterization(
                 start, end, radii, rotation_rad, large_arc_flag, sweep_flag)
 
-            arc = EllipticalArc(center, radii, rotation_rad, start_angle, sweep_angle, transformation=self.transformation)
+            arc = EllipticalArc(center, radii, rotation_rad, start_angle, sweep_angle, transformation=self.transformation, path_attrib=self.path_attrib)
 
             self.current_point = end
             return arc

svg2gcode-3.0.3/svg2gcode/svg_to_gcode/geometry/_line.py

@@ -1,33 +0,0 @@
-from svg2gcode.svg_to_gcode.geometry import Vector
-from svg2gcode.svg_to_gcode.geometry import Curve
-from svg2gcode.svg_to_gcode import formulas
-
-
-# A line segment
-class Line(Curve):
-    """The Line class inherits from the abstract Curve class and describes a straight line segment."""
-
-    __slots__ = 'slope', 'offset', 'path_attrib'
-
-    def __init__(self, start, end, path_attrib = None):
-        self.start = start
-        self.end = end
-
-        self.slope = formulas.line_slope(start, end)
-        self.offset = formulas.line_offset(start, end)
-        self.path_attrib = path_attrib
-
-    def __repr__(self):
-        return f"Line(start:{self.start}, end:{self.end}, slope:{self.slope}, offset:{self.offset}, attrib:{self.path_attrib})"
-
-    def length(self):
-        return abs(self.start - self.end)
-
-    def point(self, t):
-        x = self.start.x + t * (self.end.x - self.start.x)
-        y = self.slope * x + self.offset
-
-        return Vector(x, y)
-
-    def derivative(self, t):
-        return self.slope