drawlib 0.2.3.dev2__py3-none-any.whl → 0.2.3.dev3__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.dev3"
 
 # please list active main committers (1+ commits per month)
 AUTHORS: Final[List[str]] = [

drawlib/v0_2/apis.py

@@ -54,6 +54,8 @@ from drawlib.v0_2.private.core_canvas.canvas import (
     arc,
     # shape original
     arrow,
+    arrow_arc,
+    arrows,
     chevron,
     circle,
     # base
@@ -66,6 +68,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/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
@@ -276,6 +277,8 @@ trapezoid = canvas.trapezoid
 parallelogram = canvas.parallelogram
 triangle = canvas.triangle
 arrow = canvas.arrow
+arrows = canvas.arrows
+arrow_arc = canvas.arrow_arc
 star = canvas.star
 chevron = canvas.chevron
 

drawlib/v0_2/private/core_canvas/line.py

@@ -191,6 +191,56 @@ class CanvasLineFeature(CanvasBase):
             style=style,
         )
 
+    @error_handler
+    def line_arc(
+        self,
+        xy: Tuple[float, float],
+        width: float,
+        height: float,
+        from_angle: float = 0,
+        to_angle: float = 180,
+        lwidth: Optional[float] = None,
+        arrowhead: Literal["", "->", "<-", "<->"] = "",
+        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
+            from_angle: float: The starting angle of the arc in degrees (default is 0).
+            to_angle: float: The ending angle of the arc in degrees (default is 180).
+            lwidth: Optional[float]: Optional width of the line.
+            arrowhead: Literal["", "->", "<-", "<->"]: Optional arrowhead style ("", "->", "<-", "<->").
+            style: Union[LineStyle, str, None]: Optional line style.
+
+        Returns:
+            None
+        """
+        style = LineUtil.format_style(style)
+        # validator.validate_line_args(locals())
+
+        if from_angle > to_angle:
+            from_angle = -1 * (360 - from_angle)
+        path_points = LineArcHelper.get_ellipse_path_points(
+            xy,
+            width,
+            height,
+            from_angle,
+            to_angle,
+        )
+        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 +382,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,
+        from_angle: float,
+        to_angle: float,
+    ) -> List[
+        Union[
+            Tuple[float, float],
+            Tuple[Tuple[float, float], Tuple[float, float], Tuple[float, float]],
+        ]
+    ]:
+        """Internal function"""
+        diff = to_angle - from_angle
+        if abs(diff) > 270:
+            # having +2 for avoiding situation next_mid_angle == to_angle
+            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,
+                from_angle,
+                to_angle,
+            )
+            return [p1, (p2, p3, p4)]
+        if diff >= 0:
+            diff += 2
+        else:
+            diff -= 2
+
+        i = 0
+        start = None
+        path_points = []
+        while True:
+            last_mid_angle = from_angle + step * i
+            next_mid_angle = from_angle + step * (i + 1)
+
+            if from_angle < to_angle:
+                # anti clock wise
+                is_last = next_mid_angle > to_angle
+            else:
+                # clock wise
+                is_last = to_angle > next_mid_angle
+
+            if is_last:
+                p1, p2, p3, p4 = cls.bezier_ellipse_arc_approximation(
+                    xy,
+                    width,
+                    height,
+                    last_mid_angle,
+                    to_angle,
+                )
+                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],