FiberFusing 1.5.0.post0__0-py3-none-any.whl

FiberFusing/buffer.py

@@ -0,0 +1,163 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from typing import Tuple, Optional
+from pydantic.dataclasses import dataclass
+from pydantic import ConfigDict
+import shapely.geometry as geo
+from shapely import affinity
+
+from FiberFusing.components.utils import interpret_to_point
+from FiberFusing.components.polygon import Polygon
+
+config_dict = ConfigDict(extra='forbid', strict=True, kw_only=True)
+
+
+@dataclass(config=config_dict)
+class Circle(Polygon):
+    """
+    Represents a circular geometry centered at a specified position with a given radius.
+
+    Parameters
+    ----------
+    position : Tuple[float, float]
+        The center position of the circle.
+    radius : float
+        The radius of the circle.
+    resolution : Optional[int], optional
+        The resolution of the circle's edge. Higher values yield smoother circles. Default is 128.
+    index : Optional[float], optional
+        The refractive index of the circle. Default is None.
+    """
+    position: Tuple[float, float]
+    radius: float
+    resolution: Optional[int] = 128
+    index: Optional[float] = None
+
+    def __post_init__(self):
+        """
+        Initialize the circular geometry based on the specified position and radius.
+
+        Notes
+        -----
+        - The geometry is created using a buffer method applied to the position.
+        - The position is interpreted and converted to a `shapely` point.
+        """
+        self.position = interpret_to_point(self.position)
+
+        # Validate radius
+        if self.radius <= 0:
+            raise ValueError("Radius must be a positive value.")
+
+        # Create a circular geometry using buffer
+        circle = self.position._shapely_object.buffer(
+            self.radius,
+            resolution=self.resolution
+        )
+
+        self._shapely_object = circle
+        self.core = self.center.copy()
+
+
+@dataclass(config=config_dict)
+class Ellipse(Polygon):
+    """
+    Represents an elliptical geometry centered at a specified position with a given radius and axis ratio.
+
+    Parameters
+    ----------
+    position : tuple
+        The center position of the ellipse.
+    radius : float
+        The radius along the major axis.
+    resolution : Optional[int], optional
+        The resolution of the ellipse's edge. Higher values yield smoother edges. Default is 128.
+    index : Optional[float], optional
+        The refractive index of the ellipse. Default is None.
+    ratio : Optional[float], optional
+        The ratio between the minor and major axes. Default is 1 (circular shape).
+    """
+    position: tuple
+    radius: float
+    resolution: Optional[int] = 128
+    index: Optional[float] = None
+    ratio: Optional[float] = 1  # Default ratio of 1 makes this a circle
+
+    def __post_init__(self):
+        """
+        Initialize the elliptical geometry based on the specified position, radius, and ratio.
+
+        Notes
+        -----
+        - The ellipse is scaled using the specified ratio after creating a circular base shape.
+        - The position is interpreted and converted to a `shapely` point.
+        """
+        self.position = interpret_to_point(self.position)
+
+        # Validate radius and ratio
+        if self.radius <= 0:
+            raise ValueError("Radius must be a positive value.")
+        if self.ratio <= 0:
+            raise ValueError("Ratio must be a positive value.")
+
+        ellipse = self.position._shapely_object.buffer(
+            self.radius,
+            resolution=self.resolution
+        )
+
+        # Scale the ellipse according to the ratio
+        ellipse = affinity.scale(
+            ellipse,
+            xfact=1,
+            yfact=self.ratio,
+            origin=(0, 0)
+        )
+
+        super().__init__(instance=ellipse)
+        self.core = self.center.copy()
+
+
+@dataclass(config=config_dict)
+class Square(Polygon):
+    """
+    Represents a square geometry centered at a specified position with a given side length.
+
+    Parameters
+    ----------
+    position : tuple
+        The center position of the square.
+    length : float
+        The length of the square's sides.
+    index : Optional[float], optional
+        The refractive index of the square. Default is None.
+    """
+    position: tuple
+    length: float
+    index: Optional[float] = None
+
+    def __post_init__(self):
+        """
+        Initialize the square geometry based on the specified position and side length.
+
+        Notes
+        -----
+        - The square is created using `shapely.geometry.box` method.
+        - The position is interpreted and converted to a `shapely` point.
+        """
+        self.position = interpret_to_point(self.position)
+
+        # Validate length
+        if self.length <= 0:
+            raise ValueError("Length must be a positive value.")
+
+        square = geo.box(
+            self.position.x - self.length / 2,
+            self.position.y - self.length / 2,
+            self.position.x + self.length / 2,
+            self.position.y + self.length / 2
+        )
+
+        super().__init__(instance=square)
+        self.core = self.center.copy()
+
+# -

FiberFusing/components/base_class.py

@@ -0,0 +1,442 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import copy
+import numpy as np
+from typing import Iterable, Tuple, Callable
+from shapely import affinity
+import shapely.geometry as geo
+from FiberFusing.coordinate_system import CoordinateSystem
+from shapely.ops import split
+import FiberFusing as ff
+
+
+class Alteration:
+    def in_place_copy(function: Callable) -> Callable:
+        """
+        Decorator to manage in-place operations.
+
+        Parameters
+        ----------
+        function : Callable
+            The function to wrap.
+
+        Returns
+        -------
+        Callable
+            Wrapped function that optionally modifies the object in-place.
+        """
+        def wrapper(self, *args, in_place=False, **kwargs):
+            instance = self if in_place else self.copy()
+            return function(self, instance, *args, **kwargs)
+
+        return wrapper
+
+    def copy(self) -> 'Alteration':
+        """
+        Create a deep copy of the object.
+
+        Returns
+        -------
+        Alteration
+            A new instance that is a deep copy of the current object.
+        """
+        return copy.deepcopy(self)
+
+    def __repr__(self) -> str:
+        """
+        Return the string representation of the shapely object.
+
+        Returns
+        -------
+        str
+            The string representation of the shapely object.
+        """
+        return repr(self._shapely_object)
+
+    @property
+    def is_empty(self) -> bool:
+        """
+        Check if the shapely object is empty.
+
+        Returns
+        -------
+        bool
+            True if the object is empty, False otherwise.
+        """
+        return self._shapely_object.is_empty
+
+    @in_place_copy
+    def union(self, output, *others) -> 'Alteration':
+        """
+        Perform the union operation with other geometries.
+
+        Parameters
+        ----------
+        output : Alteration
+            The object to store the result.
+        *others : Alteration
+            Other geometries to union with.
+
+        Returns
+        -------
+        Alteration
+            The union of the geometries.
+        """
+        other_shapes = (o._shapely_object for o in others)
+        output._shapely_object = self._shapely_object.union(*other_shapes)
+        return output
+
+    @in_place_copy
+    def intersection(self, output, *others) -> 'Alteration':
+        """
+        Perform the intersection operation with other geometries.
+
+        Parameters
+        ----------
+        output : Alteration
+            The object to store the result.
+        *others : Alteration
+            Other geometries to intersect with.
+
+        Returns
+        -------
+        Alteration
+            The intersection of the geometries.
+        """
+        other_shapes = (o._shapely_object for o in others)
+        output._shapely_object = self._shapely_object.intersection(*other_shapes)
+        return output
+
+    @in_place_copy
+    def scale(self, output, factor: float, origin: Tuple[float, float] = (0, 0)) -> 'Alteration':
+        """
+        Scale the geometry by a given factor.
+
+        Parameters
+        ----------
+        output : Alteration
+            The object to store the result.
+        factor : float
+            The scaling factor.
+        origin : tuple of float, optional
+            The origin point for scaling, by default (0, 0).
+
+        Returns
+        -------
+        Alteration
+            The scaled geometry.
+        """
+        origin_point = ff.components.utils.interpret_to_point(origin)
+        output._shapely_object = affinity.scale(self._shapely_object, xfact=factor, yfact=factor, origin=origin_point._shapely_object)
+        return output
+
+    @in_place_copy
+    def translate(self, output, shift: Tuple[float, float]) -> 'Alteration':
+        """
+        Translate the geometry by a given shift.
+
+        Parameters
+        ----------
+        output : Alteration
+            The object to store the result.
+        shift : tuple of float
+            The (x, y) shift values.
+
+        Returns
+        -------
+        Alteration
+            The translated geometry.
+        """
+        shift_point = ff.components.utils.interpret_to_point(shift)
+        output._shapely_object = affinity.translate(self._shapely_object, shift_point.x, shift_point.y)
+        return output
+
+    @in_place_copy
+    def rotate(self, output, angle: float, origin: Tuple[float, float] = (0, 0)) -> 'Alteration':
+        """
+        Rotate the geometry by a specified angle around an origin.
+
+        Parameters
+        ----------
+        output : Alteration
+            The object to store the result.
+        angle : float
+            The rotation angle in degrees.
+        origin : tuple of float, optional
+            The origin point for rotation, by default (0, 0).
+
+        Returns
+        -------
+        Alteration
+            The rotated geometry.
+        """
+        origin_point = ff.components.utils.interpret_to_point(origin)
+        output._shapely_object = affinity.rotate(self._shapely_object, angle=angle, origin=origin_point._shapely_object)
+        return output
+
+
+class BaseArea(Alteration):
+    @property
+    def is_iterable(self) -> bool:
+        """
+        Check if the shapely object is iterable.
+
+        Returns
+        -------
+        bool
+            True if the object is iterable, False otherwise.
+        """
+        return isinstance(self._shapely_object, Iterable)
+
+    @property
+    def is_multi(self) -> bool:
+        """
+        Check if the shapely object is a MultiPolygon.
+
+        Returns
+        -------
+        bool
+            True if the object is a MultiPolygon, False otherwise.
+        """
+        return isinstance(self._shapely_object, geo.MultiPolygon)
+
+    @property
+    def is_empty(self) -> bool:
+        """
+        Check if the shapely object is empty.
+
+        Returns
+        -------
+        bool
+            True if the object is empty, False otherwise.
+        """
+        return self._shapely_object.is_empty
+
+    @property
+    def is_pure_polygon(self) -> bool:
+        """
+        Check if the shapely object is a pure Polygon.
+
+        Returns
+        -------
+        bool
+            True if the object is a pure Polygon, False otherwise.
+        """
+        return isinstance(self._shapely_object, geo.Polygon)
+
+    @property
+    def exterior(self):
+        """
+        Get the exterior boundary of the polygon.
+
+        Returns
+        -------
+        LinearRing
+            The exterior boundary of the polygon.
+        """
+        return self._shapely_object.exterior
+
+    def get_rasterized_mesh(self, coordinate_system: CoordinateSystem) -> np.ndarray:
+        """
+        Rasterize the shape based on the given coordinate system.
+
+        Parameters
+        ----------
+        coordinate_system : CoordinateSystem
+            The coordinate system used for rasterization.
+
+        Returns
+        -------
+        numpy.ndarray
+            The rasterized shape as a mesh.
+        """
+        raster = self.rasterize(coordinate_system=coordinate_system)
+        raster = raster.reshape(coordinate_system.shape)
+        return raster.astype(np.float64)
+
+    @property
+    def convex_hull(self) -> geo.Polygon:
+        """
+        Get the convex hull of the shape.
+
+        Returns
+        -------
+        Polygon
+            The convex hull as a Polygon.
+        """
+        return ff.Polygon(instance=self._shapely_object.convex_hull)
+
+    @property
+    def area(self) -> float:
+        """
+        Calculate the area of the shape.
+
+        Returns
+        -------
+        float
+            The area of the shape.
+        """
+        return self._shapely_object.area
+
+    @property
+    def bounds(self) -> Tuple[float, float, float, float]:
+        """
+        Get the bounds of the shape.
+
+        Returns
+        -------
+        tuple of float
+            The (minx, miny, maxx, maxy) bounds of the shape.
+        """
+        return self._shapely_object.bounds
+
+    @property
+    def center(self) -> geo.Point:
+        """
+        Get the center (centroid) of the shape.
+
+        Returns
+        -------
+        Point
+            The centroid of the shape as a Point.
+        """
+        return ff.Point(position=(self._shapely_object.centroid.x, self._shapely_object.centroid.y))
+
+    def __add__(self, other: 'BaseArea') -> 'BaseArea':
+        """
+        Add two geometries together using union.
+
+        Parameters
+        ----------
+        other : BaseArea
+            The other geometry to union with.
+
+        Returns
+        -------
+        BaseArea
+            The union of the two geometries.
+        """
+        output = self.copy()
+        output._shapely_object = self._shapely_object.union(other._shapely_object)
+        return output
+
+    def __sub__(self, other: 'BaseArea', tolerance: float = 1e-9) -> 'BaseArea':
+        """
+        Subtract one geometry from another.
+
+        Parameters
+        ----------
+        other : BaseArea
+            The geometry to subtract.
+
+        Returns
+        -------
+        BaseArea
+            The difference of the two geometries.
+        """
+        output = self.copy()
+
+        buffered_self = self._shapely_object.buffer(tolerance)
+
+        if not buffered_self.intersects(other._shapely_object):
+            return self
+
+        output._shapely_object = buffered_self.difference(other._shapely_object)
+
+        return output
+
+    def __and__(self, other: 'BaseArea') -> 'BaseArea':
+        """
+        Perform the intersection operation.
+
+        Parameters
+        ----------
+        other : BaseArea
+            The geometry to intersect with.
+
+        Returns
+        -------
+        BaseArea
+            The intersection of the two geometries.
+        """
+        output = self.copy()
+        output._shapely_object = self._shapely_object.intersection(other._shapely_object)
+        return output
+
+    def scale_position(self, factor: float) -> 'BaseArea':
+        """
+        Scale the position of the shape.
+
+        Parameters
+        ----------
+        factor : float
+            The scaling factor for the shape's position.
+
+        Returns
+        -------
+        BaseArea
+            The scaled shape.
+        """
+        new_position = affinity.scale(
+            self.center._shapely_object,
+            xfact=factor,
+            yfact=factor,
+            origin=(0, 0)
+        )
+
+        shift = (new_position.x - self.center.x, new_position.y - self.center.y)
+
+        self.core.translate(shift=shift, in_place=True)
+        self.translate(shift=shift, in_place=True)
+
+        return self
+
+    def shift_position(self, shift: Tuple[float, float], inplace: bool = True) -> 'BaseArea':
+        """
+        Shift the position of the shape.
+
+        Parameters
+        ----------
+        shift : tuple of float
+            The (x, y) shift values.
+
+        Returns
+        -------
+        BaseArea
+            The shifted shape.
+        """
+        if hasattr(self, 'core'):
+            self.core.translate(shift=shift, in_place=inplace)
+        self.translate(shift=shift, in_place=inplace)
+        return self
+
+    def split_with_line(self, line, return_largest: bool = True) -> 'ff.Polygon':
+        """
+        Split the shape using a line.
+
+        Parameters
+        ----------
+        line : LineString
+            The line used for splitting the shape.
+        return_largest : bool, optional
+            If True, returns the largest resulting polygon. Otherwise, returns the smallest. Default is True.
+
+        Returns
+        -------
+        ff.Polygon
+            The resulting polygon based on the split.
+
+        Raises
+        ------
+        ValueError
+            If the shape is not a pure polygon.
+        """
+        if not self.is_pure_polygon:
+            raise ValueError(f"Error: expected a pure polygon, but got {self._shapely_object.__class__}.")
+
+        split_geometry = split(self._shapely_object, line.copy().extend(factor=100)._shapely_object).geoms
+        areas = [poly.area for poly in split_geometry]
+        idx = np.argmax(areas) if return_largest else np.argmin(areas)
+
+        return ff.Polygon(instance=split_geometry[idx])

FiberFusing/components/linestring.py

@@ -0,0 +1,106 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from typing import Optional, Tuple
+import numpy as np
+from pydantic.dataclasses import dataclass
+from dataclasses import field
+from pydantic import ConfigDict
+from shapely.affinity import scale
+import shapely.geometry as geo
+from FiberFusing.components.base_class import Alteration
+import FiberFusing as ff
+
+
+@dataclass(config=ConfigDict(extra='forbid', arbitrary_types_allowed=True))
+class LineString(Alteration):
+    coordinates: Optional[Tuple] = field(default=None, repr=False)
+    instance: Optional[geo.LineString] = field(default=None, repr=False)
+    index: Optional[float] = field(default=None)
+
+    def __post_init__(self):
+        """
+        Initialize a LineString object either from coordinates or a Shapely LineString instance.
+        """
+        if not ((self.coordinates is None) ^ (self.instance is None)):
+            raise ValueError("Must initialize LineString with either 'coordinates' or 'instance', not both.")
+
+        if self.instance is not None:
+            self._shapely_object = self.instance
+        else:
+            if len(self.coordinates) != 2:
+                raise ValueError('LineString must be initialized with exactly two coordinate pairs.')
+            _coordinates = (self.coordinates[0]._shapely_object, self.coordinates[1]._shapely_object)
+            self._shapely_object = geo.LineString(_coordinates)
+
+    @property
+    def boundary(self) -> Tuple[geo.Point, geo.Point]:
+        """ Returns the boundary points of the line string as a tuple of Shapely Point objects. """
+        return self._shapely_object.boundary.geoms
+
+    @property
+    def center(self) -> geo.Point:
+        """ Returns the centroid of the line as a Shapely Point object. """
+        return self._shapely_object.centroid
+
+    @property
+    def mid_point(self) -> ff.Point:
+        """ Returns the midpoint of the line string as a Shapely Point object. """
+        P0, P1 = self.boundary
+        return ff.Point(position=[(P0.x + P1.x) / 2, (P0.y + P1.y) / 2])
+
+    @property
+    def length(self) -> float:
+        """ Returns the length of the line string. """
+        return self._shapely_object.length
+
+    def intersect(self, other: 'LineString') -> None:
+        """ Intersects this line string with another, updating the shapely object in place. """
+        self._shapely_object = self._shapely_object.intersection(other._shapely_object)
+
+    def get_perpendicular(self) -> 'LineString':
+        """ Returns a new LineString object that is perpendicular to this one. """
+        mid = self.mid_point
+        p0, p1 = self.boundary
+        dx, dy = p1.x - p0.x, p1.y - p0.y
+        new_coords = ff.Point(position=(mid.x - dy, mid.y + dx)), ff.Point(position=(mid.x + dy, mid.y - dx))
+        return LineString(coordinates=new_coords)
+
+    def get_position_parametrization(self, t: float) -> ff.Point:
+        """ Returns the point at parameter t along the line. 0 <= t <= 1. """
+        p0, p1 = self.boundary
+        x = p0.x * (1 - t) + p1.x * t
+        y = p0.y * (1 - t) + p1.y * t
+        return ff.Point(position=(x, y))
+
+    def render_on_axis(self, ax, **kwargs) -> None:
+        """ Renders the line string on a given matplotlib axis. """
+        x, y = self._shapely_object.xy
+        ax.plot(x, y, **kwargs)
+
+    def make_length(self, length: float) -> 'LineString':
+        """ Returns a new LineString scaled to the specified length. """
+        return self.extend(factor=length / self.length)
+
+    def centering(self, center: geo.Point) -> 'LineString':
+        """ Centers the line string at a given point. """
+        p0, p1 = self.boundary
+        mid = self.mid_point
+        dx, dy = center.x - mid.x, center.y - mid.y
+        new_coords = [(p.x + dx, p.y + dy) for p in [p0, p1]]
+        new_coords = ff.Point(position=new_coords[0]), ff.Point(position=new_coords[1])
+        return LineString(coordinates=tuple(new_coords))
+
+    def get_vector(self) -> np.ndarray:
+        """ Returns a unit vector representing the direction of the line string. """
+        p0, p1 = self.boundary
+        dx, dy = p1.x - p0.x, p1.y - p0.y
+        norm = np.sqrt(dx**2 + dy**2)
+        return np.array([dx, dy]) / norm if norm != 0 else np.array([0, 0])
+
+    def extend(self, factor: float = 1) -> 'LineString':
+        """ Returns a new LineString scaled by the specified factor. """
+        scaled_string = scale(self._shapely_object, xfact=factor, yfact=factor, origin='center')
+        return LineString(instance=scaled_string)
+
+# -