celldetective 1.4.2__py3-none-any.whl → 1.5.0b0__py3-none-any.whl

tests/gui/test_project.py

@@ -1,99 +1,147 @@
 import pytest
 from PyQt5 import QtCore
+
+import celldetective.gui.preprocessing_block
 from celldetective.gui.InitWindow import AppInitWindow
-from celldetective.utils import get_software_location
+from celldetective import get_software_location
 import os
 
 software_location = get_software_location()
 
+
 @pytest.fixture
 def app(qtbot):
-	test_app = AppInitWindow(software_location=software_location)
-	qtbot.addWidget(test_app)
-	return test_app
+    test_app = AppInitWindow(software_location=software_location)
+    qtbot.addWidget(test_app)
+    return test_app
+
 
 def test_open_project(app, qtbot):
-	app.experiment_path_selection.setText(software_location + os.sep + 'examples/demo')
-	qtbot.mouseClick(app.validate_button, QtCore.Qt.LeftButton)
-	qtbot.wait(10000)
+    app.experiment_path_selection.setText(software_location + os.sep + "examples/demo")
+    qtbot.mouseClick(app.validate_button, QtCore.Qt.LeftButton)
+    qtbot.wait(10000)
+
 
 def test_launch_demo(app, qtbot):
-	app.experiment_path_selection.setText(software_location + os.sep + 'examples/demo')
-	qtbot.mouseClick(app.validate_button, QtCore.Qt.LeftButton)
+    app.experiment_path_selection.setText(software_location + os.sep + "examples/demo")
+    qtbot.mouseClick(app.validate_button, QtCore.Qt.LeftButton)
+
 
 def test_preprocessing_panel(app, qtbot):
 
-	app.experiment_path_selection.setText(software_location + os.sep + 'examples/demo')
-	qtbot.mouseClick(app.validate_button, QtCore.Qt.LeftButton)
+    app.experiment_path_selection.setText(software_location + os.sep + "examples/demo")
+    qtbot.mouseClick(app.validate_button, QtCore.Qt.LeftButton)
+
+    qtbot.mouseClick(
+        app.control_panel.PreprocessingPanel.collapse_btn,
+        QtCore.Qt.LeftButton,
+    )
+    qtbot.mouseClick(
+        app.control_panel.PreprocessingPanel.fit_correction_layout.add_correction_btn,
+        QtCore.Qt.LeftButton,
+    )
+    qtbot.mouseClick(
+        app.control_panel.PreprocessingPanel.collapse_btn,
+        QtCore.Qt.LeftButton,
+    )
 
-	qtbot.mouseClick(app.control_panel.PreprocessingPanel.collapse_btn, QtCore.Qt.LeftButton)
-	qtbot.mouseClick(app.control_panel.PreprocessingPanel.fit_correction_layout.add_correction_btn, QtCore.Qt.LeftButton)
-	qtbot.mouseClick(app.control_panel.PreprocessingPanel.collapse_btn, QtCore.Qt.LeftButton)
 
 def test_app(app, qtbot):
 
-	# Set an experiment folder and open
-	app.experiment_path_selection.setText(os.sep.join([software_location,'examples','demo']))
-	qtbot.mouseClick(app.validate_button, QtCore.Qt.LeftButton)
-
-	# Set a position
-	#app.control_panel.position_list.setCurrentIndex(0)
-	#app.control_panel.update_position_options()
-
-	# View stacl
-	qtbot.mouseClick(app.control_panel.view_stack_btn, QtCore.Qt.LeftButton)
-	#qtbot.wait(1000)
-	app.control_panel.viewer.close()
-
-	# Expand process block
-	qtbot.mouseClick(app.control_panel.ProcessPopulations[0].collapse_btn, QtCore.Qt.LeftButton)
-
-	# Use Threshold Config Wizard
-	qtbot.mouseClick(app.control_panel.ProcessPopulations[0].upload_model_btn, QtCore.Qt.LeftButton)
-	qtbot.wait(1000)
-	qtbot.mouseClick(app.control_panel.ProcessPopulations[0].SegModelLoader.threshold_config_button, QtCore.Qt.LeftButton)
-	app.control_panel.ProcessPopulations[0].SegModelLoader.ThreshWizard.close()
-	app.control_panel.ProcessPopulations[0].SegModelLoader.close()
-
-	# Check segmentation with napari
-	#qtbot.mouseClick(app.control_panel.ProcessEffectors.check_seg_btn, QtCore.Qt.LeftButton)
-	# close napari?
-
-	# Train model
-	qtbot.mouseClick(app.control_panel.ProcessPopulations[0].train_btn, QtCore.Qt.LeftButton)
-	qtbot.wait(1000)
-	app.control_panel.ProcessPopulations[0].settings_segmentation_training.close()
-
-	# Config tracking
-	qtbot.mouseClick(app.control_panel.ProcessPopulations[0].track_config_btn, QtCore.Qt.LeftButton)
-	qtbot.wait(1000)
-	app.control_panel.ProcessPopulations[0].settings_tracking.close()
-
-	# Config measurements
-	qtbot.mouseClick(app.control_panel.ProcessPopulations[0].measurements_config_btn, QtCore.Qt.LeftButton)
-	qtbot.wait(1000)
-	app.control_panel.ProcessPopulations[0].settings_measurements.close()
-
-	# Classifier widget
-	qtbot.mouseClick(app.control_panel.ProcessPopulations[0].classify_btn, QtCore.Qt.LeftButton)
-	qtbot.wait(1000)
-	app.control_panel.ProcessPopulations[0].ClassifierWidget.close()
-
-	# Config signal annotator
-	qtbot.mouseClick(app.control_panel.ProcessPopulations[0].config_signal_annotator_btn, QtCore.Qt.LeftButton)
-	qtbot.mouseClick(app.control_panel.ProcessPopulations[0].settings_signal_annotator.rgb_btn, QtCore.Qt.LeftButton)
-	qtbot.wait(1000)
-	app.control_panel.ProcessPopulations[0].settings_signal_annotator.close()
-
-	# Signal annotator widget
-	qtbot.mouseClick(app.control_panel.ProcessPopulations[0].check_signals_btn, QtCore.Qt.LeftButton)
-	qtbot.wait(1000)
-	app.control_panel.ProcessPopulations[0].event_annotator.close()
-
-	# Table widget
-	qtbot.mouseClick(app.control_panel.ProcessPopulations[0].view_tab_btn, QtCore.Qt.LeftButton)
-	qtbot.wait(1000)
-	app.control_panel.ProcessPopulations[0].tab_ui.close()
-
-	#qtbot.mouseClick(app.control_panel.PreprocessingPanel.fit_correction_layout.add_correction_btn, QtCore.Qt.LeftButton)
-	qtbot.mouseClick(app.control_panel.ProcessPopulations[0].collapse_btn, QtCore.Qt.LeftButton)
+    # Set an experiment folder and open
+    app.experiment_path_selection.setText(
+        os.sep.join([software_location, "examples", "demo"])
+    )
+    qtbot.mouseClick(app.validate_button, QtCore.Qt.LeftButton)
+
+    # Set a position
+    # app.control_panel.position_list.setCurrentIndex(0)
+    # app.control_panel.update_position_options()
+
+    # View stacl
+    qtbot.mouseClick(app.control_panel.view_stack_btn, QtCore.Qt.LeftButton)
+    # qtbot.wait(1000)
+    app.control_panel.viewer.close()
+
+    # Expand process block
+    qtbot.mouseClick(
+        app.control_panel.ProcessPopulations[0].collapse_btn, QtCore.Qt.LeftButton
+    )
+
+    # Use Threshold Config Wizard
+    qtbot.mouseClick(
+        app.control_panel.ProcessPopulations[0].upload_model_btn, QtCore.Qt.LeftButton
+    )
+    qtbot.wait(1000)
+    qtbot.mouseClick(
+        app.control_panel.ProcessPopulations[
+            0
+        ].seg_model_loader.threshold_config_button,
+        QtCore.Qt.LeftButton,
+    )
+    app.control_panel.ProcessPopulations[0].seg_model_loader.thresh_wizard.close()
+    app.control_panel.ProcessPopulations[0].seg_model_loader.close()
+
+    # Check segmentation with napari
+    # qtbot.mouseClick(app.control_panel.ProcessEffectors.check_seg_btn, QtCore.Qt.LeftButton)
+    # close napari?
+
+    # Train model
+    qtbot.mouseClick(
+        app.control_panel.ProcessPopulations[0].train_btn, QtCore.Qt.LeftButton
+    )
+    qtbot.wait(1000)
+    app.control_panel.ProcessPopulations[0].settings_segmentation_training.close()
+
+    # Config tracking
+    qtbot.mouseClick(
+        app.control_panel.ProcessPopulations[0].track_config_btn, QtCore.Qt.LeftButton
+    )
+    qtbot.wait(1000)
+    app.control_panel.ProcessPopulations[0].settings_tracking.close()
+
+    # Config measurements
+    qtbot.mouseClick(
+        app.control_panel.ProcessPopulations[0].measurements_config_btn,
+        QtCore.Qt.LeftButton,
+    )
+    qtbot.wait(1000)
+    app.control_panel.ProcessPopulations[0].settings_measurements.close()
+
+    # Classifier widget
+    qtbot.mouseClick(
+        app.control_panel.ProcessPopulations[0].classify_btn, QtCore.Qt.LeftButton
+    )
+    qtbot.wait(1000)
+    app.control_panel.ProcessPopulations[0].classifier_widget.close()
+
+    # Config signal annotator
+    qtbot.mouseClick(
+        app.control_panel.ProcessPopulations[0].config_signal_annotator_btn,
+        QtCore.Qt.LeftButton,
+    )
+    qtbot.mouseClick(
+        app.control_panel.ProcessPopulations[0].settings_signal_annotator.rgb_btn,
+        QtCore.Qt.LeftButton,
+    )
+    qtbot.wait(1000)
+    app.control_panel.ProcessPopulations[0].settings_signal_annotator.close()
+
+    # Signal annotator widget
+    qtbot.mouseClick(
+        app.control_panel.ProcessPopulations[0].check_signals_btn, QtCore.Qt.LeftButton
+    )
+    qtbot.wait(1000)
+    app.control_panel.ProcessPopulations[0].event_annotator.close()
+
+    # Table widget
+    qtbot.mouseClick(
+        app.control_panel.ProcessPopulations[0].view_tab_btn, QtCore.Qt.LeftButton
+    )
+    qtbot.wait(1000)
+    app.control_panel.ProcessPopulations[0].tab_ui.close()
+
+    # qtbot.mouseClick(app.control_panel.PreprocessingPanel.fit_correction_layout.add_correction_btn, QtCore.Qt.LeftButton)
+    qtbot.mouseClick(
+        app.control_panel.ProcessPopulations[0].collapse_btn, QtCore.Qt.LeftButton
+    )

tests/test_filters.py

@@ -1,24 +1,48 @@
 import unittest
 import numpy as np
-from celldetective.filters import gauss_filter, abs_filter
+from celldetective.filters import gauss_filter, abs_filter, filter_image
 
 
 class TestFilters(unittest.TestCase):
 
-	@classmethod
-	def setUpClass(self):
-		self.img = np.ones((256,256),dtype=int)
-		self.img[100:110,100:110] = 0
-		self.gauss_sigma = 1.6
+    @classmethod
+    def setUpClass(self):
+        self.img = np.ones((256, 256), dtype=int)
+        self.img[100:110, 100:110] = 0
+        self.gauss_sigma = 1.6
 
-	def test_gauss_filter_is_float(self):
-		self.assertIsInstance(gauss_filter(self.img, self.gauss_sigma)[0,0], float)
-	
-	def test_gauss_filter_has_same_shape(self):
-		self.assertEqual(gauss_filter(self.img, self.gauss_sigma).shape, self.img.shape)
+    def test_gauss_filter_is_float(self):
+        self.assertIsInstance(gauss_filter(self.img, self.gauss_sigma)[0, 0], float)
 
-	def test_abs_filter_is_positive(self):
-		self.assertTrue(np.all(abs_filter(self.img) >= 0.))
+    def test_gauss_filter_has_same_shape(self):
+        self.assertEqual(gauss_filter(self.img, self.gauss_sigma).shape, self.img.shape)
 
-if __name__=="__main__":
-	unittest.main()
+    def test_abs_filter_is_positive(self):
+        self.assertTrue(np.all(abs_filter(self.img) >= 0.0))
+
+    def test_filter_image_none(self):
+        # Should return original image if filters is None
+        res = filter_image(self.img, filters=None)
+        np.testing.assert_array_equal(res, self.img)
+
+    def test_filter_image_single(self):
+        # Test with a single filter: e.g. abs
+        # Create an image with negatives
+        img_neg = self.img.copy() * -1
+        res = filter_image(img_neg, filters=[("abs",)])
+        self.assertTrue(np.all(res >= 0))
+        np.testing.assert_array_almost_equal(res, np.abs(img_neg))
+
+    def test_filter_image_chain(self):
+        # Test chaining: subtract 10 then abs
+        # Start with ones. Subtract 10 -> -9. Abs -> 9.
+        img = np.ones((5, 5), dtype=float)
+        filters = [("subtract", 10), ("abs",)]
+        res = filter_image(img, filters=filters)
+        expected = np.abs(img - 10)
+        np.testing.assert_array_almost_equal(res, expected)
+        self.assertTrue(np.allclose(res, 9.0))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_notebooks.py

@@ -0,0 +1,8 @@
+# test_notebooks.py
+import nbformat
+from nbclient import NotebookClient
+
+def test_notebook_runs():
+    nb = nbformat.read("../demos/ADCC_analysis_demo.ipynb", as_version=4)
+    client = NotebookClient(nb, timeout=600, kernel_name="python3")
+    client.execute()  # raises exception if any cell fails

tests/test_tracking.py

@@ -6,6 +6,11 @@ from celldetective.tracking import (
     extrapolate_tracks,
     filter_by_tracklength,
     interpolate_time_gaps,
+    interpolate_nan_properties,
+    compute_instantaneous_velocity,
+    compute_instantaneous_diffusion,
+    write_first_detection_class,
+    clean_trajectories,
 )
 
 
@@ -110,19 +115,13 @@ class TestTrackInterpolation(unittest.TestCase):
 
     def test_interpolate_tracks_as_expected(self):
         self.interpolated_tracks = interpolate_time_gaps(self.tracks)
-        # Sort columns to ensure order is consistent
-        self.interpolated_tracks = self.interpolated_tracks.sort_index(axis=1)
-        self.tracks_real_intep = self.tracks_real_intep.sort_index(axis=1)
-
-        # Allow for some floating point tolerance and ignore int/float differences
-        pd.testing.assert_frame_equal(
-            self.interpolated_tracks,
-            self.tracks_real_intep,
-            check_dtype=False,
-            check_index_type=False,
-            check_column_type=False,
-            rtol=1e-5,
-            atol=1e-8,
+        # We use allclose because interpolation returns floats and strict equality might fail on some platforms
+        self.assertTrue(
+            np.allclose(
+                self.interpolated_tracks.to_numpy().astype(float),
+                self.tracks_real_intep.to_numpy().astype(float),
+                equal_nan=True,
+            )
         )
 
 
@@ -222,5 +221,225 @@ class TestTrackExtrapolation(unittest.TestCase):
         )
 
 
+class TestTrackInterpolationNaN(unittest.TestCase):
+    @classmethod
+    def setUpClass(self):
+        self.tracks = pd.DataFrame(
+            [
+                {"TRACK_ID": 0.0, "FRAME": 0, "POSITION_X": np.nan, "POSITION_Y": 15},
+                {"TRACK_ID": 0.0, "FRAME": 1, "POSITION_X": 15, "POSITION_Y": 10},
+                {"TRACK_ID": 0.0, "FRAME": 2, "POSITION_X": 20, "POSITION_Y": np.nan},
+                {"TRACK_ID": 0.0, "FRAME": 3, "POSITION_X": 25, "POSITION_Y": 0},
+                {"TRACK_ID": 1.0, "FRAME": 1, "POSITION_X": 5, "POSITION_Y": 20},
+                {
+                    "TRACK_ID": 1.0,
+                    "FRAME": 2,
+                    "POSITION_X": np.nan,
+                    "POSITION_Y": np.nan,
+                },
+                {"TRACK_ID": 1.0, "FRAME": 3, "POSITION_X": 15, "POSITION_Y": 30},
+            ]
+        )
+
+    def test_interpolate_nan(self):
+        interpolated = interpolate_nan_properties(self.tracks.copy())
+
+        # Track 0: Start NaN should be filled by first valid (bfill), End NaN should be filled by last valid (ffill)
+        # But `interpolate_per_track` uses limit_direction="both", so it acts as ffill+bfill
+
+        # Track 0, Frame 0, Pos X: Should be 15 (bfill from next)
+        self.assertEqual(
+            interpolated.loc[
+                (interpolated.TRACK_ID == 0) & (interpolated.FRAME == 0), "POSITION_X"
+            ].values[0],
+            15.0,
+        )
+
+        # Track 0, Frame 2, Pos Y: Should be (10 + 0) / 2 = 5 (linear interp)
+        self.assertEqual(
+            interpolated.loc[
+                (interpolated.TRACK_ID == 0) & (interpolated.FRAME == 2), "POSITION_Y"
+            ].values[0],
+            5.0,
+        )
+
+        # Track 1, Frame 2, Pos X: (5 + 15) / 2 = 10
+        self.assertEqual(
+            interpolated.loc[
+                (interpolated.TRACK_ID == 1) & (interpolated.FRAME == 2), "POSITION_X"
+            ].values[0],
+            10.0,
+        )
+
+
+class TestPhysics(unittest.TestCase):
+    @classmethod
+    def setUpClass(self):
+        # Linear motion: dx=1, dy=0, dt=1 -> v=1
+        self.tracks_linear = pd.DataFrame(
+            [
+                {"TRACK_ID": 0, "FRAME": 0, "POSITION_X": 0, "POSITION_Y": 0},
+                {"TRACK_ID": 0, "FRAME": 1, "POSITION_X": 1, "POSITION_Y": 0},
+                {"TRACK_ID": 0, "FRAME": 2, "POSITION_X": 2, "POSITION_Y": 0},
+            ]
+        )
+
+        # Stationary: v=0
+        self.tracks_static = pd.DataFrame(
+            [
+                {"TRACK_ID": 1, "FRAME": 0, "POSITION_X": 10, "POSITION_Y": 10},
+                {"TRACK_ID": 1, "FRAME": 1, "POSITION_X": 10, "POSITION_Y": 10},
+            ]
+        )
+
+    def test_velocity(self):
+        v_linear = compute_instantaneous_velocity(self.tracks_linear.copy())
+        # First point has NaN velocity ideally or 0 depending on implementation.
+        # Looking at code: diff() produces NaN for first element.
+        self.assertTrue(np.isnan(v_linear.iloc[0]["velocity"]))
+        self.assertTrue(np.allclose(v_linear.iloc[1:]["velocity"], 1.0))
+
+        v_static = compute_instantaneous_velocity(self.tracks_static.copy())
+        self.assertTrue(np.allclose(v_static.iloc[1:]["velocity"], 0.0))
+
+    def test_diffusion(self):
+        # Simple diffusion test
+        # Track 0: Linear motion should have diffusion related to displacement
+        d_linear = compute_instantaneous_diffusion(self.tracks_linear.copy())
+        # Diffusion computation requires 3 points (t-1, t, t+1)
+        # So for 3 points, only the middle one (index 1) might have value
+
+        # We need more points for a meaningful test or check code logic
+        # Code: if len(x) > 3: ...
+
+        tracks_long = pd.DataFrame(
+            {
+                "TRACK_ID": [0] * 5,
+                "FRAME": [0, 1, 2, 3, 4],
+                "POSITION_X": [0, 1, 2, 3, 4],
+                "POSITION_Y": [0, 0, 0, 0, 0],
+            }
+        )
+        d_long = compute_instantaneous_diffusion(tracks_long)
+        self.assertIn("diffusion", d_long.columns)
+        # Check that we have some non-nan values
+        valid_diff = d_long["diffusion"].dropna()
+        self.assertGreater(len(valid_diff), 0)
+
+
+class TestFirstDetection(unittest.TestCase):
+    def test_first_detection_start(self):
+        df = pd.DataFrame(
+            [
+                {
+                    "TRACK_ID": 0,
+                    "FRAME": 0,
+                    "POSITION_X": 10,
+                    "POSITION_Y": 10,
+                    "class_id": 1,
+                },
+                {
+                    "TRACK_ID": 0,
+                    "FRAME": 1,
+                    "POSITION_X": 11,
+                    "POSITION_Y": 11,
+                    "class_id": 1,
+                },
+            ]
+        )
+        # Track starts at frame 0 -> class 2 (invalid/start)
+        res = write_first_detection_class(df.copy())
+        self.assertEqual(res["class_firstdetection"].iloc[0], 2)
+        self.assertEqual(res["t_firstdetection"].iloc[0], -1)
+
+    def test_first_detection_middle(self):
+        df = pd.DataFrame(
+            [
+                {
+                    "TRACK_ID": 1,
+                    "FRAME": 5,
+                    "POSITION_X": 50,
+                    "POSITION_Y": 50,
+                    "class_id": 1,
+                },
+                {
+                    "TRACK_ID": 1,
+                    "FRAME": 6,
+                    "POSITION_X": 51,
+                    "POSITION_Y": 51,
+                    "class_id": 1,
+                },
+            ]
+        )
+        # Track starts at frame 5 -> class 0 (valid)
+        res = write_first_detection_class(df.copy())
+        self.assertEqual(res["class_firstdetection"].iloc[0], 0)
+        # t_first should be float(t_first) - dt (dt=1) => 5 - 1 = 4.0
+        self.assertEqual(res["t_firstdetection"].iloc[0], 4.0)
+
+    def test_first_detection_edge(self):
+        df = pd.DataFrame(
+            [
+                {
+                    "TRACK_ID": 2,
+                    "FRAME": 5,
+                    "POSITION_X": 5,
+                    "POSITION_Y": 50,
+                    "class_id": 1,
+                },  # Near edge x=5 < 20
+            ]
+        )
+        # Edge threshold default 20
+        res = write_first_detection_class(df.copy(), img_shape=(100, 100))
+        self.assertEqual(res["class_firstdetection"].iloc[0], 2)
+
+
+class TestCleanTrajectories(unittest.TestCase):
+    def test_clean_pipeline(self):
+        # A mix of short tracks, nan gaps, time gaps
+        tracks = pd.DataFrame(
+            [
+                # Short track (length 2)
+                {"TRACK_ID": 0, "FRAME": 0, "POSITION_X": 0, "POSITION_Y": 0},
+                {"TRACK_ID": 0, "FRAME": 1, "POSITION_X": 1, "POSITION_Y": 1},
+                # Good track with gap
+                {"TRACK_ID": 1, "FRAME": 0, "POSITION_X": 0, "POSITION_Y": 0},
+                {
+                    "TRACK_ID": 1,
+                    "FRAME": 2,
+                    "POSITION_X": 2,
+                    "POSITION_Y": 2,
+                },  # Time gap
+                # Track with NaN
+                {"TRACK_ID": 2, "FRAME": 0, "POSITION_X": 0, "POSITION_Y": 0},
+                {"TRACK_ID": 2, "FRAME": 1, "POSITION_X": np.nan, "POSITION_Y": 1},
+                {"TRACK_ID": 2, "FRAME": 2, "POSITION_X": 2, "POSITION_Y": 2},
+            ]
+        )
+
+        # Clean: min length 3, interpolate time, interpolate nan
+        cleaned = clean_trajectories(
+            tracks.copy(),
+            minimum_tracklength=2,
+            interpolate_position_gaps=True,
+            interpolate_na=True,
+            remove_not_in_first=False,
+            remove_not_in_last=False,
+        )
+
+        # Track 0 (len 2) is NOT > 2, so it should be gone.
+        self.assertNotIn(0, cleaned["TRACK_ID"].unique())
+
+        # Track 1 should have frame 1 filled
+        self.assertIn(1, cleaned["TRACK_ID"].unique())
+        t1 = cleaned[cleaned.TRACK_ID == 1]
+        self.assertIn(1.0, t1.FRAME.values)  # interpolated frame
+
+        # Track 2 should have nan filled
+        self.assertIn(2, cleaned["TRACK_ID"].unique())
+        t2_f1 = cleaned[(cleaned.TRACK_ID == 2) & (cleaned.FRAME == 1)]
+        self.assertFalse(np.isnan(t2_f1.POSITION_X.values[0]))
+
+
 if __name__ == "__main__":
     unittest.main()