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

drawlib/__init__.py

@@ -14,7 +14,7 @@ import sys
 from typing import Final, List
 
 # please update here when you release new version
-LIB_VERSION = "0.2.3.dev2"
+LIB_VERSION = "0.2.3.dev4"
 
 # please list active main committers (1+ commits per month)
 AUTHORS: Final[List[str]] = [

drawlib/v0_2/apis.py

@@ -54,6 +54,10 @@ from drawlib.v0_2.private.core_canvas.canvas import (
     arc,
     # shape original
     arrow,
+    arrow_arc,
+    arrow_l,
+    arrow_polyline,
+    arrow_u,
     chevron,
     circle,
     # base
@@ -66,6 +70,7 @@ from drawlib.v0_2.private.core_canvas.canvas import (
     image,
     # line
     line,
+    line_arc,
     line_bezier1,
     line_bezier2,
     line_curved,

drawlib/v0_2/private/core/model.py

@@ -883,6 +883,7 @@ class ShapeTextStyle:
     angle: Optional[float] = None
     flip: Optional[bool] = None
     xy_shift: Optional[Tuple[float, float]] = None
+    xy_abs_shift: Optional[Tuple[float, float]] = None
 
     @error_handler
     def copy(self) -> ShapeTextStyle:
@@ -1107,7 +1108,7 @@ class ShapeTextStyle:
 
     @xy_shift.setter
     @error_handler
-    def xy_shift(self, value: Optional[float]) -> None:
+    def xy_shift(self, value: Optional[Tuple[float, float]]) -> None:
         """Setter of xy_shift"""
         if isinstance(value, property) or value is None:
             self._xy_shift = None
@@ -1116,6 +1117,23 @@ class ShapeTextStyle:
         coordinate_validator.validate_xy("ShapeTextStyle.xy_shift", value)
         self._xy_shift = value
 
+    @property  # type: ignore[no-redef]
+    @error_handler
+    def xy_abs_shift(self) -> Optional[Tuple[float, float]]:
+        """Getter of xy_abs_shift"""
+        return self._xy_abs_shift
+
+    @xy_abs_shift.setter
+    @error_handler
+    def xy_abs_shift(self, value: Optional[Tuple[float, float]]) -> None:
+        """Setter of xy_abs_shift"""
+        if isinstance(value, property) or value is None:
+            self._xy_abs_shift = None
+            return
+
+        coordinate_validator.validate_xy("ShapeTextStyle.xy_abs_shift", value)
+        self._xy_abs_shift = value
+
 
 @dataclasses.dataclass
 class TextStyle:

drawlib/v0_2/private/core/util.py

@@ -498,6 +498,7 @@ class ShapeUtil:
             text_angle = (text_angle + 180) % 360
 
         x, y = xy
+        # shift
         if style.xy_shift is not None:
             x_shift, y_shift = style.xy_shift
             if shape_angle == 0:
@@ -510,6 +511,11 @@ class ShapeUtil:
                 x += rotated_x_shift
                 y += rotated_y_shift
 
+        # absolute shift
+        if style.xy_abs_shift is not None:
+            x += style.xy_abs_shift[0]
+            y += style.xy_abs_shift[1]
+
         # only check color. ignore alignment
         options = TextUtil.get_text_options(style)
         if "horizontalalignment" in options:

drawlib/v0_2/private/core_canvas/base.py

@@ -18,7 +18,10 @@ import matplotlib.lines
 import matplotlib.text
 import PIL.Image
 from matplotlib import pyplot
-from matplotlib.patches import PathPatch
+from matplotlib.patches import (
+    PathPatch,
+    Polygon,
+)
 from matplotlib.path import Path
 
 import drawlib.v0_2.private.validators.args as validator
@@ -235,6 +238,55 @@ class CanvasBase:
     # Shape
     #
 
+    @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 shape(  # noqa: C901
         self,

drawlib/v0_2/private/core_canvas/canvas.py

@@ -266,6 +266,7 @@ line = canvas.line
 line_curved = canvas.line_curved
 line_bezier1 = canvas.line_bezier1
 line_bezier2 = canvas.line_bezier2
+line_arc = canvas.line_arc
 lines = canvas.lines
 lines_curved = canvas.lines_curved
 lines_bezier = canvas.lines_bezier
@@ -275,10 +276,16 @@ rhombus = canvas.rhombus
 trapezoid = canvas.trapezoid
 parallelogram = canvas.parallelogram
 triangle = canvas.triangle
-arrow = canvas.arrow
 star = canvas.star
 chevron = canvas.chevron
 
+# original arrow
+arrow = canvas.arrow
+arrow_polyline = canvas.arrow_polyline
+arrow_arc = canvas.arrow_arc
+arrow_l = canvas.arrow_l
+arrow_u = canvas.arrow_u
+
 # patches
 arc = canvas.arc
 circle = canvas.circle

drawlib/v0_2/private/core_canvas/line.py

@@ -20,7 +20,7 @@ import drawlib.v0_2.private.validators.args as validator
 from drawlib.v0_2.private.core.model import LineStyle
 from drawlib.v0_2.private.core.util import LineUtil
 from drawlib.v0_2.private.core_canvas.base import CanvasBase
-from drawlib.v0_2.private.util import error_handler
+from drawlib.v0_2.private.util import error_handler, get_rotated_path_points
 
 
 class CanvasLineFeature(CanvasBase):
@@ -191,6 +191,62 @@ class CanvasLineFeature(CanvasBase):
             style=style,
         )
 
+    @error_handler
+    def line_arc(
+        self,
+        xy: Tuple[float, float],
+        width: float,
+        height: float,
+        angle_start: float = 0,
+        angle_end: float = 180,
+        angle: float = 0,
+        arrowhead: Literal["", "->", "<-", "<->"] = "",
+        lwidth: Optional[float] = None,
+        style: Union[LineStyle, str, None] = None,
+    ) -> None:
+        """Draw arc line on ellipse.
+
+        Args:
+            xy: Tuple[float, float]: The center point of the ellipse from which the arc is drawn.
+            width: float: The width of the ellipse.
+            height: float: The height of the ellipse
+            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.
+            arrowhead: Literal["", "->", "<-", "<->"]: Optional arrowhead style ("", "->", "<-", "<->").
+            lwidth: Optional[float]: Optional width of the line.
+            style: Union[LineStyle, str, None]: Optional line style.
+
+        Returns:
+            None
+        """
+        style = LineUtil.format_style(style)
+        # validator.validate_line_args(locals())
+
+        if angle_start > angle_end:
+            angle_start = -1 * (360 - angle_start)
+        path_points = LineArcHelper.get_ellipse_path_points(
+            xy,
+            width,
+            height,
+            angle_start,
+            angle_end,
+        )
+
+        if angle != 0:
+            path_points = get_rotated_path_points(path_points, xy, angle)  # type: ignore
+
+        start_point = path_points[0]
+        path_points = path_points[1:]
+
+        self.lines_bezier(
+            start_point,  # type: ignore
+            path_points=path_points,  # type: ignore
+            width=lwidth,
+            arrowhead=arrowhead,
+            style=style,
+        )
+
     @error_handler
     def lines(
         self,
@@ -332,6 +388,141 @@ class CanvasLineFeature(CanvasBase):
         self._artists.append(FancyArrowPatch(path=path, **options))
 
 
+class LineArcHelper:
+    """Internal class"""
+
+    @classmethod
+    def get_point_on_ellipse(
+        cls,
+        xy: Tuple[float, float],
+        width: float,
+        height: float,
+        angle: float,
+    ) -> Tuple[float, float]:
+        """Internal function"""
+        x, y = xy
+        # Convert angle from degrees to radians
+        angle = math.radians(angle)
+
+        # Calculate the coordinates of the point
+        point_x = x + width / 2 * math.cos(angle)
+        point_y = y + height / 2 * math.sin(angle)
+
+        return point_x, point_y
+
+    @classmethod
+    def get_ellipse_path_points(
+        cls,
+        xy: Tuple[float, float],
+        width: float,
+        height: float,
+        angle_start: float,
+        angle_end: float,
+    ) -> List[
+        Union[
+            Tuple[float, float],
+            Tuple[Tuple[float, float], Tuple[float, float], Tuple[float, float]],
+        ]
+    ]:
+        """Internal function"""
+        diff = angle_end - angle_start
+        if abs(diff) > 270:
+            # having +2 for avoiding situation next_mid_angle == angle_end
+            step = int(diff / 3)
+        elif abs(diff) > 135:
+            step = int(diff / 2)
+        else:
+            p1, p2, p3, p4 = cls.bezier_ellipse_arc_approximation(
+                xy,
+                width,
+                height,
+                angle_start,
+                angle_end,
+            )
+            return [p1, (p2, p3, p4)]
+        if diff >= 0:
+            diff += 2
+        else:
+            diff -= 2
+
+        i = 0
+        start = None
+        path_points = []
+        while True:
+            last_mid_angle = angle_start + step * i
+            next_mid_angle = angle_start + step * (i + 1)
+
+            if angle_start < angle_end:
+                # anti clock wise
+                is_last = next_mid_angle > angle_end
+            else:
+                # clock wise
+                is_last = angle_end > next_mid_angle
+
+            if is_last:
+                p1, p2, p3, p4 = cls.bezier_ellipse_arc_approximation(
+                    xy,
+                    width,
+                    height,
+                    last_mid_angle,
+                    angle_end,
+                )
+                if start is None:
+                    start = p1
+                path_points.append((p2, p3, p4))
+                break
+
+            else:
+                p1, p2, p3, p4 = cls.bezier_ellipse_arc_approximation(
+                    xy,
+                    width,
+                    height,
+                    last_mid_angle,
+                    next_mid_angle,
+                )
+                if start is None:
+                    start = p1
+                path_points.append((p2, p3, p4))
+
+            i += 1
+
+        path_points.insert(0, start)
+        return path_points
+
+    @classmethod
+    def bezier_ellipse_arc_approximation(
+        cls,
+        xy: Tuple[float, float],
+        width: float,
+        height: float,
+        start_angle: float,
+        end_angle: float,
+    ) -> Tuple[Tuple[float, float], Tuple[float, float], Tuple[float, float], Tuple[float, float]]:
+        """Internal function"""
+        x, y = xy
+
+        # Convert angles from degrees to radians
+        start_angle = math.radians(start_angle)
+        end_angle = math.radians(end_angle)
+
+        # Calculate the points on the ellipse at the start and end angles
+        start_point = (x + width / 2 * math.cos(start_angle), y + height / 2 * math.sin(start_angle))
+        end_point = (x + width / 2 * math.cos(end_angle), y + height / 2 * math.sin(end_angle))
+
+        # Calculate the control points for the Bezier curve
+        t = (4 / 3) * math.tan((end_angle - start_angle) / 4)
+        control_point1 = (
+            start_point[0] - t * width / 2 * math.sin(start_angle),
+            start_point[1] + t * height / 2 * math.cos(start_angle),
+        )
+        control_point2 = (
+            end_point[0] + t * width / 2 * math.sin(end_angle),
+            end_point[1] - t * height / 2 * math.cos(end_angle),
+        )
+
+        return start_point, control_point1, control_point2, end_point
+
+
 def _get_mid_points(
     a: Tuple[float, float],
     b: Tuple[float, float],