AMS-BP 0.0.231__py3-none-any.whl → 0.2.0__py3-none-any.whl

AMS_BP/__init__.py

@@ -10,4 +10,4 @@ Last updated: 2024-12-16
 
 """
 
-__version__ = "0.0.231"
+__version__ = "0.2.0"

AMS_BP/cells/__init__.py

@@ -1,5 +1,31 @@
-from .spherical_cell import SphericalCell
-from .rectangular_cell import RectangularCell
-from .rod_cell import RodCell
+from boundedfbm.cells.base_cell import BaseCell
+from boundedfbm.cells.ovoid_cell import OvoidCell, make_OvoidCell
+from boundedfbm.cells.rectangular_cell import RectangularCell, make_RectangularCell
+from boundedfbm.cells.rod_cell import RodCell, make_RodCell
+from boundedfbm.cells.spherical_cell import SphericalCell, make_SphericalCell
+from boundedfbm.cells.typedefs import Vector3D
 
-__all__ = ["SphericalCell", "RectangularCell", "RodCell"]
+from .budding_yeast_cell import BuddingCell, make_BuddingCell
+from .cell_factory import (
+    CellType,
+    create_cell,
+    validate_cell_parameters,
+)
+
+__all__ = [
+    "SphericalCell",
+    "RectangularCell",
+    "RodCell",
+    "OvoidCell",
+    "BuddingCell",
+    "make_SphericalCell",
+    "make_RodCell",
+    "make_RectangularCell",
+    "make_BuddingCell",
+    "make_OvoidCell",
+    "create_cell",
+    "CellType",
+    "validate_cell_parameters",
+    "BaseCell",
+    "Vector3D",
+]

AMS_BP/cells/budding_yeast_cell.py

@@ -0,0 +1,274 @@
+from dataclasses import dataclass
+from typing import List, Tuple
+
+import numpy as np
+import pyvista as pv
+from boundedfbm.cells.base_cell import BaseCell
+from boundedfbm.cells.typedefs import Vector3D
+
+
+@dataclass
+class BuddingCell(BaseCell):
+    """
+    Represents a budding yeast cell composed of two connected ovoids (mother and bud).
+    The cells are connected at a "neck" region, with the bud growing from the mother cell.
+
+    Attributes:
+        center (np.ndarray): The (x, y, z) coordinates of the mother cell's center in XYZ plane
+        mother_radius_x (float): Mother cell radius along X axis
+        mother_radius_y (float): Mother cell radius along Y axis
+        mother_radius_z (float): Mother cell radius along Z axis
+        bud_radius_x (float): Bud radius along X axis
+        bud_radius_y (float): Bud radius along Y axis
+        bud_radius_z (float): Bud radius along Z axis
+        bud_angle (float): Angle in radians from x-axis where bud emerges
+        bud_distance (float): Distance between mother and bud centers
+        neck_radius (float): Radius of the connecting neck region
+    """
+
+    center: np.ndarray | List[float] | Tuple
+    mother_radius_x: float
+    mother_radius_y: float
+    mother_radius_z: float
+    bud_radius_x: float
+    bud_radius_y: float
+    bud_radius_z: float
+    bud_angle: float
+    bud_distance: float
+    neck_radius: float
+
+    def is_point_inside(
+        self, x: float, y: float, z: float, tolerance: float = 1e-3
+    ) -> bool:
+        """
+        Determines if a given point is inside the BuddingCell.
+        A point is inside if it's within the mother cell, the bud, or the neck region.
+
+        Args:
+            point (np.ndarray | List[float] | Tuple): The (x, y, z) coordinates of the point to check
+
+        Returns:
+            bool: True if the point is inside the cell, False otherwise
+        """
+        # Ensure point is a numpy array for vector operations
+        point = np.array([x, y, z])
+        mother_center = np.array(self.center)
+
+        # Calculate bud center based on angle and distance
+        bud_x = mother_center[0] + self.bud_distance * np.cos(self.bud_angle)
+        bud_y = mother_center[1] + self.bud_distance * np.sin(self.bud_angle)
+        bud_center = np.array([bud_x, bud_y, mother_center[2]])
+
+        # Check if point is inside the mother cell (scaled ellipsoid)
+        x, y, z = point - mother_center
+        mother_distance_squared = (
+            (x / self.mother_radius_x) ** 2
+            + (y / self.mother_radius_y) ** 2
+            + (z / self.mother_radius_z) ** 2
+        )
+        if mother_distance_squared <= 1:
+            return True
+
+        # Check if point is inside the bud (scaled ellipsoid)
+        x, y, z = point - bud_center
+        bud_distance_squared = (
+            (x / self.bud_radius_x) ** 2
+            + (y / self.bud_radius_y) ** 2
+            + (z / self.bud_radius_z) ** 2
+        )
+        if bud_distance_squared <= 1:
+            return True
+
+        # Check if point is inside the neck region
+        # First, project the point onto the line between mother and bud centers
+        mother_to_bud_vec = bud_center - mother_center
+        mother_to_bud_length = np.linalg.norm(mother_to_bud_vec)
+        mother_to_bud_unit = mother_to_bud_vec / mother_to_bud_length
+
+        mother_to_point_vec = point - mother_center
+        projection_length = np.dot(mother_to_point_vec, mother_to_bud_unit)
+
+        # Calculate minimum distance from point to the center line
+        if 0 <= projection_length <= mother_to_bud_length:
+            projection_point = mother_center + projection_length * mother_to_bud_unit
+            distance_to_line = np.linalg.norm(point - projection_point)
+
+            # The neck is modeled as a truncated cone
+            # Interpolate the radius at this point along the neck
+            if projection_length <= self.mother_radius_x:
+                # Within mother cell radius from the center
+                local_radius = self.neck_radius
+            elif projection_length >= mother_to_bud_length - self.bud_radius_x:
+                # Within bud cell radius from the bud center
+                local_radius = self.neck_radius
+            else:
+                local_radius = self.neck_radius
+
+            return distance_to_line <= local_radius
+
+        return False
+
+
+def make_BuddingCell(
+    center: np.ndarray | List[float] | Tuple,
+    mother_radius_x: float,
+    mother_radius_y: float,
+    mother_radius_z: float,
+    bud_radius_x: float,
+    bud_radius_y: float,
+    bud_radius_z: float,
+    bud_angle: float,
+    bud_distance: float,
+    neck_radius: float,
+) -> BuddingCell:
+    """
+    Create a budding yeast cell using PyVista meshes.
+
+    Args:
+        center: Center point of the mother cell
+        mother_radius_x/y/z: Radii of the mother cell along each axis
+        bud_radius_x/y/z: Radii of the bud cell along each axis
+        bud_angle: Angle in radians from x-axis where bud emerges
+        bud_distance: Distance between mother and bud centers
+        neck_radius: Radius of the connecting neck region
+
+    Returns:
+        BuddingCell: Instance with PyVista mesh
+    """
+    # Validate inputs
+    center = np.array(center)
+    if center.shape != (3,):
+        raise ValueError("Center must be a 3D point")
+
+    # Calculate bud center
+    bud_center = np.array(
+        [
+            center[0] + bud_distance * np.cos(bud_angle),
+            center[1] + bud_distance * np.sin(bud_angle),
+            center[2],
+        ]
+    )
+
+    # Create mother cell ellipsoid
+    mother = pv.ParametricEllipsoid(
+        xradius=mother_radius_x,
+        yradius=mother_radius_y,
+        zradius=mother_radius_z,
+        center=center,
+    )
+
+    # Create bud cell ellipsoid
+    bud = pv.ParametricEllipsoid(
+        xradius=bud_radius_x,
+        yradius=bud_radius_y,
+        zradius=bud_radius_z,
+        center=bud_center,
+    )
+
+    # Create neck region (cylinder)
+    # Calculate direction vector from mother to bud
+    direction = bud_center - center
+    direction = direction / np.linalg.norm(direction)
+
+    # Create cylinder for neck
+    cylinder = pv.Cylinder(
+        center=(center + bud_center) / 2,  # Midpoint
+        direction=direction,
+        radius=neck_radius,
+        height=bud_distance,
+    )
+
+    # Combine shapes using boolean operations
+    # First combine mother and neck
+    mother_and_neck = mother.boolean_union(cylinder)
+
+    # Then add the bud
+    complete_cell = mother_and_neck.boolean_union(bud)
+
+    # Clean up the mesh
+    complete_cell = complete_cell.clean()
+    complete_cell = complete_cell.fill_holes(1)
+
+    # Verify mesh integrity
+    edges = complete_cell.extract_feature_edges(
+        feature_edges=False, manifold_edges=False
+    )
+    assert edges.n_cells == 0, "Mesh has non-manifold edges"
+
+    return BuddingCell(
+        mesh=complete_cell,
+        center=center,
+        mother_radius_x=mother_radius_x,
+        mother_radius_y=mother_radius_y,
+        mother_radius_z=mother_radius_z,
+        bud_radius_x=bud_radius_x,
+        bud_radius_y=bud_radius_y,
+        bud_radius_z=bud_radius_z,
+        bud_angle=bud_angle,
+        bud_distance=bud_distance,
+        neck_radius=neck_radius,
+    )
+
+
+@dataclass
+class BuddingCellParams:
+    center: Vector3D
+    mother_radius_x: float
+    mother_radius_y: float
+    mother_radius_z: float
+    bud_radius_x: float
+    bud_radius_y: float
+    bud_radius_z: float
+    bud_angle: float
+    bud_distance: float
+    neck_radius: float
+
+    @classmethod
+    def validate_center(cls, value):
+        if not isinstance(value, (list, tuple, np.ndarray)) or len(value) != 3:
+            raise ValueError("center must be a 3D vector")
+
+    @classmethod
+    def validate_mother_radius_x(cls, value):
+        if not isinstance(value, (int, float)) or value <= 0:
+            raise ValueError("mother_radius_x must be a positive number")
+
+    @classmethod
+    def validate_mother_radius_y(cls, value):
+        if not isinstance(value, (int, float)) or value <= 0:
+            raise ValueError("mother_radius_y must be a positive number")
+
+    @classmethod
+    def validate_mother_radius_z(cls, value):
+        if not isinstance(value, (int, float)) or value <= 0:
+            raise ValueError("mother_radius_z must be a positive number")
+
+    @classmethod
+    def validate_bud_radius_x(cls, value):
+        if not isinstance(value, (int, float)) or value <= 0:
+            raise ValueError("bud_radius_x must be a positive number")
+
+    @classmethod
+    def validate_bud_radius_y(cls, value):
+        if not isinstance(value, (int, float)) or value <= 0:
+            raise ValueError("bud_radius_y must be a positive number")
+
+    @classmethod
+    def validate_bud_radius_z(cls, value):
+        if not isinstance(value, (int, float)) or value <= 0:
+            raise ValueError("bud_radius_z must be a positive number")
+
+    @classmethod
+    def validate_bud_angle(cls, value):
+        if not isinstance(value, (int, float)):
+            raise ValueError("bud_angle must be a number")
+
+    @classmethod
+    def validate_bud_distance(cls, value):
+        if not isinstance(value, (int, float)) or value <= 0:
+            raise ValueError("bud_distance must be a positive number")
+
+    @classmethod
+    def validate_neck_radius(cls, value):
+        if not isinstance(value, (int, float)) or value <= 0:
+            raise ValueError("neck_radius must be a positive number")

AMS_BP/cells/cell_factory.py

@@ -0,0 +1,148 @@
+import inspect
+from enum import Enum
+from typing import Any, Callable, Dict, List, Tuple, Union
+
+from boundedfbm.cells.base_cell import BaseCell
+
+# Import cell creation functions and parameter classes
+from boundedfbm.cells.ovoid_cell import OvoidCellParams, make_OvoidCell
+from boundedfbm.cells.rectangular_cell import (
+    RectangularCellParams,
+    make_RectangularCell,
+)
+from boundedfbm.cells.rod_cell import RodCellParams, make_RodCell
+from boundedfbm.cells.spherical_cell import SphericalCellParams, make_SphericalCell
+
+from .budding_yeast_cell import BuddingCellParams, make_BuddingCell
+
+
+# ===== Exposed Enum =====
+class CellType(str, Enum):
+    SPHERICAL = "SphericalCell"
+    ROD = "RodCell"
+    RECTANGULAR = "RectangularCell"
+    OVOID = "OvoidCell"
+    BUDDINGYEAST = "BuddingCell"
+
+
+# ===== Internal Mappings =====
+_CELL_PARAM_CLASSES: Dict[CellType, Any] = {
+    CellType.SPHERICAL: SphericalCellParams,
+    CellType.ROD: RodCellParams,
+    CellType.RECTANGULAR: RectangularCellParams,
+    CellType.OVOID: OvoidCellParams,
+    CellType.BUDDINGYEAST: BuddingCellParams,
+}
+
+_CELL_CREATION_MAP: Dict[CellType, Tuple[Callable, List[str]]] = {
+    CellType.SPHERICAL: (make_SphericalCell, ["center", "radius"]),
+    CellType.ROD: (make_RodCell, ["center", "direction", "height", "radius"]),
+    CellType.RECTANGULAR: (make_RectangularCell, ["bounds"]),
+    CellType.OVOID: (
+        make_OvoidCell,
+        ["center", "direction", "xradius", "yradius", "zradius"],
+    ),
+    CellType.BUDDINGYEAST: (
+        make_BuddingCell,
+        [
+            "center",
+            "mother_radius_x",
+            "mother_radius_y",
+            "mother_radius_z",
+            "bud_radius_x",
+            "bud_radius_y",
+            "bud_radius_z",
+            "bud_angle",
+            "bud_distance",
+            "neck_radius",
+        ],
+    ),
+}
+
+
+# ===== Internal Validator =====
+def _validate_parameters(
+    cell_type: CellType, params: Dict[str, Any]
+) -> Tuple[bool, List[str]]:
+    """Internal function to validate cell parameters against the expected schema."""
+    param_class = _CELL_PARAM_CLASSES[cell_type]
+
+    # Validate against expected parameters
+    expected_params = {
+        name for name in inspect.signature(param_class).parameters if name != "self"
+    }
+    unexpected = set(params.keys()) - expected_params
+    missing = expected_params - set(params.keys())
+
+    errors = []
+    if unexpected:
+        errors.append(f"Unexpected parameter(s): {', '.join(unexpected)}")
+    if missing:
+        errors.append(f"Missing parameter(s): {', '.join(missing)}")
+
+    if errors:
+        return False, errors
+
+    try:
+        param_class(**params)
+        return True, []
+    except ValueError as e:
+        return False, str(e).split("\n")
+
+
+# ===== Exposed Validation Function =====
+def validate_cell_parameters(
+    cell_type: Union[str, CellType], params: Dict[str, Any]
+) -> Tuple[bool, List[str]]:
+    """
+    Validate parameters for a given cell type.
+
+    Args:
+        cell_type: The cell type (string or enum)
+        params: Dictionary of parameters
+
+    Returns:
+        Tuple of (is_valid, error_messages)
+    """
+    if isinstance(cell_type, str):
+        try:
+            cell_type = CellType(cell_type)
+        except ValueError:
+            return False, [f"Unknown cell type: {cell_type}"]
+
+    if cell_type not in _CELL_PARAM_CLASSES:
+        return False, [f"Unknown cell type: {cell_type}"]
+
+    return _validate_parameters(cell_type, params)
+
+
+# ===== Exposed Factory Function =====
+def create_cell(cell_type: Union[str, CellType], params: Dict[str, Any]) -> BaseCell:
+    """
+    Create a validated cell instance.
+
+    Args:
+        cell_type: Cell type (string or enum)
+        params: Dictionary of cell parameters.
+
+    Returns:
+        BaseCell instance.
+
+    Raises:
+        ValueError: If validation fails.
+    """
+    if isinstance(cell_type, str):
+        try:
+            cell_type = CellType(cell_type)
+        except ValueError:
+            raise ValueError(f"Unknown cell type: {cell_type}")
+
+    if cell_type not in _CELL_CREATION_MAP:
+        raise ValueError(f"Unknown cell type: {cell_type}")
+
+    is_valid, errors = validate_cell_parameters(cell_type, params)
+    if not is_valid:
+        raise ValueError(f"Invalid {cell_type} configuration: {'; '.join(errors)}")
+
+    func, param_keys = _CELL_CREATION_MAP[cell_type]
+    return func(**{key: params[key] for key in param_keys})

AMS_BP/configio/configmodels.py

@@ -1,16 +1,19 @@
-from typing import List, Literal
+from typing import Any, Dict, List, Literal, Union
 
 import numpy as np
 from pydantic import BaseModel, Field, field_validator
 
+from ..cells import CellType, validate_cell_parameters
+
 
 class CellParameters(BaseModel):
-    cell_space: List[List[float]] = Field(description="Cell space dimensions in um")
-    cell_axial_radius: float = Field(description="Axial radius in um")
+    cell_type: Union[str, CellType]
+    params: Dict[str, Any]
 
-    @field_validator("cell_space")
-    def convert_cell_space(cls, v):
-        return np.array(v)
+    def model_post_init(self, __context):
+        is_valid = validate_cell_parameters(self.cell_type, self.params)
+        if not is_valid:
+            raise ValueError(f"Cell model creation unsuccessful: {is_valid[1]}")
 
 
 class MoleculeParameters(BaseModel):

AMS_BP/configio/convertconfig.py

@@ -5,8 +5,7 @@ from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 import tomli
 from pydantic import BaseModel
 
-from ..cells import RectangularCell
-from ..cells.base_cell import BaseCell
+from ..cells import BaseCell, create_cell
 from ..motion import Track_generator, create_condensate_dict
 from ..motion.track_gen import (
     _convert_tracks_to_trajectory,
@@ -672,7 +671,7 @@ class ConfigLoader:
         # make initial sample plane
         sample_plane = make_sample(
             global_params=base_config.GlobalParameters,
-            cell_params=base_config.CellParameters,
+            cell=cell,
         )
 
         # make condensates_dict
@@ -739,23 +738,19 @@ class ConfigLoader:
 
 def make_cell(cell_params) -> BaseCell:
     # make cell
-    cell_origin = (cell_params.cell_space[0][0], cell_params.cell_space[1][0])
-    cell_dimensions = (
-        cell_params.cell_space[0][1] - cell_params.cell_space[0][0],
-        cell_params.cell_space[1][1] - cell_params.cell_space[1][0],
-        cell_params.cell_axial_radius * 2,
-    )
-    cell = RectangularCell(origin=cell_origin, dimensions=cell_dimensions)
+
+    cell = create_cell(cell_params.cell_type, cell_params.params)
 
     return cell
 
 
-def make_sample(global_params, cell_params) -> SamplePlane:
+def make_sample(global_params: GlobalParameters, cell: BaseCell) -> SamplePlane:
+    bounds = cell.boundingbox
     sample_space = SampleSpace(
         x_max=global_params.sample_plane_dim[0],
         y_max=global_params.sample_plane_dim[1],
-        z_max=cell_params.cell_axial_radius,
-        z_min=-cell_params.cell_axial_radius,
+        z_max=bounds[-1],
+        z_min=bounds[-2],
     )
 
     # total time
@@ -769,15 +764,17 @@ def make_sample(global_params, cell_params) -> SamplePlane:
         fov=(
             (0, global_params.sample_plane_dim[0]),
             (0, global_params.sample_plane_dim[1]),
-            (-cell_params.cell_axial_radius, cell_params.cell_axial_radius),
-        ),
+            (bounds[-2], bounds[-1]),
+        ),  # simulates the whole simulation space to avoid the issue of PSF bleeding into FOV if the molecule's location is technically outside of the FOV dictated by the camera detector size and objective magnification.
         oversample_motion_time=global_params.oversample_motion_time,
         t_end=totaltime,
     )
     return sample_plane
 
 
-def make_condensatedict(condensate_params, cell) -> List[dict]:
+def make_condensatedict(
+    condensate_params: CondensateParameters, cell: BaseCell
+) -> List[dict]:
     condensates_dict = []
     for i in range(len(condensate_params.initial_centers)):
         condensates_dict.append(
@@ -807,26 +804,29 @@ def make_samplingfunction(condensate_params, cell) -> List[Callable]:
     return sampling_functions
 
 
-def gen_initial_positions(molecule_params, cell, condensate_params, sampling_functions):
+def gen_initial_positions(
+    molecule_params: MoleculeParameters,
+    cell: BaseCell,
+    condensate_params: CondensateParameters,
+    sampling_functions: List[Callable],
+) -> List:
     initials = []
     for i in range(len(molecule_params.num_molecules)):
         num_molecules = molecule_params.num_molecules[i]
         initial_positions = gen_points(
             pdf=sampling_functions[i],
             total_points=num_molecules,
-            min_x=cell.origin[0],
-            max_x=cell.origin[0] + cell.dimensions[0],
-            min_y=cell.origin[1],
-            max_y=cell.origin[1] + cell.dimensions[1],
-            min_z=-cell.dimensions[2] / 2,
-            max_z=cell.dimensions[2] / 2,
+            volume=cell.volume,
+            bounds=cell.boundingbox,
             density_dif=condensate_params.density_dif[i],
         )
         initials.append(initial_positions)
     return initials
 
 
-def create_track_generator(global_params, cell):
+def create_track_generator(
+    global_params: GlobalParameters, cell: BaseCell
+) -> Track_generator:
     totaltime = int(
         global_params.cycle_count
         * (global_params.exposure_time + global_params.interval_time)
@@ -834,15 +834,18 @@ def create_track_generator(global_params, cell):
     # make track generator
     track_generator = Track_generator(
         cell=cell,
-        cycle_count=totaltime / global_params.oversample_motion_time,
-        exposure_time=global_params.exposure_time,
-        interval_time=global_params.interval_time,
+        total_time=totaltime,
         oversample_motion_time=global_params.oversample_motion_time,
     )
     return track_generator
 
 
-def get_tracks(molecule_params, global_params, initial_positions, track_generator):
+def get_tracks(
+    molecule_params: MoleculeParameters,
+    global_params: GlobalParameters,
+    initial_positions: List,
+    track_generator: Track_generator,
+) -> Tuple[List, List]:
     totaltime = int(
         global_params.cycle_count
         * (global_params.exposure_time + global_params.interval_time)
@@ -897,7 +900,12 @@ def get_tracks(molecule_params, global_params, initial_positions, track_generato
     return tracks_collection, points_per_time_collection
 
 
-def add_tracks_to_sample(tracks, sample_plane, fluorophore, ID_counter=0):
+def add_tracks_to_sample(
+    tracks: List,
+    sample_plane: SamplePlane,
+    fluorophore: List[Fluorophore],
+    ID_counter=0,
+) -> SamplePlane:
     counter = ID_counter
     for track_type in range(len(tracks)):
         for j in tracks[track_type].values():

AMS_BP/groundtruth_generators/__init__.py

@@ -0,0 +1,3 @@
+from .nuclearporecomplexes import generate_nup96_positions
+
+__all__ = ["generate_nup96_positions"]