AMS-BP 0.0.2__py3-none-any.whl

AMS_BP/__init__.py

@@ -0,0 +1,13 @@
+"""
+AMS_BP is a Python package for simulating advanced fluroscence microscopy experiments.
+See the README.md file for more information.
+GitHub: https://github.com/joemans3/AMS_BP
+Pypi: https://pypi.org/project/AMS_BP/
+    - pip install AMS_BP
+Author: Baljyot Singh Parmar
+Last updated: 2024-12-16
+
+
+"""
+
+__version__ = "0.0.2"

AMS_BP/cells/__init__.py

@@ -0,0 +1,5 @@
+from .spherical_cell import SphericalCell
+from .rectangular_cell import RectangularCell
+from .rod_cell import RodCell
+
+__all__ = ["SphericalCell", "RectangularCell", "RodCell"]

AMS_BP/cells/base_cell.py

@@ -0,0 +1,55 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Tuple
+import numpy as np
+
+
+@dataclass
+class BaseCell(ABC):
+    """
+    Abstract base class for all cell types.
+
+    Attributes:
+        origin (np.ndarray): The (x, y) coordinates of the cell's origin in XY plane
+    """
+
+    origin: np.ndarray
+
+    def __post_init__(self):
+        """Validate inputs and convert to numpy arrays if needed."""
+        self.origin = np.array(self.origin, dtype=float)
+        if self.origin.shape != (2,):
+            raise ValueError("Origin must be a 2D point (x,y)")
+        self._validate_specific()
+        self._volume = self._calculate_volume()
+
+    @abstractmethod
+    def _validate_specific(self) -> None:
+        """Validate cell-specific parameters."""
+        pass
+
+    @abstractmethod
+    def _calculate_volume(self) -> float:
+        """Calculate the volume of the cell."""
+        pass
+
+    @property
+    @abstractmethod
+    def center(self) -> np.ndarray:
+        """Get the center point of the cell."""
+        pass
+
+    @abstractmethod
+    def get_bounds(self) -> Tuple[np.ndarray, np.ndarray]:
+        """Get the minimum and maximum points that define the cell's bounds."""
+        pass
+
+    @abstractmethod
+    def contains_point(self, point: np.ndarray) -> bool:
+        """Check if a point lies within the cell."""
+        pass
+
+    @property
+    def volume(self) -> float:
+        """Get the pre-calculated volume of the cell."""
+        return self._volume

AMS_BP/cells/rectangular_cell.py

@@ -0,0 +1,82 @@
+from dataclasses import dataclass
+import numpy as np
+from .base_cell import BaseCell
+from typing import Tuple
+
+
+@dataclass
+class RectangularCell(BaseCell):
+    """
+    Represents a rectangular cell in 3D space.
+
+    Attributes:
+        origin (np.ndarray): The (x, y) coordinates of the cell's origin in XY plane
+        dimensions (np.ndarray): The (length, width, height) of the cell
+    """
+
+    dimensions: np.ndarray
+
+    def _validate_specific(self) -> None:
+        """Validate rectangle-specific parameters."""
+        self.dimensions = np.array(self.dimensions, dtype=float)
+        if self.dimensions.shape != (3,):
+            raise ValueError("Dimensions must be a 3D vector (length, width, height)")
+        if np.any(self.dimensions <= 0):
+            raise ValueError("All dimensions must be positive")
+
+    def _calculate_volume(self) -> float:
+        """Calculate the volume of the rectangular cell."""
+        return float(np.prod(self.dimensions))
+
+    @property
+    def center(self) -> np.ndarray:
+        """Get the center point of the rectangular cell."""
+        return np.array(
+            [
+                self.origin[0] + self.dimensions[0] / 2,
+                self.origin[1] + self.dimensions[1] / 2,
+                0.0,
+            ]
+        )
+
+    def get_bounds(self) -> Tuple[np.ndarray, np.ndarray]:
+        """
+        Get the minimum and maximum points that define the cell's bounds.
+
+        Returns:
+            Tuple containing (min_point, max_point)
+        """
+        min_point = np.array(
+            [
+                self.origin[0],
+                self.origin[1],
+                -self.dimensions[2] / 2,  # Z extends downward from 0
+            ]
+        )
+
+        max_point = np.array(
+            [
+                self.origin[0] + self.dimensions[0],
+                self.origin[1] + self.dimensions[1],
+                self.dimensions[2] / 2,  # Z extends upward from 0
+            ]
+        )
+
+        return min_point, max_point
+
+    def contains_point(self, point: np.ndarray) -> bool:
+        """
+        Check if a point lies within the rectangular cell.
+
+        Args:
+            point: A 3D point to check
+
+        Returns:
+            bool: True if the point is inside the cell, False otherwise
+        """
+        point = np.array(point)
+        if point.shape != (3,):
+            raise ValueError("Point must be a 3D point")
+
+        min_point, max_point = self.get_bounds()
+        return np.all(point >= min_point) and np.all(point <= max_point)

AMS_BP/cells/rod_cell.py

@@ -0,0 +1,98 @@
+from dataclasses import dataclass
+import numpy as np
+from .base_cell import BaseCell
+from typing import Tuple
+
+
+@dataclass
+class RodCell(BaseCell):
+    """
+    Represents a rod-like cell in 3D space.
+
+    Attributes:
+        origin (np.ndarray): The (x, y) coordinates of the cell's origin in XY plane
+        length (float): Total length of the rod (including end caps)
+        radius (float): Radius of both the cylindrical body and hemispheres
+    """
+
+    length: float
+    radius: float
+
+    def _validate_specific(self) -> None:
+        """Validate rod-specific parameters."""
+        if self.length <= 0:
+            raise ValueError("Length must be positive")
+        if self.radius <= 0:
+            raise ValueError("Radius must be positive")
+
+    def _calculate_volume(self) -> float:
+        """Calculate the volume of the rod."""
+        cylinder_volume = np.pi * self.radius**2 * (self.length - 2 * self.radius)
+        sphere_volume = (4 / 3) * np.pi * self.radius**3
+        return cylinder_volume + sphere_volume
+
+    @property
+    def center(self) -> np.ndarray:
+        """Get the center point of the rod."""
+        return np.array([self.origin[0] + self.length / 2, self.origin[1], 0.0])
+
+    def get_bounds(self) -> Tuple[np.ndarray, np.ndarray]:
+        """
+        Get the minimum and maximum points that define the rod's bounding box.
+
+        Returns:
+            Tuple containing (min_point, max_point)
+        """
+        min_point = np.array(
+            [
+                self.origin[0],
+                self.origin[1] - self.radius,
+                -self.radius,  # Z extends downward from 0
+            ]
+        )
+
+        max_point = np.array(
+            [
+                self.origin[0] + self.length,
+                self.origin[1] + self.radius,
+                self.radius,  # Z extends upward from 0
+            ]
+        )
+
+        return min_point, max_point
+
+    def contains_point(self, point: np.ndarray) -> bool:
+        """
+        Check if a point lies within the rod.
+
+        Args:
+            point: A 3D point to check
+
+        Returns:
+            bool: True if the point is inside the rod, False otherwise
+        """
+        point = np.array(point)
+        if point.shape != (3,):
+            raise ValueError("Point must be a 3D point")
+
+        # Project point onto XY plane for cylinder check
+        x, y, z = point - np.array([self.origin[0], self.origin[1], 0])
+
+        # Check if point is within the length bounds
+        if x < 0 or x > self.length:
+            return False
+
+        # If point is within the cylindrical section
+        if self.radius <= x <= (self.length - self.radius):
+            # Check distance from central axis
+            return np.sqrt(y**2 + z**2) <= self.radius
+
+        # Check left hemisphere (if x < radius)
+        elif x < self.radius:
+            center = np.array([self.radius, 0, 0])
+            return np.linalg.norm(np.array([x, y, z]) - center) <= self.radius
+
+        # Check right hemisphere (if x > length - radius)
+        else:
+            center = np.array([self.length - self.radius, 0, 0])
+            return np.linalg.norm(np.array([x, y, z]) - center) <= self.radius

AMS_BP/cells/spherical_cell.py

@@ -0,0 +1,74 @@
+from dataclasses import dataclass
+import numpy as np
+from .base_cell import BaseCell
+from typing import Tuple
+
+
+@dataclass
+class SphericalCell(BaseCell):
+    """
+    Represents a spherical cell in 3D space, centered around Z=0.
+
+    Attributes:
+        origin (np.ndarray): The (x, y) coordinates of the cell's center in XY plane
+        radius (float): Radius of the sphere
+    """
+
+    radius: float
+
+    def _validate_specific(self) -> None:
+        """Validate sphere-specific parameters."""
+        if self.radius <= 0:
+            raise ValueError("Radius must be positive")
+
+    def _calculate_volume(self) -> float:
+        """Calculate the volume of the sphere."""
+        return (4 / 3) * np.pi * self.radius**3
+
+    @property
+    def center(self) -> np.ndarray:
+        """Get the center point of the sphere."""
+        return np.array([self.origin[0], self.origin[1], 0.0])
+
+    def get_bounds(self) -> Tuple[np.ndarray, np.ndarray]:
+        """
+        Get the minimum and maximum points that define the sphere's bounding box.
+
+        Returns:
+            Tuple containing (min_point, max_point)
+        """
+        min_point = np.array(
+            [
+                self.origin[0] - self.radius,
+                self.origin[1] - self.radius,
+                -self.radius,  # Z extends downward from 0
+            ]
+        )
+
+        max_point = np.array(
+            [
+                self.origin[0] + self.radius,
+                self.origin[1] + self.radius,
+                self.radius,  # Z extends upward from 0
+            ]
+        )
+
+        return min_point, max_point
+
+    def contains_point(self, point: np.ndarray) -> bool:
+        """
+        Check if a point lies within the sphere.
+
+        Args:
+            point: A 3D point to check
+
+        Returns:
+            bool: True if the point is inside the sphere, False otherwise
+        """
+        point = np.array(point)
+        if point.shape != (3,):
+            raise ValueError("Point must be a 3D point")
+
+        # Calculate distance from center to point
+        center_3d = self.center
+        return np.linalg.norm(point - center_3d) <= self.radius

AMS_BP/configio/configmodels.py

@@ -0,0 +1,93 @@
+from typing import List, Literal
+
+import numpy as np
+from pydantic import BaseModel, Field, field_validator
+
+
+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")
+
+    @field_validator("cell_space")
+    def convert_cell_space(cls, v):
+        return np.array(v)
+
+
+class MoleculeParameters(BaseModel):
+    num_molecules: List[int]
+    track_type: List[Literal["fbm", "constant"]] = Field(
+        description="Type of molecular motion, either fbm or constant"
+    )
+    diffusion_coefficient: List[List[float]] = Field(
+        description="Diffusion coefficients in um^2/s"
+    )
+    diffusion_track_amount: List[List[float]]
+    hurst_exponent: List[List[float]]
+    hurst_track_amount: List[List[float]]
+    allow_transition_probability: List[bool]
+    transition_matrix_time_step: List[int] = Field(description="Time step in ms")
+    diffusion_transition_matrix: List[List[List[float]]]
+    hurst_transition_matrix: List[List[List[float]]]
+    state_probability_diffusion: List[List[float]]
+    state_probability_hurst: List[List[float]]
+
+    @field_validator(
+        "diffusion_coefficient",
+        "diffusion_track_amount",
+        "hurst_exponent",
+        "hurst_track_amount",
+        "state_probability_diffusion",
+        "state_probability_hurst",
+    )
+    def convert_to_array(cls, v):
+        return np.array(v)
+
+    @field_validator("diffusion_transition_matrix", "hurst_transition_matrix")
+    def convert_matrix_to_array(cls, v):
+        return np.array(v)
+
+
+class GlobalParameters(BaseModel):
+    sample_plane_dim: List[float] = Field(description="Sample plane dimensions in um")
+    cycle_count: int
+    exposure_time: int = Field(description="Exposure time in ms")
+    interval_time: int = Field(description="Interval time in ms")
+    oversample_motion_time: int = Field(description="Oversample motion time in ms")
+
+    @field_validator("sample_plane_dim")
+    def convert_sample_plane_dim(cls, v):
+        return np.array(v)
+
+
+class CondensateParameters(BaseModel):
+    initial_centers: List[List[List[float]]] = Field(
+        description="Initial centers in um"
+    )
+    initial_scale: List[List[float]] = Field(description="Initial scale in um")
+    diffusion_coefficient: List[List[float]] = Field(
+        description="Diffusion coefficients in um^2/s"
+    )
+    hurst_exponent: List[List[float]]
+    density_dif: List[int]
+
+    # @field_validator(
+    #     "initial_centers", "initial_scale", "diffusion_coefficient", "hurst_exponent"
+    # )
+    # def convert_to_array(cls, v):
+    #     return np.array(v)
+    #
+
+
+class OutputParameters(BaseModel):
+    output_path: str
+    output_name: str
+    subsegment_type: str
+    subsegment_number: int
+
+
+class ConfigList(BaseModel):
+    CellParameters: CellParameters
+    MoleculeParameters: MoleculeParameters
+    GlobalParameters: GlobalParameters
+    CondensateParameters: CondensateParameters
+    OutputParameters: OutputParameters