drawlib 0.2.3.dev2__py3-none-any.whl → 0.2.3.dev4__py3-none-any.whl

drawlib/v0_2/private/core_canvas/original_arrow.py

@@ -10,17 +10,24 @@
 
 """Canvas's original arrow feature implementation module."""
 
-from typing import Literal, Optional, Tuple, Union
+import math
+from typing import List, Literal, Optional, Tuple, Union
+
+from matplotlib.patches import PathPatch
+from matplotlib.path import Path
 
 import drawlib.v0_2.private.validators.args as validator
 from drawlib.v0_2.private.core.model import ShapeStyle, ShapeTextStyle
 from drawlib.v0_2.private.core.theme import dtheme
 from drawlib.v0_2.private.core.util import ShapeUtil
 from drawlib.v0_2.private.core_canvas.base import CanvasBase
+from drawlib.v0_2.private.core_canvas.line import LineArcHelper
 from drawlib.v0_2.private.util import (
     error_handler,
     get_angle,
     get_distance,
+    get_rotated_path_points,
+    get_rotated_points,
 )
 
 
@@ -137,3 +144,472 @@ class CanvasOriginalArrowFeature(CanvasBase):
             textsize=textsize,
             textstyle=textstyle,
         )
+
+    @error_handler
+    def arrow_polyline(
+        self,
+        xys: List[Tuple[float, float]],
+        tail_width: float,
+        head_width: float,
+        head_length: float,
+        head: Literal[
+            "->",
+            "<-",
+            "<->",
+        ] = "->",
+        r: float = 0,
+        style: Union[ShapeStyle, str, None] = None,
+    ) -> None:
+        """Draw single and double-headed arrow.
+
+        Args:
+            xys: List[Tuple[float, float]]: Arrow points.
+            tail_width: float: Width of the arrow tail.
+            head_width: float: Width of the arrow head.
+            head_length: float: Length of the arrow head.
+            head: Literal["->", "<-", "<->"]: Arrow head style ("->", "<-", "<->").
+            r (float, optional): Radius for rounded connections (default is 0.0).
+            style: Union[ShapeStyle, str, None]: Optional style of the arrow.
+
+        Returns:
+            None
+        """
+        # matplotlib FancyArrow, FancyArrowPatch seems not good
+        # for implement this function.
+        # Calculate arrow points pass it to shape().
+
+        style, _ = ShapeUtil.format_styles(
+            style,
+            None,
+            dtheme.arrowstyles.get,
+            dtheme.arrowtextstyles.get,
+        )
+        validator.validate_shape_args(locals())
+
+        def point_on_line(a: Tuple[float, float], b: Tuple[float, float], n: float) -> Tuple[float, float]:
+            ab = (b[0] - a[0], b[1] - a[1])
+            ab_length = math.sqrt(ab[0] ** 2 + ab[1] ** 2)
+            ab_unit = (ab[0] / ab_length, ab[1] / ab_length)
+            scaled_vector = (ab_unit[0] * n, ab_unit[1] * n)
+            new_point = (a[0] + scaled_vector[0], a[1] + scaled_vector[1])
+            return new_point
+
+        def point_parallel_to_line(
+            a: Tuple[float, float], b: Tuple[float, float], distance: float
+        ) -> Tuple[float, float]:
+            ab = (b[0] - a[0], b[1] - a[1])
+            ab_length = math.sqrt(ab[0] ** 2 + ab[1] ** 2)
+            ab_unit = (ab[0] / ab_length, ab[1] / ab_length)
+            ab_perpendicular = (-ab_unit[1], ab_unit[0])
+            scaled_vector = (ab_perpendicular[0] * distance, ab_perpendicular[1] * distance)
+            new_point = (a[0] + scaled_vector[0], a[1] + scaled_vector[1])
+            return new_point
+
+        if head in {"<-", "<->"}:
+            xys_start = point_on_line(xys[0], xys[1], head_length)
+        else:
+            xys_start = xys[0]
+
+        if head in {"->", "<->"}:
+            xys_end = point_on_line(xys[-1], xys[-2], head_length)
+        else:
+            xys_end = xys[-1]
+
+        new_xys = xys[1:-1]
+        new_xys.insert(0, xys_start)
+        new_xys.append(xys_end)
+        aph = ArrowPolylineHelper(new_xys, r, 100)
+        parallel_xys1 = aph.get_parallel_curve_points(tail_width / 2)
+        parallel_xys2 = aph.get_parallel_curve_points(tail_width / -2)
+        parallel_xys2.reverse()
+
+        if head in {"<-", "<->"}:
+            ahp1 = point_parallel_to_line(xys_start, xys[1], head_width / 2)
+            ahp2 = point_parallel_to_line(xys_start, xys[1], head_width / -2)
+            parallel_xys1.insert(0, xys[0])
+            parallel_xys1.insert(1, ahp1)
+            parallel_xys2.append(ahp2)
+
+        if head in {"->", "<->"}:
+            ahp3 = point_parallel_to_line(xys_end, xys[-2], head_width / -2)
+            ahp4 = point_parallel_to_line(xys_end, xys[-2], head_width / 2)
+            parallel_xys1.append(ahp3)
+            parallel_xys1.append(xys[-1])
+            parallel_xys1.append(ahp4)
+
+        parallel_xys1.extend(parallel_xys2)
+        self.polygon(xys=parallel_xys1, style=style, text="", textstyle=None)
+
+    @error_handler
+    def arrow_arc(
+        self,
+        xy: Tuple[float, float],
+        width: float,
+        height: float,
+        tail_width: float,
+        head_width: float,
+        head_angle: float = 10,
+        head: Literal["->", "<-", "<->"] = "->",
+        angle_start: float = 0,
+        angle_end: float = 180,
+        angle: float = 0,
+        style: Union[ShapeStyle, str, None] = None,
+    ) -> None:
+        """Draw arc arrow.
+
+        Args:
+            xy: Tuple[float, float]: The center point of the circle from which the arc arrow is drawn.
+            width: float: The width of the ellipse.
+            height: float: The height of the ellipse
+            tail_width: float: The width of the tail of the arrow.
+            head_width: float: The width of the head of the arrow.
+            head_angle: float: The angle of the arrowhead in degrees (default is 10).
+            head: Literal["->", "<-", "<->"]: The arrowhead style ("->", "<-", "<->").
+            angle_start: float: The starting angle of the arc in degrees (default is 0).
+            angle_end: float: The ending angle of the arc in degrees (default is 180).
+            angle (float): The angle of ellipse.
+            style: Union[ShapeStyle, str, None]: Optional shape style.
+
+        Returns:
+            None
+        """
+        style, _ = ShapeUtil.format_styles(
+            style,
+            None,
+            dtheme.arrowstyles.get,
+            dtheme.arrowtextstyles.get,
+        )
+        validator.validate_shape_args(locals())
+
+        width_int = width - tail_width
+        width_ext = width + tail_width
+        height_int = height - tail_width
+        height_ext = height + tail_width
+
+        if head in {"<-", "<->"}:
+            angle_start2 = angle_start + head_angle
+            angle_start2 %= 360
+        else:
+            angle_start2 = angle_start
+
+        if head in {"->", "<->"}:
+            angle_end2 = angle_end - head_angle
+            angle_end2 %= 360
+        else:
+            angle_end2 = angle_end
+
+        if angle_start2 > angle_end2:
+            pp1_fa = -1 * (360 - angle_start2)
+            pp1_ta = angle_end2
+            pp2_fa = angle_end2
+            pp2_ta = pp1_fa
+        else:
+            pp1_fa = angle_start2
+            pp1_ta = angle_end2
+            pp2_fa = angle_end2
+            pp2_ta = angle_start2
+
+        path_points1 = LineArcHelper.get_ellipse_path_points(
+            xy,
+            width_int,
+            height_int,
+            pp1_fa,
+            pp1_ta,
+        )
+        path_points2 = LineArcHelper.get_ellipse_path_points(
+            xy,
+            width_ext,
+            height_ext,
+            pp2_fa,
+            pp2_ta,
+        )
+
+        if angle_start > angle_end:
+            angle_start = -1 * (360 - angle_start)
+
+        if head in {"<-", "<->"}:
+            path_points1.insert(
+                0,
+                LineArcHelper.get_point_on_ellipse(
+                    xy,
+                    width,
+                    height,
+                    angle_start,
+                ),
+            )
+            path_points1.insert(
+                1,
+                LineArcHelper.get_point_on_ellipse(
+                    xy,
+                    width - head_width,
+                    height - head_width,
+                    angle_start2,
+                ),
+            )
+            path_points2.append(
+                LineArcHelper.get_point_on_ellipse(
+                    xy,
+                    width + head_width,
+                    height + head_width,
+                    angle_start2,
+                )
+            )
+
+        if head in {"->", "<->"}:
+            path_points1.append(
+                LineArcHelper.get_point_on_ellipse(
+                    xy,
+                    width - head_width,
+                    height - head_width,
+                    angle_end2,
+                )
+            )
+            path_points1.append(
+                LineArcHelper.get_point_on_ellipse(
+                    xy,
+                    width,
+                    height,
+                    angle_end,
+                )
+            )
+            path_points2.insert(
+                0,
+                LineArcHelper.get_point_on_ellipse(
+                    xy,
+                    width + head_width,
+                    height + head_width,
+                    angle_end2,
+                ),
+            )
+
+        path_points1.extend(path_points2)
+
+        if angle != 0:
+            path_points1 = get_rotated_path_points(path_points1, xy, angle)  # type: ignore
+
+        # create Path
+        vertices = [path_points1[0]]
+        codes = [Path.MOVETO]
+        for p in path_points1[1:]:
+            length = len(p)
+            if length not in {2, 3}:
+                raise ValueError()
+
+            if not isinstance(p[0], tuple):
+                vertices.append(p)
+                codes.append(Path.LINETO)
+
+            elif length == 2:
+                vertices.extend([p[0], p[1]])  # type: ignore
+                codes.extend([Path.CURVE3] * 2)
+
+            else:
+                vertices.extend([p[0], p[1], p[2]])  # type: ignore
+                codes.extend([Path.CURVE4] * 3)
+
+        vertices.append(path_points1[0])
+        codes.append(Path.CLOSEPOLY)
+        path = Path(vertices=vertices, codes=codes)
+
+        # create PathPatch
+
+        options = ShapeUtil.get_shape_options(style)
+        self._artists.append(PathPatch(path=path, **options))
+
+    @error_handler
+    def arrow_l(
+        self,
+        xy: Tuple[float, float],
+        width: float,
+        height: float,
+        tail_width: float,
+        head_width: float,
+        head_length: float,
+        head: Literal["->", "<-", "<->"] = "->",
+        r: float = 0,
+        angle: float = 0,
+        style: Union[ShapeStyle, str, None] = None,
+    ) -> None:
+        """Draw "L" shape arrow.
+
+        Args:
+            xy: Tuple[float, float]: The center point of L arrow.
+            width: float: The width L arrow.
+            height: float: The height of L arrow.
+            tail_width: float: The width of the tail of the arrow.
+            head_width: float: The width of the head of the arrow.
+            head_length: float: Length of the arrow head.
+            head: Literal["->", "<-", "<->"]: Arrow head style ("->", "<-", "<->").
+            r (float, optional): Radius for rounded connections (default is 0.0).
+            angle: float: rotate angle.
+            style: Union[ShapeStyle, str, None]: Optional shape style.
+
+        Returns:
+            None
+        """
+        style, _ = ShapeUtil.format_styles(
+            style,
+            None,
+            dtheme.arrowstyles.get,
+            dtheme.arrowtextstyles.get,
+        )
+        validator.validate_shape_args(locals())
+
+        p1 = (xy[0] - width / 2, xy[1] + height / 2)
+        p2 = (xy[0] - width / 2, xy[1] - height / 2)
+        p3 = (xy[0] + width / 2, xy[1] - height / 2)
+
+        xys = [p1, p2, p3]
+        if angle != 0:
+            xys = get_rotated_points(xys=xys, center=xy, angle=angle)
+
+        self.arrow_polyline(
+            xys=xys,
+            tail_width=tail_width,
+            head_width=head_width,
+            head_length=head_length,
+            head=head,
+            r=r,
+            style=style,
+        )
+
+    @error_handler
+    def arrow_u(
+        self,
+        xy: Tuple[float, float],
+        width: float,
+        height: float,
+        tail_width: float,
+        head_width: float,
+        head_length: float,
+        head: Literal["->", "<-", "<->"] = "->",
+        r: float = 0,
+        angle: float = 0,
+        style: Union[ShapeStyle, str, None] = None,
+    ) -> None:
+        """Draw "U" shape arrow.
+
+        Args:
+            xy: Tuple[float, float]: The center point U arrow.
+            width: float: The width of the U arrow.
+            height: float: The height of the U arrow.
+            tail_width: float: The width of the tail of the arrow.
+            head_width: float: The width of the head of the arrow.
+            head_length: float: Length of the arrow head.
+            head: Literal["->", "<-", "<->"]: Arrow head style ("->", "<-", "<->").
+            r (float, optional): Radius for rounded connections (default is 0.0).
+            angle: float: rotate angle.
+            style: Union[ShapeStyle, str, None]: Optional shape style.
+
+        Returns:
+            None
+        """
+        style, _ = ShapeUtil.format_styles(
+            style,
+            None,
+            dtheme.arrowstyles.get,
+            dtheme.arrowtextstyles.get,
+        )
+        validator.validate_shape_args(locals())
+
+        p1 = (xy[0] - width / 2, xy[1] + height / 2)
+        p2 = (xy[0] - width / 2, xy[1] - height / 2)
+        p3 = (xy[0] + width / 2, xy[1] - height / 2)
+        p4 = (xy[0] + width / 2, xy[1] + height / 2)
+
+        xys = [p1, p2, p3, p4]
+        if angle != 0:
+            xys = get_rotated_points(xys=xys, center=xy, angle=angle)
+
+        self.arrow_polyline(
+            xys=xys,
+            tail_width=tail_width,
+            head_width=head_width,
+            head_length=head_length,
+            head=head,
+            r=r,
+            style=style,
+        )
+
+
+class ArrowPolylineHelper:
+    """Internal class"""
+
+    def __init__(
+        self,
+        xys: List[Tuple[float, float]],
+        r: float,
+        num_points: int = 100,
+    ) -> None:
+        """Internal function"""
+
+        def get_mid_points(
+            a: Tuple[float, float],
+            b: Tuple[float, float],
+        ) -> Tuple[Tuple[float, float], Tuple[float, float]]:
+            ab = [b[0] - a[0], b[1] - a[1]]
+            ab_distance = math.sqrt(ab[0] ** 2 + ab[1] ** 2)
+            ab_unit = [ab[0] / ab_distance, ab[1] / ab_distance]
+            c = (a[0] + r * ab_unit[0], a[1] + r * ab_unit[1])
+            d = (b[0] - r * ab_unit[0], b[1] - r * ab_unit[1])
+            return c, d
+
+        def bernstein_poly(i: int, n: int, t: float) -> float:
+            return math.comb(n, i) * (t**i) * ((1 - t) ** (n - i))
+
+        def get_points(
+            bezier_points: List[Tuple[float, float]],
+        ) -> List[Tuple[float, float]]:
+            n = len(bezier_points) - 1
+            curve = []
+            for t in [i / (num_points - 1) for i in range(num_points)]:
+                x = sum(bernstein_poly(i, n, t) * bezier_points[i][0] for i in range(n + 1))
+                y = sum(bernstein_poly(i, n, t) * bezier_points[i][1] for i in range(n + 1))
+                curve.append((x, y))
+            return curve
+
+        points = []
+        bezier_start: Tuple[float, float] = (0, 0)
+        last_i = len(xys) - 2
+        # last_xy = (0, 0)
+        for i in range(len(xys)):
+            # first straight line
+            if i == 0:
+                _, bezier_start = get_mid_points(xys[0], xys[1])
+                points.append(xys[0])
+                continue
+
+            # last straight line
+            if i == last_i:
+                p1, _ = get_mid_points(xys[i], xys[i + 1])
+                bezier_points = [bezier_start, xys[i], p1]
+                points.extend(get_points(bezier_points))
+                points.append(xys[i + 1])
+                break
+
+            p1, p2 = get_mid_points(xys[i], xys[i + 1])
+            bezier_points = [bezier_start, xys[i], p1]
+            points.extend(get_points(bezier_points))
+            bezier_start = p2
+
+        self._original_curve_points = points
+
+    def get_parallel_curve_points(self, distance: float) -> List[Tuple[float, float]]:
+        """Internal function"""
+
+        def get_distance(p1: Tuple[float, float], p2: Tuple[float, float]) -> float:
+            return math.sqrt((p1[0] - p2[0]) ** 2 + (p1[1] - p2[1]) ** 2)
+
+        parallel_curve_points = []
+        for i in range(1, len(self._original_curve_points)):
+            p0, p1 = self._original_curve_points[i - 1], self._original_curve_points[i]
+            dx, dy = p1[0] - p0[0], p1[1] - p0[1]
+            length = get_distance(p0, p1)
+            nx, ny = -dy / length, dx / length
+            px0, py0 = p0[0] + distance * nx, p0[1] + distance * ny
+            px1, py1 = p1[0] + distance * nx, p1[1] + distance * ny
+            parallel_curve_points.append((px0, py0))
+            if i == len(self._original_curve_points) - 1:
+                parallel_curve_points.append((px1, py1))
+
+        return parallel_curve_points

drawlib/v0_2/private/core_canvas/patches.py

@@ -16,7 +16,6 @@ from matplotlib.patches import (
     Arc,
     Circle,
     Ellipse,
-    Polygon,
     RegularPolygon,
     Wedge,
 )
@@ -26,7 +25,7 @@ from drawlib.v0_2.private.core.model import ShapeStyle, ShapeTextStyle
 from drawlib.v0_2.private.core.theme import dtheme
 from drawlib.v0_2.private.core.util import ShapeUtil
 from drawlib.v0_2.private.core_canvas.base import CanvasBase
-from drawlib.v0_2.private.util import error_handler, get_center_and_size
+from drawlib.v0_2.private.util import error_handler
 
 
 class CanvasPatchesFeature(CanvasBase):
@@ -46,8 +45,8 @@ class CanvasPatchesFeature(CanvasBase):
         xy: Tuple[float, float],
         width: float,
         height: float,
-        from_angle: Union[int, float] = 0.0,
-        to_angle: Union[int, float] = 360.0,
+        angle_start: Union[int, float] = 0.0,
+        angle_end: Union[int, float] = 360.0,
         angle: Union[int, float] = 0.0,
         style: Union[ShapeStyle, str, None] = None,
         text: str = "",
@@ -60,8 +59,8 @@ class CanvasPatchesFeature(CanvasBase):
             xy: Center of the arc.
             width: Width of the arc.
             height: Height of the arc.
-            from_angle (optional): Starting angle of the arc (default is 0.0).
-            to_angle (optional): Ending angle of the arc (default is 360.0).
+            angle_start (optional): Starting angle of the arc (default is 0.0).
+            angle_end (optional): Ending angle of the arc (default is 360.0).
             angle (optional): Rotation angle of the arc.
             style (optional): Style of the arc.
             text (optional): Text shown at the center of the arc.
@@ -90,8 +89,8 @@ class CanvasPatchesFeature(CanvasBase):
                 width=width,
                 height=height,
                 angle=angle,
-                theta1=from_angle,
-                theta2=to_angle,
+                theta1=angle_start,
+                theta2=angle_end,
                 **options,
             )
         )
@@ -227,55 +226,6 @@ class CanvasPatchesFeature(CanvasBase):
             ),
         )
 
-    @error_handler
-    def polygon(
-        self,
-        xys: List[Tuple[float, float]],
-        style: Union[ShapeStyle, str, None] = None,
-        text: str = "",
-        textsize: Optional[float] = None,
-        textstyle: Union[ShapeTextStyle, str, None] = None,
-    ) -> None:
-        """Draw a polygon on the canvas.
-
-        Args:
-            xys: List of vertices [(x1, y1), ...(x_n, y_n)].
-            style (optional): Style of the polygon.
-            text (optional): Text shown at the center of the polygon.
-            textsize (optional): Font size of the text.
-            textstyle (optional): Style of the text.
-
-        Returns:
-            None
-        """
-        style, textstyle = ShapeUtil.format_styles(
-            style,
-            textstyle,
-            dtheme.polygonstyles.get,
-            dtheme.polygontextstyles.get,
-        )
-        validator.validate_shape_args(locals())
-
-        if textsize is not None:
-            textstyle.size = textsize
-
-        style.halign = None
-        style.valign = None
-        options = ShapeUtil.get_shape_options(style)
-        self._artists.append(Polygon(xy=xys, closed=True, **options))
-
-        if not text:
-            return
-        center, (_, _) = get_center_and_size(xys)
-        self._artists.append(
-            ShapeUtil.get_shape_text(
-                center,
-                text=text,
-                angle=0,
-                style=textstyle,
-            ),
-        )
-
     @error_handler
     def regularpolygon(
         self,
@@ -345,8 +295,8 @@ class CanvasPatchesFeature(CanvasBase):
         xy: Tuple[float, float],
         radius: float,
         width: Optional[float] = None,
-        from_angle: float = 0,
-        to_angle: float = 360,
+        angle_start: float = 0,
+        angle_end: float = 360,
         angle: Union[int, float] = 0.0,
         style: Union[ShapeStyle, str, None] = None,
         text: str = "",
@@ -360,8 +310,8 @@ class CanvasPatchesFeature(CanvasBase):
             radius: Radius of the wedge.
             width (optional): Length from outer to inner circumference.
                               Default is same as radius.
-            from_angle (optional): Starting angle of the wedge (default is 0).
-            to_angle (optional): Ending angle of the wedge (default is 360).
+            angle_start (optional): Starting angle of the wedge (default is 0).
+            angle_end (optional): Ending angle of the wedge (default is 360).
             angle (optional): Rotation angle of the wedge.
             style (optional): Style of the wedge.
             text (optional): Text shown at the center of the wedge.
@@ -391,8 +341,8 @@ class CanvasPatchesFeature(CanvasBase):
                 center=xy,
                 r=radius,
                 width=width,  # None makes no hole
-                theta1=from_angle + angle,
-                theta2=to_angle + angle,
+                theta1=angle_start + angle,
+                theta2=angle_end + angle,
                 **options,
             )
         )
@@ -459,8 +409,8 @@ class CanvasPatchesFeature(CanvasBase):
         self,
         xy: Tuple[float, float],
         radius: float,
-        from_angle: float = 0,
-        to_angle: float = 180,
+        angle_start: float = 0,
+        angle_end: float = 180,
         angle: Union[int, float] = 0.0,
         style: Union[ShapeStyle, str, None] = None,
         text: str = "",
@@ -472,8 +422,8 @@ class CanvasPatchesFeature(CanvasBase):
         Args:
             xy: Center of the fan.
             radius: Radius of the fan.
-            from_angle (optional): Starting angle of the fan (default is 0).
-            to_angle (optional): Ending angle of the fan (default is 180).
+            angle_start (optional): Starting angle of the fan (default is 0).
+            angle_end (optional): Ending angle of the fan (default is 180).
             angle (optional): Rotation angle of the fan.
             style (optional): Style of the fan.
             text (optional): Text shown at the center of the fan.
@@ -495,8 +445,8 @@ class CanvasPatchesFeature(CanvasBase):
             xy=xy,
             radius=radius,
             width=None,
-            from_angle=from_angle,
-            to_angle=to_angle,
+            angle_start=angle_start,
+            angle_end=angle_end,
             angle=angle,
             style=style,
             text=text,