otary 0.1.0__tar.gz

otary-0.1.0/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.3
+Name: otary
+Version: 0.1.0
+Summary: Image and 2D Geometry library for easy and fast image manipulation
+Author: Alexandre Poupeau
+Author-email: alexandre.poupeau.contact@gmail.com
+Requires-Python: >=3.11.2,<4.0.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: metpy (>=1.6.2,<2.0.0)
+Requires-Dist: opencv-python (>=4.10.0.84,<5.0.0.0)
+Requires-Dist: pymupdf (>=1.24.12,<2.0.0)
+Requires-Dist: setuptools (>=70.0.0,<71.0.0)
+Requires-Dist: shapely (>=2.0.4,<3.0.0)
+Requires-Dist: sympy (>=1.12,<2.0)
+Description-Content-Type: text/markdown
+
+

otary-0.1.0/otary/geometry/__init__.py

@@ -0,0 +1,32 @@
+"""
+Module to facilitate imports in geometry
+"""
+
+__all__ = [
+    "DEFAULT_MARGIN_ANGLE_ERROR",
+    "Point",
+    "Segment",
+    "Vector",
+    "LinearSpline",
+    "VectorizedLinearSpline",
+    "Polygon",
+    "Triangle",
+    "Rectangle",
+    "Ellipse",
+    "Circle",
+]
+
+# pylint: disable=cyclic-import
+from otary.geometry.utils.constants import DEFAULT_MARGIN_ANGLE_ERROR
+from otary.geometry.discrete.point import Point
+from otary.geometry.discrete.linear.segment import Segment
+from otary.geometry.discrete.linear.directed.vector import Vector
+from otary.geometry.discrete.linear.spline import LinearSpline
+from otary.geometry.discrete.linear.directed.vectorized_linear_spline import (
+    VectorizedLinearSpline,
+)
+from otary.geometry.discrete.shape.polygon import Polygon
+from otary.geometry.discrete.shape.triangle import Triangle
+from otary.geometry.discrete.shape.rectangle import Rectangle
+from otary.geometry.continuous.shape.ellipse import Ellipse
+from otary.geometry.continuous.shape.circle import Circle

otary-0.1.0/otary/geometry/continuous/entity.py

@@ -0,0 +1,172 @@
+"""
+ContinuousGeometryEntity module class
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+
+import cv2
+import numpy as np
+
+from otary.geometry.entity import GeometryEntity
+from otary.geometry import Polygon, Rectangle
+
+
+class ContinuousGeometryEntity(GeometryEntity, ABC):
+    """
+    ContinuousGeometryEntity class which is the abstract base class for
+    continuous or smooth geometry objects like circles, ellipse, etc...
+    """
+
+    DEFAULT_N_POINTS_POLYGONAL_APPROX = 1000
+
+    def __init__(
+        self, n_points_polygonal_approx: int = DEFAULT_N_POINTS_POLYGONAL_APPROX
+    ):
+        """Initialize a ContinuousGeometryEntity object
+
+        Args:
+            n_points_polygonal_approx (int, optional): n points to be used in
+                the polygonal approximation.
+                Defaults to DEFAULT_N_POINTS_POLYGONAL_APPROX.
+        """
+        self._n_points_polygonal_approx = n_points_polygonal_approx
+
+    # --------------------------------- PROPERTIES ------------------------------------
+
+    @property
+    def n_points_polygonal_approx(self) -> int:
+        """Get the number of points for the polygonal approximation.
+
+        Returns:
+            int: The number of points used in the polygonal approximation.
+        """
+        return self._n_points_polygonal_approx
+
+    @n_points_polygonal_approx.setter
+    def n_points_polygonal_approx(self, value):
+        """
+        Set the number of points for the polygonal approximation.
+        This would also update the polygonal approximation of the geometry entity.
+
+        Args:
+            value (int): The number of points to be used in the polygonal approximation.
+        """
+        self._n_points_polygonal_approx = value
+        self.update_polyapprox()
+
+    @property
+    def polyaprox(self) -> Polygon:
+        """Generate a polygonal approximation of the continuous geometry entity
+        No setter is defined for this property as it is a read-only property.
+
+        Returns:
+            Polygon: polygonal approximation of the continuous geometry entity
+        """
+        return self._polyapprox
+
+    @abstractmethod
+    def polygonal_approx(self, n_points: int, is_cast_int: bool) -> Polygon:
+        """Generate a polygonal approximation of the continuous geometry entity
+
+        Args:
+            n_points (int): number of points that make up the polygonal
+                approximation. The bigger the better to obtain more precise
+                results in intersection or other similar computations.
+
+        Returns:
+            Polygon: polygonal approximation of the continuous geometry entity
+        """
+
+    @property
+    def xmax(self) -> float:
+        """Get the maximum X coordinate of the geometry entity
+
+        Returns:
+            np.ndarray: 2D point
+        """
+        return self.polyaprox.xmax
+
+    @property
+    def xmin(self) -> float:
+        """Get the minimum X coordinate of the geometry entity
+
+        Returns:
+            np.ndarray: 2D point
+        """
+        return self.polyaprox.xmin
+
+    @property
+    def ymax(self) -> float:
+        """Get the maximum Y coordinate of the geometry entity
+
+        Returns:
+            np.ndarray: 2D point
+        """
+        return self.polyaprox.ymax
+
+    @property
+    def ymin(self) -> float:
+        """Get the minimum Y coordinate of the geometry entity
+
+        Returns:
+            np.ndarray: 2D point
+        """
+        return self.polyaprox.ymin
+
+    # ---------------------------- MODIFICATION METHODS -------------------------------
+
+    # done in the derived classes
+
+    # ------------------------------- CLASSIC METHODS ---------------------------------
+
+    def update_polyapprox(self) -> None:
+        """Update the polygonal approximation of the continuous geometry entity"""
+        self._polyapprox = self.polygonal_approx(
+            n_points=self.n_points_polygonal_approx, is_cast_int=False
+        )
+
+    def enclosing_axis_aligned_bbox(self) -> Rectangle:
+        """Compute the smallest area enclosing Axis-Aligned Bounding Box (AABB)
+        See: https://docs.opencv.org/3.4/dd/d49/tutorial_py_contour_features.html
+
+        Returns:
+            Rectangle: Rectangle object
+        """
+        topleft_x, topleft_y, width, height = cv2.boundingRect(
+            array=self.polyaprox.asarray
+        )
+        bbox = np.array(
+            [
+                [topleft_x, topleft_y],
+                [topleft_x + width, topleft_y],
+                [topleft_x + width, topleft_y + height],
+                [topleft_x, topleft_y + height],
+            ]
+        )
+        return Rectangle(bbox)
+
+    def enclosing_oriented_bbox(self) -> Rectangle:
+        """Compute the smallest area enclosing Oriented Bounding Box (OBB)
+        See: https://docs.opencv.org/3.4/dd/d49/tutorial_py_contour_features.html
+
+        Returns:
+            Rectangle: Rectangle object
+        """
+        rect = cv2.minAreaRect(self.polyaprox.asarray)
+        bbox = cv2.boxPoints(rect)
+        return Rectangle(bbox)
+
+    def enclosing_convex_hull(self) -> "Polygon":
+        """Compute the smallest area enclosing Convex Hull
+        See: https://docs.opencv.org/3.4/dd/d49/tutorial_py_contour_features.html
+
+        Returns:
+            Polygon: Polygon object
+        """
+        # pylint: disable=import-outside-toplevel
+        from otary.geometry import Polygon
+
+        convexhull = np.squeeze(cv2.convexHull(self.polyaprox.asarray))
+        return Polygon(convexhull)

otary-0.1.0/otary/geometry/continuous/shape/circle.py

@@ -0,0 +1,237 @@
+"""
+Circle Geometric Object
+"""
+
+from typing import Self, Optional
+import math
+
+import numpy as np
+from numpy.typing import NDArray
+
+from shapely import Polygon as SPolygon, LinearRing
+
+from otary.geometry.utils.tools import rotate_2d_points
+from otary.geometry.continuous.entity import ContinuousGeometryEntity
+from otary.geometry import Ellipse, Polygon
+from otary.utils.tools import assert_transform_shift_vector
+
+
+class Circle(Ellipse):
+    """Circle geometrical object"""
+
+    def __init__(
+        self,
+        center: NDArray,
+        radius: float,
+        n_points_polygonal_approx: int = ContinuousGeometryEntity.DEFAULT_N_POINTS_POLYGONAL_APPROX,
+    ):
+        """Initialize a Circle geometrical object
+
+        Args:
+            center (NDArray): center 2D point
+            radius (float): radius value
+            n_points_polygonal_approx (int, optional): number of points to be used in
+                the polygonal approximation of the circle. Defaults to
+                ContinuousGeometryEntity.DEFAULT_N_POINTS_POLYGONAL_APPROX.
+        """
+        super().__init__(
+            foci1=center,
+            foci2=center,
+            semi_major_axis=radius,
+            n_points_polygonal_approx=n_points_polygonal_approx,
+        )
+        self.center = center
+        self.radius = radius
+        self.update_polyapprox()
+
+    # --------------------------------- PROPERTIES ------------------------------------
+
+    @property
+    def perimeter(self) -> float:
+        """Perimeter of the circle
+
+        Returns:
+            float: perimeter value
+        """
+        return 2 * math.pi * self.radius
+
+    @property
+    def centroid(self) -> NDArray:
+        """Center of the circle
+
+        Returns:
+            float: center 2D point
+        """
+        return self.center
+
+    @property
+    def shapely_surface(self) -> SPolygon:
+        """Returns the Shapely.Polygon as an surface representation of the Circle.
+        See https://shapely.readthedocs.io/en/stable/reference/shapely.Polygon.html
+
+        Returns:
+            Polygon: shapely.Polygon object
+        """
+        return SPolygon(self.polyaprox.asarray, holes=None)
+
+    @property
+    def shapely_edges(self) -> LinearRing:
+        """Returns the Shapely.LinearRing as a curve representation of the Circle.
+        See https://shapely.readthedocs.io/en/stable/reference/shapely.LinearRing.html
+
+        Returns:
+            LinearRing: shapely.LinearRing object
+        """
+        return LinearRing(coordinates=self.polyaprox.asarray)
+
+    def polygonal_approx(self, n_points: int, is_cast_int: bool = False) -> Polygon:
+        """Generate a Polygon object that is an approximation of the circle
+        as a discrete geometrical object made up of only points and segments.
+
+        Args:
+            n_points (int): number of points that make up the circle
+                polygonal approximation
+            is_cast_int (bool): whether to cast to int the points coordinates or
+                not. Defaults to False
+
+        Returns:
+            Polygon: Polygon representing the circle as a succession of n points
+
+        """
+        points = []
+        for theta in np.linspace(0, 2 * math.pi, n_points):
+            x = self.center[0] + self.radius * math.cos(theta)
+            y = self.center[1] + self.radius * math.sin(theta)
+            points.append([x, y])
+
+        poly = Polygon(points=np.asarray(points), is_cast_int=is_cast_int)
+        return poly
+
+    def curvature(self, point: Optional[NDArray] = None) -> float:
+        """Curvature of circle is a constant and does not depend on a position of
+        a point
+
+        Returns:
+            float: curvature value
+        """
+        return 1 / self.radius
+
+    @property
+    def xmax(self) -> float:
+        """Get the maximum X coordinate of the geometry entity
+
+        Returns:
+            NDArray: 2D point
+        """
+        return self.center[0] + self.radius
+
+    @property
+    def xmin(self) -> float:
+        """Get the minimum X coordinate of the geometry entity
+
+        Returns:
+            NDArray: 2D point
+        """
+        return self.center[0] - self.radius
+
+    @property
+    def ymax(self) -> float:
+        """Get the maximum Y coordinate of the geometry entity
+
+        Returns:
+            NDArray: 2D point
+        """
+        return self.center[1] + self.radius
+
+    @property
+    def ymin(self) -> float:
+        """Get the minimum Y coordinate of the geometry entity
+
+        Returns:
+            NDArray: 2D point
+        """
+        return self.center[1] - self.radius
+
+    # ---------------------------- MODIFICATION METHODS -------------------------------
+
+    def rotate(
+        self,
+        angle: float,
+        is_degree: bool = False,
+        is_clockwise: bool = True,
+        pivot: Optional[NDArray] = None,
+    ) -> Self:
+        """Rotate the circle around a pivot point.
+
+        Args:
+            angle (float): angle by which to rotate the circle
+            is_degree (bool, optional): whether the angle is in degrees. Defaults to False.
+            is_clockwise (bool, optional): whether the rotation is clockwise. Defaults to True.
+            pivot (Optional[NDArray], optional): pivot point around which to rotate. Defaults to None.
+
+        Returns:
+            Self: rotated circle object
+        """
+        if pivot is None:
+            # If no pivot is given, the circle is rotated around its center
+            # and thus is not modified
+            return self
+
+        self.center = rotate_2d_points(
+            points=self.center,
+            angle=angle,
+            is_degree=is_degree,
+            is_clockwise=is_clockwise,
+            pivot=pivot,
+        )
+        self.update_polyapprox()
+        return self
+
+    def shift(self, vector: NDArray) -> Self:
+        """Shift the circle by a given vector.
+
+        Args:
+            vector (NDArray): 2D vector by which to shift the circle
+
+        Returns:
+            Self: shifted circle object
+        """
+        vector = assert_transform_shift_vector(vector=vector)
+        self.center += vector
+        self.update_polyapprox()
+        return self
+
+    def normalize(self, x: float, y: float) -> Self:
+        """Normalize the circle by dividing the points by a norm on the x and y
+        coordinates. This does not change the circle radius.
+
+        Args:
+            x (float): x coordinate norm
+            y (float): y coordinate norm
+
+        Returns:
+            Self: normalized circle object
+        """
+        self.center = self.center / np.array([x, y])
+        self.update_polyapprox()
+        return self
+
+    # ------------------------------- CLASSIC METHODS ---------------------------------
+
+    def copy(self) -> Self:
+        """Copy the circle object
+
+        Returns:
+            Self: copied circle object
+        """
+        return type(self)(
+            center=self.center,
+            radius=self.radius,
+            n_points_polygonal_approx=self.n_points_polygonal_approx,
+        )
+
+    def __str__(self) -> str:
+        return f"Circle(center={self.center}, radius={self.radius})"
+
+    def __repr__(self):
+        return f"Circle(center={self.center}, radius={self.radius})"