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

meerk40t/fill/patternfill.py

@@ -1,1061 +1,1061 @@
-"""
-    Obsolete! No longer needed, just there for reference
-"""
-from copy import copy
-
-from meerk40t.svgelements import (
-    Arc,
-    Close,
-    Color,
-    CubicBezier,
-    Line,
-    Matrix,
-    Move,
-    Path,
-    Point,
-    Polygon,
-    Polyline,
-    QuadraticBezier,
-)
-from meerk40t.tools.pathtools import VectorMontonizer
-
-_FACTOR = 1000
-
-
-class LivingHinges:
-    """
-    This class generates a predefined pattern in a *rectangular* area
-    """
-
-    def __init__(self, xpos, ypos, width, height):
-        self.pattern = None
-        self.start_x = xpos
-        self.start_y = ypos
-        self.width = width
-        self.height = height
-        # We set it off somewhat...
-        self.gap = 0
-        self.x0 = width * self.gap
-        self.y0 = height * self.gap
-        self.x1 = width * (1 - self.gap)
-        self.y1 = height * (1 - self.gap)
-        # Declare all used variables to satisfy codacy
-        self.param_a = 0
-        self.param_b = 0
-        self.cell_height_percentage = 200
-        self.cell_width_percentage = 200
-        self.cell_height = height * self.cell_height_percentage / _FACTOR
-        self.cell_width = width * self.cell_width_percentage / _FACTOR
-        self.cell_padding_v_percentage = 0
-        self.cell_padding_h_percentage = 0
-        self.cell_padding_h = self.cell_width * self.cell_padding_h_percentage / _FACTOR
-        self.cell_padding_v = (
-            self.cell_height * self.cell_padding_v_percentage / _FACTOR
-        )
-        # Requires recalculation
-        self.path = None
-        self.preview_path = None
-        self.outershape = None
-        # Specifically for the shape pattern we hold a list of precalculated polygons
-        self.pattern = []
-        self._extend_patterns = True
-        self.set_cell_values(100, 100)
-        self.set_padding_values(50, 50)
-        self.set_predefined_pattern(
-            entry=(
-                set_line,
-                False,
-                "",
-                "",
-                (-200, -350, 0, 0),
-                True,
-            )
-        )
-        self.cutpattern = None
-
-    def set_predefined_pattern(self, entry):
-        # The pattern needs to be defined within a 0,0  - 1,1 rectangle
-        #
-        self.cutpattern = entry
-
-        self._extend_patterns = entry[5]
-        additional_parameter = entry[1]
-        info1 = entry[2]
-        info2 = entry[3]
-        self.pattern = list(
-            entry[0](self.param_a, self.param_b, outershape=self.outershape)
-        )
-        self.path = None
-        self.preview_path = None
-        return additional_parameter, info1, info2
-
-    def make_outline(self, x0, y0, x1, y1):
-        # Draw a rectangle
-        pt0 = Point(x0, y0)
-        pt1 = Point(x1, y0)
-        pt2 = Point(x1, y1)
-        pt3 = Point(x0, y1)
-
-        self.path.move(pt0)
-        self.path.line(pt1)
-        self.path.line(pt2)
-        self.path.line(pt3)
-        self.path.line(pt0)
-
-    def draw_trace(self, offset_x, offset_y, width, height):
-        # Draw the pattern
-        # The extents of the cell will be at (offset_x, offset_y)
-        # in the upper-left corner and (width, height) in the bottom-right corner
-
-        def create_point(x, y):
-            return Point(x * width + offset_x, y * height + offset_y)
-
-        # self.path.move(offset_x, offset_y)
-        # print (f"After initial move: {str(self.path)}")
-        current_x = 0
-        current_y = 0
-        s_left = self.start_x
-        s_right = s_left + self.width
-        s_top = self.start_y
-        s_bottom = s_top + self.height
-        for entry in self.pattern:
-            old_x = current_x
-            old_y = current_y
-            key = entry[0].lower()
-            if key == "m":
-                endpoint = create_point(entry[1], entry[2])
-                self.path.move(endpoint)
-                current_x = entry[1]
-                current_y = entry[2]
-            elif key == "h":
-                current_x += entry[1]
-                dx = entry[1]
-                self.path.horizontal(dx, relative=True)
-            elif key == "v":
-                current_y += entry[1]
-                dy = entry[1]
-                self.path.vertical(dy, relative=True)
-            elif key == "l":
-                # Line to...
-                current_x = entry[1]
-                current_y = entry[2]
-                endpoint = create_point(entry[1], entry[2])
-                self.path.line(endpoint)
-            elif key == "a":
-                current_x = entry[6]
-                current_y = entry[7]
-                rx = entry[1]
-                ry = entry[2]
-                rotation = entry[3]
-                arc = entry[4]
-                sweep = entry[5]
-                endpoint = create_point(current_x, current_y)
-                self.path.arc(rx, ry, rotation, arc, sweep, endpoint)
-            elif key == "c":
-                current_x = entry[5]
-                current_y = entry[6]
-                control1 = create_point(entry[1], entry[2])
-                control2 = create_point(entry[3], entry[4])
-                endpoint = create_point(entry[5], entry[6])
-                self.path.cubic(control1, control2, endpoint)
-            elif key == "q":
-                current_x = entry[3]
-                current_y = entry[4]
-                control1 = create_point(entry[1], entry[2])
-                endpoint = create_point(entry[3], entry[4])
-                self.path.quad(control1, endpoint)
-
-    def set_hinge_shape(self, shapenode):
-        # reset cache
-        self.outershape = shapenode
-
-    def set_hinge_area(self, hinge_left, hinge_top, hinge_width, hinge_height):
-        self.start_x = hinge_left
-        self.start_y = hinge_top
-        self.width = hinge_width
-        self.height = hinge_height
-        self.x0 = hinge_width * self.gap
-        self.y0 = hinge_height * self.gap
-        self.x1 = hinge_width * (1 - self.gap)
-        self.y1 = hinge_height * (1 - self.gap)
-        # Requires recalculation
-        self.path = None
-        self.preview_path = None
-
-    def set_cell_values(self, percentage_x, percentage_y):
-        self.cell_width_percentage = percentage_x
-        self.cell_height_percentage = percentage_y
-        # Requires recalculation
-        self.path = None
-        self.preview_path = None
-
-    def set_padding_values(self, padding_x, padding_y):
-        self.cell_padding_h_percentage = padding_x
-        self.cell_padding_v_percentage = padding_y
-        # Requires recalculation
-        self.path = None
-        self.preview_path = None
-
-    def set_additional_parameters(self, param_a, param_b):
-        self.param_a = param_a
-        self.param_b = param_b
-        # Reset cache for shape pattern
-        # Make sure pattern is updated with additional parameter
-        self.set_predefined_pattern(self.cutpattern)
-
-    @staticmethod
-    def outside(bb_to_check, master_bb):
-        out_x = "inside"
-        out_y = "inside"
-        if bb_to_check[0] > master_bb[2] or bb_to_check[2] < master_bb[0]:
-            # fully out on x
-            out_x = "outside"
-        elif bb_to_check[0] < master_bb[0] or bb_to_check[2] > master_bb[2]:
-            out_x = "cross"
-        if bb_to_check[1] > master_bb[3] or bb_to_check[3] < master_bb[1]:
-            out_y = "outside"
-        elif bb_to_check[1] < master_bb[1] or bb_to_check[3] > master_bb[3]:
-            out_x = "cross"
-        return out_x, out_y
-
-    def generate(self, show_outline=False, force=False, final=False, clip_bounds=True):
-        if final and self.path is not None and not force:
-            # No need to recalculate...
-            return
-        elif not final and self.preview_path is not None and not force:
-            # No need to recalculate...
-            return
-
-        self.cell_width = self.width * self.cell_width_percentage / _FACTOR
-        self.cell_height = self.height * self.cell_height_percentage / _FACTOR
-        self.cell_padding_h = self.cell_width * self.cell_padding_h_percentage / _FACTOR
-        self.cell_padding_v = (
-            self.cell_height * self.cell_padding_v_percentage / _FACTOR
-        )
-        self.path = Path(stroke=Color("red"), stroke_width=500)
-
-        if show_outline:
-            self.make_outline(self.x0, self.y0, self.x1, self.y1)
-
-        #  Determine rows and columns of cuts to create
-        #  will round down so add 1 and trim later
-        #  Determine rows and columns of cuts to create
-        #  will round down so add 1 and trim later
-        if self.cell_width + 2 * self.cell_padding_h == 0:
-            cols = 1
-        else:
-            cols = (
-                int(
-                    ((self.x1 - self.x0) + self.cell_width)
-                    / (self.cell_width + (2 * self.cell_padding_h))
-                )
-                + 1
-            )
-        if self.cell_height + 2 * self.cell_padding_v == 0:
-            rows = 1
-        else:
-            rows = (
-                int(
-                    ((self.y1 - self.y0) + self.cell_height)
-                    / (self.cell_height + (2 * self.cell_padding_v))
-                )
-                + 1
-            )
-
-        if self._extend_patterns:
-            start_value = -2
-            end_value = 1
-            off_x = -1 * (self.cell_width / 2)
-        else:
-            cols = max(1, cols - 2)
-            rows = max(1, rows - 2)
-            start_value = 0
-            end_value = 0
-            off_x = 0
-        # print (f"Area: {self.width:.1f}, {self.height:.1f}, Cell: {self.cell_width:.1f}, {self.cell_height:.1f}")
-        # print (f"Rows: {rows}, Cols={cols}")
-        # print (f"Ratios: {self.cell_width_percentage}, {self.cell_height_percentage}")
-        # print (f"Padding: {self.cell_padding_h_percentage}, {self.cell_padding_v_percentage}")
-        for col in range(start_value, cols + end_value, 1):
-            top_left_x = self.x0 + off_x
-            x_offset = col * (self.cell_width + (2 * self.cell_padding_h))
-            x_current = top_left_x + x_offset
-            for row in range(start_value, rows + end_value, 1):
-                top_left_y = self.y0
-                y_offset = row * (self.cell_height + (2 * self.cell_padding_v)) + (
-                    (self.cell_height + (2 * self.cell_padding_v)) / 2
-                ) * (col % 2)
-                y_current = top_left_y + y_offset
-
-                if x_current < self.x1 and y_current < self.y1:
-                    # Don't call draw if outside of hinge area
-                    self.draw_trace(
-                        x_current,
-                        y_current,
-                        self.cell_width,
-                        self.cell_height,
-                    )
-                    if show_outline:
-                        self.make_outline(
-                            x_current,
-                            y_current,
-                            x_current + self.cell_width,
-                            y_current + self.cell_height,
-                        )
-        if not clip_bounds:
-            return
-        rectangular = True
-        if (
-            self.outershape is not None
-            and hasattr(self.outershape, "as_path")
-            and self.outershape.type != "elem rect"
-        ):
-            rectangular = False
-        if final and not rectangular:
-            self.path.transform *= Matrix.translate(self.start_x, self.start_y)
-            from time import time
-
-            t0 = time()
-            vm = VectorMontonizer()
-            outer_bb = self.outershape.bbox()
-            outer_path = self.outershape.as_path()
-            outer_poly = Polygon(
-                [outer_path.point(i / 1000.0, error=1e4) for i in range(1001)]
-            )
-            vm.add_polyline(outer_poly)
-            path = Path(stroke=Color("red"), stroke_width=500)
-            deleted = 0
-            total = 0
-            # pt_min_x = 1E+30
-            # pt_min_y = 1E+30
-            # pt_max_x = -1 * pt_min_x
-            # pt_max_y = -1 * pt_min_y
-            # Numpy does not work
-            # vm.add_polyline(outer_poly)
-            # path = Path(stroke=Color("red"), stroke_width=500)
-            # for sub_inner in self.path.as_subpaths():
-            #     sub_inner = Path(sub_inner)
-            #     pts_sub = sub_inner.npoint(linspace(0, 1, 1000))
-            #     good_pts = [p for p in pts_sub if vm.is_point_inside(p[0] + self.start_x, p[1] + self.start_y)]
-            #     path += Path(Polyline(good_pts), stroke=Color("red"), stroke_width=500)
-            for sub_inner in self.path.as_subpaths():
-                sub_bbox = sub_inner.bbox()
-                outx, outy = self.outside(sub_bbox, outer_bb)
-                if outx == "outside" or outy == "outside":
-                    continue
-
-                sub_inner = Path(sub_inner)
-                pts_sub = [sub_inner.point(i / 1000.0, error=1e4) for i in range(1001)]
-                fullyinside = True
-                for i in range(len(pts_sub) - 1, -1, -1):
-                    total += 1
-                    pt = pts_sub[i]
-                    pt[0] += self.start_x
-                    pt[1] += self.start_y
-                    # pt_min_x = min(pt_min_x, pt[0])
-                    # pt_min_y = min(pt_min_y, pt[1])
-                    # pt_max_x = max(pt_max_x, pt[0])
-                    # pt_max_y = max(pt_max_y, pt[1])
-                    if not vm.is_point_inside(pt[0], pt[1]):
-                        # if we do have points beyond, then we create a seperate path
-                        if i < len(pts_sub) - 1:
-                            goodpts = pts_sub[i + 1 :]
-                            path += Path(
-                                Polyline(goodpts), stroke=Color("red"), stroke_width=500
-                            )
-                        del pts_sub[i:]
-                        deleted += 1
-                        fullyinside = False
-                if fullyinside:
-                    path += abs(sub_inner)
-                else:
-                    path += Path(
-                        Polyline(pts_sub), stroke=Color("red"), stroke_width=500
-                    )
-            self.path = path
-        else:
-            # Former method....
-            # ...is limited to rectangular area but maintains inner cubics,
-            # quads and arcs while the vectormontonizer is more versatile
-            # when it comes to the surrounding shape but transforms all
-            # path elements to lines
-            self.path = self.clip_path(self.path, 0, 0, self.width, self.height)
-            self.path.transform *= Matrix.translate(self.start_x, self.start_y)
-            self.preview_path = copy(self.path)
-
-    def clip_path(self, path, xmin, ymin, xmax, ymax):
-        """
-        Clip a path at a rectangular area, will return the clipped path
-
-        Args:
-            path : The path to clip
-            xmin : Left side of the rectangular area
-            ymin : Upper side of the rectangular area
-            xmax : Right side of the rectangular area
-            ymax : Lower side of the rectangular area
-        """
-
-        def approximate_line(part_of_path, current_x, current_y):
-            # print(f"Check: {type(part_of_path).__name__} {part_of_path.bbox()} {clipbb}")
-            from numpy import linspace
-
-            added = 0
-            partial = 0
-            ignored = 0
-            subj = part_of_path.npoint(linspace(0, 1, interpolation))
-            subj.reshape((2, interpolation))
-            iterated_points = list(map(Point, subj))
-            for p in iterated_points:
-                segbb = (
-                    min(current_x, p[0]),
-                    min(current_y, p[1]),
-                    max(current_x, p[0]),
-                    max(current_y, p[1]),
-                )
-                sx, sy = self.outside(segbb, clipbb)
-                # print(f"{segbb} - {clipbb} {sx} - {sy}")
-                if sx == "outside" or sy == "outside":
-                    # Fully outside, so drop
-                    add_move(newpath, e.end)
-                    ignored += 1
-                elif statex == "inside" and statey == "inside":
-                    # Fully inside, so append
-                    if current_x != new_cx or current_y != new_cy:
-                        add_move(newpath, Point(current_x, current_y))
-                    newpath.line(p)
-                    added += 1
-                else:
-                    dx = p[0] - current_x
-                    dy = p[1] - current_y
-                    new_cx = current_x
-                    new_cy = current_y
-                    new_ex = p[0]
-                    new_ey = p[1]
-                    if dx == 0:
-                        # Vertical line needs special treatment
-                        if xmin <= new_cx <= xmax:
-                            new_cy = min(max(new_cy, ymin), ymax)
-                            new_ey = min(max(new_ey, ymin), ymax)
-                            if new_cx != current_x or new_cy != current_y:
-                                # Needs a move
-                                add_move(newpath, Point(new_cx, new_cy))
-                            newpath.line(Point(new_ex, new_ey))
-                            partial += 1
-                        else:
-                            ignored += 1
-                    else:
-                        # regular line, so lets establish x0 x1
-                        # could still be an outward pointing line....
-                        new_cx = min(max(new_cx, xmin), xmax)
-                        new_ex = min(max(new_ex, xmin), xmax)
-                        # corresponding y values...
-                        edx = p[0] - current_x
-                        edy = p[1] - current_y
-                        new_cy = current_y + (new_cx - current_x) / edx * edy
-                        new_ey = current_y + (new_ex - current_x) / edx * edy
-                        # Y can still cross...
-                        new_cx_clipped = new_cx
-                        new_ex_clipped = new_ex
-                        new_cy_clipped = min(max(new_cy, ymin), ymax)
-                        new_ey_clipped = min(max(new_ey, ymin), ymax)
-                        # Adjust x - value
-                        if dy != 0:
-                            new_cx_clipped = new_cx + dx / dy * (
-                                new_cy_clipped - new_cy
-                            )
-                            new_ex_clipped = new_ex + dx / dy * (
-                                new_ey_clipped - new_ey
-                            )
-
-                        new_cx = new_cx_clipped
-                        new_cy = new_cy_clipped
-                        new_ex = new_ex_clipped
-                        new_ey = new_ey_clipped
-                        if min(new_cy, new_ey) == ymax and dy != 0:
-                            # Outward...
-                            ignored += 1
-                        elif max(new_cy, new_ey) == ymin and dy != 0:
-                            # Outward...
-                            ignored += 1
-                        else:
-                            if new_cx != current_x or new_cy != current_y:
-                                # Needs a move
-                                add_move(newpath, Point(new_cx, new_cy))
-                            newpath.line(Point(new_ex, new_ey))
-                            partial += 1
-                current_x = p[0]
-                current_y = p[1]
-            if current_x != part_of_path.end[0] or current_y != part_of_path.end[1]:
-                add_move(newpath, part_of_path.end)
-            # print (f"From iterated line: added={added}, partial={partial}, ignored={ignored}")
-
-        def add_move(addpath, destination):
-            # Was the last segment as well a move? Then just update the coords...
-            if len(addpath) > 0:
-                if isinstance(addpath[-1], Move):
-                    addpath[-1].end = destination
-                    return
-            addpath.move(destination)
-
-        interpolation = 50
-        fully_deleted = 0
-        partial_deleted = 0
-        not_deleted = 0
-        clipbb = (xmin, ymin, xmax, ymax)
-        current_x = 0
-        current_y = 0
-        first_point = path.first_point
-        if first_point is not None:
-            current_x = first_point[0]
-            current_y = first_point[1]
-        newpath = Path(
-            stroke=path.stroke, stroke_width=path.stroke_width, transform=path.transform
-        )
-        for e in path:
-            if hasattr(e, "bbox"):
-                segbb = e.bbox()
-            elif hasattr(e, "end"):
-                segbb = (
-                    min(current_x, e.end[0]),
-                    min(current_y, e.end[1]),
-                    max(current_x, e.end[0]),
-                    max(current_y, e.end[1]),
-                )
-            else:
-                segbb = (xmin, ymin, 0, 0)
-            if isinstance(e, Move):
-                add_move(newpath, e.end)
-                current_x = e.end[0]
-                current_y = e.end[1]
-                not_deleted += 1
-            elif isinstance(e, Line):
-                statex, statey = self.outside(segbb, clipbb)
-                dx = e.end[0] - current_x
-                dy = e.end[1] - current_y
-                if statex == "outside" or statey == "outside":
-                    # Fully outside, so drop
-                    add_move(newpath, e.end)
-                    fully_deleted += 1
-                elif statex == "inside" and statey == "inside":
-                    # Fully inside, so append
-                    newpath.line(e.end)
-                    not_deleted += 1
-                else:
-                    # needs dealing, its either for the time being, just ignored...
-                    new_cx = current_x
-                    new_cy = current_y
-                    new_ex = e.end[0]
-                    new_ey = e.end[1]
-                    if dx == 0:
-                        # Vertical line needs special treatment
-                        if xmin <= new_cx <= xmax:
-                            new_cy = min(max(new_cy, ymin), ymax)
-                            new_ey = min(max(new_ey, ymin), ymax)
-                            if new_cx != current_x or new_cy != current_y:
-                                # Needs a move
-                                add_move(newpath, Point(new_cx, new_cy))
-                            newpath.line(Point(new_ex, new_ey))
-                    else:
-                        # regular line, so lets establish x0 x1
-                        # could still be an outward pointing line....
-                        new_cx = min(max(new_cx, xmin), xmax)
-                        new_ex = min(max(new_ex, xmin), xmax)
-                        # corresponding y values...
-                        edx = e.end[0] - current_x
-                        edy = e.end[1] - current_y
-                        new_cy = current_y + (new_cx - current_x) / edx * edy
-                        new_ey = current_y + (new_ex - current_x) / edx * edy
-                        # Y can still cross...
-                        new_cx_clipped = new_cx
-                        new_ex_clipped = new_ex
-                        new_cy_clipped = min(max(new_cy, ymin), ymax)
-                        new_ey_clipped = min(max(new_ey, ymin), ymax)
-                        # Adjust x - value
-                        if dy != 0:
-                            new_cx_clipped = new_cx + dx / dy * (
-                                new_cy_clipped - new_cy
-                            )
-                            new_ex_clipped = new_ex + dx / dy * (
-                                new_ey_clipped - new_ey
-                            )
-
-                        new_cx = new_cx_clipped
-                        new_cy = new_cy_clipped
-                        new_ex = new_ex_clipped
-                        new_ey = new_ey_clipped
-                        if min(new_cy, new_ey) == ymax and dy != 0:
-                            # Outward...
-                            pass
-                        elif max(new_cy, new_ey) == ymin and dy != 0:
-                            # Outward...
-                            pass
-                        else:
-                            if new_cx != current_x or new_cy != current_y:
-                                # Needs a move
-                                add_move(newpath, Point(new_cx, new_cy))
-                            newpath.line(Point(new_ex, new_ey))
-                    if current_x != e.end[0] or current_y != e.end[1]:
-                        add_move(newpath, e.end)
-                    partial_deleted += 1
-                current_x = e.end[0]
-                current_y = e.end[1]
-            elif isinstance(e, Close):
-                newpath.closed()
-                not_deleted += 1
-            elif isinstance(e, QuadraticBezier):
-                statex, statey = self.outside(segbb, clipbb)
-                if statex == "outside" and statey == "outside":
-                    # Fully outside, so drop
-                    add_move(newpath, e.end)
-                    fully_deleted += 1
-                elif statex == "inside" and statey == "inside":
-                    # Fully inside, so append
-                    newpath.quad(e.control, e.end)
-                    not_deleted += 1
-                else:
-                    approximate_line(e, current_x, current_y)
-                current_x = e.end[0]
-                current_y = e.end[1]
-            elif isinstance(e, CubicBezier):
-                statex, statey = self.outside(segbb, clipbb)
-                if statex == "outside" and statey == "outside":
-                    # Fully outside, so drop
-                    add_move(newpath, e.end)
-                    fully_deleted += 1
-                elif statex == "inside" and statey == "inside":
-                    # Fully inside, so append
-                    newpath.cubic(e.control1, e.control2, e.end)
-                    not_deleted += 1
-                else:
-                    approximate_line(e, current_x, current_y)
-                    partial_deleted += 1
-                current_x = e.end[0]
-                current_y = e.end[1]
-            elif isinstance(e, Arc):
-                for e_cubic in e.as_cubic_curves():
-                    segbb = e_cubic.bbox()
-                    statex, statey = self.outside(segbb, clipbb)
-                    if statex == "outside" and statey == "outside":
-                        # Fully outside, so drop
-                        add_move(newpath, e.end)
-                        fully_deleted += 1
-                    elif statex == "inside" and statey == "inside":
-                        # Fully inside, so append
-                        newpath.cubic(e_cubic.control1, e_cubic.control2, e_cubic.end)
-                        not_deleted += 1
-                    else:
-                        approximate_line(e_cubic, current_x, current_y)
-                        partial_deleted += 1
-                    current_x = e_cubic.end[0]
-                    current_y = e_cubic.end[1]
-                current_x = e.end[0]
-                current_y = e.end[1]
-
-        flag = True
-        while flag:
-            flag = False
-            if len(newpath) > 0 and isinstance(newpath[-1], Move):
-                # We don't need a move at the end of the path...
-                del newpath[-1]
-                flag = True
-
-        # print(
-        #     f"Ready: left untouched: {not_deleted}, fully deleted={fully_deleted}, partial deletion:{partial_deleted}"
-        # )
-        return newpath
-
-
-def set_line(*args, **kwargs):
-    yield "M", 0, 0.5
-    yield "L", 1, 0.5
-
-
-def set_fishbone(a, b, *args, **kwargs):
-    dx = a / 5.0 * 0.5
-    dy = b / 5.0 * 0.5
-    yield "M", 0 + dx, 1 - dy
-    yield "L", 0.5, 0
-    # self.pattern.append(("M", 0.5, 0))
-    yield "L", 1 - dx, 1 - dy
-
-
-def set_diagonal(a, b, *args, **kwargs):
-    dx = a / 5.0 * 1.0
-    dy = b / 5.0 * 1.0
-    yield "M", 0 + dx, 1 - dy
-    yield "L", 1 - dx, 0 + dy
-
-
-def set_diamond1(a, b, *args, **kwargs):
-    yield "M", 0, 0.5
-    yield "L", 0.5, 0
-    yield "L", 1, 0.5
-    yield "L", 0.5, 1
-    yield "L", 0, 0.5
-
-
-def set_diamond2(a, b, *args, **kwargs):
-    yield "M", 0, 0
-    yield "L", 0.5, 0.4
-    yield "L", 1, 0
-    yield "M", 0, 1
-    yield "L", 0.5, 0.6
-    yield "L", 1, 1
-
-
-def set_cross(a, b, *args, **kwargs):
-    # Pattern: cross
-    dx = a / 5.0 * 0.5
-    dy = b / 5.0 * 0.5
-    yield "M", 0.0, 0.25 + dy
-    yield "L", 0.25 + dx, 0.50
-    yield "L", 0.0, 0.75 - dy
-    yield "M", 0.25 + dx, 0.50
-    yield "L", 0.75 - dx, 0.50
-    yield "M", 1, 0.25 + dy
-    yield "L", 0.75 - dx, 0.50
-    yield "L", 1, 0.75 - dy
-
-
-def set_fabric(a, b, *args, **kwargs):
-    yield "M", 0.25, 0.25
-    yield "L", 0, 0.25
-    yield "L", 0, 0
-    yield "L", 0.5, 0
-    yield "L", 0.5, 1
-    yield "L", 1, 1
-    yield "L", 1, 0.75
-    yield "L", 0.75, 0.75
-
-    yield "M", 0.75, 0.25
-    yield "L", 0.75, 0
-    yield "L", 1, 0
-    yield "L", 1, 0.5
-    yield "L", 0, 0.5
-    yield "L", 0, 1
-    yield "L", 0.25, 1
-    yield "L", 0.25, 0.75
-
-
-def set_beehive(a, b, *args, **kwargs):
-    dx = a / 5.0 * 0.5
-    dy = b / 5.0 * 0.5
-    # top
-    yield "M", 0, 0.5 - dy
-    yield "L", dx, dy
-    yield "L", 1 - dx, dy
-    yield "L", 1, 0.5 - dy
-    # inner
-    yield "M", 0, 0.5
-    yield "L", dx, 2 * dy
-    yield "L", 1 - dx, 2 * dy
-    yield "L", 1, 0.5
-    yield "L", 1 - dx, 1 - 2 * dy
-    yield "L", dx, 1 - 2 * dy
-    yield "L", 0, 0.5
-    # bottom
-    yield "M", 0, 0.5 + dy
-    yield "L", dx, 1 - dy
-    yield "L", 1 - dx, 1 - dy
-    yield "L", 1, 0.5 + dy
-
-
-def set_bowlingpin(a, b, *args, **kwargs):
-    yield "M", 0.2, 0.6
-    ctrl_x = 0.1 + a
-    ctrl_y = 0.5
-    yield "Q", ctrl_x, ctrl_y, 0.2, 0.4
-
-    ctrl_x = 0.5
-    ctrl_y = 0.1 - b
-    yield "Q", ctrl_x, ctrl_y, 0.8, 0.4
-
-    ctrl_x = 0.9 - a
-    ctrl_y = 0.5
-    yield "Q", ctrl_x, ctrl_y, 0.8, 0.6
-
-    ctrl_x = 0.5
-    ctrl_y = 0.9 + b
-    yield "Q", ctrl_x, ctrl_y, 0.2, 0.6
-
-
-def set_wave(a, b, *args, **kwargs):
-    # Pattern: wavy
-    yield "M", 0.0, 0.25
-    yield "L", 0.25, 0.25
-    ctrl_x = 0.5 + a
-    ctrl_y = 0.25 + b
-    yield "Q", ctrl_x, ctrl_y, 0.5, 0.5
-    ctrl_x = 0.5 - a
-    ctrl_y = 0.75 - b
-    yield "Q", ctrl_x, ctrl_y, 0.75, 0.75
-    yield "L", 1, 0.75
-
-
-def set_bezier(a, b, *args, **kwargs):
-    anchor_tip = a  # distance factor from anchor to place control point
-    anchor_center = b
-    yield "M", 0, 0
-    yield "C", 1 * anchor_tip, 0, 1 / 2 - (1 * anchor_center), 1, 1 / 2, 1
-    yield "C", 1 / 2 + (1 * anchor_center), 1, 1 * (1 - anchor_tip), 0, 1, 0
-
-
-def set_brackets(a, b, *args, **kwargs):
-    p_a = a
-    p_b = b
-    yield "M", 0.0, 0.5
-    yield "C", 0.0, p_a, 1.0, p_b, 1.0, 0.5
-    yield "C", 1.0, 1 - p_a, 0.0, 1 - p_b, 0.0, 0.5
-
-
-def set_shape(a, b, *args, outershape=None, **kwargs):
-    # concentric shapes
-    polycache = list()
-
-    if len(polycache) != 0:
-        # We've done our bit already
-        return
-    resolution = 200.0
-    if outershape is None:
-        shape = Path(Polyline((0, 0), (1, 0), (1, 1), (0, 1), (0, 0)))
-    else:
-        shape = outershape.as_path()
-    bb = shape.bbox()
-    wd = bb[2] - bb[0]
-    if wd == 0:
-        wd = 1
-    ht = bb[3] - bb[1]
-    if ht == 0:
-        ht = 1
-    tx = 0
-    ty = 0
-    tc = int(resolution)
-    # minx = miny = 1e18
-    # maxx = maxy = -1e18
-    # Convert to polygon and bring it to 0 / 1
-    if wd == 0:
-        ratiox = 1
-    else:
-        ratiox = 1 / wd
-
-    if ht == 0:
-        ratioy = 1
-    else:
-        ratioy = 1 / ht
-    amount = int(abs(10 * a))  # (1 to 50)
-    segments = int(abs(10 * b))
-    seg_break = int(resolution) / (segments + 1)
-    seg_len = resolution / 40.0
-    for i in range(int(resolution) + 1):
-        pt = shape.point(i / resolution, error=1e4)
-        pt[0] = (pt[0] - bb[0]) * ratiox
-        pt[1] = (pt[1] - bb[1]) * ratioy
-        xx = pt[0]
-        yy = pt[1]
-        tx += xx
-        ty += yy
-        # minx = min(minx, xx)
-        # miny = min(miny, yy)
-        # maxx = max(maxx, xx)
-        # maxy = max(maxy, yy)
-        polycache.append(pt)
-    geometric_center_x = tx / tc
-    geometric_center_y = ty / tc
-    # print(
-    #     f"geometric center master: {geometric_center_x:.1f}, {geometric_center_y:.1f}"
-    # )
-    # print(f"boundaries: {minx:.1f}, {miny:.1f} - {maxx:.1f}, {maxy:.1f}")
-    dx = 0
-    dy = 0
-    regular = False
-    ratio = 1.0
-    dx = 1.0 / (amount + 1)
-
-    ratio = 1
-    for num in range(amount):
-        ratio -= dx
-        regular = not regular
-        current_x = None
-        current_y = None
-        if regular:
-            segcount = int(seg_break * 0.25)
-        else:
-            segcount = int(seg_break * 0.5)
-        # tx = 0
-        # ty = 0
-        # minx = miny = 1e18
-        # maxx = maxy = -1e18
-        for i in range(int(resolution) + 1):
-            xx = (polycache[i][0] - geometric_center_x) * ratio + geometric_center_x
-            yy = (polycache[i][1] - geometric_center_y) * ratio + geometric_center_y
-            # tx += xx
-            # ty += yy
-            # minx = min(minx, xx)
-            # miny = min(miny, yy)
-            # maxx = max(maxx, xx)
-            # maxy = max(maxy, yy)
-            segcount += 1
-            if segcount < seg_break:
-                if current_x is None:
-                    yield "M", xx, yy
-                else:
-                    yield "L", xx, yy
-                current_x = xx
-                current_y = yy
-            elif segcount >= seg_break + seg_len:
-                segcount = 0
-                current_x = None
-                current_y = None
-        # geo_x = tx / tc
-        # geo_y = ty / tc
-        # print(f"geometric center copy: {geo_x:.1f}, {geo_y:.1f}")
-        # print(f"boundaries: {minx:.1f}, {miny:.1f} - {maxx:.1f}, {maxy:.1f}")
-
-
-def plugin(kernel, lifecycle):
-    if lifecycle == "register":
-        _ = kernel.translation
-        context = kernel.root
-        context.register(
-            "pattern/line",
-            (
-                set_line,
-                False,
-                "",
-                "",
-                (-200, -350, 0, 0),
-                True,
-            ),
-        )
-        context.register(
-            "pattern/fishbone",
-            (
-                set_fishbone,
-                True,
-                "Left/Right Indentation",
-                "Top/Bottom Indentation",
-                (100, 100, 0, 0),
-                True,
-            ),
-        )
-        context.register(
-            "pattern/diagonal",
-            (
-                set_diagonal,
-                True,
-                "Left/Right Indentation",
-                "Top/Bottom Indentation",
-                (-100, -100, 0, 0),
-                True,
-            ),
-        )
-        context.register(
-            "pattern/diamond1",
-            (
-                set_diamond1,
-                False,
-                "",
-                "",
-                (-150, 100, 0, 0),
-                True,
-            ),
-        )
-        context.register(
-            "pattern/diamond2",
-            (
-                set_diamond2,
-                False,
-                "",
-                "",
-                (-120, 60, 0, 0),
-                True,
-            ),
-        )
-        context.register(
-            "pattern/cross",
-            (
-                set_cross,
-                True,
-                "Left/Right Indentation",
-                "Top/Bottom Indentation",
-                (-150, -40, 0, 0),
-                True,
-            ),
-        )
-        context.register(
-            "pattern/bezier",
-            (
-                set_bezier,
-                True,
-                "",
-                "",
-                (-20, -160, 0.4, 0.3),
-                True,
-            ),
-        )
-        context.register(
-            "pattern/wave",
-            (
-                set_wave,
-                True,
-                "",
-                "",
-                (-130, -260, 0, 0),
-                True,
-            ),
-        )
-        context.register(
-            "pattern/bowlingpin",
-            (
-                set_bowlingpin,
-                True,
-                "Left/Right Bowl",
-                "Top/Bottom Bowl",
-                (-210, -50, -0.3, 0),
-                True,
-            ),
-        )
-        context.register(
-            "pattern/beehive",
-            (
-                set_beehive,
-                True,
-                "Position of left side",
-                "Distance of second line",
-                (-10, 60, 1.4, 0),
-                True,
-            ),
-        )
-        context.register(
-            "pattern/fabric",
-            (
-                set_fabric,
-                False,
-                "",
-                "",
-                (-180, 130, 0, 0),
-                True,
-            ),
-        )
-        context.register(
-            "pattern/brackets",
-            (
-                set_brackets,
-                True,
-                "",
-                "",
-                (-140, -110, 0.7, 0.7),
-                True,
-            ),
-        )
-        context.register(
-            "pattern/shape",
-            (
-                set_shape,
-                True,
-                "Number of copies",
-                "Number of segments",
-                (0, 0, 1, 0.4),
-                False,
-            ),
-        )
+# """
+#     Obsolete! No longer needed, just there for reference
+# """
+# from copy import copy
+#
+# from meerk40t.svgelements import (
+#     Arc,
+#     Close,
+#     Color,
+#     CubicBezier,
+#     Line,
+#     Matrix,
+#     Move,
+#     Path,
+#     Point,
+#     Polygon,
+#     Polyline,
+#     QuadraticBezier,
+# )
+# from meerk40t.tools.pathtools import VectorMontonizer
+#
+# _FACTOR = 1000
+#
+#
+# class LivingHinges:
+#     """
+#     This class generates a predefined pattern in a *rectangular* area
+#     """
+#
+#     def __init__(self, xpos, ypos, width, height):
+#         self.pattern = None
+#         self.start_x = xpos
+#         self.start_y = ypos
+#         self.width = width
+#         self.height = height
+#         # We set it off somewhat...
+#         self.gap = 0
+#         self.x0 = width * self.gap
+#         self.y0 = height * self.gap
+#         self.x1 = width * (1 - self.gap)
+#         self.y1 = height * (1 - self.gap)
+#         # Declare all used variables to satisfy codacy
+#         self.param_a = 0
+#         self.param_b = 0
+#         self.cell_height_percentage = 200
+#         self.cell_width_percentage = 200
+#         self.cell_height = height * self.cell_height_percentage / _FACTOR
+#         self.cell_width = width * self.cell_width_percentage / _FACTOR
+#         self.cell_padding_v_percentage = 0
+#         self.cell_padding_h_percentage = 0
+#         self.cell_padding_h = self.cell_width * self.cell_padding_h_percentage / _FACTOR
+#         self.cell_padding_v = (
+#             self.cell_height * self.cell_padding_v_percentage / _FACTOR
+#         )
+#         # Requires recalculation
+#         self.path = None
+#         self.preview_path = None
+#         self.outershape = None
+#         # Specifically for the shape pattern we hold a list of precalculated polygons
+#         self.pattern = []
+#         self._extend_patterns = True
+#         self.set_cell_values(100, 100)
+#         self.set_padding_values(50, 50)
+#         self.set_predefined_pattern(
+#             entry=(
+#                 set_line,
+#                 False,
+#                 "",
+#                 "",
+#                 (-200, -350, 0, 0),
+#                 True,
+#             )
+#         )
+#         self.cutpattern = None
+#
+#     def set_predefined_pattern(self, entry):
+#         # The pattern needs to be defined within a 0,0  - 1,1 rectangle
+#         #
+#         self.cutpattern = entry
+#
+#         self._extend_patterns = entry[5]
+#         additional_parameter = entry[1]
+#         info1 = entry[2]
+#         info2 = entry[3]
+#         self.pattern = list(
+#             entry[0](self.param_a, self.param_b, outershape=self.outershape)
+#         )
+#         self.path = None
+#         self.preview_path = None
+#         return additional_parameter, info1, info2
+#
+#     def make_outline(self, x0, y0, x1, y1):
+#         # Draw a rectangle
+#         pt0 = Point(x0, y0)
+#         pt1 = Point(x1, y0)
+#         pt2 = Point(x1, y1)
+#         pt3 = Point(x0, y1)
+#
+#         self.path.move(pt0)
+#         self.path.line(pt1)
+#         self.path.line(pt2)
+#         self.path.line(pt3)
+#         self.path.line(pt0)
+#
+#     def draw_trace(self, offset_x, offset_y, width, height):
+#         # Draw the pattern
+#         # The extents of the cell will be at (offset_x, offset_y)
+#         # in the upper-left corner and (width, height) in the bottom-right corner
+#
+#         def create_point(x, y):
+#             return Point(x * width + offset_x, y * height + offset_y)
+#
+#         # self.path.move(offset_x, offset_y)
+#         # print (f"After initial move: {str(self.path)}")
+#         current_x = 0
+#         current_y = 0
+#         s_left = self.start_x
+#         s_right = s_left + self.width
+#         s_top = self.start_y
+#         s_bottom = s_top + self.height
+#         for entry in self.pattern:
+#             old_x = current_x
+#             old_y = current_y
+#             key = entry[0].lower()
+#             if key == "m":
+#                 endpoint = create_point(entry[1], entry[2])
+#                 self.path.move(endpoint)
+#                 current_x = entry[1]
+#                 current_y = entry[2]
+#             elif key == "h":
+#                 current_x += entry[1]
+#                 dx = entry[1]
+#                 self.path.horizontal(dx, relative=True)
+#             elif key == "v":
+#                 current_y += entry[1]
+#                 dy = entry[1]
+#                 self.path.vertical(dy, relative=True)
+#             elif key == "l":
+#                 # Line to...
+#                 current_x = entry[1]
+#                 current_y = entry[2]
+#                 endpoint = create_point(entry[1], entry[2])
+#                 self.path.line(endpoint)
+#             elif key == "a":
+#                 current_x = entry[6]
+#                 current_y = entry[7]
+#                 rx = entry[1]
+#                 ry = entry[2]
+#                 rotation = entry[3]
+#                 arc = entry[4]
+#                 sweep = entry[5]
+#                 endpoint = create_point(current_x, current_y)
+#                 self.path.arc(rx, ry, rotation, arc, sweep, endpoint)
+#             elif key == "c":
+#                 current_x = entry[5]
+#                 current_y = entry[6]
+#                 control1 = create_point(entry[1], entry[2])
+#                 control2 = create_point(entry[3], entry[4])
+#                 endpoint = create_point(entry[5], entry[6])
+#                 self.path.cubic(control1, control2, endpoint)
+#             elif key == "q":
+#                 current_x = entry[3]
+#                 current_y = entry[4]
+#                 control1 = create_point(entry[1], entry[2])
+#                 endpoint = create_point(entry[3], entry[4])
+#                 self.path.quad(control1, endpoint)
+#
+#     def set_hinge_shape(self, shapenode):
+#         # reset cache
+#         self.outershape = shapenode
+#
+#     def set_hinge_area(self, hinge_left, hinge_top, hinge_width, hinge_height):
+#         self.start_x = hinge_left
+#         self.start_y = hinge_top
+#         self.width = hinge_width
+#         self.height = hinge_height
+#         self.x0 = hinge_width * self.gap
+#         self.y0 = hinge_height * self.gap
+#         self.x1 = hinge_width * (1 - self.gap)
+#         self.y1 = hinge_height * (1 - self.gap)
+#         # Requires recalculation
+#         self.path = None
+#         self.preview_path = None
+#
+#     def set_cell_values(self, percentage_x, percentage_y):
+#         self.cell_width_percentage = percentage_x
+#         self.cell_height_percentage = percentage_y
+#         # Requires recalculation
+#         self.path = None
+#         self.preview_path = None
+#
+#     def set_padding_values(self, padding_x, padding_y):
+#         self.cell_padding_h_percentage = padding_x
+#         self.cell_padding_v_percentage = padding_y
+#         # Requires recalculation
+#         self.path = None
+#         self.preview_path = None
+#
+#     def set_additional_parameters(self, param_a, param_b):
+#         self.param_a = param_a
+#         self.param_b = param_b
+#         # Reset cache for shape pattern
+#         # Make sure pattern is updated with additional parameter
+#         self.set_predefined_pattern(self.cutpattern)
+#
+#     @staticmethod
+#     def outside(bb_to_check, master_bb):
+#         out_x = "inside"
+#         out_y = "inside"
+#         if bb_to_check[0] > master_bb[2] or bb_to_check[2] < master_bb[0]:
+#             # fully out on x
+#             out_x = "outside"
+#         elif bb_to_check[0] < master_bb[0] or bb_to_check[2] > master_bb[2]:
+#             out_x = "cross"
+#         if bb_to_check[1] > master_bb[3] or bb_to_check[3] < master_bb[1]:
+#             out_y = "outside"
+#         elif bb_to_check[1] < master_bb[1] or bb_to_check[3] > master_bb[3]:
+#             out_x = "cross"
+#         return out_x, out_y
+#
+#     def generate(self, show_outline=False, force=False, final=False, clip_bounds=True):
+#         if final and self.path is not None and not force:
+#             # No need to recalculate...
+#             return
+#         elif not final and self.preview_path is not None and not force:
+#             # No need to recalculate...
+#             return
+#
+#         self.cell_width = self.width * self.cell_width_percentage / _FACTOR
+#         self.cell_height = self.height * self.cell_height_percentage / _FACTOR
+#         self.cell_padding_h = self.cell_width * self.cell_padding_h_percentage / _FACTOR
+#         self.cell_padding_v = (
+#             self.cell_height * self.cell_padding_v_percentage / _FACTOR
+#         )
+#         self.path = Path(stroke=Color("red"), stroke_width=500)
+#
+#         if show_outline:
+#             self.make_outline(self.x0, self.y0, self.x1, self.y1)
+#
+#         #  Determine rows and columns of cuts to create
+#         #  will round down so add 1 and trim later
+#         #  Determine rows and columns of cuts to create
+#         #  will round down so add 1 and trim later
+#         if self.cell_width + 2 * self.cell_padding_h == 0:
+#             cols = 1
+#         else:
+#             cols = (
+#                 int(
+#                     ((self.x1 - self.x0) + self.cell_width)
+#                     / (self.cell_width + (2 * self.cell_padding_h))
+#                 )
+#                 + 1
+#             )
+#         if self.cell_height + 2 * self.cell_padding_v == 0:
+#             rows = 1
+#         else:
+#             rows = (
+#                 int(
+#                     ((self.y1 - self.y0) + self.cell_height)
+#                     / (self.cell_height + (2 * self.cell_padding_v))
+#                 )
+#                 + 1
+#             )
+#
+#         if self._extend_patterns:
+#             start_value = -2
+#             end_value = 1
+#             off_x = -1 * (self.cell_width / 2)
+#         else:
+#             cols = max(1, cols - 2)
+#             rows = max(1, rows - 2)
+#             start_value = 0
+#             end_value = 0
+#             off_x = 0
+#         # print (f"Area: {self.width:.1f}, {self.height:.1f}, Cell: {self.cell_width:.1f}, {self.cell_height:.1f}")
+#         # print (f"Rows: {rows}, Cols={cols}")
+#         # print (f"Ratios: {self.cell_width_percentage}, {self.cell_height_percentage}")
+#         # print (f"Padding: {self.cell_padding_h_percentage}, {self.cell_padding_v_percentage}")
+#         for col in range(start_value, cols + end_value, 1):
+#             top_left_x = self.x0 + off_x
+#             x_offset = col * (self.cell_width + (2 * self.cell_padding_h))
+#             x_current = top_left_x + x_offset
+#             for row in range(start_value, rows + end_value, 1):
+#                 top_left_y = self.y0
+#                 y_offset = row * (self.cell_height + (2 * self.cell_padding_v)) + (
+#                     (self.cell_height + (2 * self.cell_padding_v)) / 2
+#                 ) * (col % 2)
+#                 y_current = top_left_y + y_offset
+#
+#                 if x_current < self.x1 and y_current < self.y1:
+#                     # Don't call draw if outside of hinge area
+#                     self.draw_trace(
+#                         x_current,
+#                         y_current,
+#                         self.cell_width,
+#                         self.cell_height,
+#                     )
+#                     if show_outline:
+#                         self.make_outline(
+#                             x_current,
+#                             y_current,
+#                             x_current + self.cell_width,
+#                             y_current + self.cell_height,
+#                         )
+#         if not clip_bounds:
+#             return
+#         rectangular = True
+#         if (
+#             self.outershape is not None
+#             and hasattr(self.outershape, "as_path")
+#             and self.outershape.type != "elem rect"
+#         ):
+#             rectangular = False
+#         if final and not rectangular:
+#             self.path.transform *= Matrix.translate(self.start_x, self.start_y)
+#             from time import time
+#
+#             t0 = time()
+#             vm = VectorMontonizer()
+#             outer_bb = self.outershape.bbox()
+#             outer_path = self.outershape.as_path()
+#             outer_poly = Polygon(
+#                 [outer_path.point(i / 1000.0, error=1e4) for i in range(1001)]
+#             )
+#             vm.add_polyline(outer_poly)
+#             path = Path(stroke=Color("red"), stroke_width=500)
+#             deleted = 0
+#             total = 0
+#             # pt_min_x = 1E+30
+#             # pt_min_y = 1E+30
+#             # pt_max_x = -1 * pt_min_x
+#             # pt_max_y = -1 * pt_min_y
+#             # Numpy does not work
+#             # vm.add_polyline(outer_poly)
+#             # path = Path(stroke=Color("red"), stroke_width=500)
+#             # for sub_inner in self.path.as_subpaths():
+#             #     sub_inner = Path(sub_inner)
+#             #     pts_sub = sub_inner.npoint(linspace(0, 1, 1000))
+#             #     good_pts = [p for p in pts_sub if vm.is_point_inside(p[0] + self.start_x, p[1] + self.start_y)]
+#             #     path += Path(Polyline(good_pts), stroke=Color("red"), stroke_width=500)
+#             for sub_inner in self.path.as_subpaths():
+#                 sub_bbox = sub_inner.bbox()
+#                 outx, outy = self.outside(sub_bbox, outer_bb)
+#                 if outx == "outside" or outy == "outside":
+#                     continue
+#
+#                 sub_inner = Path(sub_inner)
+#                 pts_sub = [sub_inner.point(i / 1000.0, error=1e4) for i in range(1001)]
+#                 fullyinside = True
+#                 for i in range(len(pts_sub) - 1, -1, -1):
+#                     total += 1
+#                     pt = pts_sub[i]
+#                     pt[0] += self.start_x
+#                     pt[1] += self.start_y
+#                     # pt_min_x = min(pt_min_x, pt[0])
+#                     # pt_min_y = min(pt_min_y, pt[1])
+#                     # pt_max_x = max(pt_max_x, pt[0])
+#                     # pt_max_y = max(pt_max_y, pt[1])
+#                     if not vm.is_point_inside(pt[0], pt[1]):
+#                         # if we do have points beyond, then we create a seperate path
+#                         if i < len(pts_sub) - 1:
+#                             goodpts = pts_sub[i + 1 :]
+#                             path += Path(
+#                                 Polyline(goodpts), stroke=Color("red"), stroke_width=500
+#                             )
+#                         del pts_sub[i:]
+#                         deleted += 1
+#                         fullyinside = False
+#                 if fullyinside:
+#                     path += abs(sub_inner)
+#                 else:
+#                     path += Path(
+#                         Polyline(pts_sub), stroke=Color("red"), stroke_width=500
+#                     )
+#             self.path = path
+#         else:
+#             # Former method....
+#             # ...is limited to rectangular area but maintains inner cubics,
+#             # quads and arcs while the vectormontonizer is more versatile
+#             # when it comes to the surrounding shape but transforms all
+#             # path elements to lines
+#             self.path = self.clip_path(self.path, 0, 0, self.width, self.height)
+#             self.path.transform *= Matrix.translate(self.start_x, self.start_y)
+#             self.preview_path = copy(self.path)
+#
+#     def clip_path(self, path, xmin, ymin, xmax, ymax):
+#         """
+#         Clip a path at a rectangular area, will return the clipped path
+#
+#         Args:
+#             path : The path to clip
+#             xmin : Left side of the rectangular area
+#             ymin : Upper side of the rectangular area
+#             xmax : Right side of the rectangular area
+#             ymax : Lower side of the rectangular area
+#         """
+#
+#         def approximate_line(part_of_path, current_x, current_y):
+#             # print(f"Check: {type(part_of_path).__name__} {part_of_path.bbox()} {clipbb}")
+#             from numpy import linspace
+#
+#             added = 0
+#             partial = 0
+#             ignored = 0
+#             subj = part_of_path.npoint(linspace(0, 1, interpolation))
+#             subj.reshape((2, interpolation))
+#             iterated_points = list(map(Point, subj))
+#             for p in iterated_points:
+#                 segbb = (
+#                     min(current_x, p[0]),
+#                     min(current_y, p[1]),
+#                     max(current_x, p[0]),
+#                     max(current_y, p[1]),
+#                 )
+#                 sx, sy = self.outside(segbb, clipbb)
+#                 # print(f"{segbb} - {clipbb} {sx} - {sy}")
+#                 if sx == "outside" or sy == "outside":
+#                     # Fully outside, so drop
+#                     add_move(newpath, e.end)
+#                     ignored += 1
+#                 elif statex == "inside" and statey == "inside":
+#                     # Fully inside, so append
+#                     if current_x != new_cx or current_y != new_cy:
+#                         add_move(newpath, Point(current_x, current_y))
+#                     newpath.line(p)
+#                     added += 1
+#                 else:
+#                     dx = p[0] - current_x
+#                     dy = p[1] - current_y
+#                     new_cx = current_x
+#                     new_cy = current_y
+#                     new_ex = p[0]
+#                     new_ey = p[1]
+#                     if dx == 0:
+#                         # Vertical line needs special treatment
+#                         if xmin <= new_cx <= xmax:
+#                             new_cy = min(max(new_cy, ymin), ymax)
+#                             new_ey = min(max(new_ey, ymin), ymax)
+#                             if new_cx != current_x or new_cy != current_y:
+#                                 # Needs a move
+#                                 add_move(newpath, Point(new_cx, new_cy))
+#                             newpath.line(Point(new_ex, new_ey))
+#                             partial += 1
+#                         else:
+#                             ignored += 1
+#                     else:
+#                         # regular line, so lets establish x0 x1
+#                         # could still be an outward pointing line....
+#                         new_cx = min(max(new_cx, xmin), xmax)
+#                         new_ex = min(max(new_ex, xmin), xmax)
+#                         # corresponding y values...
+#                         edx = p[0] - current_x
+#                         edy = p[1] - current_y
+#                         new_cy = current_y + (new_cx - current_x) / edx * edy
+#                         new_ey = current_y + (new_ex - current_x) / edx * edy
+#                         # Y can still cross...
+#                         new_cx_clipped = new_cx
+#                         new_ex_clipped = new_ex
+#                         new_cy_clipped = min(max(new_cy, ymin), ymax)
+#                         new_ey_clipped = min(max(new_ey, ymin), ymax)
+#                         # Adjust x - value
+#                         if dy != 0:
+#                             new_cx_clipped = new_cx + dx / dy * (
+#                                 new_cy_clipped - new_cy
+#                             )
+#                             new_ex_clipped = new_ex + dx / dy * (
+#                                 new_ey_clipped - new_ey
+#                             )
+#
+#                         new_cx = new_cx_clipped
+#                         new_cy = new_cy_clipped
+#                         new_ex = new_ex_clipped
+#                         new_ey = new_ey_clipped
+#                         if min(new_cy, new_ey) == ymax and dy != 0:
+#                             # Outward...
+#                             ignored += 1
+#                         elif max(new_cy, new_ey) == ymin and dy != 0:
+#                             # Outward...
+#                             ignored += 1
+#                         else:
+#                             if new_cx != current_x or new_cy != current_y:
+#                                 # Needs a move
+#                                 add_move(newpath, Point(new_cx, new_cy))
+#                             newpath.line(Point(new_ex, new_ey))
+#                             partial += 1
+#                 current_x = p[0]
+#                 current_y = p[1]
+#             if current_x != part_of_path.end[0] or current_y != part_of_path.end[1]:
+#                 add_move(newpath, part_of_path.end)
+#             # print (f"From iterated line: added={added}, partial={partial}, ignored={ignored}")
+#
+#         def add_move(addpath, destination):
+#             # Was the last segment as well a move? Then just update the coords...
+#             if len(addpath) > 0:
+#                 if isinstance(addpath[-1], Move):
+#                     addpath[-1].end = destination
+#                     return
+#             addpath.move(destination)
+#
+#         interpolation = 50
+#         fully_deleted = 0
+#         partial_deleted = 0
+#         not_deleted = 0
+#         clipbb = (xmin, ymin, xmax, ymax)
+#         current_x = 0
+#         current_y = 0
+#         first_point = path.first_point
+#         if first_point is not None:
+#             current_x = first_point[0]
+#             current_y = first_point[1]
+#         newpath = Path(
+#             stroke=path.stroke, stroke_width=path.stroke_width, transform=path.transform
+#         )
+#         for e in path:
+#             if hasattr(e, "bbox"):
+#                 segbb = e.bbox()
+#             elif hasattr(e, "end"):
+#                 segbb = (
+#                     min(current_x, e.end[0]),
+#                     min(current_y, e.end[1]),
+#                     max(current_x, e.end[0]),
+#                     max(current_y, e.end[1]),
+#                 )
+#             else:
+#                 segbb = (xmin, ymin, 0, 0)
+#             if isinstance(e, Move):
+#                 add_move(newpath, e.end)
+#                 current_x = e.end[0]
+#                 current_y = e.end[1]
+#                 not_deleted += 1
+#             elif isinstance(e, Line):
+#                 statex, statey = self.outside(segbb, clipbb)
+#                 dx = e.end[0] - current_x
+#                 dy = e.end[1] - current_y
+#                 if statex == "outside" or statey == "outside":
+#                     # Fully outside, so drop
+#                     add_move(newpath, e.end)
+#                     fully_deleted += 1
+#                 elif statex == "inside" and statey == "inside":
+#                     # Fully inside, so append
+#                     newpath.line(e.end)
+#                     not_deleted += 1
+#                 else:
+#                     # needs dealing, its either for the time being, just ignored...
+#                     new_cx = current_x
+#                     new_cy = current_y
+#                     new_ex = e.end[0]
+#                     new_ey = e.end[1]
+#                     if dx == 0:
+#                         # Vertical line needs special treatment
+#                         if xmin <= new_cx <= xmax:
+#                             new_cy = min(max(new_cy, ymin), ymax)
+#                             new_ey = min(max(new_ey, ymin), ymax)
+#                             if new_cx != current_x or new_cy != current_y:
+#                                 # Needs a move
+#                                 add_move(newpath, Point(new_cx, new_cy))
+#                             newpath.line(Point(new_ex, new_ey))
+#                     else:
+#                         # regular line, so lets establish x0 x1
+#                         # could still be an outward pointing line....
+#                         new_cx = min(max(new_cx, xmin), xmax)
+#                         new_ex = min(max(new_ex, xmin), xmax)
+#                         # corresponding y values...
+#                         edx = e.end[0] - current_x
+#                         edy = e.end[1] - current_y
+#                         new_cy = current_y + (new_cx - current_x) / edx * edy
+#                         new_ey = current_y + (new_ex - current_x) / edx * edy
+#                         # Y can still cross...
+#                         new_cx_clipped = new_cx
+#                         new_ex_clipped = new_ex
+#                         new_cy_clipped = min(max(new_cy, ymin), ymax)
+#                         new_ey_clipped = min(max(new_ey, ymin), ymax)
+#                         # Adjust x - value
+#                         if dy != 0:
+#                             new_cx_clipped = new_cx + dx / dy * (
+#                                 new_cy_clipped - new_cy
+#                             )
+#                             new_ex_clipped = new_ex + dx / dy * (
+#                                 new_ey_clipped - new_ey
+#                             )
+#
+#                         new_cx = new_cx_clipped
+#                         new_cy = new_cy_clipped
+#                         new_ex = new_ex_clipped
+#                         new_ey = new_ey_clipped
+#                         if min(new_cy, new_ey) == ymax and dy != 0:
+#                             # Outward...
+#                             pass
+#                         elif max(new_cy, new_ey) == ymin and dy != 0:
+#                             # Outward...
+#                             pass
+#                         else:
+#                             if new_cx != current_x or new_cy != current_y:
+#                                 # Needs a move
+#                                 add_move(newpath, Point(new_cx, new_cy))
+#                             newpath.line(Point(new_ex, new_ey))
+#                     if current_x != e.end[0] or current_y != e.end[1]:
+#                         add_move(newpath, e.end)
+#                     partial_deleted += 1
+#                 current_x = e.end[0]
+#                 current_y = e.end[1]
+#             elif isinstance(e, Close):
+#                 newpath.closed()
+#                 not_deleted += 1
+#             elif isinstance(e, QuadraticBezier):
+#                 statex, statey = self.outside(segbb, clipbb)
+#                 if statex == "outside" and statey == "outside":
+#                     # Fully outside, so drop
+#                     add_move(newpath, e.end)
+#                     fully_deleted += 1
+#                 elif statex == "inside" and statey == "inside":
+#                     # Fully inside, so append
+#                     newpath.quad(e.control, e.end)
+#                     not_deleted += 1
+#                 else:
+#                     approximate_line(e, current_x, current_y)
+#                 current_x = e.end[0]
+#                 current_y = e.end[1]
+#             elif isinstance(e, CubicBezier):
+#                 statex, statey = self.outside(segbb, clipbb)
+#                 if statex == "outside" and statey == "outside":
+#                     # Fully outside, so drop
+#                     add_move(newpath, e.end)
+#                     fully_deleted += 1
+#                 elif statex == "inside" and statey == "inside":
+#                     # Fully inside, so append
+#                     newpath.cubic(e.control1, e.control2, e.end)
+#                     not_deleted += 1
+#                 else:
+#                     approximate_line(e, current_x, current_y)
+#                     partial_deleted += 1
+#                 current_x = e.end[0]
+#                 current_y = e.end[1]
+#             elif isinstance(e, Arc):
+#                 for e_cubic in e.as_cubic_curves():
+#                     segbb = e_cubic.bbox()
+#                     statex, statey = self.outside(segbb, clipbb)
+#                     if statex == "outside" and statey == "outside":
+#                         # Fully outside, so drop
+#                         add_move(newpath, e.end)
+#                         fully_deleted += 1
+#                     elif statex == "inside" and statey == "inside":
+#                         # Fully inside, so append
+#                         newpath.cubic(e_cubic.control1, e_cubic.control2, e_cubic.end)
+#                         not_deleted += 1
+#                     else:
+#                         approximate_line(e_cubic, current_x, current_y)
+#                         partial_deleted += 1
+#                     current_x = e_cubic.end[0]
+#                     current_y = e_cubic.end[1]
+#                 current_x = e.end[0]
+#                 current_y = e.end[1]
+#
+#         flag = True
+#         while flag:
+#             flag = False
+#             if len(newpath) > 0 and isinstance(newpath[-1], Move):
+#                 # We don't need a move at the end of the path...
+#                 del newpath[-1]
+#                 flag = True
+#
+#         # print(
+#         #     f"Ready: left untouched: {not_deleted}, fully deleted={fully_deleted}, partial deletion:{partial_deleted}"
+#         # )
+#         return newpath
+#
+#
+# def set_line(*args, **kwargs):
+#     yield "M", 0, 0.5
+#     yield "L", 1, 0.5
+#
+#
+# def set_fishbone(a, b, *args, **kwargs):
+#     dx = a / 5.0 * 0.5
+#     dy = b / 5.0 * 0.5
+#     yield "M", 0 + dx, 1 - dy
+#     yield "L", 0.5, 0
+#     # self.pattern.append(("M", 0.5, 0))
+#     yield "L", 1 - dx, 1 - dy
+#
+#
+# def set_diagonal(a, b, *args, **kwargs):
+#     dx = a / 5.0 * 1.0
+#     dy = b / 5.0 * 1.0
+#     yield "M", 0 + dx, 1 - dy
+#     yield "L", 1 - dx, 0 + dy
+#
+#
+# def set_diamond1(a, b, *args, **kwargs):
+#     yield "M", 0, 0.5
+#     yield "L", 0.5, 0
+#     yield "L", 1, 0.5
+#     yield "L", 0.5, 1
+#     yield "L", 0, 0.5
+#
+#
+# def set_diamond2(a, b, *args, **kwargs):
+#     yield "M", 0, 0
+#     yield "L", 0.5, 0.4
+#     yield "L", 1, 0
+#     yield "M", 0, 1
+#     yield "L", 0.5, 0.6
+#     yield "L", 1, 1
+#
+#
+# def set_cross(a, b, *args, **kwargs):
+#     # Pattern: cross
+#     dx = a / 5.0 * 0.5
+#     dy = b / 5.0 * 0.5
+#     yield "M", 0.0, 0.25 + dy
+#     yield "L", 0.25 + dx, 0.50
+#     yield "L", 0.0, 0.75 - dy
+#     yield "M", 0.25 + dx, 0.50
+#     yield "L", 0.75 - dx, 0.50
+#     yield "M", 1, 0.25 + dy
+#     yield "L", 0.75 - dx, 0.50
+#     yield "L", 1, 0.75 - dy
+#
+#
+# def set_fabric(a, b, *args, **kwargs):
+#     yield "M", 0.25, 0.25
+#     yield "L", 0, 0.25
+#     yield "L", 0, 0
+#     yield "L", 0.5, 0
+#     yield "L", 0.5, 1
+#     yield "L", 1, 1
+#     yield "L", 1, 0.75
+#     yield "L", 0.75, 0.75
+#
+#     yield "M", 0.75, 0.25
+#     yield "L", 0.75, 0
+#     yield "L", 1, 0
+#     yield "L", 1, 0.5
+#     yield "L", 0, 0.5
+#     yield "L", 0, 1
+#     yield "L", 0.25, 1
+#     yield "L", 0.25, 0.75
+#
+#
+# def set_beehive(a, b, *args, **kwargs):
+#     dx = a / 5.0 * 0.5
+#     dy = b / 5.0 * 0.5
+#     # top
+#     yield "M", 0, 0.5 - dy
+#     yield "L", dx, dy
+#     yield "L", 1 - dx, dy
+#     yield "L", 1, 0.5 - dy
+#     # inner
+#     yield "M", 0, 0.5
+#     yield "L", dx, 2 * dy
+#     yield "L", 1 - dx, 2 * dy
+#     yield "L", 1, 0.5
+#     yield "L", 1 - dx, 1 - 2 * dy
+#     yield "L", dx, 1 - 2 * dy
+#     yield "L", 0, 0.5
+#     # bottom
+#     yield "M", 0, 0.5 + dy
+#     yield "L", dx, 1 - dy
+#     yield "L", 1 - dx, 1 - dy
+#     yield "L", 1, 0.5 + dy
+#
+#
+# def set_bowlingpin(a, b, *args, **kwargs):
+#     yield "M", 0.2, 0.6
+#     ctrl_x = 0.1 + a
+#     ctrl_y = 0.5
+#     yield "Q", ctrl_x, ctrl_y, 0.2, 0.4
+#
+#     ctrl_x = 0.5
+#     ctrl_y = 0.1 - b
+#     yield "Q", ctrl_x, ctrl_y, 0.8, 0.4
+#
+#     ctrl_x = 0.9 - a
+#     ctrl_y = 0.5
+#     yield "Q", ctrl_x, ctrl_y, 0.8, 0.6
+#
+#     ctrl_x = 0.5
+#     ctrl_y = 0.9 + b
+#     yield "Q", ctrl_x, ctrl_y, 0.2, 0.6
+#
+#
+# def set_wave(a, b, *args, **kwargs):
+#     # Pattern: wavy
+#     yield "M", 0.0, 0.25
+#     yield "L", 0.25, 0.25
+#     ctrl_x = 0.5 + a
+#     ctrl_y = 0.25 + b
+#     yield "Q", ctrl_x, ctrl_y, 0.5, 0.5
+#     ctrl_x = 0.5 - a
+#     ctrl_y = 0.75 - b
+#     yield "Q", ctrl_x, ctrl_y, 0.75, 0.75
+#     yield "L", 1, 0.75
+#
+#
+# def set_bezier(a, b, *args, **kwargs):
+#     anchor_tip = a  # distance factor from anchor to place control point
+#     anchor_center = b
+#     yield "M", 0, 0
+#     yield "C", 1 * anchor_tip, 0, 1 / 2 - (1 * anchor_center), 1, 1 / 2, 1
+#     yield "C", 1 / 2 + (1 * anchor_center), 1, 1 * (1 - anchor_tip), 0, 1, 0
+#
+#
+# def set_brackets(a, b, *args, **kwargs):
+#     p_a = a
+#     p_b = b
+#     yield "M", 0.0, 0.5
+#     yield "C", 0.0, p_a, 1.0, p_b, 1.0, 0.5
+#     yield "C", 1.0, 1 - p_a, 0.0, 1 - p_b, 0.0, 0.5
+#
+#
+# def set_shape(a, b, *args, outershape=None, **kwargs):
+#     # concentric shapes
+#     polycache = list()
+#
+#     if len(polycache) != 0:
+#         # We've done our bit already
+#         return
+#     resolution = 200.0
+#     if outershape is None:
+#         shape = Path(Polyline((0, 0), (1, 0), (1, 1), (0, 1), (0, 0)))
+#     else:
+#         shape = outershape.as_path()
+#     bb = shape.bbox()
+#     wd = bb[2] - bb[0]
+#     if wd == 0:
+#         wd = 1
+#     ht = bb[3] - bb[1]
+#     if ht == 0:
+#         ht = 1
+#     tx = 0
+#     ty = 0
+#     tc = int(resolution)
+#     # minx = miny = 1e18
+#     # maxx = maxy = -1e18
+#     # Convert to polygon and bring it to 0 / 1
+#     if wd == 0:
+#         ratiox = 1
+#     else:
+#         ratiox = 1 / wd
+#
+#     if ht == 0:
+#         ratioy = 1
+#     else:
+#         ratioy = 1 / ht
+#     amount = int(abs(10 * a))  # (1 to 50)
+#     segments = int(abs(10 * b))
+#     seg_break = int(resolution) / (segments + 1)
+#     seg_len = resolution / 40.0
+#     for i in range(int(resolution) + 1):
+#         pt = shape.point(i / resolution, error=1e4)
+#         pt[0] = (pt[0] - bb[0]) * ratiox
+#         pt[1] = (pt[1] - bb[1]) * ratioy
+#         xx = pt[0]
+#         yy = pt[1]
+#         tx += xx
+#         ty += yy
+#         # minx = min(minx, xx)
+#         # miny = min(miny, yy)
+#         # maxx = max(maxx, xx)
+#         # maxy = max(maxy, yy)
+#         polycache.append(pt)
+#     geometric_center_x = tx / tc
+#     geometric_center_y = ty / tc
+#     # print(
+#     #     f"geometric center master: {geometric_center_x:.1f}, {geometric_center_y:.1f}"
+#     # )
+#     # print(f"boundaries: {minx:.1f}, {miny:.1f} - {maxx:.1f}, {maxy:.1f}")
+#     dx = 0
+#     dy = 0
+#     regular = False
+#     ratio = 1.0
+#     dx = 1.0 / (amount + 1)
+#
+#     ratio = 1
+#     for num in range(amount):
+#         ratio -= dx
+#         regular = not regular
+#         current_x = None
+#         current_y = None
+#         if regular:
+#             segcount = int(seg_break * 0.25)
+#         else:
+#             segcount = int(seg_break * 0.5)
+#         # tx = 0
+#         # ty = 0
+#         # minx = miny = 1e18
+#         # maxx = maxy = -1e18
+#         for i in range(int(resolution) + 1):
+#             xx = (polycache[i][0] - geometric_center_x) * ratio + geometric_center_x
+#             yy = (polycache[i][1] - geometric_center_y) * ratio + geometric_center_y
+#             # tx += xx
+#             # ty += yy
+#             # minx = min(minx, xx)
+#             # miny = min(miny, yy)
+#             # maxx = max(maxx, xx)
+#             # maxy = max(maxy, yy)
+#             segcount += 1
+#             if segcount < seg_break:
+#                 if current_x is None:
+#                     yield "M", xx, yy
+#                 else:
+#                     yield "L", xx, yy
+#                 current_x = xx
+#                 current_y = yy
+#             elif segcount >= seg_break + seg_len:
+#                 segcount = 0
+#                 current_x = None
+#                 current_y = None
+#         # geo_x = tx / tc
+#         # geo_y = ty / tc
+#         # print(f"geometric center copy: {geo_x:.1f}, {geo_y:.1f}")
+#         # print(f"boundaries: {minx:.1f}, {miny:.1f} - {maxx:.1f}, {maxy:.1f}")
+#
+#
+# def plugin(kernel, lifecycle):
+#     if lifecycle == "register":
+#         _ = kernel.translation
+#         context = kernel.root
+#         context.register(
+#             "pattern/line",
+#             (
+#                 set_line,
+#                 False,
+#                 "",
+#                 "",
+#                 (-200, -350, 0, 0),
+#                 True,
+#             ),
+#         )
+#         context.register(
+#             "pattern/fishbone",
+#             (
+#                 set_fishbone,
+#                 True,
+#                 "Left/Right Indentation",
+#                 "Top/Bottom Indentation",
+#                 (100, 100, 0, 0),
+#                 True,
+#             ),
+#         )
+#         context.register(
+#             "pattern/diagonal",
+#             (
+#                 set_diagonal,
+#                 True,
+#                 "Left/Right Indentation",
+#                 "Top/Bottom Indentation",
+#                 (-100, -100, 0, 0),
+#                 True,
+#             ),
+#         )
+#         context.register(
+#             "pattern/diamond1",
+#             (
+#                 set_diamond1,
+#                 False,
+#                 "",
+#                 "",
+#                 (-150, 100, 0, 0),
+#                 True,
+#             ),
+#         )
+#         context.register(
+#             "pattern/diamond2",
+#             (
+#                 set_diamond2,
+#                 False,
+#                 "",
+#                 "",
+#                 (-120, 60, 0, 0),
+#                 True,
+#             ),
+#         )
+#         context.register(
+#             "pattern/cross",
+#             (
+#                 set_cross,
+#                 True,
+#                 "Left/Right Indentation",
+#                 "Top/Bottom Indentation",
+#                 (-150, -40, 0, 0),
+#                 True,
+#             ),
+#         )
+#         context.register(
+#             "pattern/bezier",
+#             (
+#                 set_bezier,
+#                 True,
+#                 "",
+#                 "",
+#                 (-20, -160, 0.4, 0.3),
+#                 True,
+#             ),
+#         )
+#         context.register(
+#             "pattern/wave",
+#             (
+#                 set_wave,
+#                 True,
+#                 "",
+#                 "",
+#                 (-130, -260, 0, 0),
+#                 True,
+#             ),
+#         )
+#         context.register(
+#             "pattern/bowlingpin",
+#             (
+#                 set_bowlingpin,
+#                 True,
+#                 "Left/Right Bowl",
+#                 "Top/Bottom Bowl",
+#                 (-210, -50, -0.3, 0),
+#                 True,
+#             ),
+#         )
+#         context.register(
+#             "pattern/beehive",
+#             (
+#                 set_beehive,
+#                 True,
+#                 "Position of left side",
+#                 "Distance of second line",
+#                 (-10, 60, 1.4, 0),
+#                 True,
+#             ),
+#         )
+#         context.register(
+#             "pattern/fabric",
+#             (
+#                 set_fabric,
+#                 False,
+#                 "",
+#                 "",
+#                 (-180, 130, 0, 0),
+#                 True,
+#             ),
+#         )
+#         context.register(
+#             "pattern/brackets",
+#             (
+#                 set_brackets,
+#                 True,
+#                 "",
+#                 "",
+#                 (-140, -110, 0.7, 0.7),
+#                 True,
+#             ),
+#         )
+#         context.register(
+#             "pattern/shape",
+#             (
+#                 set_shape,
+#                 True,
+#                 "Number of copies",
+#                 "Number of segments",
+#                 (0, 0, 1, 0.4),
+#                 False,
+#             ),
+#         )