rearrange test and dependencies

README.md

@@ -62,7 +62,7 @@ with Image(list(image_ids.values())[0], **server_info) as image:
 A `Tiler` object performs trap registration. It is built in different ways, the easiest one is using an image and a the default parameters set.
 
 ```python
-from aliby.segment import Tiler, TilerParameters
+from agora.tile.tiler import Tiler, TilerParameters
 with Image(list(image_ids.values())[0], **server_info) as image:
     tiler = Tiler.from_image(image, TilerParameters.default())
 ```

pyproject.toml

@@ -3,6 +3,11 @@ name = "aliby"
 version = "0.1.7"
 description = ""
 authors = ["Alan Munoz <alan.munoz@ed.ac.uk>"]
+packages = [
+    { include = "aliby" },
+    { include = "extraction" },
+    { include = "utils" },
+]
 
 [tool.poetry.dependencies]
 python = ">=3.7.1,<3.11"
@@ -12,6 +17,9 @@ dask = "^2021.12.0"
 pathos = "^0.2.8"
 tqdm = "^4.62.3"
 pandas = "^1.3.5"
+scikit-learn = "0.22.2.post1"
+more-itertools = "^8.12.0"
+py-find-1st = "^1.1.5"
 scikit-image = "^0.19.1"
 opencv-python = "^4.5.4"
 requests-toolbelt = "^0.9.1"
@@ -21,11 +29,10 @@ imageio = "2.8.0"
 omero-py = ">=5.6.2"
 zeroc-ice = "3.6.5"
 tensorflow = ">=1.15,<=2.3"
-aliby-parser = "*"
-aliby-extraction = "*"
-aliby-post = "*"
 aliby-agora = "*"
+aliby-argo = "*"
 aliby-baby = "*"
+aliby-post = "*"
 
 
 [tool.poetry.dev-dependencies]

tests/test_post_processing.py → tests/aliby/test_post_processing.py

@@ -5,8 +5,13 @@ from scipy import ndimage
 from skimage import draw
 import unittest
 
-from core.post_processing import conical, ellipse_perimeter, \
-    union_of_spheres, volume_of_sphere, circle_outline
+from aliby.post_processing import (
+    conical,
+    ellipse_perimeter,
+    union_of_spheres,
+    volume_of_sphere,
+    circle_outline,
+)
 
 
 class VolumeEstimation(unittest.TestCase):
@@ -16,7 +21,7 @@ class VolumeEstimation(unittest.TestCase):
         b_sum = morph.ball(radius).sum()
         # Close relative to the value.
         print(radius, con, b_sum)
-        self.assertAlmostEqual(abs(con - b_sum)/b_sum, 0, delta=0.10)
+        self.assertAlmostEqual(abs(con - b_sum) / b_sum, 0, delta=0.10)
 
     def test_conical_ellipse(self):
         e = ellipse_perimeter(4, 5)
@@ -28,35 +33,43 @@ class VolumeEstimation(unittest.TestCase):
         radii = range(3, 30)
         con = [conical(circle_outline(radius)) for radius in radii]
         spheres = [union_of_spheres(circle_outline(r)) for r in radii]
-        true = [4*(r**3)*np.pi/3 for r in radii]
-        mVol = [4 / 3 * np.pi * np.sqrt(morph.disk(radius).sum() / np.pi)**3
-                for radius in radii]
-        plt.scatter(true, con, label='Conical')
-        plt.scatter(true, spheres, label='Spheres')
-        plt.scatter(true, mVol, label='mVol')
-        plt.plot(true, true, 'k-' )
+        true = [4 * (r ** 3) * np.pi / 3 for r in radii]
+        mVol = [
+            4 / 3 * np.pi * np.sqrt(morph.disk(radius).sum() / np.pi) ** 3
+            for radius in radii
+        ]
+        plt.scatter(true, con, label="Conical")
+        plt.scatter(true, spheres, label="Spheres")
+        plt.scatter(true, mVol, label="mVol")
+        plt.plot(true, true, "k-")
         plt.xlabel("Analytical")
         plt.ylabel("Estimated")
         plt.title("Disk")
         plt.legend()
         plt.show()
 
-
     def test_ellipse_error(self):
         x_radii = range(3, 30)
-        y_radii = [np.ceil(2.5*r) for r in x_radii]
-        ellipses = [ellipse_perimeter(x_r, y_r)
-                    for x_r, y_r in zip(x_radii, y_radii)]
+        y_radii = [np.ceil(2.5 * r) for r in x_radii]
+        ellipses = [ellipse_perimeter(x_r, y_r) for x_r, y_r in zip(x_radii, y_radii)]
         con = [conical(ellipse) for ellipse in ellipses]
         spheres = [union_of_spheres(ellipse) for ellipse in ellipses]
-        mVol = np.array([4 / 3 * np.pi * np.sqrt(ndimage.binary_fill_holes(
-            ellipse).sum() / np.pi) ** 3 for ellipse in ellipses])
-        true = np.array([4 * np.pi * x_r * y_r * x_r / 3
-                         for x_r, y_r in zip(x_radii, y_radii)])
-        plt.scatter(true, con, label='Conical')
-        plt.scatter(true, spheres, label='Spheres')
-        plt.scatter(true, mVol, label='mVol')
-        plt.plot(true, true, 'k-')
+        mVol = np.array(
+            [
+                4
+                / 3
+                * np.pi
+                * np.sqrt(ndimage.binary_fill_holes(ellipse).sum() / np.pi) ** 3
+                for ellipse in ellipses
+            ]
+        )
+        true = np.array(
+            [4 * np.pi * x_r * y_r * x_r / 3 for x_r, y_r in zip(x_radii, y_radii)]
+        )
+        plt.scatter(true, con, label="Conical")
+        plt.scatter(true, spheres, label="Spheres")
+        plt.scatter(true, mVol, label="mVol")
+        plt.plot(true, true, "k-")
         plt.xlabel("Analytical")
         plt.ylabel("Estimated")
         plt.title("Ellipse")
@@ -65,24 +78,30 @@ class VolumeEstimation(unittest.TestCase):
 
     def test_minor_major_error(self):
         r = np.random.choice(list(range(3, 30)))
-        x_radii = np.linspace(r/3, r, 20)
-        y_radii = r**2/x_radii
+        x_radii = np.linspace(r / 3, r, 20)
+        y_radii = r ** 2 / x_radii
 
-        ellipses = [ellipse_perimeter(x_r, y_r)
-                    for x_r, y_r in zip(x_radii, y_radii)]
+        ellipses = [ellipse_perimeter(x_r, y_r) for x_r, y_r in zip(x_radii, y_radii)]
         con = np.array([conical(ellipse) for ellipse in ellipses])
         spheres = np.array([union_of_spheres(ellipse) for ellipse in ellipses])
-        mVol = np.array([4 / 3 * np.pi * np.sqrt(ndimage.binary_fill_holes(
-            ellipse).sum() / np.pi) ** 3
-                for ellipse in ellipses])
-
-        true = np.array([4 * np.pi * x_r * y_r * x_r / 3
-                         for x_r, y_r in zip(x_radii, y_radii)])
-
-        ratio = y_radii/x_radii
-        plt.scatter(ratio, con/true, label='Conical')
-        plt.scatter(ratio, spheres/true, label='Spheres')
-        plt.scatter(ratio, mVol/true, label='mVol')
+        mVol = np.array(
+            [
+                4
+                / 3
+                * np.pi
+                * np.sqrt(ndimage.binary_fill_holes(ellipse).sum() / np.pi) ** 3
+                for ellipse in ellipses
+            ]
+        )
+
+        true = np.array(
+            [4 * np.pi * x_r * y_r * x_r / 3 for x_r, y_r in zip(x_radii, y_radii)]
+        )
+
+        ratio = y_radii / x_radii
+        plt.scatter(ratio, con / true, label="Conical")
+        plt.scatter(ratio, spheres / true, label="Spheres")
+        plt.scatter(ratio, mVol / true, label="mVol")
         plt.xlabel("Major/Minor")
         plt.ylabel("Estimated / Analytical")
         plt.title(f"Error by circularity, r = {r}")
@@ -90,9 +109,5 @@ class VolumeEstimation(unittest.TestCase):
         plt.show()
 
 
-
-
-
-
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

tests/test_tiler.py → tests/aliby/test_tiler.py

 import argparse
 
-from core.experiment import ExperimentLocal
-from core.segment import Tiler
+from aliby.experiment import ExperimentLocal
+from aliby.tile.tiler import Tiler
 
 
 def define_parser():
     parser = argparse.ArgumentParser()
-    parser.add_argument('root_dir')
-    parser.add_argument('--position', default=None)
-    parser.add_argument('--template', default=None)
-    parser.add_argument('--trap', type=int, default=0)
-    parser.add_argument('--channel', type=str, default='Brightfield')
-    parser.add_argument('-z', '--z_positions', type=int, default=5)
-    parser.add_argument('--time', type=int, default=0)
-    parser.add_argument('--tile_size', type=int, default=96)
+    parser.add_argument("root_dir")
+    parser.add_argument("--position", default=None)
+    parser.add_argument("--template", default=None)
+    parser.add_argument("--trap", type=int, default=0)
+    parser.add_argument("--channel", type=str, default="Brightfield")
+    parser.add_argument("-z", "--z_positions", type=int, default=5)
+    parser.add_argument("--time", type=int, default=0)
+    parser.add_argument("--tile_size", type=int, default=96)
     return parser
 
 
@@ -30,20 +30,24 @@ def change_position(position, tiler):
 def get_n_traps_timepoints(tiler):
     return tiler.n_traps, tiler.n_timepoints
 
+
 def trap_timelapse(tiler, trap_idx, channel, z):
     channel_id = tiler.get_channel_index(channel)
-    timelapse = tiler.get_trap_timelapse(trap_idx, channels=[channel_id],
-                                         z=list(range(z)))
+    timelapse = tiler.get_trap_timelapse(
+        trap_idx, channels=[channel_id], z=list(range(z))
+    )
     return timelapse
 
+
 def timepoint_traps(tiler, tp_idx, channel, z, tile_size):
     channel_id = tiler.get_channel_index(channel)
-    traps = tiler.get_traps_timepoint(tp_idx, tile_size=tile_size,
-                                      channels=[channel_id], z=list(range(z)))
+    traps = tiler.get_traps_timepoint(
+        tp_idx, tile_size=tile_size, channels=[channel_id], z=list(range(z))
+    )
     return traps
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     parser = define_parser()
     args = parser.parse_args()
 
@@ -54,10 +58,7 @@ if __name__ == '__main__':
 
     n_traps, n_tps = get_n_traps_timepoints(tiler)
 
-    timelapse = trap_timelapse(tiler, args.trap, args.channel,
-                               args.z_positions)
-    traps = timepoint_traps(tiler, args.time, args.channel, args.z_positions,
-                           args.tile_size)
-
-
-
+    timelapse = trap_timelapse(tiler, args.trap, args.channel, args.z_positions)
+    traps = timepoint_traps(
+        tiler, args.time, args.channel, args.z_positions, args.tile_size
+    )

tests/test_traps.py → tests/aliby/test_traps.py

 import unittest
 import numpy as np
 
-from agora.tile.traps import identify_trap_locations
+from aliby.tile.traps import identify_trap_locations
 
 
 class TestCase(unittest.TestCase):