meerk40t 0.9.7020__py2.py3-none-any.whl → 0.9.7040__py2.py3-none-any.whl

meerk40t/core/node/image_processed.py

@@ -163,19 +163,25 @@ class ImageProcessedNode(Node):
         return default_map
 
     def can_drop(self, drag_node):
+        if self.is_a_child_of(drag_node):
+            return False
         # Dragging element into element.
         return bool(
-            hasattr(drag_node, "as_geometry") or
-            hasattr(drag_node, "as_image") or
-            (drag_node.type.startswith("op ") and drag_node.type != "op dots") or
-            drag_node.type in ("file", "group")
+            hasattr(drag_node, "as_geometry")
+            or hasattr(drag_node, "as_image")
+            or (drag_node.type.startswith("op ") and drag_node.type != "op dots")
+            or drag_node.type in ("file", "group")
         )
 
     def drop(self, drag_node, modify=True, flag=False):
         # Dragging element into element.
         if not self.can_drop(drag_node):
             return False
-        if hasattr(drag_node, "as_geometry") or hasattr(drag_node, "as_image") or drag_node.type in ("file", "group"):
+        if (
+            hasattr(drag_node, "as_geometry")
+            or hasattr(drag_node, "as_image")
+            or drag_node.type in ("file", "group")
+        ):
             if modify:
                 self.insert_sibling(drag_node)
             return True

meerk40t/core/node/image_raster.py

@@ -92,19 +92,25 @@ class ImageRasterNode(Node):
         return default_map
 
     def can_drop(self, drag_node):
+        if self.is_a_child_of(drag_node):
+            return False
         # Dragging element into element.
         return bool(
-            hasattr(drag_node, "as_geometry") or
-            hasattr(drag_node, "as_image") or
-            (drag_node.type.startswith("op ") and drag_node.type != "op dots") or
-            drag_node.type in ("file", "group")
+            hasattr(drag_node, "as_geometry")
+            or hasattr(drag_node, "as_image")
+            or (drag_node.type.startswith("op ") and drag_node.type != "op dots")
+            or drag_node.type in ("file", "group")
         )
 
     def drop(self, drag_node, modify=True, flag=False):
         # Dragging element into element.
         if not self.can_drop(drag_node):
             return False
-        if hasattr(drag_node, "as_geometry") or hasattr(drag_node, "as_image") or drag_node.type in ("file", "group"):
+        if (
+            hasattr(drag_node, "as_geometry")
+            or hasattr(drag_node, "as_image")
+            or drag_node.type in ("file", "group")
+        ):
             if modify:
                 self.insert_sibling(drag_node)
             return True

meerk40t/core/node/node.py

@@ -193,7 +193,7 @@ class Node:
     def targeted(self, value):
         self._target = value
         self.notify_targeted(self)
-    
+
     @property
     def expanded(self):
         return self._expanded
@@ -457,17 +457,23 @@ class Node:
 
     def restore_tree(self, tree_data):
         # Takes a backup and reapplies it again to the tree
-        # Caveat: we can't just simply take the backup and load it into the tree, 
-        # although it is already a perfectly independent copy. 
+        # Caveat: we can't just simply take the backup and load it into the tree,
+        # although it is already a perfectly independent copy.
         #           self._children.extend(tree_data)
-        # If loaded directly as above then this stored state will be used 
-        # as the basis for further modifications consequently changing the 
+        # If loaded directly as above then this stored state will be used
+        # as the basis for further modifications consequently changing the
         # original data (as it is still the original structure) used in the undostack.
         # tree_data contains the copied branch nodes
-        
+
         self._children.clear()
         links = {id(self): (self, None)}
-        attrib_list = ("_selected", "_emphasized", "_emphasized_time", "_highlighted", "_expanded")
+        attrib_list = (
+            "_selected",
+            "_emphasized",
+            "_emphasized_time",
+            "_highlighted",
+            "_expanded",
+        )
         for c in tree_data:
             c._build_copy_nodes(links=links)
             node_copy = copy(c)
@@ -499,9 +505,12 @@ class Node:
             node_copy._parent = copied_parent
             copied_parent._children.append(node_copy)
             if node.type == "reference":
-                original_referenced, copied_referenced = links[id(node.node)]
-                node_copy.node = copied_referenced
-                copied_referenced._references.append(node_copy)
+                try:
+                    original_referenced, copied_referenced = links[id(node.node)]
+                    node_copy.node = copied_referenced
+                    copied_referenced._references.append(node_copy)
+                except KeyError:
+                    pass
 
     def _validate_tree(self):
         for c in self._children:
@@ -525,12 +534,23 @@ class Node:
         """
         if links is None:
             links = {id(self): (self, None)}
-        attrib_list = ("_selected", "_emphasized", "_emphasized_time", "_highlighted", "_expanded")
+        attrib_list = (
+            "_selected",
+            "_emphasized",
+            "_emphasized_time",
+            "_highlighted",
+            "_expanded",
+            "_translated_text",
+        )
         for c in self._children:
             c._build_copy_nodes(links=links)
             node_copy = copy(c)
             for att in attrib_list:
-                if getattr(node_copy, att) != getattr(c, att):
+                if not hasattr(c, att):
+                    continue
+                if not hasattr(node_copy, att) or getattr(node_copy, att) != getattr(
+                    c, att
+                ):
                     # print (f"Strange {att} not identical, fixing")
                     setattr(node_copy, att, getattr(c, att))
             node_copy._root = self._root
@@ -580,7 +600,7 @@ class Node:
             result = "<invalid pattern>"
         return result
 
-    def default_map(self, default_map=None):   # , skip_label=False
+    def default_map(self, default_map=None):  # , skip_label=False
         if default_map is None:
             default_map = self._default_map
         default_map["id"] = str(self.id) if self.id is not None else "-"
@@ -814,7 +834,9 @@ class Node:
                 node = self
             self._parent.notify_modified(node=node, **kwargs)
 
-    def notify_translated(self, node=None, dx=0, dy=0, invalidate=False, interim=False, **kwargs):
+    def notify_translated(
+        self, node=None, dx=0, dy=0, invalidate=False, interim=False, **kwargs
+    ):
         if invalidate:
             self.set_dirty_bounds()
         if self._parent is not None:
@@ -826,7 +848,15 @@ class Node:
             )
 
     def notify_scaled(
-        self, node=None, sx=1, sy=1, ox=0, oy=0, invalidate=False, interim=False, **kwargs
+        self,
+        node=None,
+        sx=1,
+        sy=1,
+        ox=0,
+        oy=0,
+        invalidate=False,
+        interim=False,
+        **kwargs,
     ):
         if invalidate:
             self.set_dirty_bounds()
@@ -835,7 +865,14 @@ class Node:
                 node = self
             # Any change to position / size needs a recalculation of the bounds
             self._parent.notify_scaled(
-                node=node, sx=sx, sy=sy, ox=ox, oy=oy, invalidate=True, interim=interim, **kwargs
+                node=node,
+                sx=sx,
+                sy=sy,
+                ox=ox,
+                oy=oy,
+                invalidate=True,
+                interim=interim,
+                **kwargs,
             )
 
     def notify_altered(self, node=None, **kwargs):
@@ -950,6 +987,7 @@ class Node:
         This is a special case of the modified call, we are scaling
         the node without fundamentally altering its properties
         """
+
         def apply_it(box):
             x0, y0, x1, y1 = box
             if sx != 1.0:
@@ -1217,7 +1255,9 @@ class Node:
         If the node exists elsewhere in the tree it will be removed from that location.
         """
         reference_sibling = self
-        source_siblings = None if new_sibling.parent is None else new_sibling.parent.children 
+        source_siblings = (
+            None if new_sibling.parent is None else new_sibling.parent.children
+        )
         destination_siblings = reference_sibling.parent.children
 
         if source_siblings:
@@ -1331,7 +1371,8 @@ class Node:
         if children:
             self.remove_all_children(fast=fast)
         if self._parent:
-            self._parent._children.remove(self)
+            if self in self._parent._children:
+                self._parent._children.remove(self)
             self._parent.set_dirty_bounds()
         if not fast:
             self.notify_detached(self)
@@ -1353,6 +1394,14 @@ class Node:
             child.remove_all_children(fast=fast, destroy=destroy)
             child.remove_node(fast=fast, destroy=destroy)
 
+    def is_a_child_of(self, node):
+        candidate = self
+        while candidate is not None:
+            if candidate is node:
+                return True
+            candidate = candidate.parent
+        return False
+
     def has_ancestor(self, type):
         """
         Return whether this node has an ancestor node that matches the given type, or matches the major type.
@@ -1391,7 +1440,9 @@ class Node:
         dest.insert_node(self, pos=pos)
 
     @staticmethod
-    def union_bounds(nodes, bounds=None, attr="bounds", ignore_locked=True, ignore_hidden=False):
+    def union_bounds(
+        nodes, bounds=None, attr="bounds", ignore_locked=True, ignore_hidden=False
+    ):
         """
         Returns the union of the node list given, optionally unioned the given bounds value
 

meerk40t/core/node/refnode.py

@@ -54,5 +54,6 @@ class ReferenceNode(Node):
         return False
 
     def notify_destroyed(self, node=None, **kwargs):
-        self.node._references.remove(self)
+        if self.node is not None and self in self.node._references:
+            self.node._references.remove(self)
         super().notify_destroyed()

meerk40t/core/planner.py

@@ -181,6 +181,29 @@ def plugin(kernel, lifecycle=None):
                 "section": "_20_Reducing Movements",
                 "conditional": (context, "opt_reduce_travel"),
             },
+            {
+                "attr": "opt_stitching",
+                "object": context,
+                "default": False,
+                "type": bool,
+                "label": _("Combine path segments"),
+                "tip": 
+                    _("Stitch segments together that are very close (ideally having joint start/end points).") + "\n" +
+                    _("Only inside a single cut/engrave operation."),
+                "page": "Optimisations",
+                "section": "_05_Stitching",
+            },
+            {
+                "attr": "opt_stitch_tolerance",
+                "object": context,
+                "default": "0",
+                "type": Length,
+                "label": _("Tolerance"),
+                "tip": _("Tolerance to decide whether two path segments should be joined."),
+                "page": "Optimisations",
+                "section": "_05_Stitching",
+                "conditional": (context, "opt_stitching"),
+            },
             {
                 "attr": "opt_inner_first",
                 "object": context,

meerk40t/core/svg_io.py

@@ -124,7 +124,6 @@ def plugin(kernel, lifecycle=None):
                 "page": "Input/Output",
                 "section": "Input",
             },
-
         ]
         kernel.register_choices("preferences", choices)
         # The order is relevant as both loaders support SVG
@@ -237,7 +236,9 @@ class SVGWriter:
             if elements.last_file_autoexec is not None:
                 subelement = SubElement(root, "autoexec")
                 subelement.set("autoexec", str(elements.last_file_autoexec))
-                subelement.set("autoexec-active", str(elements.last_file_autoexec_active))
+                subelement.set(
+                    "autoexec-active", str(elements.last_file_autoexec_active)
+                )
 
         SVGWriter._write_tree(root, elements._tree, version)
 
@@ -279,7 +280,7 @@ class SVGWriter:
             if len(c.children) > 1:
                 flag = False
             return flag
-                    
+
         if c.type == "elem ellipse":
             subelement = SubElement(xml_tree, SVG_TAG_ELLIPSE)
             subelement.set(SVG_ATTR_CENTER_X, str(c.cx))
@@ -632,7 +633,12 @@ class SVGWriter:
                 pass
         # Node does not have settings, write object dict
         for key, value in node.__dict__.items():
-            if not key or key.startswith("_") or key in saved_attributes or value is None:
+            if (
+                not key
+                or key.startswith("_")
+                or key in saved_attributes
+                or value is None
+            ):
                 continue
             if key in (
                 "references",
@@ -663,7 +669,8 @@ class SVGWriter:
         for c in node.children:
             if c.type == "reference":
                 c = c.node  # Contain direct reference not reference node reference.
-                contains.append(c.id)
+                if c.id is not None:  # Something strange happened here...
+                    contains.append(c.id)
         if contains:
             subelement.set("references", " ".join(contains))
 
@@ -706,7 +713,13 @@ class SVGProcessor:
     Special care is taken to load MK specific objects like `note` and `operations`
     """
 
-    def __init__(self, elements, load_operations, load_hidden_to_regmarks = True, reuse_operations=True):
+    def __init__(
+        self,
+        elements,
+        load_operations,
+        load_hidden_to_regmarks=True,
+        reuse_operations=True,
+    ):
         self.elements = elements
 
         self.operation_list = list()
@@ -789,7 +802,7 @@ class SVGProcessor:
             self.elements.classify(self.element_list)
 
     def check_for_bound_information(self, node, element):
-        # Do we have existing boundary information? 
+        # Do we have existing boundary information?
         if "bounds" not in element.values:
             return False
         bbstr = element.values["bounds"]
@@ -816,15 +829,16 @@ class SVGProcessor:
                             bbox[idx] = val
                 except Exception:
                     # Whatever it was, we don't continue...
-                    pass                    
+                    pass
             node._paint_bounds = list(bbox)
             node._paint_bounds_dirty = False
             return True
 
-    def check_for_mk_path_attributes(self, node, element):
+    def check_for_mk_path_attributes(self, node, element, skip=None):
         """
         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.
+        the functional_parameter attribute for the node. This can be skipped if needed (eg. for basic shapes) as this
+        is not needed for them.
 
         @param node:
         @param element:
@@ -833,7 +847,8 @@ class SVGProcessor:
         for prop in element.values:
             lc = element.values.get(prop)
             if prop.startswith("mk"):
-                # print (f"Property: {prop} = [{type(lc).__name__}] {lc}")
+                if skip and prop in skip:
+                    continue
                 if lc is not None:
                     setattr(node, prop, lc)
                     # This needs to be done as some node types are not based on Parameters
@@ -975,7 +990,9 @@ class SVGProcessor:
             return tag_label
         return local_dict.get("label")
 
-    def _parse_text(self, element, ident, label, lock, context_node, e_list, set_hidden):
+    def _parse_text(
+        self, element, ident, label, lock, context_node, e_list, set_hidden
+    ):
         """
         Parses an SVGText object, into an `elem text` node.
 
@@ -1024,7 +1041,9 @@ class SVGProcessor:
         self.check_for_bound_information(node, element)
         e_list.append(node)
 
-    def _parse_path(self, element, ident, label, lock, context_node, e_list, set_hidden):
+    def _parse_path(
+        self, element, ident, label, lock, context_node, e_list, set_hidden
+    ):
         """
         Parses an SVG Path object.
 
@@ -1055,7 +1074,12 @@ class SVGProcessor:
             pass
         element.approximate_arcs_with_cubics()
         node = context_node.add(
-            path=element, type="elem path", id=ident, label=label, lock=lock, hidden=set_hidden
+            path=element,
+            type="elem path",
+            id=ident,
+            label=label,
+            lock=lock,
+            hidden=set_hidden,
         )
         self.check_for_label_display(node, element)
         self.check_for_line_attributes(node, element)
@@ -1064,7 +1088,9 @@ class SVGProcessor:
         self.check_for_bound_information(node, element)
         e_list.append(node)
 
-    def _parse_polyline(self, element, ident, label, lock, context_node, e_list, set_hidden):
+    def _parse_polyline(
+        self, element, ident, label, lock, context_node, e_list, set_hidden
+    ):
         """
         Parses svg Polyline and Polygon objects into `elem polyline` nodes.
 
@@ -1089,7 +1115,7 @@ class SVGProcessor:
         self.check_for_label_display(node, element)
         self.check_for_line_attributes(node, element)
         self.check_for_fill_attributes(node, element)
-        self.check_for_mk_path_attributes(node, element)
+        self.check_for_mk_path_attributes(node, element, skip=("mkparam",))
         if not self.check_for_bound_information(node, element) and self.precalc_bbox:
             # bounds will be done here, paintbounds won't...
             if element.transform.is_identity():
@@ -1113,7 +1139,9 @@ class SVGProcessor:
             node._points_dirty = False
         e_list.append(node)
 
-    def _parse_ellipse(self, element, ident, label, lock, context_node, e_list, set_hidden):
+    def _parse_ellipse(
+        self, element, ident, label, lock, context_node, e_list, set_hidden
+    ):
         """
         Parses the SVG Circle, and Ellipse nodes into `elem ellipse` nodes.
 
@@ -1137,11 +1165,13 @@ class SVGProcessor:
         )
         self.check_for_label_display(node, element)
         self.check_for_line_attributes(node, element)
-        self.check_for_mk_path_attributes(node, element)
+        self.check_for_mk_path_attributes(node, element, skip=("mkparam",))
         self.check_for_bound_information(node, element)
         e_list.append(node)
 
-    def _parse_rect(self, element, ident, label, lock, context_node, e_list, set_hidden):
+    def _parse_rect(
+        self, element, ident, label, lock, context_node, e_list, set_hidden
+    ):
         """
         Parse SVG Rect objects into `elem rect` objects.
 
@@ -1165,7 +1195,7 @@ class SVGProcessor:
         )
         self.check_for_label_display(node, element)
         self.check_for_line_attributes(node, element)
-        self.check_for_mk_path_attributes(node, element)
+        self.check_for_mk_path_attributes(node, element, skip=("mkparam",))
         if not self.check_for_bound_information(node, element) and self.precalc_bbox:
             # bounds will be done here, paintbounds won't...
             points = (
@@ -1191,7 +1221,9 @@ class SVGProcessor:
             node._points_dirty = False
         e_list.append(node)
 
-    def _parse_line(self, element, ident, label, lock, context_node, e_list, set_hidden):
+    def _parse_line(
+        self, element, ident, label, lock, context_node, e_list, set_hidden
+    ):
         """
         Parse SVG Line objects into `elem line`
 
@@ -1215,7 +1247,7 @@ class SVGProcessor:
         )
         self.check_for_label_display(node, element)
         self.check_for_line_attributes(node, element)
-        self.check_for_mk_path_attributes(node, element)
+        self.check_for_mk_path_attributes(node, element, skip=("mkparam",))
         if not self.check_for_bound_information(node, element) and self.precalc_bbox:
             # bounds will be done here, paintbounds won't...
             points = (
@@ -1239,7 +1271,9 @@ class SVGProcessor:
             node._points_dirty = False
         e_list.append(node)
 
-    def _parse_image(self, element, ident, label, lock, context_node, e_list, set_hidden):
+    def _parse_image(
+        self, element, ident, label, lock, context_node, e_list, set_hidden
+    ):
         """
         Parse SVG Image objects into either `image raster` or `elem image` objects, potentially other classes.
 
@@ -1516,7 +1550,6 @@ class SVGProcessor:
                 if branch not in ("elements", "regmarks"):
                     return
         if element.values.get("visibility") == "hidden" or display == "none":
-
             if self.load_hidden_to_regmarks:
                 if branch != "regmarks":
                     self.parse(
@@ -1554,19 +1587,33 @@ class SVGProcessor:
             self.check_for_bound_information(node, element)
             e_list.append(node)
         elif isinstance(element, SVGText):
-            self._parse_text(element, ident, _label, _lock, context_node, e_list, set_hidden)
+            self._parse_text(
+                element, ident, _label, _lock, context_node, e_list, set_hidden
+            )
         elif isinstance(element, Path):
-            self._parse_path(element, ident, _label, _lock, context_node, e_list, set_hidden)
+            self._parse_path(
+                element, ident, _label, _lock, context_node, e_list, set_hidden
+            )
         elif isinstance(element, (Polygon, Polyline)):
-            self._parse_polyline(element, ident, _label, _lock, context_node, e_list, set_hidden)
+            self._parse_polyline(
+                element, ident, _label, _lock, context_node, e_list, set_hidden
+            )
         elif isinstance(element, (Circle, Ellipse)):
-            self._parse_ellipse(element, ident, _label, _lock, context_node, e_list, set_hidden)
+            self._parse_ellipse(
+                element, ident, _label, _lock, context_node, e_list, set_hidden
+            )
         elif isinstance(element, Rect):
-            self._parse_rect(element, ident, _label, _lock, context_node, e_list, set_hidden)
+            self._parse_rect(
+                element, ident, _label, _lock, context_node, e_list, set_hidden
+            )
         elif isinstance(element, SimpleLine):
-            self._parse_line(element, ident, _label, _lock, context_node, e_list, set_hidden)
+            self._parse_line(
+                element, ident, _label, _lock, context_node, e_list, set_hidden
+            )
         elif isinstance(element, SVGImage):
-            self._parse_image(element, ident, _label, _lock, context_node, e_list, set_hidden)
+            self._parse_image(
+                element, ident, _label, _lock, context_node, e_list, set_hidden
+            )
         elif isinstance(element, SVG):
             # SVG is type of group, it must be processed before Group. Nothing special is done with the type.
             if self.reverse:
@@ -1708,7 +1755,9 @@ class SVGProcessor:
             file_node = context_node.add(type="file", filepath=self.pathname)
             for node in self.regmark_list:
                 if node._parent is context_node:
-                    if node.type == "group" and (node.id == "regmarks" or node.label == "regmarks"):
+                    if node.type == "group" and (
+                        node.id == "regmarks" or node.label == "regmarks"
+                    ):
                         for n in list(node.children):
                             file_node.append_child(n)
                         node.remove_node()  # Removing group/file node.
@@ -1740,6 +1789,7 @@ class SVGProcessor:
         if needs_update:
             self.elements.process_keyhole_updates(None)
 
+
 class SVGLoader:
     """
     SVG loader - loading elements, regmarks and operations
@@ -1783,7 +1833,12 @@ class SVGLoader:
         reuse = elements_service.reuse_operations_on_load
         to_regmarks = elements_service.load_hidden_to_regmarks
         elements_service._loading_cleared = True
-        svg_processor = SVGProcessor(elements_service, load_operations=True, reuse_operations=reuse, load_hidden_to_regmarks=to_regmarks)
+        svg_processor = SVGProcessor(
+            elements_service,
+            load_operations=True,
+            reuse_operations=reuse,
+            load_hidden_to_regmarks=to_regmarks,
+        )
         svg_processor.process(svg, pathname)
         svg_processor.cleanup()
         return True
@@ -1830,7 +1885,9 @@ class SVGLoaderPlain:
             raise BadFileError(str(e)) from e
         elements_service._loading_cleared = True
         to_regmarks = elements_service.load_hidden_to_regmarks
-        svg_processor = SVGProcessor(elements_service, load_operations=False, load_hidden_to_regmarks=to_regmarks)
+        svg_processor = SVGProcessor(
+            elements_service, load_operations=False, load_hidden_to_regmarks=to_regmarks
+        )
         svg_processor.process(svg, pathname)
         svg_processor.cleanup()
         return True

meerk40t/core/undos.py

@@ -81,7 +81,7 @@ class Undo:
             elif self._undo_index < len(self._undo_stack) and self._undo_stack[self._undo_index].hold:
                 # Just add another one on top of it
                 self._undo_index += 1
-            elif self._undo_stack[self._undo_index].message == self.LAST_STATE:
+            elif self._undo_index < len(self._undo_stack) and self._undo_stack[self._undo_index].message == self.LAST_STATE:
                 # Will be overwritten
                 pass
             elif self._undo_index < len(self._undo_stack) - 1 and self._undo_stack[self._undo_index + 1].message != self.LAST_STATE:

meerk40t/core/wordlist.py

@@ -394,6 +394,7 @@ class Wordlist:
 
     def load_csv_file(self, filename, force_header=None):
         self.empty_csv()
+        ct = 0
         headers = []
         decoder = EncodingDetectFile()
         result = decoder.load(filename)

meerk40t/device/dummydevice.py

@@ -1,7 +1,7 @@
 from meerk40t.core.spoolers import Spooler
 from meerk40t.core.view import View
-from meerk40t.kernel import Service, signal_listener
 from meerk40t.device.devicechoices import get_effect_choices
+from meerk40t.kernel import Service, signal_listener
 
 from .mixins import Status
 
@@ -161,3 +161,9 @@ class DummyDevice(Service, Status):
         @return: the location in device native units for the current known position.
         """
         return self.native_x, self.native_y
+
+    def location(self):
+        """
+        Provide information about the device interface
+        """
+        return "mock"

meerk40t/dxf/dxf_io.py

@@ -251,6 +251,8 @@ class DXFProcessor:
         elif dxftype == "ELLIPSE":
             center = (entity.dxf.center)  # Center point of the ellipse (3D, but we'll use x,y)
             major_axis = entity.dxf.major_axis  # Vector representing the major axis
+            minor_axis = entity.minor_axis  # Vector representing the minor axis
+            # They should have the same sign, if they are different then they are mirrored?!
             ratio = entity.dxf.ratio  # Ratio of minor to major axis
             start_angle, end_angle = get_angles(entity)
 
@@ -262,6 +264,10 @@ class DXFProcessor:
                 major_axis[0] ** 2 + major_axis[1] ** 2
             )  # Length of the major axis (in XY plane)
             b = a * ratio  # Length of the minor axis
+            # Different signs? Inverse
+            if major_axis[0] * minor_axis[1] < 0:
+                b *= -1
+
             # geom = Geomstr.ellipse(
             #     start_t=start_angle,
             #     end_t=end_angle,