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

AMS_BP/probabilityfuncs/probability_functions.py

@@ -31,7 +31,7 @@ prob_func = multiple_top_hat_probability(
     subspace_centers=np.array([[1, 1], [2, 2], [3, 3]]),
     subspace_radius=np.array([1.0, 0.5, 0.75]),
     density_dif=0.2,
-    space_size=np.array([10, 10])
+    cell=BaseCell type
 )
 
 prob = prob_func(np.array([1.5, 1.5]))
@@ -41,77 +41,19 @@ Note:
 After initialization, do not change the parameters directly. Use the update_parameters method to modify any values.
 """
 
-import numpy as np
-from typing import Union
-from ..cells.spherical_cell import SphericalCell
-from ..cells.rod_cell import RodCell
-from ..cells.rectangular_cell import RectangularCell
-
-CellType = Union[SphericalCell, RodCell, RectangularCell]
-
-
-def generate_points(
-    pdf: callable,
-    total_points: int,
-    min_x: float,
-    max_x: float,
-    center: np.ndarray,
-    radius: float,
-    bias_subspace_x: float,
-    space_prob: float,
-    density_dif: float,
-) -> np.ndarray:
-    """
-    Generates random (x, y) points using the accept/reject method based on a given distribution.
+from collections.abc import Callable
+from typing import Tuple
 
-    Parameters:
-    -----------
-    pdf : callable
-        Probability density function to sample from.
-    total_points : int
-        Number of points to generate.
-    min_x : float
-        Minimum x value for sampling.
-    max_x : float
-        Maximum x value for sampling.
-    center : np.ndarray
-        Coordinates of the center of the top-hat distribution.
-    radius : float
-        Radius of the top-hat region.
-    bias_subspace_x : float
-        Probability at the top of the top-hat.
-    space_prob : float
-        Probability outside the top-hat region.
-    density_dif : float
-        Scaling factor for density differences.
+import numpy as np
 
-    Returns:
-    --------
-    np.ndarray
-        Array of generated points.
-    """
-    xy_coords = []
-    while len(xy_coords) < total_points:
-        # generate candidate variable
-        var = np.random.uniform([min_x, min_x], [max_x, max_x])
-        # generate varibale to condition var1
-        var2 = np.random.uniform(0, 1)
-        # apply condition
-        pdf_val = pdf(var, center, radius, bias_subspace_x, space_prob)
-        if var2 < ((1.0 / density_dif) * (max_x - min_x) ** 2) * pdf_val:
-            xy_coords.append(var)
-    return np.array(xy_coords)
+from ..cells import BaseCell
 
 
 def generate_points_from_cls(
-    pdf: callable,
+    pdf: Callable,
     total_points: int,
-    min_x: float,
-    max_x: float,
-    min_y: float,
-    max_y: float,
-    min_z: float,
-    max_z: float,
+    volume: float,
+    bounds: Tuple[float, float, float, float, float, float],
     density_dif: float,
 ) -> np.ndarray:
     """
@@ -123,18 +65,21 @@ def generate_points_from_cls(
         Probability density function to sample from.
     total_points : int
         Number of points to generate.
-    min_x : float
-        Minimum x value for sampling.
-    max_x : float
-        Maximum x value for sampling.
-    min_y : float
-        Minimum y value for sampling.
-    max_y : float
-        Maximum y value for sampling.
-    min_z : float
-        Minimum z value for sampling.
-    max_z : float
-        Maximum z value for sampling.
+    bound : list with the following
+        min_x : float
+            Minimum x value for sampling.
+        max_x : float
+            Maximum x value for sampling.
+        min_y : float
+            Minimum y value for sampling.
+        max_y : float
+            Maximum y value for sampling.
+        min_z : float
+            Minimum z value for sampling.
+        max_z : float
+            Maximum z value for sampling.
+    volume : float,
+        volume of region sampling
     density_dif : float
         Scaling factor for density differences.
 
@@ -143,8 +88,8 @@ def generate_points_from_cls(
     np.ndarray
         Array of generated (x, y, z) points.
     """
+    min_x, max_x, min_y, max_y, min_z, max_z = bounds
     xyz_coords = []
-    area = (max_x - min_x) * (max_y - min_y) * (max_z - min_z)
     while len(xyz_coords) < total_points:
         # generate candidate variable
         var = np.random.uniform([min_x, min_y, min_z], [max_x, max_y, max_z])
@@ -152,7 +97,7 @@ def generate_points_from_cls(
         var2 = np.random.uniform(0, 1)
         # apply condition
         pdf_val = pdf(var)
-        if var2 < ((1.0 / density_dif) * area) * pdf_val:
+        if var2 < ((1.0 / density_dif) * volume) * pdf_val:
             xyz_coords.append(var)
     return np.array(xyz_coords)
 
@@ -166,7 +111,7 @@ class multiple_top_hat_probability:
         subspace_centers: np.ndarray,
         subspace_radius: np.ndarray,
         density_dif: float,
-        cell: CellType,
+        cell: BaseCell,
     ) -> None:
         """
         Initialize the probability function.
@@ -181,7 +126,7 @@ class multiple_top_hat_probability:
             Radius of each subspace
         density_dif : float
             Difference in density between subspaces and non-subspaces
-        cell : CellType
+        cell : BaseCell
             Cell object defining the boundary
         """
         self.num_subspace = num_subspace
@@ -205,7 +150,7 @@ class multiple_top_hat_probability:
             raise TypeError("Position must be a numpy array.")
 
         # First check if point is within the cell
-        if not self.cell.contains_point(position):
+        if not self.cell.contains_point(*position):
             return 0.0
 
         # Then check if point is within any subspace
@@ -285,14 +230,12 @@ class multiple_top_hat_probability:
         self._density_dif = value
 
     @property
-    def cell(self) -> CellType:
+    def cell(self) -> BaseCell:
         """Returns the cell object."""
         return self._cell
 
     @cell.setter
-    def cell(self, value: CellType) -> None:
-        if not isinstance(value, CellType):
-            raise TypeError("Cell must be a valid cell object.")
+    def cell(self, value: BaseCell) -> None:
         self._cell = value
 
     @property
@@ -318,7 +261,7 @@ class multiple_top_hat_probability:
         subspace_centers: np.ndarray | None = None,
         subspace_radius: np.ndarray | None = None,
         density_dif: float | None = None,
-        cell: CellType | None = None,
+        cell: BaseCell | None = None,
     ) -> None:
         """Updates the parameters of the probability function."""
         if num_subspace is not None:
@@ -332,19 +275,9 @@ class multiple_top_hat_probability:
         if cell is not None:
             self.cell = cell
 
-        # Recalculate total volume based on cell type
-        if isinstance(self.cell, SphericalCell):
-            total_volume = (4 / 3) * np.pi * self.cell.radius**3
-        elif isinstance(self.cell, RodCell):
-            total_volume = self.cell.volume
-        elif isinstance(self.cell, RectangularCell):
-            total_volume = float(np.prod(self.cell.dimensions))
-        else:
-            raise ValueError("Unsupported cell type")
-
         self.subspace_probability = self._calculate_subspace_probability(
-            total_volume, self.density_dif
+            self.cell.volume, self.density_dif
         )
         self.non_subspace_probability = self._calculate_non_subspace_probability(
-            total_volume, self.density_dif, self.num_subspace, self.subspace_radius
+            self.cell.volume, self.density_dif, self.num_subspace, self.subspace_radius
         )

AMS_BP/sample/sim_sampleplane.py

@@ -133,8 +133,8 @@ class SampleSpace:
         z_min, z_max = fov.z_bounds
 
         return (
-            0 <= x_min <= x_max <= self.x_max
-            and 0 <= y_min <= y_max <= self.y_max
+            x_min <= x_min <= x_max <= self.x_max
+            and x_min <= y_min <= y_max <= self.y_max
             and self.z_min <= z_min <= z_max <= self.z_max
         )
 
@@ -207,23 +207,23 @@ class SamplePlane:
         trajectory: Optional[Dict[int, Tuple[float, float, float]]] = None,
     ) -> bool:
         """Add a fluorescent object to the sample plane"""
-        # Verify position is within sample space
-        if not self._space.contains_position(position):
-            return False
-
-        # Verify initial position is within FOV
-        if not self.is_within_fov(position):
-            return False
-
-        # If trajectory provided, verify all positions
-        if trajectory is not None:
-            if not all(
-                self._space.contains_position(pos) for pos in trajectory.values()
-            ):
-                return False
-            if not all(self.is_within_fov(pos) for pos in trajectory.values()):
-                return False
-
+        # # Verify position is within sample space
+        # if not self._space.contains_position(position):
+        #     return False
+        #
+        # # Verify initial position is within FOV
+        # if not self.is_within_fov(position):
+        #     return False
+
+        # # If trajectory provided, verify all positions
+        # if trajectory is not None:
+        #     if not all(
+        #         self._space.contains_position(pos) for pos in trajectory.values()
+        #     ):
+        #         return False
+        #     if not all(self.is_within_fov(pos) for pos in trajectory.values()):
+        #         return False
+        #
         if object_id in self._objects:
             return False
 
@@ -239,11 +239,11 @@ class SamplePlane:
         obj = FluorescentObject(object_id, position, fluorophore, trajectory)
         self._objects[object_id] = obj
 
-        # Update spatial index for all time points
-        for t in self.time_points:
-            pos = trajectory[t]
-            self._update_spatial_index(object_id, pos, t)
-
+        # # Update spatial index for all time points
+        # for t in self.time_points:
+        #     pos = trajectory[t]
+        #     self._update_spatial_index(object_id, pos, t)
+        #
         return True
 
     def get_all_objects(self) -> List[FluorescentObject]:
@@ -332,3 +332,34 @@ class SamplePlane:
     ) -> Tuple[Tuple[float, float], Tuple[float, float], Tuple[float, float]]:
         """Return the sample space bounds"""
         return self._space.bounds
+
+
+def _FOV_lims(
+    xyoffset: Tuple[float, float],
+    detector_pixelcount: Tuple[int, int],
+    detector_pixelsize_magnification: float,
+) -> Tuple[Tuple[float, float], Tuple[float, float]]:
+    """
+    Utility to determine the FOV (what regions in the sample space the camera can capture) -> mainly used for defining laser position callables.
+
+    Parameters:
+    -----------
+    xyoffset: Tuple[float, float]
+        position in the sample plane which defines the bottom left corner on the detector pixel array; in units of the sample space (um)
+
+    detector_pixelcount: Tuple[int, int]
+        number of pixels in the detector in the both x and y
+
+    detector_pixelsize_magnification: float
+        the pixel size of each pixel (of detector_pixelcount) after the magnification of the optical setup is considered. I.e what each pixel in the final image represents in the units of the sample space (um).
+
+    Returns:
+    --------
+    (x_lims, y_lims): Tuple[Tuple[float, float], Tuple[float, float]]
+        min < max for each lim
+    """
+    x_min = xyoffset[0]
+    y_min = xyoffset[1]
+    x_max = x_min + detector_pixelcount[0] * detector_pixelsize_magnification
+    y_max = y_min + detector_pixelcount[1] * detector_pixelsize_magnification
+    return ((x_min, x_max), (y_min, y_max))

AMS_BP/sim_config.toml

@@ -1,26 +1,31 @@
-version = "0.1"
+version = "0.2"
 length_unit = "um"        # always um.
 time_unit = "ms"          # always ms
 diffusion_unit = "um^2/s" # always um^2/s
 
 [Cell_Parameters]
-cell_space = [[4, 7], [3, 9]] # um ([[x_min, x_max], [y_min, y_max]])
-cell_axial_radius = 0.5       # um +/- from 0. Total z range = 2*cell_axial_radius
+cell_type = "RodCell" # any of RectangularCell, SphericalCell, OvoidCell, RodCell, BuddingCell
+[Cell_Parameters.params] # see docs for parameters for each cell type
+center = [5, 5, 0]
+direction = [1, 0, 0]
+radius = 1.0
+height = 4.0
+# bounds = [[3, 7], [3, 9], [-1, 1]]
 
 [Molecule_Parameters]
 num_molecules = [
     5000,
     5000,
 ] # size of array tells the types of molecules (must be same as num_of_fluorophores below). All of the Molecule_Parameters are of the same first dimension as this.
-track_type = ["constant", "constant"] # "constant", "fbm"
+track_type = ["fbm", "fbm"] # "constant", "fbm"
 diffusion_coefficient = [
     [
-        0.0,
-        0.0,
+        0.2,
+        0.4,
     ],
     [
-        0.0,
-        0.0,
+        0.2,
+        0.4,
     ],
 ] # um^2/s, size of each index (eg. len(...[0]) is the # of diffusion coefficients the system can explore.
 

AMS_BP/sim_microscopy.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass
-from typing import Callable, Dict, List, Literal, Optional, Tuple
+from typing import Callable, Dict, List, Literal, Optional, Tuple, Union
 
 import numpy as np
 
@@ -16,7 +16,7 @@ from .photophysics.photon_physics import (
     incident_photons,
 )
 from .photophysics.state_kinetics import StateTransitionCalculator
-from .sample.flurophores.flurophore_schema import WavelengthDependentProperty
+from .sample.flurophores.flurophore_schema import StateType, WavelengthDependentProperty
 from .sample.sim_sampleplane import EMPTY_STATE_HISTORY_DICT, SamplePlane
 from .utils.util_functions import ms_to_seconds
 
@@ -70,10 +70,14 @@ class VirtualMicroscope:
             "_time": self._time,
         }
 
-    def _set_laser_powers(self, laser_power: Dict[str, float]) -> None:
+    def _set_laser_powers(
+        self, laser_power: Dict[str, Union[float, Callable[[float], float]]]
+    ) -> None:
         if laser_power is not None:
             for laser in laser_power.keys():
-                if isinstance(self.lasers[laser].params.power, float):
+                if isinstance(self.lasers[laser].params.power, float) and isinstance(
+                    laser_power[laser], float
+                ):
                     if laser_power[laser] > self.lasers[laser].params.max_power:
                         raise ValueError(
                             "Provided laser power for laser: {} nm, is larger than the maximum power: {}".format(
@@ -84,7 +88,14 @@ class VirtualMicroscope:
                 self.lasers[laser].params.power = laser_power[laser]
 
     def _set_laser_positions(
-        self, laser_positions: Dict[str, Tuple[float, float, float]]
+        self,
+        laser_positions: Dict[
+            str,
+            Union[
+                Tuple[float, float, float],
+                Callable[[float], Tuple[float, float, float]],
+            ],
+        ],
     ) -> None:
         if laser_positions is not None:
             for laser in laser_positions.keys():
@@ -93,15 +104,28 @@ class VirtualMicroscope:
     def run_sim(
         self,
         z_val: float,  # um
-        laser_power: Dict[str, float],  # str = lasername, float = power in W
+        laser_power: Dict[
+            str, Union[float, Callable[[float], float]]  # power or f(t) -> power
+        ],  # str = lasername, float = power in W
         xyoffset: Tuple[
             float, float
         ],  # location of the bottom left corner of the field of view -> sample -> camera
-        laser_position: Dict[str, Tuple[float, float, float]]
-        | None,  # str = lasername, Tuple = x, y, z in um at the sample plane
+        laser_position: Optional[
+            Dict[
+                str,  # laser name
+                Union[
+                    Tuple[float, float, float],  # x, y, z
+                    Callable[[float], Tuple[float, float, float]],  # f(t) -> x, y, z
+                ],
+            ]
+        ] = None,  # str = lasername, Tuple = x, y, z in um at the sample plane
         duration_total: Optional[int] = None,  # ms
         exposure_time: Optional[int] = None,
         interval_time: Optional[int] = None,
+        scanning: Optional[
+            bool
+        ] = False,  # True if scanning -> laser will autoposition to the xy location of the fluorophore but at the z_val of the plane being imaged and NOT the z value of the fluorophore.
+        # as a consequence the "effective" time spent by the laser of on the fluorophore position is not the dwell time of traditional confocal, but "always on". TODO: better fix.
     ) -> Tuple[np.ndarray, MetaData]:
         self._set_laser_powers(laser_power=laser_power)
         if laser_position is not None:
@@ -149,7 +173,9 @@ class VirtualMicroscope:
                 statehist = fluorObj.state_history[time]
                 # if not aval transitions go next
                 # this assumes that the bleached state is the only state from which there are no more transitions
-                if not statehist[2]:
+                if (not statehist[2]) and (
+                    statehist[0].state_type != StateType.FLUORESCENT
+                ):
                     fluorObj.state_history[time + self.sample_plane.dt] = statehist
                     continue
 
@@ -165,6 +191,11 @@ class VirtualMicroscope:
                 ) -> dict:
                     laser_intensities = {}
                     for laserID in laser_power.keys():
+                        if scanning:
+                            self.lasers[laserID].params.position = (
+                                *florPos[:2],
+                                0,
+                            )  # z value is 0 since this is the neew focus plane
                         laser_intensities[laserID] = {
                             "wavelength": self.lasers[laserID].params.wavelength,
                             "intensity": (

AMS_BP/utils/util_functions.py

@@ -1,6 +1,7 @@
 import json
 import os
 import pickle
+from bisect import bisect_right
 
 import numpy as np
 import skimage as skimage
@@ -9,6 +10,14 @@ from PIL import Image
 from ..utils.decorators import cache
 
 
+def find_le(a, x) -> int:
+    "Find rightmost value less than or equal to x"
+    i = bisect_right(a, x)
+    if i:
+        return a[i - 1]
+    raise ValueError
+
+
 def convert_arrays_to_lists(obj: np.ndarray | dict) -> list | dict:
     """
     Recursively convert NumPy arrays to lists.

{ams_bp-0.0.231.dist-info → ams_bp-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AMS_BP
-Version: 0.0.231
+Version: 0.2.0
 Summary: Advanced Microscopy Simulations developed for the Weber Lab by Baljyot Singh Parmar
 Project-URL: Documentation, https://joemans3.github.io/AMS_BP/
 Project-URL: Source code, https://github.com/joemans3/AMS_BP
@@ -8,10 +8,12 @@ Author-email: Baljyot Singh Parmar <baljyotparmar@hotmail.com>
 Maintainer-email: Baljyot Singh Parmar <baljyotparmar@hotmail.com>
 License-File: LICENSE
 Keywords: SMS
-Requires-Python: >=3.10
+Requires-Python: >=3.12
+Requires-Dist: boundedfbm>=0.2.0
 Requires-Dist: jsonschema>=4.23.0
 Requires-Dist: numpy>=1.21.2
 Requires-Dist: pydantic>=2.9.2
+Requires-Dist: pyvista>=0.44.2
 Requires-Dist: scikit-image>=0.18.3
 Requires-Dist: scipy>=1.7.1
 Requires-Dist: tomli>=2.0.2
@@ -79,6 +81,14 @@ run_AMS_BP runsim CONFIG_FILE
 - `-o, --output_path PATH`: Specify the output directory for the configuration file
 - `-r, --recursive_o`: Create output directory if it doesn't exist
 
+## Overview of Simulation Workflow
+![Overview Schematic](./docs/assets/figures/Fig1_Schema.svg)
+*A ground truth is created, **a**, with $`f_{n}`$ fluorophore types of $`N_{f_{n}}`$ molecules each. If applicable, the motion of these molecules is modelled using a 3D bounded FBM with fluctuating generalized diffusion coefficients and Hurst parameters. Variations are modelled as a Markov Chain and require rate constants as parameters. Different fluorophores can have different motion models. The resolution of the motion models is $`\Delta t`$ and cannot be smaller than 1 ms (for computational efficiency). Given the microscope parameters specific to the experimental procedure to simulate, at every time $`t_{j}`$, the excitation intensity for each channel (**b**) is calculated at each fluorophore's location, **c**. For $`t_{j} \rightarrow t_{j+\Delta t}`$, the photophysical state trajectory of the fluorophore is simulated using the light intensity at the molecule's location as input for any light-dependent transition rates, **d**. For the duration that the shutter is open and light is emitted from the sample, emission filters for each channel are applied before the convolution with PSF models, **e**. The incident photons on the detector are then converted to photoelectrons and finally to digital units using the detector models provided, **f**.*
+
+
+
+
+
 ## Configuration File
 
 The configuration file (sim_config.toml) is divided into several key sections:
@@ -96,7 +106,6 @@ diffusion_unit = "um^2/s" # diffusion coefficient units
 
 1. **Cell Parameters**
    - Define cell space dimensions
-   - Set cell axial radius
 
 2. **Molecule Parameters**
    - Number of molecules per type
@@ -124,7 +133,8 @@ diffusion_unit = "um^2/s" # diffusion coefficient units
 
 ## Running Experiments
 
-AMS-BP supports two types of experiments:
+AMS-BP's CLI currently supports two types of experiments:
+> (however this can be extended when used as a library) 
 
 ### 1. Time Series
 ```toml
@@ -171,3 +181,14 @@ frames, metadata = function_exp(microscope=microscope, config=config_exp)
 from AMS_BP.configio.saving import save_config_frames
 save_config_frames(metadata, frames, setup_config["base_config"].OutputParameters)
 ```
+
+## API Reference and Docs
+Find detailed API references for the library at: [joemans3/github.io/AMS_BP](https://joemans3.github.io/AMS_BP/)
+> A more detailed example is provided in the jupyter notebook in the examples. For starters refer to the [VisualizingIndividualModules](examples/VisualizingIndividualModules/modules_explained.ipynb). Then head over to the [laser modulation module](examples/VisualizingIndividualModules/laser_modulation.ipynb) which will show how to change the laser power over time in the simulations. Then view an example of a complex experiment setup for [FRAP](examples/QuantitativeExperiments/FRAP_methods.ipynb) which is possible by the use of compositions of modules in this simulation library.
+
+## High Priority Features
+1. Irregular cell shapes with motion models
+2. Stimulated Emission models
+3. STORM workflow examples
+4. CTRW motion models
+5. Simpler configurations

{ams_bp-0.0.231.dist-info → ams_bp-0.2.0.dist-info}/RECORD

@@ -1,25 +1,24 @@
-AMS_BP/__init__.py,sha256=rqdkAwhLvzoA4UNC7EgJOgze5vTlp72Cm62WfiIINCc,328
+AMS_BP/__init__.py,sha256=pj8JaDmWwnqBAxuQAgDPFFVkI2FOkCRpIN4GlyKBTQw,326
 AMS_BP/run_cell_simulation.py,sha256=7InopFikjo0HfaLO2siXskBIbyCIte9avG4YXjjaWCI,7420
-AMS_BP/sim_config.toml,sha256=3IqOQIJYmP5g4okk15nqQiNZb3ij7Pt63HbpI-5tySw,11672
-AMS_BP/sim_microscopy.py,sha256=0UZfyT44nrB4JdfnFnRPTVBm3tPbCyOnPXiBBZs8xIc,18617
-AMS_BP/cells/__init__.py,sha256=yWFScBC1uOGDkeC8i1m1ZBtIREcyt4JHxYa72LxbBZU,177
-AMS_BP/cells/base_cell.py,sha256=FIPB9J8F40tb53vv7C6qG-SaAFLOI8-MGIk1mmZ-gnI,1503
-AMS_BP/cells/rectangular_cell.py,sha256=5yGxvTXYvgldLXyWXpE_SD9Zx2NLerC-I2j02reHsJ0,2515
-AMS_BP/cells/rod_cell.py,sha256=jQ1kLEk74Pv2rcXPRJ6-QJJhux-mYiDSytzqlxCNWfA,3181
-AMS_BP/cells/spherical_cell.py,sha256=n3ou3tW0nCxXIwv6uLkVKHkYCfgoNn8VI6CVTLBIll0,2140
+AMS_BP/sim_config.toml,sha256=G0wW9qsxciZA1Y0Zm6YgZ00ZDBEBBLw_XXq4gsVRjSY,11778
+AMS_BP/sim_microscopy.py,sha256=Vsga9lTWqP0pjEnfFj0qKaSz7YZ_F4E3TqsaErwhi3E,19991
+AMS_BP/cells/__init__.py,sha256=Rd2gpWWUZJxW2u_piI2ZcIqLtYkzVOr_MjU3upiUv8Q,866
+AMS_BP/cells/budding_yeast_cell.py,sha256=BiZ_rML5xjcS8NMP785VzUPVxo41yhihsbvbwSYLQvM,9440
+AMS_BP/cells/cell_factory.py,sha256=Mhk-0KzLVfaub81Asj5PibOcps0s8I24iC4qZs0VVK4,4435
 AMS_BP/configio/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-AMS_BP/configio/configmodels.py,sha256=Gd2Qdut0u5zS0IpjPwGIB3ur-b4Dfa9e8SbhotBKymc,2894
-AMS_BP/configio/convertconfig.py,sha256=Fg9pOCZSxmWuHnrg-5xZRvhPEK6Qc1kXqu6LL9e9QYw,34741
+AMS_BP/configio/configmodels.py,sha256=9rPXIYh228fEEf4tDGcE0kSC_RB97VocBaIobhCeuBQ,2998
+AMS_BP/configio/convertconfig.py,sha256=Np2xKMnAKMkqPip_uqGYOUmp7_5BWn1ZnUBesfkyvis,34588
 AMS_BP/configio/experiments.py,sha256=HdfaSi0gPPJ_wLF87XcW5ICja19Uezx7-ygFEwNzi30,3995
 AMS_BP/configio/saving.py,sha256=596QgAadV32rzsN4B2FngGFcBWCzCDnLFN-qtQsv3bM,857
+AMS_BP/groundtruth_generators/__init__.py,sha256=UPVmhiB81OfyqAes5LoN-n6XgQuBCYCqRPAGd2jpMfc,99
+AMS_BP/groundtruth_generators/nuclearporecomplexes.py,sha256=1aBcWltsKo0OGd7A9GfuEZ3azQBx5SzpjrSLLMXuYn8,2518
 AMS_BP/metadata/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 AMS_BP/metadata/metadata.py,sha256=YDumjc5sI3lY_UZx8f0ZhMqbG2qKQkysXwl7CY4ZtnY,2927
 AMS_BP/motion/__init__.py,sha256=cy3W-wCRjjlN1DrTqYc-JltYwcE8SZCXMVPJ2o6q_BQ,178
-AMS_BP/motion/condensate_movement.py,sha256=eig4WtD7o1cvIafWMjOk6pqxyhe_IIucgLcBEoDvasU,11648
-AMS_BP/motion/track_gen.py,sha256=Z3QJLVMP1gX4SlgOXFxBg8sJhBG0Xq25ixnBoEHEAZI,19462
-AMS_BP/motion/movement/__init__.py,sha256=PqovpG4dAuFFIP9M2_kt-6egQJX3P5ig4MMWVzNaswg,278
-AMS_BP/motion/movement/boundary_conditions.py,sha256=jpfK3AEUY8btrTsu19bpUfx-jri7_HfyxqMFjMoxAVM,2200
-AMS_BP/motion/movement/fbm_BP.py,sha256=dH-JZiAInnIaZXH1wAAo8dOIX9zafclqnZ4dOhKtnO0,9327
+AMS_BP/motion/condensate_movement.py,sha256=TXSsX1UiCfJJhyWnnK0nOgYkg06LTrhCXiBV7u6KjA0,11478
+AMS_BP/motion/track_gen.py,sha256=V3bFDxDajObRhPWiOzjWiW_VA9aJEWFwDjxMqqlVRXs,17543
+AMS_BP/motion/movement/__init__.py,sha256=tBNb9UVDPAAnjENRtvI35YF2BdKKBqBkgWJMZSENL8U,59
+AMS_BP/motion/movement/boundary_conditions.py,sha256=AxBpvR2zredg6uaZoI1fypxkaRd0IZP8MBbkfMh5sKk,2546
 AMS_BP/optics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 AMS_BP/optics/camera/__init__.py,sha256=eCoDUFHcoCWgbgYdLn8EH7AULM53A3XWTXNZnV8QxeY,182
 AMS_BP/optics/camera/detectors.py,sha256=_815Ovo7Aj375OZh5Xim8pFuZEEcSVtSdnLRYFqb3_8,10355
@@ -29,17 +28,18 @@ AMS_BP/optics/filters/filters.py,sha256=-iw7eqmDO77SEqlFTv5jJNVwpA8y93TLsjy5hhsA
 AMS_BP/optics/filters/channels/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 AMS_BP/optics/filters/channels/channelschema.py,sha256=SConyA5yVdfnI_8sgcxVC8SV7S8tGUJYPPC6jn7lglU,906
 AMS_BP/optics/lasers/__init__.py,sha256=T7dHohhyLf_pBw4TidarYHWmiwxVXGE71-Bf1aeBbuc,564
-AMS_BP/optics/lasers/laser_profiles.py,sha256=J9czY646XcW8GzXx9Eb16mG7tQdWw4oVYveOrihZCeY,22745
+AMS_BP/optics/lasers/laser_profiles.py,sha256=_h3g_TjolJI5NTg7T_m_ntyNpSFTJvxW0AeXf0svm-I,17284
+AMS_BP/optics/lasers/scanning_patterns.py,sha256=Xen96e5BlYI892HzZDXdwm80id6TbyNCNj-qvnRnSnI,3393
 AMS_BP/optics/psf/__init__.py,sha256=ezrKPgpTeR4gTHOvF0mhF6u2zMMTd8Bgp8PGeOf11fA,121
-AMS_BP/optics/psf/psf_engine.py,sha256=Do54D1jMbSrj5uljdTrrEttCvxq3qbVT74acRuOk15c,9434
+AMS_BP/optics/psf/psf_engine.py,sha256=FbR4VHQ-VgCWrrDj8AHPPnVgwVUGs-OP19w_TjcbMcU,10215
 AMS_BP/photophysics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-AMS_BP/photophysics/photon_physics.py,sha256=QRG_QIZ4csJ3g5qGP9Wtk7kzqm8_MUbVHfFef6cMtHQ,6671
-AMS_BP/photophysics/state_kinetics.py,sha256=0cc7Vc4LtAbEdGDeg22IJmRGLsONOty4c32hXHO-TSU,5281
+AMS_BP/photophysics/photon_physics.py,sha256=9FWBXaxuSRaSxW8bY0x1d5R5buooibZbRdYTuQcMXhQ,6624
+AMS_BP/photophysics/state_kinetics.py,sha256=hDb1VqoeEkbYcse-N-S7BzyE4hIt4KLMju7ZKOIJDYc,6980
 AMS_BP/probabilityfuncs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 AMS_BP/probabilityfuncs/markov_chain.py,sha256=LV6KGr8Lv4NIvBPJqsR0CEynssa_mPH30qLaK85GObA,4339
-AMS_BP/probabilityfuncs/probability_functions.py,sha256=j_rIxrupGBf_FKkQBh1TvEa34A44jAasaZQRg2u3FuY,11793
+AMS_BP/probabilityfuncs/probability_functions.py,sha256=sYLhR61x-w322hxk368jUStH11Wq-KbqOU9zArZlatg,9662
 AMS_BP/sample/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-AMS_BP/sample/sim_sampleplane.py,sha256=A1BnGaFDnJ0VYaXUmpr0bLdZ01UzfZrATBTubGt3gjo,11525
+AMS_BP/sample/sim_sampleplane.py,sha256=szr0Y9zFsaJy0aY_Gm5AAVBbY8UsRwehxowUGfaK_2Q,12889
 AMS_BP/sample/flurophores/__init__.py,sha256=arLVUx1-yh5T41fH9Mr6RNY8Ao3ZioFQUtsfEZlzQkU,250
 AMS_BP/sample/flurophores/flurophore_schema.py,sha256=j8jnr4w4ltuhXUkjd74IoyyuotyH52mn8FWkgahX5Vw,10886
 AMS_BP/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -47,9 +47,9 @@ AMS_BP/utils/constants.py,sha256=-r3cnEiuxb-XzRgGhpOuJshYYhKnDu_hv0YSffkxAfc,273
 AMS_BP/utils/decorators.py,sha256=4qFdvzPJne0dhkhD1znPxRln1Rfr5NX8rdcCDcbATRU,6224
 AMS_BP/utils/errors.py,sha256=7BOd-L4_YeKmWn3Q4EOdTnNF3Bj_exDa3eg5X0yCZrc,759
 AMS_BP/utils/maskMaker.py,sha256=2ca3n2nc8rFtUh1LurKXOJJsUmhrOpWbRnVX7fjRVvs,335
-AMS_BP/utils/util_functions.py,sha256=jI6WBh09_khdABnEoVK7SK1WRvCLHuw40f5ALyflzlc,9478
-ams_bp-0.0.231.dist-info/METADATA,sha256=Rs9gQc6T1-ZcguRTLWfsl42ZsTmJCtVgXRn-pcL7noY,5284
-ams_bp-0.0.231.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-ams_bp-0.0.231.dist-info/entry_points.txt,sha256=MFUK9bZWW61djfsavqopMqiVPVn4lJtt6v8qzyEFyNM,76
-ams_bp-0.0.231.dist-info/licenses/LICENSE,sha256=k_-JV1DQKvO0FR8WjvOisqdTl0kp6VJ7RFM3YZhao0c,1071
-ams_bp-0.0.231.dist-info/RECORD,,
+AMS_BP/utils/util_functions.py,sha256=9Qlr4kjY04fObktR8TrzB0IgoG1yXtcmxPRX9AN34mM,9671
+ams_bp-0.2.0.dist-info/METADATA,sha256=GJLdow0hQ3y6LLNubb0q0xfzw00oSeftbRgfnr_K4u8,7658
+ams_bp-0.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+ams_bp-0.2.0.dist-info/entry_points.txt,sha256=MFUK9bZWW61djfsavqopMqiVPVn4lJtt6v8qzyEFyNM,76
+ams_bp-0.2.0.dist-info/licenses/LICENSE,sha256=k_-JV1DQKvO0FR8WjvOisqdTl0kp6VJ7RFM3YZhao0c,1071
+ams_bp-0.2.0.dist-info/RECORD,,