meerk40t 0.9.2000__py2.py3-none-any.whl → 0.9.3001__py2.py3-none-any.whl

meerk40t/core/svg_io.py

@@ -1,5 +1,5 @@
 """
-This modeu
+This extension governs SVG loading and saving, registering both the load and the save values for SVG.
 """
 
 import ast
@@ -122,6 +122,11 @@ MEERK40T_XMLS_ID = "meerk40t"
 
 
 def capstr(linecap):
+    """
+    Given the mk enum values for linecap, returns the svg string.
+    @param linecap:
+    @return:
+    """
     if linecap == Linecap.CAP_BUTT:
         return "butt"
     elif linecap == Linecap.CAP_SQUARE:
@@ -131,6 +136,12 @@ def capstr(linecap):
 
 
 def joinstr(linejoin):
+    """
+    Given the mk enum value for linejoin, returns the svg string.
+
+    @param linejoin:
+    @return:
+    """
     if linejoin == Linejoin.JOIN_ARCS:
         return "arcs"
     elif linejoin == Linejoin.JOIN_BEVEL:
@@ -144,19 +155,18 @@ def joinstr(linejoin):
 
 
 def rulestr(fillrule):
+    """
+    Given the mk enum value for fillrule, returns the svg string.
+
+    @param fillrule:
+    @return:
+    """
     if fillrule == Fillrule.FILLRULE_EVENODD:
         return "evenodd"
     else:
         return "nonzero"
 
 
-def copy_attributes(source, target):
-    if hasattr(source, "stroke"):
-        target.stroke = source.stroke
-    if hasattr(source, "fill"):
-        target.fill = source.fill
-
-
 class SVGWriter:
     @staticmethod
     def save_types():
@@ -252,13 +262,11 @@ class SVGWriter:
             return flag
 
         if c.type == "elem ellipse":
-            element = c.shape
-            copy_attributes(c, element)
             subelement = SubElement(xml_tree, SVG_TAG_ELLIPSE)
-            subelement.set(SVG_ATTR_CENTER_X, str(element.cx))
-            subelement.set(SVG_ATTR_CENTER_Y, str(element.cy))
-            subelement.set(SVG_ATTR_RADIUS_X, str(element.rx))
-            subelement.set(SVG_ATTR_RADIUS_Y, str(element.ry))
+            subelement.set(SVG_ATTR_CENTER_X, str(c.cx))
+            subelement.set(SVG_ATTR_CENTER_Y, str(c.cy))
+            subelement.set(SVG_ATTR_RADIUS_X, str(c.rx))
+            subelement.set(SVG_ATTR_RADIUS_Y, str(c.ry))
             t = Matrix(c.matrix)
             if not t.is_identity():
                 subelement.set(
@@ -266,7 +274,6 @@ class SVGWriter:
                     f"matrix({t.a}, {t.b}, {t.c}, {t.d}, {t.e}, {t.f})",
                 )
         elif c.type == "elem image":
-            element = c.image
             subelement = SubElement(xml_tree, SVG_TAG_IMAGE)
             stream = BytesIO()
             try:
@@ -289,23 +296,19 @@ class SVGWriter:
                     f"matrix({t.a}, {t.b}, {t.c}, {t.d}, {t.e}, {t.f})",
                 )
         elif c.type == "elem line":
-            element = c.shape
-            copy_attributes(c, element)
             subelement = SubElement(xml_tree, SVG_TAG_LINE)
-            subelement.set(SVG_ATTR_X1, str(element.x1))
-            subelement.set(SVG_ATTR_Y1, str(element.y1))
-            subelement.set(SVG_ATTR_X2, str(element.x2))
-            subelement.set(SVG_ATTR_Y2, str(element.y2))
+            subelement.set(SVG_ATTR_X1, str(c.x1))
+            subelement.set(SVG_ATTR_Y1, str(c.y1))
+            subelement.set(SVG_ATTR_X2, str(c.x2))
+            subelement.set(SVG_ATTR_Y2, str(c.y2))
             t = c.matrix
             if not t.is_identity():
                 subelement.set(
                     "transform",
                     f"matrix({t.a}, {t.b}, {t.c}, {t.d}, {t.e}, {t.f})",
                 )
-
         elif c.type == "elem path":
-            element = c.path
-            copy_attributes(c, element)
+            element = c.geometry.as_path()
             subelement = SubElement(xml_tree, SVG_TAG_PATH)
             subelement.set(SVG_ATTR_DATA, element.d(transformed=False))
             t = c.matrix
@@ -315,9 +318,6 @@ class SVGWriter:
                     f"matrix({t.a}, {t.b}, {t.c}, {t.d}, {t.e}, {t.f})",
                 )
         elif c.type == "elem point":
-            element = Point(c.point)
-            c.x = element.x
-            c.y = element.y
             subelement = SubElement(xml_tree, "element")
             t = c.matrix
             if not t.is_identity():
@@ -325,14 +325,14 @@ class SVGWriter:
                     "transform",
                     f"matrix({t.a}, {t.b}, {t.c}, {t.d}, {t.e}, {t.f})",
                 )
-            SVGWriter._write_custom(subelement, c)
+            subelement.set("x", str(c.x))
+            subelement.set("y", str(c.y))
         elif c.type == "elem polyline":
-            element = c.shape
-            copy_attributes(c, element)
             subelement = SubElement(xml_tree, SVG_TAG_POLYLINE)
+            points = list(c.geometry.as_points())
             subelement.set(
                 SVG_ATTR_POINTS,
-                " ".join([f"{e[0]} {e[1]}" for e in element.points]),
+                " ".join([f"{e.real} {e.imag}" for e in points]),
             )
             t = c.matrix
             if not t.is_identity():
@@ -341,15 +341,13 @@ class SVGWriter:
                     f"matrix({t.a}, {t.b}, {t.c}, {t.d}, {t.e}, {t.f})",
                 )
         elif c.type == "elem rect":
-            element = c.shape
-            copy_attributes(c, element)
             subelement = SubElement(xml_tree, SVG_TAG_RECT)
-            subelement.set(SVG_ATTR_X, str(element.x))
-            subelement.set(SVG_ATTR_Y, str(element.y))
-            subelement.set(SVG_ATTR_RADIUS_X, str(element.rx))
-            subelement.set(SVG_ATTR_RADIUS_Y, str(element.ry))
-            subelement.set(SVG_ATTR_WIDTH, str(element.width))
-            subelement.set(SVG_ATTR_HEIGHT, str(element.height))
+            subelement.set(SVG_ATTR_X, str(c.x))
+            subelement.set(SVG_ATTR_Y, str(c.y))
+            subelement.set(SVG_ATTR_RADIUS_X, str(c.rx))
+            subelement.set(SVG_ATTR_RADIUS_Y, str(c.ry))
+            subelement.set(SVG_ATTR_WIDTH, str(c.width))
+            subelement.set(SVG_ATTR_HEIGHT, str(c.height))
             t = c.matrix
             if not t.is_identity():
                 subelement.set(
@@ -405,9 +403,6 @@ class SVGWriter:
             group_element = SubElement(xml_tree, SVG_TAG_GROUP)
             SVGWriter._write_custom(group_element, c)
             SVGWriter._write_elements(group_element, c, version)
-            if hasattr(c, "_operands"):
-                for q in c._operands:
-                    SVGWriter._write_element(group_element, q, version)
             return
         elif c.type == "file":
             # This is a structural group node of elements. Recurse call to write values.
@@ -531,15 +526,11 @@ class SVGWriter:
         Write the operations branch part of the tree to disk.
 
         @param xml_tree:
-        @param elem_tree:
+        @param op_tree:
         @return:
         """
         for c in op_tree.children:
-            if c.type.startswith("util") or c.type.startswith("place"):
-                subelement = SubElement(xml_tree, MEERK40T_XMLS_ID + ":operation")
-                SVGWriter._write_custom(subelement, c)
-            else:
-                SVGWriter._write_operation(xml_tree, c)
+            SVGWriter._write_operation(xml_tree, c, version)
 
     @staticmethod
     def _write_regmarks(xml_tree, reg_tree, version):
@@ -550,7 +541,7 @@ class SVGWriter:
             SVGWriter._write_elements(regmark, reg_tree, version)
 
     @staticmethod
-    def _write_operation(xml_tree, node):
+    def _write_operation(xml_tree, node, version):
         """
         Write an individual operation. This is any node directly under `branch ops`
 
@@ -558,17 +549,16 @@ class SVGWriter:
         @param node:
         @return:
         """
-        for c in node.children:
-            if c.type.startswith("effect"):
-                xml_tree = SubElement(xml_tree, SVG_TAG_GROUP)
-                SVGWriter._write_custom(xml_tree, c)
-
-        subelement = SubElement(xml_tree, MEERK40T_XMLS_ID + ":operation")
+        # All operations are groups.
+        subelement = SubElement(xml_tree, SVG_TAG_GROUP)
         subelement.set("type", str(node.type))
+
         if node.label is not None:
             subelement.set("label", str(node.label))
+
         if node.lock is not None:
             subelement.set("lock", str(node.lock))
+
         try:
             for key, value in node.settings.items():
                 if not key:
@@ -583,15 +573,46 @@ class SVGWriter:
                     continue
                 subelement.set(key, str(value))
         except AttributeError:
-            pass
+            # Node does not have settings, write object dict
+            for key, value in node.__dict__.items():
+                if not key:
+                    # If key is None, do not save.
+                    continue
+                if key.startswith("_"):
+                    continue
+                if value is None:
+                    continue
+                if key in (
+                    "references",
+                    "tag",
+                    "type",
+                    "draw",
+                    "stroke_width",
+                    "matrix",
+                ):
+                    # References key from previous loaded version (filter out, rebuild)
+                    continue
+                subelement.set(key, str(value))
+
+        # Store current node reference values.
+        SVGWriter._write_references(subelement, node)
+        subelement.set(SVG_ATTR_ID, str(node.id))
+
+        for c in node.children:
+            # Recurse all non-ref nodes
+            if c.type == "reference":
+                continue
+            SVGWriter._write_operation(subelement, c, version)
+
+    @staticmethod
+    def _write_references(subelement, node):
         contains = list()
         for c in node.children:
             if c.type == "reference":
                 c = c.node  # Contain direct reference not reference node reference.
-            contains.append(str(c.id))
+                contains.append(c.id)
         if contains:
             subelement.set("references", " ".join(contains))
-        subelement.set(SVG_ATTR_ID, str(node.id))
 
     @staticmethod
     def _write_custom(subelement, node):
@@ -608,15 +629,7 @@ class SVGWriter:
                 # References key from previous loaded version (filter out, rebuild)
                 continue
             subelement.set(key, str(value))
-
-        contains = list()
-        for c in node.children:
-            if c.type == "reference":
-                c = c.node  # Contain direct reference not reference node reference.
-            contains.append(c.id)
-        if contains:
-            subelement.set("references", " ".join(contains))
-
+        SVGWriter._write_references(subelement, node)
         subelement.set(SVG_ATTR_ID, str(node.id))
 
     @staticmethod
@@ -633,17 +646,25 @@ class SVGWriter:
 
 
 class SVGProcessor:
+    """
+    SVGProcessor is the parser for svg objects. We employ svgelements to do the actual parsing of the file and convert
+    the parsed objects into mk nodes, operations, elements, and regmarks.
+
+    Special care is taken to load MK specific objects like `note` and `operations`
+    """
+
     def __init__(self, elements, load_operations):
         self.elements = elements
+
+        self.operation_list = list()
         self.element_list = list()
         self.regmark_list = list()
+
         self.reverse = False
         self.requires_classification = True
         self.operations_replaced = False
         self.pathname = None
-        self.regmark = None
         self.load_operations = load_operations
-        self.operation_list = list()
 
         # Setting this is bringing as much benefit as anticipated
         # Both the time to load the file (unexpectedly) and the time
@@ -658,26 +679,39 @@ class SVGProcessor:
         self.precalc_bbox = True
 
     def process(self, svg, pathname):
+        """
+        Process sends the data to parse and deals with creating the file_node, setting the operations, classifying
+        either directly from the data within the file or automatically.
+
+        @param svg:
+        @param pathname:
+        @return:
+        """
         self.pathname = pathname
-        context_node = self.elements.get(type="branch elems")
+
+        context_node = self.elements.elem_branch
         file_node = context_node.add(type="file", filepath=pathname)
-        self.regmark = self.elements.reg_branch
         file_node.focus()
 
-        self.parse(svg, file_node, self.element_list)
+        self.parse(svg, file_node, self.element_list, branch="elements")
+
         if self.load_operations and self.operations_replaced:
+            for child in list(self.elements.op_branch.children):
+                if not hasattr(child, "_ref_load"):
+                    child.remove_all_children(fast=True, destroy=True)
+                    child.remove_node(fast=True, destroy=True)
             self.elements.undo.mark("op-replaced")
-            self.elements.clear_operations()
-            for node in self.operation_list:
-                op = self.elements.op_branch.add_node(node)
-            for op in self.elements.ops():
-                if not hasattr(op, "settings"):
-                    # Some special nodes might lack settings these can't have references.
+            for op in self.elements.op_branch.flat():
+                try:
+                    refs = op._ref_load
+                    del op._ref_load
+                except AttributeError:
                     continue
-                refs = op.settings.get("references")
                 if refs is None:
                     continue
+
                 self.requires_classification = False
+
                 for ref in refs.split(" "):
                     for e in self.element_list:
                         if e.id == ref:
@@ -687,6 +721,14 @@ class SVGProcessor:
             self.elements.classify(self.element_list)
 
     def check_for_mk_path_attributes(self, node, element):
+        """
+        Checks for some mk special parameters starting with mk. Especially mkparam, and uses this property to fill in
+        the functional_parameter attribute for the node.
+
+        @param node:
+        @param element:
+        @return:
+        """
         for prop in element.values:
             lc = element.values.get(prop)
             if prop.startswith("mk"):
@@ -701,8 +743,21 @@ class SVGProcessor:
                             node.functional_parameter = value
                         except (ValueError, SyntaxError):
                             pass
+                    elif prop == "mkbcparam":
+                        try:
+                            value = ast.literal_eval(lc)
+                            node.mkbcparam = value
+                        except (ValueError, SyntaxError):
+                            pass
 
     def check_for_fill_attributes(self, node, element):
+        """
+        Called for paths and poly lines. This checks for an attribute of `fill-rule` in the SVG and sets the MK equal.
+
+        @param node:
+        @param element:
+        @return:
+        """
         lc = element.values.get(SVG_ATTR_FILL_RULE)
         if lc is not None:
             nlc = Fillrule.FILLRULE_NONZERO
@@ -714,6 +769,14 @@ class SVGProcessor:
             node.fillrule = nlc
 
     def check_for_line_attributes(self, node, element):
+        """
+        Called for many element types. This checks for the stroke-cap and line-join attributes in the svgelements
+        primitive and sets the node with the mk equal
+
+        @param node:
+        @param element:
+        @return:
+        """
         lc = element.values.get(SVG_ATTR_STROKE_CAP)
         if lc is not None:
             nlc = Linecap.CAP_ROUND
@@ -765,28 +828,18 @@ class SVGProcessor:
                 return True, abs(Path(element)).first_point
         return False, None
 
-    def parse(self, element, context_node, e_list, uselabel=None):
-        def is_child(candidate, parent_node):
-            if candidate is None:
-                return False
-            if candidate is parent_node:
-                return True
-            if candidate.parent is None:
-                return False
-            return is_child(candidate.parent, parent_node)
+    def get_tag_label(self, element):
+        """
+        Gets the tag label from the element. This is usually an inkscape label.
 
-        if element.values.get("visibility") == "hidden":
-            # This does not allow substructures...
-            # Are we already underneath regmark?
-            if not is_child(context_node, self.regmark):
-                context_node = self.regmark
-            e_list = self.regmark_list
-        ident = element.id
+        Let's see whether we can get the label from an inkscape save
+        We only want the 'label' attribute from the current tag, so
+        we look at element.values["attributes"]
+
+        @param element:
+        @return:
+        """
 
-        tag_label = None
-        # Let's see whether we can get the label from an inkscape save
-        # We only want the 'label' attribute from the current tag, so
-        # we look at element.values["attributes"]
         if "attributes" in element.values:
             local_dict = element.values["attributes"]
         else:
@@ -802,20 +855,502 @@ class SVGProcessor:
             tag_label = local_dict.get(ink_tag)
             if tag_label == "":
                 tag_label = None
-            # print ("Found label: %s" %_label)
         except (AttributeError, KeyError):
             # Label might simply be "label"
+            pass
+        if tag_label is None:
             tag_label = local_dict.get("label")
+        return tag_label
+
+    def _parse_text(self, element, ident, label, lock, context_node, e_list):
+        """
+        Parses an SVGText object, into an `elem text` node.
+
+        @param element:
+        @param ident:
+        @param label:
+        @param lock:
+        @param context_node:
+        @param e_list:
+        @return:
+        """
+
+        if element.text is None:
+            return
+
+        decor = element.values.get("text-decoration", "").lower()
+        node = context_node.add(
+            id=ident,
+            text=element.text,
+            x=element.x,
+            y=element.y,
+            font=element.values.get("font"),
+            anchor=element.values.get(SVG_ATTR_TEXT_ANCHOR),
+            baseline=element.values.get(
+                SVG_ATTR_TEXT_ALIGNMENT_BASELINE,
+                element.values.get(SVG_ATTR_TEXT_DOMINANT_BASELINE, "baseline"),
+            ),
+            matrix=element.transform,
+            fill=element.fill,
+            stroke=element.stroke,
+            stroke_width=element.stroke_width,
+            stroke_scale=bool(
+                SVG_VALUE_NON_SCALING_STROKE
+                not in element.values.get(SVG_ATTR_VECTOR_EFFECT, "")
+            ),
+            underline="underline" in decor,
+            strikethrough="line-through" in decor,
+            overline="overline" in decor,
+            texttransform=element.values.get("text-transform"),
+            type="elem text",
+            label=label,
+            settings=element.values,
+        )
+        e_list.append(node)
+
+    def _parse_path(self, element, ident, label, lock, context_node, e_list):
+        """
+        Parses an SVG Path object.
+
+        There were a few versions of meerk40t where Path was used to store other save nodes. But, there is not
+        enough information to reconstruct those elements.
+
+        @param element:
+        @param ident:
+        @param label:
+        @param lock:
+        @param context_node:
+        @param e_list:
+        @return:
+        """
+        if len(element) < 0:
+            return
+
+        if element.values.get("type") == "elem polyline":
+            # Type is polyline we should restore the node type if we have sufficient info to do so.
+            pass
+        if element.values.get("type") == "elem ellipse":
+            # There is not enough info to reconstruct this.
+            pass
+        if element.values.get("type") == "elem rect":
+            # There is not enough info to reconstruct this.
+            pass
+        if element.values.get("type") == "elem line":
+            pass
+        element.approximate_arcs_with_cubics()
+        node = context_node.add(
+            path=element, type="elem path", id=ident, label=label, lock=lock
+        )
+        self.check_for_line_attributes(node, element)
+        self.check_for_fill_attributes(node, element)
+        self.check_for_mk_path_attributes(node, element)
+        e_list.append(node)
+
+    def _parse_polyline(self, element, ident, label, lock, context_node, e_list):
+        """
+        Parses svg Polyline and Polygon objects into `elem polyline` nodes.
+
+        @param element:
+        @param ident:
+        @param label:
+        @param lock:
+        @param context_node:
+        @param e_list:
+        @return:
+        """
+        if element.is_degenerate():
+            return
+        node = context_node.add(
+            shape=element,
+            type="elem polyline",
+            id=ident,
+            label=label,
+            lock=lock,
+        )
+        self.check_for_line_attributes(node, element)
+        self.check_for_fill_attributes(node, element)
+        self.check_for_mk_path_attributes(node, element)
+        if self.precalc_bbox:
+            # bounds will be done here, paintbounds wont...
+            if element.transform.is_identity():
+                points = element.points
+            else:
+                points = list(
+                    map(element.transform.point_in_matrix_space, element.points)
+                )
+            xmin = min(p.x for p in points if p is not None)
+            ymin = min(p.y for p in points if p is not None)
+            xmax = max(p.x for p in points if p is not None)
+            ymax = max(p.y for p in points if p is not None)
+            node._bounds = [
+                xmin,
+                ymin,
+                xmax,
+                ymax,
+            ]
+            node._bounds_dirty = False
+            node.revalidate_points()
+            node._points_dirty = False
+        e_list.append(node)
+
+    def _parse_ellipse(self, element, ident, label, lock, context_node, e_list):
+        """
+        Parses the SVG Circle, and Ellipse nodes into `elem ellipse` nodes.
+
+        @param element:
+        @param ident:
+        @param label:
+        @param lock:
+        @param context_node:
+        @param e_list:
+        @return:
+        """
+        if element.is_degenerate():
+            return
+        node = context_node.add(
+            shape=element,
+            type="elem ellipse",
+            id=ident,
+            label=label,
+            lock=lock,
+        )
+        e_list.append(node)
+
+    def _parse_rect(self, element, ident, label, lock, context_node, e_list):
+        """
+        Parse SVG Rect objects into `elem rect` objects.
+
+        @param element:
+        @param ident:
+        @param label:
+        @param lock:
+        @param context_node:
+        @param e_list:
+        @return:
+        """
+        if element.is_degenerate():
+            return
+        node = context_node.add(
+            shape=element, type="elem rect", id=ident, label=label, lock=lock
+        )
+        self.check_for_line_attributes(node, element)
+        if self.precalc_bbox:
+            # bounds will be done here, paintbounds wont...
+            points = (
+                Point(element.x, element.y),
+                Point(element.x + element.width, element.y),
+                Point(element.x + element.width, element.y + element.height),
+                Point(element.x, element.y + element.height),
+            )
+            if not element.transform.is_identity():
+                points = list(map(element.transform.point_in_matrix_space, points))
+            xmin = min(p.x for p in points)
+            ymin = min(p.y for p in points)
+            xmax = max(p.x for p in points)
+            ymax = max(p.y for p in points)
+            node._bounds = [
+                xmin,
+                ymin,
+                xmax,
+                ymax,
+            ]
+            node._bounds_dirty = False
+            node.revalidate_points()
+            node._points_dirty = False
+        e_list.append(node)
+
+    def _parse_line(self, element, ident, label, lock, context_node, e_list):
+        """
+        Parse SVG Line objects into `elem line`
+
+        @param element:
+        @param ident:
+        @param label:
+        @param lock:
+        @param context_node:
+        @param e_list:
+        @return:
+        """
+        if element.is_degenerate():
+            return
+        node = context_node.add(
+            shape=element, type="elem line", id=ident, label=label, lock=lock
+        )
+        self.check_for_line_attributes(node, element)
+        if self.precalc_bbox:
+            # bounds will be done here, paintbounds wont...
+            points = (
+                Point(element.x1, element.y1),
+                Point(element.x2, element.y2),
+            )
+            if not element.transform.is_identity():
+                points = list(map(element.transform.point_in_matrix_space, points))
+            xmin = min(p.x for p in points)
+            ymin = min(p.y for p in points)
+            xmax = max(p.x for p in points)
+            ymax = max(p.y for p in points)
+            node._bounds = [
+                xmin,
+                ymin,
+                xmax,
+                ymax,
+            ]
+            node._bounds_dirty = False
+            node.revalidate_points()
+            node._points_dirty = False
+        e_list.append(node)
+
+    def _parse_image(self, element, ident, label, lock, context_node, e_list):
+        """
+        Parse SVG Image objects into either `image raster` or `elem image` objects, potentially other classes.
+
+        @param element:
+        @param ident:
+        @param label:
+        @param lock:
+        @param context_node:
+        @param e_list:
+        @return:
+        """
+        try:
+            element.load(os.path.dirname(self.pathname))
+            try:
+                operations = ast.literal_eval(element.values["operations"])
+            except (ValueError, SyntaxError, KeyError):
+                operations = None
+
+            if element.image is not None:
+                try:
+                    dpi = element.image.info["dpi"]
+                except KeyError:
+                    dpi = None
+                _dpi = 500
+                if (
+                    isinstance(dpi, tuple)
+                    and len(dpi) >= 2
+                    and dpi[0] != 0
+                    and dpi[1] != 0
+                ):
+                    _dpi = round((float(dpi[0]) + float(dpi[1])) / 2, 0)
+                _overscan = None
+                try:
+                    _overscan = str(element.values.get("overscan"))
+                except (ValueError, TypeError):
+                    pass
+                _direction = None
+                try:
+                    _direction = int(element.values.get("direction"))
+                except (ValueError, TypeError):
+                    pass
+                _invert = None
+                try:
+                    _invert = bool(element.values.get("invert") == "True")
+                except (ValueError, TypeError):
+                    pass
+                _dither = None
+                try:
+                    _dither = bool(element.values.get("dither") == "True")
+                except (ValueError, TypeError):
+                    pass
+                _dither_type = None
+                try:
+                    _dither_type = element.values.get("dither_type")
+                except (ValueError, TypeError):
+                    pass
+                _red = None
+                try:
+                    _red = float(element.values.get("red"))
+                except (ValueError, TypeError):
+                    pass
+                _green = None
+                try:
+                    _green = float(element.values.get("green"))
+                except (ValueError, TypeError):
+                    pass
+                _blue = None
+                try:
+                    _blue = float(element.values.get("blue"))
+                except (ValueError, TypeError):
+                    pass
+                _lightness = None
+                try:
+                    _lightness = float(element.values.get("lightness"))
+                except (ValueError, TypeError):
+                    pass
+                node = context_node.add(
+                    image=element.image,
+                    matrix=element.transform,
+                    type="elem image",
+                    id=ident,
+                    overscan=_overscan,
+                    direction=_direction,
+                    dpi=_dpi,
+                    invert=_invert,
+                    dither=_dither,
+                    dither_type=_dither_type,
+                    red=_red,
+                    green=_green,
+                    blue=_blue,
+                    lightness=_lightness,
+                    label=label,
+                    operations=operations,
+                    lock=lock,
+                )
+                e_list.append(node)
+        except OSError:
+            pass
+
+    def _parse_element(self, element, ident, label, lock, context_node, e_list):
+        """
+        SVGElement is type. Generic or unknown node type. These nodes do not have children, these are used in
+        meerk40t contain notes and operations. Element type="elem point", and other points will also load with
+        this code.
+
+        @param element:
+        @param ident:
+        @param label:
+        @param lock:
+        @param context_node:
+        @param e_list:
+        @return:
+        """
+
+        # Fix: we have mixed capitalisaton in full_ns and tag --> adjust
+        tag = element.values.get(SVG_ATTR_TAG).lower()
+        if tag is not None:
+            # We remove the name space.
+            full_ns = f"{{{MEERK40T_NAMESPACE.lower()}}}"
+            if full_ns in tag:
+                tag = tag.replace(full_ns, "")
+
+        # Check if note-type
+        if tag == "note":
+            self.elements.note = element.values.get(SVG_TAG_TEXT)
+            self.elements.signal("note", self.pathname)
+            return
+
+        node_type = element.values.get("type")
+        if node_type is None:
+            # Type is not given. Abort.
+            return
+
+        if node_type == "op":
+            # Meerk40t 0.7.x fallback node types.
+            op_type = element.values.get("operation")
+            if op_type is None:
+                return
+            node_type = f"op {op_type.lower()}"
+            element.values["attributes"]["type"] = node_type
+
+        node_id = element.values.get("id")
+
+        # Get node dictionary.
+        try:
+            attrs = element.values["attributes"]
+        except KeyError:
+            attrs = element.values
+
+        # If type exists in the dictionary, delete it to avoid double attribute issues.
+        try:
+            del attrs["type"]
+        except KeyError:
+            pass
+
+        # Set dictionary types with proper classes.
+        if "lock" in attrs:
+            attrs["lock"] = lock
+        if "transform" in element.values:
+            # Uses chained transforms from primary context.
+            attrs["matrix"] = Matrix(element.values["transform"])
+        if "fill" in attrs:
+            attrs["fill"] = Color(attrs["fill"])
+        if "stroke" in attrs:
+            attrs["stroke"] = Color(attrs["stroke"])
+
+        if tag == "operation":
+            # Operation type node.
+            if not self.load_operations:
+                # We don't do that.
+                return
+            if not self.operations_replaced:
+                self.operations_replaced = True
+
+            try:
+                if node_type == "op hatch":
+                    # Special fallback operation, op hatch is an op engrave with an effect hatch within it.
+                    node_type = "op engrave"
+                    op = self.elements.op_branch.add(type=node_type, **attrs)
+                    effect = op.add(type="effect hatch", **attrs)
+                else:
+                    op = self.elements.op_branch.add(type=node_type, **attrs)
+                op._ref_load = element.values.get("references")
+
+                if op is None or not hasattr(op, "type") or op.type is None:
+                    return
+                if hasattr(op, "validate"):
+                    op.validate()
+
+                op.id = node_id
+                self.operation_list.append(op)
+            except AttributeError:
+                # This operation is invalid.
+                return
+            except ValueError:
+                # This operation type failed to bootstrap.
+                return
+
+        elif tag == "element":
+            # Check if SVGElement: element
+            if "settings" in attrs:
+                del attrs[
+                    "settings"
+                ]  # If settings was set, delete it, or it will mess things up
+            elem = context_node.add(type=node_type, **attrs)
+            try:
+                elem.validate()
+            except AttributeError:
+                pass
+            elem.id = node_id
+            e_list.append(elem)
+
+    def parse(self, element, context_node, e_list, branch=None, uselabel=None):
+        """
+        Parse does the bulk of the work. Given an element, here the base case is an SVG itself, we parse such that
+        any groups will call and check all children recursively, updating the context_node, and passing each element
+        to this same function.
+
+
+        @param element: Element to parse.
+        @param context_node: Current context parent we're writing to.
+        @param e_list: elements list of all the nodes added by this function.
+        @param branch: Branch we are currently adding elements to.
+        @param uselabel:
+        @return:
+        """
+
+        if element.values.get("visibility") == "hidden":
+            if branch != "regmarks":
+                self.parse(
+                    element,
+                    self.elements.reg_branch,
+                    self.regmark_list,
+                    branch="regmarks",
+                )
+                return
+
+        ident = element.id
+
         if uselabel:
             _label = uselabel
         else:
-            _label = tag_label
+            _label = self.get_tag_label(element)
 
         _lock = None
         try:
             _lock = bool(element.values.get("lock") == "True")
         except (ValueError, TypeError):
             pass
+
         is_dot, dot_point = SVGProcessor.is_dot(element)
         if is_dot:
             node = context_node.add(
@@ -829,392 +1364,95 @@ class SVGProcessor:
             )
             e_list.append(node)
         elif isinstance(element, SVGText):
-            if element.text is None:
-                return
-
-            decor = element.values.get("text-decoration", "").lower()
-            node = context_node.add(
-                id=ident,
-                text=element.text,
-                x=element.x,
-                y=element.y,
-                font=element.values.get("font"),
-                anchor=element.values.get(SVG_ATTR_TEXT_ANCHOR),
-                baseline=element.values.get(
-                    SVG_ATTR_TEXT_ALIGNMENT_BASELINE,
-                    element.values.get(SVG_ATTR_TEXT_DOMINANT_BASELINE, "baseline"),
-                ),
-                matrix=element.transform,
-                fill=element.fill,
-                stroke=element.stroke,
-                stroke_width=element.stroke_width,
-                stroke_scale=bool(
-                    SVG_VALUE_NON_SCALING_STROKE
-                    not in element.values.get(SVG_ATTR_VECTOR_EFFECT, "")
-                ),
-                underline="underline" in decor,
-                strikethrough="line-through" in decor,
-                overline="overline" in decor,
-                texttransform=element.values.get("text-transform"),
-                type="elem text",
-                label=_label,
-                settings=element.values,
-            )
-            e_list.append(node)
+            self._parse_text(element, ident, _label, _lock, context_node, e_list)
         elif isinstance(element, Path):
-            if len(element) >= 0:
-                if element.values.get("type") == "elem polyline":
-                    # Type is polyline we should restore the node type if we have sufficient info to do so.
-                    pass
-                if element.values.get("type") == "elem ellipse":
-                    # There is not enough info to reconstruct this.
-                    pass
-                if element.values.get("type") == "elem rect":
-                    # There is not enough info to reconstruct this.
-                    pass
-                if element.values.get("type") == "elem line":
-                    pass
-                element.approximate_arcs_with_cubics()
-                node = context_node.add(
-                    path=element, type="elem path", id=ident, label=_label, lock=_lock
-                )
-                self.check_for_line_attributes(node, element)
-                self.check_for_fill_attributes(node, element)
-                self.check_for_mk_path_attributes(node, element)
-                e_list.append(node)
+            self._parse_path(element, ident, _label, _lock, context_node, e_list)
         elif isinstance(element, (Polygon, Polyline)):
-            if element.is_degenerate():
-                return
-            node = context_node.add(
-                shape=element,
-                type="elem polyline",
-                id=ident,
-                label=_label,
-                lock=_lock,
-            )
-            self.check_for_line_attributes(node, element)
-            self.check_for_fill_attributes(node, element)
-            self.check_for_mk_path_attributes(node, element)
-            if self.precalc_bbox:
-                # bounds will be done here, paintbounds wont...
-                if element.transform.is_identity():
-                    points = element.points
-                else:
-                    points = list(
-                        map(element.transform.point_in_matrix_space, element.points)
-                    )
-                xmin = min(p.x for p in points if p is not None)
-                ymin = min(p.y for p in points if p is not None)
-                xmax = max(p.x for p in points if p is not None)
-                ymax = max(p.y for p in points if p is not None)
-                node._bounds = [
-                    xmin,
-                    ymin,
-                    xmax,
-                    ymax,
-                ]
-                node._bounds_dirty = False
-                node.revalidate_points()
-                node._points_dirty = False
-            e_list.append(node)
+            self._parse_polyline(element, ident, _label, _lock, context_node, e_list)
         elif isinstance(element, (Circle, Ellipse)):
-            if element.is_degenerate():
-                return
-            node = context_node.add(
-                shape=element,
-                type="elem ellipse",
-                id=ident,
-                label=_label,
-                lock=_lock,
-            )
-            e_list.append(node)
+            self._parse_ellipse(element, ident, _label, _lock, context_node, e_list)
         elif isinstance(element, Rect):
-            if element.is_degenerate():
-                return
-            node = context_node.add(
-                shape=element, type="elem rect", id=ident, label=_label, lock=_lock
-            )
-            self.check_for_line_attributes(node, element)
-            if self.precalc_bbox:
-                # bounds will be done here, paintbounds wont...
-                points = (
-                    Point(element.x, element.y),
-                    Point(element.x + element.width, element.y),
-                    Point(element.x + element.width, element.y + element.height),
-                    Point(element.x, element.y + element.height),
-                )
-                if not element.transform.is_identity():
-                    points = list(map(element.transform.point_in_matrix_space, points))
-                xmin = min(p.x for p in points)
-                ymin = min(p.y for p in points)
-                xmax = max(p.x for p in points)
-                ymax = max(p.y for p in points)
-                node._bounds = [
-                    xmin,
-                    ymin,
-                    xmax,
-                    ymax,
-                ]
-                node._bounds_dirty = False
-                node.revalidate_points()
-                node._points_dirty = False
-            e_list.append(node)
+            self._parse_rect(element, ident, _label, _lock, context_node, e_list)
         elif isinstance(element, SimpleLine):
-            if element.is_degenerate():
-                return
-            node = context_node.add(
-                shape=element, type="elem line", id=ident, label=_label, lock=_lock
-            )
-            self.check_for_line_attributes(node, element)
-            if self.precalc_bbox:
-                # bounds will be done here, paintbounds wont...
-                points = (
-                    Point(element.x1, element.y1),
-                    Point(element.x2, element.y2),
-                )
-                if not element.transform.is_identity():
-                    points = list(map(element.transform.point_in_matrix_space, points))
-                xmin = min(p.x for p in points)
-                ymin = min(p.y for p in points)
-                xmax = max(p.x for p in points)
-                ymax = max(p.y for p in points)
-                node._bounds = [
-                    xmin,
-                    ymin,
-                    xmax,
-                    ymax,
-                ]
-                node._bounds_dirty = False
-                node.revalidate_points()
-                node._points_dirty = False
-            e_list.append(node)
+            self._parse_line(element, ident, _label, _lock, context_node, e_list)
         elif isinstance(element, SVGImage):
-            try:
-                element.load(os.path.dirname(self.pathname))
-                try:
-                    operations = ast.literal_eval(element.values["operations"])
-                except (ValueError, SyntaxError, KeyError):
-                    operations = None
-
-                if element.image is not None:
-                    try:
-                        dpi = element.image.info["dpi"]
-                    except KeyError:
-                        dpi = None
-                    _dpi = 500
-                    if (
-                        isinstance(dpi, tuple)
-                        and len(dpi) >= 2
-                        and dpi[0] != 0
-                        and dpi[1] != 0
-                    ):
-                        _dpi = round((float(dpi[0]) + float(dpi[1])) / 2, 0)
-                    _overscan = None
-                    try:
-                        _overscan = str(element.values.get("overscan"))
-                    except (ValueError, TypeError):
-                        pass
-                    _direction = None
-                    try:
-                        _direction = int(element.values.get("direction"))
-                    except (ValueError, TypeError):
-                        pass
-                    _invert = None
-                    try:
-                        _invert = bool(element.values.get("invert") == "True")
-                    except (ValueError, TypeError):
-                        pass
-                    _dither = None
-                    try:
-                        _dither = bool(element.values.get("dither") == "True")
-                    except (ValueError, TypeError):
-                        pass
-                    _dither_type = None
-                    try:
-                        _dither_type = element.values.get("dither_type")
-                    except (ValueError, TypeError):
-                        pass
-                    _red = None
-                    try:
-                        _red = float(element.values.get("red"))
-                    except (ValueError, TypeError):
-                        pass
-                    _green = None
-                    try:
-                        _green = float(element.values.get("green"))
-                    except (ValueError, TypeError):
-                        pass
-                    _blue = None
-                    try:
-                        _blue = float(element.values.get("blue"))
-                    except (ValueError, TypeError):
-                        pass
-                    _lightness = None
-                    try:
-                        _lightness = float(element.values.get("lightness"))
-                    except (ValueError, TypeError):
-                        pass
-                    node = context_node.add(
-                        image=element.image,
-                        matrix=element.transform,
-                        type="elem image",
-                        id=ident,
-                        overscan=_overscan,
-                        direction=_direction,
-                        dpi=_dpi,
-                        invert=_invert,
-                        dither=_dither,
-                        dither_type=_dither_type,
-                        red=_red,
-                        green=_green,
-                        blue=_blue,
-                        lightness=_lightness,
-                        label=_label,
-                        operations=operations,
-                        lock=_lock,
-                    )
-                    e_list.append(node)
-            except OSError:
-                pass
+            self._parse_image(element, ident, _label, _lock, context_node, e_list)
         elif isinstance(element, SVG):
-            # SVG is type of group, must go first
+            # SVG is type of group, it must be processed before Group. Nothing special is done with the type.
             if self.reverse:
                 for child in reversed(element):
-                    self.parse(child, context_node, e_list)
+                    self.parse(child, context_node, e_list, branch=branch)
             else:
                 for child in element:
-                    self.parse(child, context_node, e_list)
+                    self.parse(child, context_node, e_list, branch=branch)
         elif isinstance(element, Group):
-            if _label == "regmarks" or ident == "regmarks":
-                # We don't need a top-level group here, the regmarks node is a group...
-                context_node = self.regmark
-                e_list = self.regmark_list
-            else:
-                # Load group with specific group attributes (if needed)
-                e_dict = dict(element.values["attributes"])
-                e_type = e_dict.get("type", "group")
-                stroke = e_dict.get("stroke")
-                for attr in ("type", "id", "label", "stroke"):
-                    if attr in e_dict:
-                        del e_dict[attr]
-                if stroke is None:
-                    context_node = context_node.add(
-                        type=e_type, id=ident, label=_label, **e_dict
-                    )
-                else:
-                    context_node = context_node.add(
-                        type=e_type,
-                        id=ident,
-                        label=_label,
-                        stroke=Color(stroke),
-                        **e_dict,
-                    )
-                if hasattr(context_node, "effect"):
-                    context_node.effect = False
+            if branch != "regmarks" and (_label == "regmarks" or ident == "regmarks"):
+                # Recurse at same level within regmarks.
+                self.parse(
+                    element,
+                    self.elements.reg_branch,
+                    self.regmark_list,
+                    branch="regmarks",
+                )
+                return
+
+            # Load group with specific group attributes (if needed)
+            e_dict = dict(element.values["attributes"])
+            e_type = e_dict.get("type", "group")
+            if branch != "operations" and (
+                e_type.startswith("op ")
+                or e_type.startswith("place ")
+                or e_type.startswith("util ")
+            ):
+                # This is an operations but we are not in operations context.
+                if not self.load_operations:
+                    # We don't do that.
+                    return
+                self.operations_replaced = True
+                self.parse(
+                    element,
+                    self.elements.op_branch,
+                    self.operation_list,
+                    branch="operations",
+                )
+                return
+            if "stroke" in e_dict:
+                e_dict["stroke"] = Color(e_dict.get("stroke"))
+            if "fill" in e_dict:
+                e_dict["fill"] = Color(e_dict.get("fill"))
+            for attr in ("type", "id", "label"):
+                if attr in e_dict:
+                    del e_dict[attr]
+            context_node = context_node.add(
+                type=e_type, id=ident, label=_label, **e_dict
+            )
+            context_node._ref_load = element.values.get("references")
+            e_list.append(context_node)
+            if hasattr(context_node, "validate"):
+                context_node.validate()
 
             # recurse to children
             if self.reverse:
                 for child in reversed(element):
-                    self.parse(child, context_node, e_list)
+                    self.parse(child, context_node, e_list, branch=branch)
             else:
                 for child in element:
-                    self.parse(child, context_node, e_list)
+                    self.parse(child, context_node, e_list, branch=branch)
         elif isinstance(element, Use):
             # recurse to children, but do not subgroup elements.
             # We still use the original label
-
             if self.reverse:
                 for child in reversed(element):
-                    self.parse(child, context_node, e_list, uselabel=_label)
+                    self.parse(
+                        child, context_node, e_list, branch=branch, uselabel=_label
+                    )
             else:
                 for child in element:
-                    self.parse(child, context_node, e_list, uselabel=_label)
+                    self.parse(
+                        child, context_node, e_list, branch=branch, uselabel=_label
+                    )
         else:
-            # SVGElement is type. Generic or unknown node type.
-            # Fix: we have mixed capitalisaton in full_ns and tag --> adjust
-            tag = element.values.get(SVG_ATTR_TAG).lower()
-            if tag is not None:
-                # We remove the name space.
-                full_ns = f"{{{MEERK40T_NAMESPACE.lower()}}}"
-                if full_ns in tag:
-                    tag = tag.replace(full_ns, "")
-            # Check if note-type
-            if tag == "note":
-                self.elements.note = element.values.get(SVG_TAG_TEXT)
-                self.elements.signal("note", self.pathname)
-                return
-            node_type = element.values.get("type")
-            if node_type == "op":
-                # Meerk40t 0.7.x fallback node types.
-                op_type = element.values.get("operation")
-                if op_type is None:
-                    return
-                node_type = f"op {op_type.lower()}"
-                element.values["attributes"]["type"] = node_type
-
-            if node_type is None:
-                # Type is not given. Abort.
-                return
-
-            node_id = element.values.get("id")
-            try:
-                attrs = element.values["attributes"]
-            except KeyError:
-                attrs = element.values
-            try:
-                del attrs["type"]
-            except KeyError:
-                pass
-            if "lock" in attrs:
-                attrs["lock"] = _lock
-            if "transform" in element.values:
-                # Uses chained transforms from primary context.
-                attrs["matrix"] = Matrix(element.values["transform"])
-            if "fill" in attrs:
-                attrs["fill"] = Color(attrs["fill"])
-            if "stroke" in attrs:
-                attrs["stroke"] = Color(attrs["stroke"])
-
-            if self.load_operations and tag == "operation":
-                # Check if SVGElement: operation
-                if not self.operations_replaced:
-                    self.operations_replaced = True
-
-                try:
-                    if node_type == "op hatch":
-                        # Special fallback operation, op hatch is an op engrave with an effect hatch within it.
-                        node_type = "op engrave"
-                        op = self.elements.op_branch.create(type=node_type, **attrs)
-                        op.add(type="effect hatch", **attrs)
-                    else:
-                        op = self.elements.op_branch.create(type=node_type, **attrs)
-                    if op is None or not hasattr(op, "type") or op.type is None:
-                        return
-                    if hasattr(op, "validate"):
-                        op.validate()
-                    op.id = node_id
-                    if context_node.type.startswith("effect"):
-                        op.append_child(context_node)
-                    self.operation_list.append(op)
-                except AttributeError:
-                    # This operation is invalid.
-                    return
-                except ValueError:
-                    # This operation type failed to bootstrap.
-                    return
-            elif tag == "element":
-                # Check if SVGElement: element
-                if "settings" in attrs:
-                    del attrs[
-                        "settings"
-                    ]  # If settings was set, delete it, or it will mess things up
-                elem = context_node.add(type=node_type, **attrs)
-                try:
-                    elem.validate()
-                except AttributeError:
-                    pass
-                elem.id = node_id
-                e_list.append(elem)
+            self._parse_element(element, ident, _label, _lock, context_node, e_list)
 
 
 class SVGLoader: