FiberFusing 1.9.2__tar.gz → 1.9.4__tar.gz

{fiberfusing-1.9.2 → fiberfusing-1.9.4}/FiberFusing/__init__.py

@@ -5,6 +5,7 @@ from .geometries.polygon import Polygon, EmptyPolygon  # noqa: F401
 from .shapes import Circle, Square  # noqa: F401
 from .background import BackGround  # noqa: F401
 from .optical_structure import CircleOpticalStructure  # noqa: F401
+from .graded_index import GradedIndex  # noqa: F401
 micro = 1e-6
 
 

{fiberfusing-1.9.2 → fiberfusing-1.9.4}/FiberFusing/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.9.2'
-__version_tuple__ = version_tuple = (1, 9, 2)
+__version__ = version = '1.9.4'
+__version_tuple__ = version_tuple = (1, 9, 4)
 
-__commit_id__ = commit_id = 'gf65944ebc'
+__commit_id__ = commit_id = 'g4851a65b0'

{fiberfusing-1.9.2 → fiberfusing-1.9.4}/FiberFusing/fiber/generic_fiber.py

@@ -12,7 +12,7 @@ from FiberFusing.geometries.point import Point
 from FiberFusing.coordinate_system import CoordinateSystem
 from FiberFusing.plottings import plot_polygon
 from FiberFusing.helper import _plot_helper
-
+from FiberFusing.graded_index import GradedIndex
 
 pp = pprint.PrettyPrinter(indent=4, sort_dicts=False, compact=True, width=1)
 
@@ -110,7 +110,7 @@ class GenericFiber():
 
         return fiber_copy
 
-    def create_and_add_new_structure(self, refractive_index: float = None, NA: float = None, **kwargs) -> None:
+    def create_and_add_new_structure(self, refractive_index: float | GradedIndex = None, NA: float = None, **kwargs) -> None:
         """
         Adds a new circular structure to the collection.
 
@@ -136,32 +136,6 @@ class GenericFiber():
         setattr(self, new_structure.name, new_structure)
         self.structure_list.append(new_structure)
 
-    def create_and_add_new_graded_index_structure(self, refractive_index_in: float, refractive_index_out: float, **kwargs) -> None:
-        """
-        Adds a new graded index structure to the collection.
-
-        Parameters
-        ----------
-        refractive_index : float, optional
-            The refractive index of the new structure. If provided, NA should be None.
-        NA : float, optional
-            The numerical aperture of the new structure. If provided, refractive_index should be None.
-
-        Raises
-        ------
-        ValueError
-            If both refractive_index and NA are provided or if neither is provided.
-        """
-        new_structure = CircleOpticalStructure(
-            **kwargs,
-            refractive_index_in=refractive_index_in,
-            refractive_index_out=refractive_index_out,
-            position=self.position
-        )
-        setattr(self, new_structure.name, new_structure)
-        self.structure_list.append(new_structure)
-
-
     def _interpret_index_or_NA_to_index(self, refractive_index: float, NA: float) -> float:
         """
         Interprets and converts NA or index to a refractive index.
@@ -232,12 +206,11 @@ class GenericFiber():
             raster = structure.polygon.get_rasterized_mesh(coordinate_system=coordinate_system)
             mesh[numpy.where(raster != 0)] = 0
 
-            if structure.is_graded:
+            if isinstance(structure.refractive_index, GradedIndex):
                 refractive_index = self.get_graded_index_mesh(
                     coordinate_system=coordinate_system,
                     polygon=structure.polygon,
-                    min_index=structure.refractive_index_in,
-                    max_index=structure.refractive_index_out
+                    refractive_index=structure.refractive_index,
                 )
             else:
                 refractive_index = structure.refractive_index
@@ -429,7 +402,7 @@ class GenericFiber():
 
         return distance
 
-    def get_graded_index_mesh(self, coordinate_system: CoordinateSystem, polygon, min_index: float, max_index: float) -> numpy.ndarray:
+    def get_graded_index_mesh(self, coordinate_system: CoordinateSystem, polygon, refractive_index: GradedIndex) -> numpy.ndarray:
         """
         Compute the graded index mesh for a given polygon within the coordinate system.
 
@@ -443,10 +416,8 @@ class GenericFiber():
             The coordinate system defining the spatial grid where the index profile will be computed.
         polygon : Polygon
             The polygon object representing the area for which the graded index mesh is computed.
-        min_index : float
-            The minimum refractive index value, typically at the outer boundary of the polygon.
-        max_index : float
-            The maximum refractive index value, typically at the center of the polygon.
+        refractive_index : GradedIndex
+            The graded index object containing the minimum and maximum refractive index values.
 
         Returns
         -------
@@ -485,8 +456,8 @@ class GenericFiber():
             normalized_distance_mesh = masked_distance_mesh
 
         # Scale the normalized mesh to the index range [min_index, max_index]
-        delta_n = max_index - min_index
-        graded_index_mesh = normalized_distance_mesh * delta_n + min_index
+        delta_n = refractive_index.outside - refractive_index.inside
+        graded_index_mesh = normalized_distance_mesh * delta_n + refractive_index.inside
 
         return graded_index_mesh
 

{fiberfusing-1.9.2 → fiberfusing-1.9.4}/FiberFusing/fiber/loader.py

@@ -235,84 +235,3 @@ class FiberLoader:
         processed_layers = self.reorder_layers_if_needed(processed_layers, order)
 
         return {'layers': processed_layers}
-
-
-# =============================================================================
-# CONVENIENCE FUNCTIONS FOR BACKWARD COMPATIBILITY
-# =============================================================================
-
-# Global loader instance
-_default_loader = FiberLoader()
-
-
-def load_fiber(fiber_name: str, clad_refractive_index: float, position: Tuple[float, float] = (0, 0), remove_cladding: bool = False) -> GenericFiber:
-    """
-    Convenience function to load a fiber using the default loader.
-
-    Parameters
-    ----------
-    fiber_name : str
-        The name of the fiber to load.
-    clad_refractive_index : float
-        The refractive index of the cladding material.
-    position : Tuple[float, float], optional
-        The spatial position of the fiber, defaulting to (0, 0).
-    remove_cladding : bool, optional
-        Whether to exclude the cladding layer from the fiber configuration.
-
-    Returns
-    -------
-    GenericFiber
-        A configured GenericFiber object with the specified properties.
-    """
-    return _default_loader.load_fiber(fiber_name, clad_refractive_index, position, remove_cladding)
-
-
-def make_fiber(structure_list: List[Dict], clad_refractive_index: float, position: Tuple[float, float] = (0, 0)) -> GenericFiber:
-    """
-    Convenience function to make a fiber using the default loader.
-
-    Parameters
-    ----------
-    structure_list : List[Dict]
-        A list of dictionaries, each containing the parameters for a fiber structure.
-    clad_refractive_index : float
-        The refractive index of the cladding material.
-    position : Tuple[float, float], optional
-        The spatial position of the fiber.
-
-    Returns
-    -------
-    GenericFiber
-        The newly created GenericFiber object populated with specified structures.
-    """
-    return _default_loader.make_fiber(structure_list, clad_refractive_index, position)
-
-
-def load_fiber_as_dict(fiber_name: str, clad_refractive_index: float = None, order: str = 'in-to-out') -> dict:
-    """
-    Convenience function to load fiber configuration as dictionary using the default loader.
-
-    Parameters
-    ----------
-    fiber_name : str
-        Name of the fiber file without extension.
-    clad_refractive_index : float, optional
-        Refractive index to use for material index calculation.
-    order : str, optional
-        Layer order in the output dictionary; 'in-to-out' or 'out-to-in' (for backward compatibility).
-
-    Returns
-    -------
-    dict
-        Dictionary containing the processed fiber configuration.
-    """
-    # Convert string to enum for backward compatibility
-    if order == 'out-to-in':
-        layer_order = LayerOrder.OUT_TO_IN
-    else:
-        layer_order = LayerOrder.IN_TO_OUT
-
-    return _default_loader.load_fiber_as_dict(fiber_name, clad_refractive_index, layer_order)
-
-# -

fiberfusing-1.9.4/FiberFusing/geometries/__init__.py

@@ -0,0 +1,13 @@
+from pydantic import ConfigDict
+
+config_dict = ConfigDict(
+    extra='forbid',
+    arbitrary_types_allowed=True,
+    kw_only=True
+)
+
+from .base_class import Alteration  # noqa: F401
+from .point import Point  # noqa: F401
+from .linestring import LineString  # noqa: F401
+from .polygon import Polygon, EmptyPolygon  # noqa: F401
+

fiberfusing-1.9.4/FiberFusing/geometries/base_class.py

@@ -0,0 +1,173 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from typing import Tuple, Callable, Self
+import copy
+from shapely import affinity
+
+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) -> Self:
+        """
+        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) -> Self:
+        """
+        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)) -> Self:
+        """
+        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.geometries.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]) -> Self:
+        """
+        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.geometries.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)) -> Self:
+        """
+        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.geometries.utils.interpret_to_point(origin)
+        output._shapely_object = affinity.rotate(self._shapely_object, angle=angle, origin=origin_point._shapely_object)
+        return output

{fiberfusing-1.9.2 → fiberfusing-1.9.4}/FiberFusing/geometries/linestring.py

@@ -1,18 +1,17 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-from typing import Optional, Tuple
+from typing import Optional, Tuple, Self
 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.geometries.base_class import Alteration
-import FiberFusing as ff
 
+from FiberFusing.geometries.base_class import Alteration
+from FiberFusing import geometries
 
-@dataclass(config=ConfigDict(extra='forbid', arbitrary_types_allowed=True))
+@dataclass(config=geometries.config_dict)
 class LineString(Alteration):
     coordinates: Optional[Tuple] = field(default=None, repr=False)
     instance: Optional[geo.LineString] = field(default=None, repr=False)
@@ -44,51 +43,92 @@ class LineString(Alteration):
         return self._shapely_object.centroid
 
     @property
-    def mid_point(self) -> 'ff.Point':
+    def mid_point(self) -> 'geometries.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])
+        return geometries.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. """
+    def intersect(self, other: Self) -> None:
+        """
+        Intersects this line string with another, updating the shapely object in place.
+
+        Parameters
+        ----------
+        other : LineString
+            The other line string to intersect with.
+
+        """
         self._shapely_object = self._shapely_object.intersection(other._shapely_object)
 
-    def get_perpendicular(self) -> 'LineString':
+    def get_perpendicular(self) -> Self:
         """ 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))
+        new_coords = geometries.Point(position=(mid.x - dy, mid.y + dx)), geometries.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. """
+    def get_position_parametrization(self, t: float) -> 'geometries.Point':
+        """
+        Returns the point at parameter t along the line. 0 <= t <= 1.
+
+        Parameters
+        ----------
+        t : float
+            The parameter along the line, where 0 <= t <= 1.
+
+        Returns
+        -------
+        geometries.Point
+            The point at parameter t along the line.
+        """
         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))
+        return geometries.Point(position=(x, y))
 
     def render_on_axis(self, ax, **kwargs) -> None:
-        """ Renders the line string on a given matplotlib axis. """
+        """
+        Renders the line string on a given matplotlib axis.
+
+        Parameters
+        ----------
+        ax : matplotlib.axes.Axes
+            The axes to render the line string on.
+        **kwargs : keyword arguments
+            Additional keyword arguments to pass to the plot function.
+        """
         x, y = self._shapely_object.xy
         ax.plot(x, y, **kwargs)
 
-    def make_length(self, length: float) -> 'LineString':
+    def make_length(self, length: float) -> Self:
         """ 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. """
+    def centering(self, center: geo.Point) -> Self:
+        """
+        Centers the line string at a given point.
+
+        Parameters
+        ----------
+        center : geo.Point
+            The point to center the line string around.
+
+        Returns
+        -------
+        LineString
+            A new LineString centered at the specified 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])
+        new_coords = geometries.Point(position=new_coords[0]), geometries.Point(position=new_coords[1])
         return LineString(coordinates=tuple(new_coords))
 
     def get_vector(self) -> np.ndarray:
@@ -98,8 +138,17 @@ class LineString(Alteration):
         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. """
+    def extend(self, factor: float = 1) -> Self:
+        """
+        Returns a new LineString scaled by the specified factor.
+
+        Parameters
+        ----------
+        factor : float
+            The scaling factor to apply to the line string.
+
+        Returns
+        """
         scaled_string = scale(self._shapely_object, xfact=factor, yfact=factor, origin='center')
         return LineString(instance=scaled_string)
 

{fiberfusing-1.9.2 → fiberfusing-1.9.4}/FiberFusing/geometries/point.py

@@ -2,19 +2,17 @@
 # -*- coding: utf-8 -*-
 
 # Built-in imports
-from typing import Optional, Tuple
+from typing import Optional, Tuple, Self
 import numpy
 from pydantic.dataclasses import dataclass
-from pydantic import ConfigDict
-from FiberFusing.geometries.base_class import Alteration
 import shapely.geometry as geo
 import matplotlib.pyplot as plt
-import FiberFusing as ff
-from FiberFusing.helper import _plot_helper
 
+from FiberFusing.helper import _plot_helper
+from FiberFusing import geometries
 
-@dataclass(config=ConfigDict(extra='forbid', arbitrary_types_allowed=True))
-class Point(Alteration):
+@dataclass(config=geometries.config_dict)
+class Point(geometries.base_class.Alteration):
     position: Optional[Tuple[float, float]] = None
     instance: Optional[geo.Point] = None
     index: Optional[float] = None
@@ -38,54 +36,90 @@ class Point(Alteration):
         """Returns the y-coordinate of the point."""
         return self._shapely_object.y
 
-    def shift_position(self, shift: Tuple[float, float]) -> 'Point':
+    def shift_position(self, shift: Tuple[float, float]) -> Self:
         """
         Shifts the point by a given offset and returns a new Point instance.
+
+        Parameters
+        ----------
+        shift : tuple of float
+            The (x, y) offset to shift the point by.
+
+        Returns
+        -------
+        Point
+            A new Point instance representing the shifted position.
         """
-        point_shift = ff.geometries.utils.interpret_to_point(shift)
+        point_shift = geometries.utils.interpret_to_point(shift)
         return self.__add__(point_shift)
 
-    def __add__(self, other) -> 'Point':
+    def __add__(self, other) -> Self:
         """
         Adds the coordinates of another point to this one and returns a new Point instance.
+
+        Parameters
+        ----------
+        other : Point
+            The other point to add.
+
+        Returns
+        -------
+        Point
+            A new Point instance representing the sum of the two points.
         """
-        other = ff.geometries.utils.interpret_to_point(other)
+        other = geometries.utils.interpret_to_point(other)
 
         return Point(position=(self.x + other.x, self.y + other.y))
 
-    def __sub__(self, other) -> 'Point':
+    def __sub__(self, other) -> Self:
         """
         Subtracts the coordinates of another point from this one and returns a new Point instance.
         """
-        other = ff.geometries.utils.interpret_to_point(other)
+        other = geometries.utils.interpret_to_point(other)
         return Point(position=(self.x - other.x, self.y - other.y))
 
-    def __neg__(self) -> 'Point':
+    def __neg__(self) -> Self:
         """
         Negates the coordinates of this point and returns a new Point instance.
         """
         return Point(position=[-self.x, -self.y])
 
-    def __mul__(self, factor: float) -> 'Point':
+    def __mul__(self, factor: float) -> Self:
         """
         Multiplies the coordinates of this point by a scalar and returns a new Point instance.
         """
         return Point(position=[self.x * factor, self.y * factor])
 
-    def distance(self, other: 'Point') -> float:
+    def distance(self, other: Self) -> float:
         """
         Computes the Euclidean distance between this point and another point.
+
+        Parameters
+        ----------
+        other : Point
+            The other point to compute the distance to.
+
+        Returns
+        -------
+        float
+            The Euclidean distance between the two points.
         """
         return numpy.sqrt((self.x - other.x)**2 + (self.y - other.y)**2)
 
     @_plot_helper
-    def plot(
-        self,
-        ax: plt.Axes = None,
-        marker: str = 'x',
-        size: int = 20,
-        label: str = None) -> None:
+    def plot(self, ax: plt.Axes = None, marker: str = 'x', size: int = 20, label: str = None) -> None:
         """
         Renders this point on the given axis, optionally with text.
+
+        Parameters
+        ----------
+        ax : plt.Axes
+            The Matplotlib axis to render the point on.
+        marker : str
+            The marker style for the point.
+        size : int
+            The size of the point marker.
+        label : str
+            The label for the point, if any.
         """
         ax.scatter(self.x, self.y, label=label, marker=marker, s=size)