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

meerk40t/core/elements/element_treeops.py

@@ -1,5 +1,5 @@
 """
-This is a large number of flagged tree operations. The details of how these are registered is availible in the treeop.py
+This is a large number of flagged tree operations. The details of how these are registered is available in the treeop.py
 file. These define the right-click node menu operations. That menu is dynamically created based on various context
 cues.
 """
@@ -9,7 +9,6 @@ import math
 import os.path
 from copy import copy
 
-from meerk40t.core.cutcode.cutcode import CutCode
 from meerk40t.core.node.elem_image import ImageNode
 from meerk40t.core.node.node import Node
 from meerk40t.core.treeop import (
@@ -29,6 +28,7 @@ from meerk40t.core.treeop import (
 from meerk40t.core.units import UNITS_PER_INCH, Length
 from meerk40t.kernel import CommandSyntaxError
 from meerk40t.svgelements import Matrix, Point, Polygon
+from meerk40t.tools.geomstr import Geomstr
 
 from .element_types import *
 
@@ -49,13 +49,7 @@ def init_tree(kernel):
     # --------------------------- TREE OPERATIONS ---------------------------
 
     def is_regmark(node):
-        result = False
-        try:
-            if node._parent.type == "branch reg":
-                result = True
-        except AttributeError:
-            pass
-        return result
+        return node.has_ancestor("branch reg")
 
     def has_changes(node):
         result = False
@@ -67,6 +61,10 @@ def init_tree(kernel):
             pass
         return result
 
+    def is_developer_mode():
+        flag = getattr(self.kernel.root, "developer_mode", False)
+        return flag
+
     @tree_separator_after()
     @tree_conditional(lambda node: len(list(self.ops(selected=True))) == 1)
     @tree_operation(_("Operation properties"), node_type=op_nodes, help="")
@@ -121,6 +119,17 @@ def init_tree(kernel):
         if activate is not None:
             activate(node)
 
+    # @tree_operation(_("Debug group"), node_type=("group", "file"), help="")
+    # def debug_group(node, **kwargs):
+    #     if node is None:
+    #         return
+    #     info = ""
+    #     for idx, e in enumerate(list(node.children)):
+    #         if info:
+    #             info += "\n"
+    #         info += f"{idx}#: {e.type}, identical to parent: {e is node}"
+    #     print (info)
+
     @tree_conditional(lambda node: not is_regmark(node))
     @tree_operation(_("Ungroup elements"), node_type=("group", "file"), help="")
     def ungroup_elements(node, **kwargs):
@@ -190,8 +199,31 @@ def init_tree(kernel):
     @tree_conditional(lambda node: len(list(self.elems(emphasized=True))) > 1)
     @tree_operation(_("Group elements"), node_type=elem_nodes, help="")
     def group_elements(node, **kwargs):
-        group_node = node.parent.add(type="group", label="Group")
-        for e in list(self.elems(emphasized=True)):
+        def minimal_parent(data):
+            result = None
+            root = self.elem_branch
+            curr_level = None
+            for node in data:
+                plevel = 0
+                candidate = node.parent
+                while candidate is not None and candidate.parent is not root:
+                    candidate = candidate.parent
+                    plevel += 1
+                if curr_level is None or plevel < curr_level:
+                    curr_level = plevel
+                    result = node.parent
+                if plevel == 0:
+                    # No need to continue
+                    break
+            if result is None:
+                result = root
+            return result
+
+        raw_data = list(self.elems(emphasized=True))
+        data = self.condense_elements(raw_data, expand_at_end=False)
+        parent_node = minimal_parent(data)
+        group_node = parent_node.add(type="group", label="Group")
+        for e in data:
             group_node.append_child(e)
 
     @tree_conditional(
@@ -982,42 +1014,24 @@ def init_tree(kernel):
     # REMOVE SINGLE (Tree Selected - ELEMENT)
     # ==========
 
-    @tree_conditional(lambda node: hasattr(node, "effect") and not node.effect)
-    @tree_operation(
-        _("Effect: On"),
-        node_type=effect_nodes,
-        help="",
-    )
-    def effect_on(node, **kwargs):
-        node.effect = not node.effect
-
-    @tree_conditional(lambda node: hasattr(node, "effect") and node.effect)
-    @tree_operation(
-        _("Effect: Off"),
-        node_type=effect_nodes,
-        help="",
-    )
-    def effect_off(node, **kwargs):
-        node.effect = not node.effect
-
-    @tree_conditional(lambda node: node.can_remove)
-    @tree_conditional(
-        lambda cond: len(
-            list(self.flat(selected=True, cascade=False, types=elem_nodes))
-        )
-        == 1
-    )
-    @tree_operation(
-        _("Delete element '{name}' fully"),
-        node_type=elem_nodes,
-        help="",
-    )
-    def remove_type_elem(node, **kwargs):
-        if hasattr(node, "can_remove") and not node.can_remove:
-            pass
-        else:
-            self.set_emphasis(None)
-            node.remove_node()
+    # @tree_conditional(lambda node: node.can_remove)
+    # @tree_conditional(
+    #     lambda cond: len(
+    #         list(self.flat(selected=True, cascade=False, types=elem_nodes))
+    #     )
+    #     == 1
+    # )
+    # @tree_operation(
+    #     _("Delete element '{name}' fully"),
+    #     node_type=elem_nodes,
+    #     help="",
+    # )
+    # def remove_type_elem(node, **kwargs):
+    #     if hasattr(node, "can_remove") and not node.can_remove:
+    #         pass
+    #     else:
+    #         self.set_emphasis(None)
+    #         node.remove_node()
 
     @tree_conditional(
         lambda cond: len(list(self.flat(selected=True, cascade=False, types=op_nodes)))
@@ -1202,7 +1216,7 @@ def init_tree(kernel):
     # REMOVE ELEMENTS
     # ==========
     # More than one, special case == 1 already dealt with
-    @tree_conditional(lambda node: len(list(self.elems(emphasized=True))) > 1)
+    @tree_conditional(lambda node: len(list(self.elems(emphasized=True))) >= 1)
     @tree_calc("ecount", lambda i: len(list(self.elems(emphasized=True))))
     @tree_operation(
         _("Delete {ecount} elements, as selected in scene"),
@@ -1221,7 +1235,7 @@ def init_tree(kernel):
         self.signal("make_reference", node)
 
     @tree_conditional(
-        lambda node: isinstance(node.shape, Polygon) and len(node.shape.points) >= 3
+        lambda node: node.closed and len(list(node.geometry.as_points())) >= 3
     )
     @tree_operation(
         _("Make Polygon regular"),
@@ -1229,74 +1243,28 @@ def init_tree(kernel):
         help="",
     )
     def make_polygon_regular(node, **kwargs):
-        # from .units import Length
-        # from ..svgelements import Color
-
-        # def mk_debug_point(x, y, col):
-        #     circ = Ellipse(cx=x, cy=y, r=float(Length("1mm")))
-        #     circ.transform = copy(node.shape.transform)
-        #     self.elem_branch.add(
-        #         shape=circ,
-        #         type="elem ellipse",
-        #         stroke=Color(col),
-        #         fill=Color(col),
-        #         matrix=copy(node.matrix),
-        #     )
-
         if node is None or node.type != "elem polyline":
             return
-        number_points = len(node.shape.points)
-        # print (f"Number of points: {number_points}")
-        # for prop in dir(node):
-        #     print (f"{prop} - {getattr(node, 'prop', '')}")
-        # for idx, pt in enumerate(node.shape.points):
-        #     print (f"{idx}: {pt.x:.1f}, {pt.y:.1f}")
-        if number_points < 3 or not isinstance(node.shape, Polygon):
-            return
-        pts = node.shape.points
-        dx = pts[1].x - pts[0].x
-        dy = pts[1].y - pts[0].y
-        baseline = math.sqrt(dx * dx + dy * dy)
-        apothem = baseline / (2 * math.tan(math.tau / (2 * number_points)))
-        circumradius = baseline / (2 * math.sin(math.tau / (2 * number_points)))
-        midpoint = Point(pts[0].x + 0.5 * dx, pts[0].y + 0.5 * dy)
-        #  mk_debug_point(midpoint.x, midpoint.y, "black")
-        ax = 0
-        ay = 0
-        for idx, pt in enumerate(pts):
-            ax += pt.x
-            ay += pt.y
-        ax /= number_points
-        ay /= number_points
+        pts = list(node.geometry.as_points())
+        vertex_count = len(pts) - 1
+        baseline = abs(pts[1] - pts[0])
+        circumradius = baseline / (2 * math.sin(math.tau / (2 * vertex_count)))
+        # apothem = baseline / (2 * math.tan(math.tau / (2 * vertex_count)))
+        # midpoint = (pts[0] - pts[1]) / 2
+
         # The arithmetic center (ax, ay) indicates to which
         # 'side' of the baseline the polygon needs to be constructed
-        arithmetic_center = Point(ax, ay)
-        # mk_debug_point(ax, ay, "green")
-        angle = pts[0].angle_to(pts[1])
-        midangle = midpoint.angle_to(arithmetic_center)
-        angle += math.tau / 4
-        first_point = Point.polar(midpoint, angle, apothem)
-        second_point = Point.polar(midpoint, angle + math.tau / 2, apothem)
-        # mk_debug_point(first_point.x, first_point.y, "yellow")
-        # mk_debug_point(second_point.x, second_point.y, "cyan")
-        deltaangle = math.tau / number_points
-        d1 = arithmetic_center.distance_to(first_point)
-        d2 = arithmetic_center.distance_to(second_point)
-        if d1 < d2:
-            center_point = copy(first_point)
-        else:
-            center_point = copy(second_point)
-        # mk_debug_point(center_point.x, center_point.y, "red")
-
-        if center_point.angle_to(pts[0]) > center_point.angle_to(pts[1]):
-            deltaangle *= -1
-        angle = center_point.angle_to(pts[0])
-        for idx in range(number_points):
-            # if idx > 1:
-            pt = Point.polar(center_point, angle, circumradius)
-            pts[idx].x = pt.x
-            pts[idx].y = pt.y
-            angle += deltaangle
+        arithmetic_center = sum(pts[:-1]) / vertex_count
+
+        start_angle = Geomstr.angle(None, arithmetic_center, pts[0])
+
+        node.geometry = Geomstr.regular_polygon(
+            vertex_count,
+            arithmetic_center,
+            radius=circumradius,
+            radius_inner=circumradius,
+            start_angle=start_angle,
+        )
         node.altered()
         self.signal("refresh_scene", "Scene")
 
@@ -1422,48 +1390,89 @@ def init_tree(kernel):
         node.reverse()
         self.signal("refresh_tree", list(self.flat(types="reference")))
 
-    @tree_separator_after()
-    @tree_conditional(lambda node: self.classify_autogenerate)
+    @tree_submenu(_("Classification"))
     @tree_operation(
-        _("Refresh classification"),
-        node_type="branch ops",
+        _("Generate operations if needed"),
+        node_type=("branch ops", "branch elems"),
+        help="",
+        enable=False,
+    )
+    def do_classification_comment_1(node, **kwargs):
+        return
+
+    @tree_submenu(_("Classification"))
+    @tree_operation(
+        _("Refresh classification for all"),
+        node_type=("branch ops", "branch elems"),
         help=_("Reclassify elements and create operations if necessary"),
     )
-    def refresh_clasifications_1(node, **kwargs):
+    def refresh_classification_for_all_std(node, **kwargs):
+        previous = self.classify_autogenerate
+        self.classify_autogenerate = True
         self.remove_elements_from_operations(list(self.elems()))
         self.classify(list(self.elems()))
+        self.classify_autogenerate = previous
         self.signal("refresh_tree", list(self.flat(types="reference")))
 
-    @tree_conditional(lambda node: not self.classify_autogenerate)
+    @tree_conditional(lambda node: self.have_unassigned_elements())
+    @tree_submenu(_("Classification"))
     @tree_operation(
-        _("Refresh classification"),
-        node_type="branch ops",
-        help=_("Reclassify elements and use only existing operations"),
+        _("Classification for unassigned"),
+        node_type=("branch ops", "branch elems"),
+        help=_("Classify unassigned elements and create operations if necessary"),
     )
-    def refresh_clasifications_2(node, **kwargs):
-        self.remove_elements_from_operations(list(self.elems()))
-        self.classify(list(self.elems()))
+    def do_classification_for_unassigned_std(node, **kwargs):
+        previous = self.classify_autogenerate
+        self.classify_autogenerate = True
+        target_list = list(self.unassigned_elements())
+        self.classify(target_list)
+        self.classify_autogenerate = previous
         self.signal("refresh_tree", list(self.flat(types="reference")))
 
-    @tree_separator_after()
-    @tree_conditional(lambda node: not self.classify_autogenerate)
+    @tree_submenu(_("Classification"))
+    @tree_separator_before()
     @tree_operation(
-        _("Refresh ... (incl autogeneration)"),
-        node_type="branch ops",
-        help=_("Reclassify elements and create operations if necessary"),
+        _("Use only existing operations"),
+        node_type=("branch ops", "branch elems"),
+        help="",
+        enable=False,
     )
-    def refresh_clasifications_3(node, **kwargs):
+    def do_classification_comment_2(node, **kwargs):
+        return
+
+    @tree_submenu(_("Classification"))
+    @tree_operation(
+        _("Refresh classification for all"),
+        node_type=("branch ops", "branch elems"),
+        help=_("Reclassify all elements and use only existing operations"),
+    )
+    def refresh_classification_for_all_existing_only(node, **kwargs):
         previous = self.classify_autogenerate
-        self.classify_autogenerate = True
+        self.classify_autogenerate = False
         self.remove_elements_from_operations(list(self.elems()))
         self.classify(list(self.elems()))
         self.classify_autogenerate = previous
         self.signal("refresh_tree", list(self.flat(types="reference")))
 
+    @tree_submenu(_("Classification"))
+    @tree_conditional(lambda node: self.have_unassigned_elements())
+    @tree_operation(
+        _("Classification for unassigned"),
+        node_type=("branch ops", "branch elems"),
+        help=_("Classify unassigned elements and use only existing operations"),
+    )
+    def do_classification_for_unassigned_existing_only(node, **kwargs):
+        previous = self.classify_autogenerate
+        self.classify_autogenerate = False
+        target_list = list(self.unassigned_elements())
+        self.classify(target_list)
+        self.classify_autogenerate = previous
+        self.signal("refresh_tree", list(self.flat(types="reference")))
+
     @tree_conditional(lambda cond: self.have_unassigned_elements())
     @tree_operation(
         _("Select unassigned elements"),
-        node_type="branch ops",
+        node_type=("branch ops", "branch elems"),
         help=_("Select all elements that won't be burned"),
     )
     def select_unassigned(node, **kwargs):
@@ -1505,6 +1514,7 @@ def init_tree(kernel):
         difference = [m for m in materials if m not in secs]
         return difference
 
+    @tree_separator_before()
     @tree_submenu(_("Load"))
     @tree_values("opname", values=self.op_data.section_set)
     @tree_operation("{opname}", node_type="branch ops", help="")
@@ -1699,13 +1709,6 @@ def init_tree(kernel):
         )
         self.signal("updateop_tree")
 
-    @tree_operation(_("Reclassify operations"), node_type="branch elems", help="")
-    def reclassify_operations(node, **kwargs):
-        elems = list(self.elems())
-        self.remove_elements_from_operations(elems)
-        self.classify(list(self.elems()))
-        self.signal("refresh_tree")
-
     @tree_operation(
         _("Remove all assignments from operations"),
         node_type="branch elems",
@@ -1718,62 +1721,153 @@ def init_tree(kernel):
                     ref.remove_node()
         self.signal("refresh_tree")
 
-    @tree_submenu(_("Append special effect"))
-    @tree_operation(_("Append Line-fill 0.1mm"), node_type="branch elems", help="")
-    def append_element_effect_eulerian(
-        node, node_type="branch elems", pos=None, **kwargs
-    ):
-        self.elem_branch.add(
+    hatchable_elems = (
+        "elem path",
+        "elem rect",
+        "elem circle",
+        "elem ellipse",
+        "elem polyline",
+    )
+
+    @tree_submenu(_("Apply special effect"))
+    @tree_operation(_("Append Line-fill 0.1mm"), node_type=hatchable_elems, help="")
+    def append_element_effect_eulerian(node, pos=None, **kwargs):
+        group_node = node.parent.add(
             type="effect hatch",
             hatch_type="scanline",
             hatch_distance="0.1mm",
             hatch_angle="0deg",
             pos=pos,
         )
+        for e in list(self.elems(emphasized=True)):
+            group_node.append_child(e)
+        if self.classify_new:
+            self.classify([group_node])
+
         self.signal("updateelem_tree")
 
-    @tree_submenu(_("Append special effect"))
+    @tree_submenu(_("Apply special effect"))
     @tree_operation(
-        _("Append diagonal Line-fill 0.1mm"), node_type="branch elems", help=""
+        _("Append diagonal Line-fill 0.1mm"), node_type=hatchable_elems, help=""
     )
-    def append_element_effect_eulerian_45(
-        node, node_type="branch elems", pos=None, **kwargs
-    ):
-        self.elem_branch.add(
+    def append_element_effect_eulerian_45(node, pos=None, **kwargs):
+        group_node = node.parent.add(
             type="effect hatch",
             hatch_type="scanline",  # scanline / eulerian
             hatch_distance="0.1mm",
             hatch_angle="45deg",
             pos=pos,
         )
+        for e in list(self.elems(emphasized=True)):
+            group_node.append_child(e)
+        if self.classify_new:
+            self.classify([group_node])
+
         self.signal("updateelem_tree")
 
-    @tree_submenu(_("Append special effect"))
-    @tree_operation(_("Append Line-Fill 1mm"), node_type="branch elems", help="")
-    def append_element_effect_line(node, node_type="branch elems", pos=None, **kwargs):
-        self.elem_branch.add(
+    @tree_submenu(_("Apply special effect"))
+    @tree_operation(_("Append Line-Fill 1mm"), node_type=hatchable_elems, help="")
+    def append_element_effect_line(node, pos=None, **kwargs):
+        group_node = node.parent.add(
             type="effect hatch",
             hatch_type="scanline",
             hatch_distance="1mm",
             hatch_angle="0deg",
             pos=pos,
         )
+        for e in list(self.elems(emphasized=True)):
+            group_node.append_child(e)
+        if self.classify_new:
+            self.classify([group_node])
+
         self.signal("updateelem_tree")
 
-    @tree_submenu(_("Append special effect"))
+    @tree_submenu(_("Apply special effect"))
     @tree_operation(
-        _("Append diagonal Line-Fill 1mm"), node_type="branch elems", help=""
+        _("Append diagonal Line-Fill 1mm"), node_type=hatchable_elems, help=""
     )
-    def append_element_effect_line_45(
-        node, node_type="branch elems", pos=None, **kwargs
-    ):
-        self.elem_branch.add(
+    def append_element_effect_line_45(node, pos=None, **kwargs):
+        group_node = node.parent.add(
             type="effect hatch",
             hatch_type="scanline",
             hatch_distance="1mm",
             hatch_angle="45deg",
             pos=pos,
         )
+        for e in list(self.elems(emphasized=True)):
+            group_node.append_child(e)
+        if self.classify_new:
+            self.classify([group_node])
+
+        self.signal("updateelem_tree")
+
+    @tree_submenu(_("Apply special effect"))
+    @tree_operation(
+        _("Append wobble {type} {radius} @{interval}").format(
+            type="Circle", radius="0.5mm", interval="0.05mm"
+        ),
+        node_type=hatchable_elems,
+        help="",
+    )
+    def append_element_effect_wobble_c05(node, pos=None, **kwargs):
+        group_node = node.parent.add(
+            type="effect wobble",
+            wobble_type="circle",
+            wobble_radius="0.5mm",
+            wobble_interval="0.05mm",
+            pos=pos,
+        )
+        for e in list(self.elems(emphasized=True)):
+            group_node.append_child(e)
+        if self.classify_new:
+            self.classify([group_node])
+
+        self.signal("updateelem_tree")
+
+    @tree_submenu(_("Apply special effect"))
+    @tree_operation(
+        _("Append wobble {type} {radius} @{interval}").format(
+            type="Circle", radius="1mm", interval="0.1mm"
+        ),
+        node_type=hatchable_elems,
+        help="",
+    )
+    def append_element_effect_wobble_c1(node, pos=None, **kwargs):
+        group_node = node.parent.add(
+            type="effect wobble",
+            wobble_type="circle",
+            wobble_radius="1mm",
+            wobble_interval="0.1mm",
+            pos=pos,
+        )
+        for e in list(self.elems(emphasized=True)):
+            group_node.append_child(e)
+        if self.classify_new:
+            self.classify([group_node])
+
+        self.signal("updateelem_tree")
+
+    @tree_submenu(_("Apply special effect"))
+    @tree_operation(
+        _("Append wobble {type} {radius} @{interval}").format(
+            type="Circle", radius="3mm", interval="0.1mm"
+        ),
+        node_type=hatchable_elems,
+        help="",
+    )
+    def append_element_effect_wobble_c3(node, pos=None, **kwargs):
+        group_node = node.parent.add(
+            type="effect wobble",
+            wobble_type="circle_right",
+            wobble_radius="3mm",
+            wobble_interval="0.1mm",
+            pos=pos,
+        )
+        for e in list(self.elems(emphasized=True)):
+            group_node.append_child(e)
+        if self.classify_new:
+            self.classify([group_node])
+
         self.signal("updateelem_tree")
 
     @tree_operation(
@@ -2176,19 +2270,26 @@ def init_tree(kernel):
                 had_optional = False
                 # Need to add stroke and fill, as copy will take the
                 # default values for these attributes
-                for optional in ("fill", "stroke"):
-                    if hasattr(orgnode, optional):
+                options = ["fill", "stroke", "wxfont"]
+                for optional in options:
+                    if hasattr(e, optional):
                         setattr(copy_node, optional, getattr(orgnode, optional))
-                for optional in ("wxfont", "mktext", "mkfont", "mkfontsize"):
-                    if hasattr(orgnode, optional):
-                        had_optional = True
+                hadoptional = False
+                options = []
+                for prop in dir(e):
+                    if prop.startswith("mk"):
+                        options.append(prop)
+                for optional in options:
+                    if hasattr(e, optional):
                         setattr(copy_node, optional, getattr(orgnode, optional))
+                        hadoptional = True
+
                 if self.copy_increases_wordlist_references and hasattr(orgnode, "text"):
                     copy_node.text = self.wordlist_delta(orgnode.text, delta_wordlist)
                 elif self.copy_increases_wordlist_references and hasattr(e, "mktext"):
                     copy_node.mktext = self.wordlist_delta(e.mktext, delta_wordlist)
                 orgparent.add_node(copy_node)
-                if had_optional:
+                if hadoptional:
                     for property_op in self.kernel.lookup_all("path_updater/.*"):
                         property_op(self.kernel.root, copy_node)
 
@@ -2335,6 +2436,33 @@ def init_tree(kernel):
                 setattr(newnode, item[0], item[1])
             newnode.altered()
 
+    @tree_conditional(
+        lambda node: hasattr(node, "as_geometry") and node.has_ancestor("branch elems")
+    )
+    @tree_operation(
+        _("Convert to path"),
+        node_type=effect_nodes,
+        help="Convert effect to path",
+    )
+    def convert_to_path(singlenode, **kwargs):
+        elements = self.elem_branch
+        for node in list(elements.flat(types=effect_nodes, emphasized=True)):
+            if not hasattr(node, "as_geometry"):
+                continue
+            node_attributes = []
+            for attrib in ("stroke", "fill", "stroke_width", "stroke_scaled"):
+                if hasattr(node, attrib):
+                    oldval = getattr(node, attrib, None)
+                    node_attributes.append([attrib, oldval])
+            geometry = node.as_geometry()
+            node.remove_all_children()
+            if not len(geometry):
+                return
+            newnode = node.replace_node(geometry=geometry, type="elem path")
+            for item in node_attributes:
+                setattr(newnode, item[0], item[1])
+            newnode.altered()
+
     @tree_submenu(_("Flip"))
     @tree_separator_before()
     @tree_conditional(lambda node: not is_regmark(node))
@@ -2527,8 +2655,6 @@ def init_tree(kernel):
     @tree_separator_before()
     @tree_operation(_("Create placement"), node_type=elem_nodes, help="")
     def regmark_as_placement(node, **kwargs):
-        if node is None:
-            return
         if hasattr(node, "path"):
             bb = node.path.bbox(transformed=False)
         elif hasattr(node, "shape"):
@@ -2556,8 +2682,6 @@ def init_tree(kernel):
     @tree_submenu(_("Toggle Magnet-Lines"))
     @tree_operation(_("Around border"), node_type=elem_group_nodes, help="")
     def regmark_to_magnet_1(node, **kwargs):
-        if node is None:
-            return
         if not hasattr(node, "bounds"):
             return
         self.signal("magnet_gen", ("outer", node))
@@ -2566,18 +2690,10 @@ def init_tree(kernel):
     @tree_submenu(_("Toggle Magnet-Lines"))
     @tree_operation(_("At center"), node_type=elem_group_nodes, help="")
     def regmark_to_magnet_2(node, **kwargs):
-        if node is None:
-            return
         if not hasattr(node, "bounds"):
             return
         self.signal("magnet_gen", ("center", node))
 
-    # @tree_conditional(lambda node: not node.lock)
-    # @tree_conditional_try(lambda node: not node.lock)
-    # @tree_operation(_("Actualize pixels"), node_type="elem image", help="")
-    # def image_actualize_pixels(node, **kwargs):
-    #     self("image resample\n")
-
     @tree_conditional(lambda node: not node.lock)
     @tree_submenu(_("Z-depth divide"))
     @tree_iterate("divide", 2, 10)
@@ -2639,7 +2755,21 @@ def init_tree(kernel):
     def image_ccw(node, **kwargs):
         self("image ccw\n")
 
+    @tree_conditional(lambda node: not node.lock)
+    @tree_separator_before()
+    @tree_submenu(_("Image"))
+    @tree_operation(_("Identify inner white areas"), node_type="elem image", help="")
+    def image_white_area(node, **kwargs):
+        self("image innerwhite -l -o -m 2\n")
+
+    @tree_conditional(lambda node: not node.lock)
     @tree_submenu(_("Image"))
+    @tree_operation(_("Split image along white areas"), node_type="elem image", help="")
+    def image_white_area_split(node, **kwargs):
+        self("image innerwhite -w -o -m 2\n")
+
+    @tree_submenu(_("Image"))
+    @tree_separator_before()
     @tree_operation(
         _("Save original image to output.png"), node_type="elem image", help=""
     )
@@ -2653,6 +2783,16 @@ def init_tree(kernel):
     def image_save_processed(node, **kwargs):
         self("image save output.png --processed\n")
 
+    @tree_conditional(lambda node: not node.lock and is_developer_mode())
+    @tree_submenu(_("Convert"))
+    @tree_operation(_("Raw Image"), node_type="elem image", help="")
+    def image_convert_raw(node, **kwargs):
+        node.replace_node(
+            image=node.image,
+            matrix=node.matrix,
+            type="image raster",
+        )
+
     @tree_conditional(lambda node: len(node.children) > 0)
     @tree_separator_before()
     @tree_operation(