restructure examples

Author: BenjaminMidtvedt

.gitignore

@@ -9,4 +9,9 @@ dist/*
 *.egg-info/
 */datasets/*
 */theory
-_src/build/**/*
+_src/build/**/*
+
+ParticleSizing
+3DTracking
+CellData
+ParticleTracking

autotrack-examples/train_label_free_multiparticle_tracker.ipynb

@@ -26,6 +26,7 @@
 from .sequences import *
 from .elementwise import *
 from .statistics import *
+from .holography import *
 
 from .image import strip
 

autotrack-examples/train_label_free_particle_orientation.ipynb

@@ -42,6 +42,7 @@
         "MitoGAN",
         "1Qf5vIWEksKPHJ1CBK6GPEhsSCvFFHFrg",
     ),
+    "CellData": ("1CJW7msDiI7xq7oMce4l9tRkNN6O5eKtj", "CellData", ""),
 }
 
 

autotrack-examples/train_label_free_particle_tracker_experimental_data.ipynb

@@ -191,7 +191,7 @@ def action(self, replicate_index=None):
         # Get the input arguments to the method .get()
 
         feature_input = self.properties(replicate_index=replicate_index).copy()
-        
+
         # Call the _process_properties hook, default does nothing.
         # Can be used to ensure properties are formatted correctly
         # or to rescale properties.
@@ -232,7 +232,7 @@ def action(self, replicate_index=None):
     def __call__(
         self, image_list: Image or List[Image] = None, replicate_index=None, **kwargs
     ):
-        
+
         # Potentially fragile. Maybe a special variable dt._last_input instead?
         if image_list is not None and not (
             isinstance(image_list, list) and len(image_list) == 0
@@ -352,7 +352,7 @@ def plot(
         if isinstance(output_image, Image):
             # Single image
             plt.imshow(output_image[:, :, 0], **kwargs)
-            plt.show()
+            return plt.gca()
 
         else:
             # Assume video

deeptrack/__init__.py

@@ -0,0 +1,93 @@
+from .features import Feature
+import numpy as np
+
+
+def get_propagation_matrix(shape, to_z, pixel_size, wavelength):
+
+    k = 2 * np.pi / wavelength
+    yr, xr, *_ = shape
+
+    x = 2 * np.pi / pixel_size * np.arange(-(xr / 2 - 1 / 2), (xr / 2 + 1 / 2), 1) / xr
+    y = 2 * np.pi / pixel_size * np.arange(-(yr / 2 - 1 / 2), (yr / 2 + 1 / 2), 1) / yr
+    KXk, KYk = np.meshgrid(x, y)
+
+    K = np.real(
+        np.sqrt(np.array(1 - (KXk / k) ** 2 - (KYk / k) ** 2, dtype=np.complex64))
+    )
+    C = np.fft.fftshift(((KXk / k) ** 2 + (KYk / k) ** 2 < 1) * 1.0)
+
+    return C * np.fft.fftshift(np.exp(k * 1j * to_z * (K - 1)))
+
+
+class Rescale(Feature):
+    """Rescales an optical field by subtracting the real part of the field beofre multiplication.
+
+    Parameters
+    ----------
+    rescale : float
+        index of z-propagator matrix
+    """
+
+    def __init__(self, rescale=1, **kwargs):
+        super().__init__(rescale=rescale, **kwargs)
+
+    def get(self, image, rescale, **kwargs):
+        image = np.array(image)
+        image[..., 0] = (image[..., 0] - 1) * rescale + 1
+        image[..., 1] *= rescale
+
+        return image
+
+
+class FourierTransform(Feature):
+    """Creates matrices for propagating an optical field.
+
+    Parameters
+    ----------
+    i : int
+        index of z-propagator matrix
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+    def get(self, image, padding=32, **kwargs):
+
+        im = np.copy(image[..., 0] + 1j * image[..., 1])
+        im = np.pad(im, ((padding, padding), (padding, padding)), mode="symmetric")
+        f1 = np.fft.fft2(im)
+        return f1
+
+
+class InverseFourierTransform(Feature):
+    """Creates matrices for propagating an optical field.
+
+    Parameters
+    ----------
+    i : int
+        index of z-propagator matrix
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+    def get(self, image, padding=32, **kwargs):
+        im = np.fft.ifft2(image)
+        imnew = np.zeros(
+            (image.shape[0] - padding * 2, image.shape[1] - padding * 2, 2)
+        )
+        imnew[..., 0] = np.real(im[padding:-padding, padding:-padding])
+        imnew[..., 1] = np.imag(im[padding:-padding, padding:-padding])
+        return imnew
+
+
+class FourierTransformTransformation(Feature):
+    def __init__(self, Tz, Tzinv, i, **kwargs):
+        super().__init__(Tz=Tz, Tzinv=Tzinv, i=i, **kwargs)
+
+    def get(self, image, Tz, Tzinv, i, **kwargs):
+        if i < 0:
+            image *= Tzinv ** np.abs(i)
+        else:
+            image *= Tz ** i
+        return image

deeptrack/extras/datasets.py

@@ -326,7 +326,11 @@ def __getattr__(self, key):
 
     def __getitem__(self, idx):
         idx = strip(idx)
-        out = Image(self._value.__getitem__(idx), copy=False)
+        out = self._value.__getitem__(idx)
+        if isinstance(out, (bool, int, float, complex)):
+            return out
+
+        out = Image(out, copy=False)
         out.merge_properties_from([self, idx])
         return out
 

deeptrack/features.py

@@ -1,8 +1,31 @@
+""" User defined equivariances for training autotrackers.
+
+Example:
+    action = Multiply(value=np.random.uniform(0.5, 1.5))
+    equivariance = Equivariance(mul=action.value) 
+
+"""
+
 from ...features import Feature
 import numpy as np
 
 
 class Equivariance(Feature):
+    """Defines equivariance between action and prediction.
+
+    Should define both a multiplicative equivariance (1, if invariant) and a additive equivariance (0, if invariant)
+
+    Parameters
+    ----------
+    mul : float, array-like
+        Multiplicative equivariance
+    add : float, array-like
+        Additive equivariance
+    indexes : optional, int or slice
+        Index of related predicted value(s)
+
+    """
+
     def __init__(self, mul, add, indexes=slice(None, None, 1), **kwargs):
         super().__init__(mul=mul, add=add, indexes=indexes, **kwargs)
 
@@ -22,6 +45,15 @@ def get(self, matvec, mul, add, indexes, **kwargs):
 
 
 class TranslationalEquivariance(Equivariance):
+    """Defines translation-like equivariance between action and prediction, for use with dt.Affine
+
+    Parameters
+    ----------
+    translate : float, array-like
+        Should be exactly `affine.translate`
+
+    """
+
     def __init__(self, translation, indexes=None):
         if indexes is None:
             indexes = self.get_indexes
@@ -40,25 +72,43 @@ def get_indexes(self, translation):
 
 
 class Rotational2DEquivariance(Equivariance):
-    def __init__(self, rotation, indexes=None):
+    """Defines rotation-like equivariance between action and prediction, for use with dt.Affine
+
+    Parameters
+    ----------
+    rotate : float, array-like
+        Should be exactly `affine.rotate`
+
+    """
+
+    def __init__(self, rotate, indexes=None):
         if indexes is None:
             indexes = self.get_indexes
         super().__init__(
-            rotation=rotation, add=self.get_add, mul=self.get_mul, indexes=indexes
+            rotate=rotate, add=self.get_add, mul=self.get_mul, indexes=indexes
         )
 
     def get_add(self):
         return np.zeros((2, 1))
 
-    def get_mul(self, rotation):
-        s, c = np.sin(rotation), np.cos(rotation)
+    def get_mul(self, rotate):
+        s, c = np.sin(rotate), np.cos(rotate)
         return np.array([[c, s], [-s, c]])
 
     def get_indexes(self):
         return slice(2)
 
 
 class ScaleEquivariance(Equivariance):
+    """Defines scale-like equivariance between action and prediction, for use with dt.Affine
+
+    Parameters
+    ----------
+    scale : float, array-like
+        Should be exactly `affine.scale`
+
+    """
+
     def __init__(self, scale, indexes=None):
         if indexes is None:
             indexes = self.get_indexes
@@ -77,6 +127,17 @@ def get_indexes(self, scale):
 
 
 class LogScaleEquivariance(Equivariance):
+    """Defines scale-like equivariance between action and prediction, for use with dt.Affine
+
+    Converts the scaling to log scale, for an additive equivariance.
+
+    Parameters
+    ----------
+    scale : float, array-like
+        Should be exactly `affine.scale`
+
+    """
+
     def __init__(self, scale, indexes=None):
         if indexes is None:
             indexes = self.get_indexes