Simple-Track 2.1.0__tar.gz → 2.2.1__tar.gz

{simple_track-2.1.0 → simple_track-2.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Simple-Track
-Version: 2.1.0
+Version: 2.2.1
 Summary: Threshold-based object tracking algorithm for 2D data 
 Author-email: Adam Gainford <adam.gainford@reading.ac.uk>, Thorwald Stein <t.h.m.stein@reading.ac.uk>
 License-Expression: MPL-2.0
@@ -52,8 +52,6 @@ While Simple-Track is designed to accept a wide range of input data, certain req
 
 * The input data must be gridded and contain a consistent spatial domain and resolution between frames.
 
-* The input grid must be evenly shaped (this will be relaxed in the future)
-
 * The features of interest must be defined by a threshold value, and these features must translate as a result of a spatially consistent background flow.
 
 * The time between frames should be sufficiently short such that features can be reasonably expected to persist between frames. This is not a strict requirement since the tool includes an artificial advection step that projects data onto a common time, but it is likely that longer time steps will lead to more errors in feature matching and therefore less accurate tracking statistics. 

{simple_track-2.1.0 → simple_track-2.2.1}/README.md

@@ -30,8 +30,6 @@ While Simple-Track is designed to accept a wide range of input data, certain req
 
 * The input data must be gridded and contain a consistent spatial domain and resolution between frames.
 
-* The input grid must be evenly shaped (this will be relaxed in the future)
-
 * The features of interest must be defined by a threshold value, and these features must translate as a result of a spatially consistent background flow.
 
 * The time between frames should be sufficiently short such that features can be reasonably expected to persist between frames. This is not a strict requirement since the tool includes an artificial advection step that projects data onto a common time, but it is likely that longer time steps will lead to more errors in feature matching and therefore less accurate tracking statistics. 

{simple_track-2.1.0 → simple_track-2.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "Simple-Track"
-version = "2.1.0"
+version = "2.2.1"
 authors = [
   { name="Adam Gainford", email="adam.gainford@reading.ac.uk" },
   { name="Thorwald Stein", email="t.h.m.stein@reading.ac.uk"} 
@@ -43,4 +43,4 @@ testpaths = ["tests"]
 
 [tool.ruff.lint]
 select = ["E", "F", "B", "I", "UP", "SIM", "D101"]
-ignore = ["SIM102"]
+ignore = ["SIM102"]

{simple_track-2.1.0 → simple_track-2.2.1}/src/Simple_Track.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Simple-Track
-Version: 2.1.0
+Version: 2.2.1
 Summary: Threshold-based object tracking algorithm for 2D data 
 Author-email: Adam Gainford <adam.gainford@reading.ac.uk>, Thorwald Stein <t.h.m.stein@reading.ac.uk>
 License-Expression: MPL-2.0
@@ -52,8 +52,6 @@ While Simple-Track is designed to accept a wide range of input data, certain req
 
 * The input data must be gridded and contain a consistent spatial domain and resolution between frames.
 
-* The input grid must be evenly shaped (this will be relaxed in the future)
-
 * The features of interest must be defined by a threshold value, and these features must translate as a result of a spatially consistent background flow.
 
 * The time between frames should be sufficiently short such that features can be reasonably expected to persist between frames. This is not a strict requirement since the tool includes an artificial advection step that projects data onto a common time, but it is likely that longer time steps will lead to more errors in feature matching and therefore less accurate tracking statistics. 

{simple_track-2.1.0 → simple_track-2.2.1}/src/simpletrack/feature.py

@@ -311,11 +311,12 @@ class Feature:
 
         # Reverse eigenvectors to be in (y,x) format, consistent with rest of package
         # Native converts from numpy type to python type
+        # Real ensures types are not complex, which can happen with PCA decomposition
         return (
-            native(major_unit_vector[::-1]),
-            native(minor_unit_vector[::-1]),
-            native(major_diameter / 2),
-            native(minor_diameter / 2),
+            native(np.real(major_unit_vector[::-1])),
+            native(np.real(minor_unit_vector[::-1])),
+            native(np.real(major_diameter / 2)),
+            native(np.real(minor_diameter / 2)),
         )
 
     def calculate_centroid(self) -> tuple:

{simple_track-2.1.0 → simple_track-2.2.1}/src/simpletrack/flow_solver.py

@@ -55,9 +55,15 @@ class FlowSolver:
                 Defaults to True.
         """
         if isinstance(subdomain_size, int):
+            if subdomain_size % 2 != 0:
+                raise ValueError(
+                    f"Expected subdomain_size to be even, got {subdomain_size}"
+                )
             self.subdomain_shape = np.array([subdomain_size, subdomain_size], dtype=int)
-        elif isinstance(subdomain_size, float):
-            raise TypeError("Expected int or array-like, got float")
+        elif isinstance(subdomain_size, (float, str)):
+            raise TypeError(
+                f"Expected int or array-like, got type{type(subdomain_size)}"
+            )
         elif subdomain_size is None:
             self.subdomain_shape = None
         else:
@@ -108,9 +114,16 @@ class FlowSolver:
             prev_features, current_features, equal_shape=True, ndim=2, dtype=int
         )
 
+        # If input arrays are not an even/"nice" shape, pad them to the next order of
+        # magnitude. This is required for an integer number of overlapping subdomains
+        # fit into the domain. Flow field will be cropped to original shape
+        input_shape = prev_features.shape
+        prev_features = self.pad_to_max_order_of_magnitude(prev_features)
+        current_features = self.pad_to_max_order_of_magnitude(current_features)
+
         # Determine a subdomain size if not provided
         if self.subdomain_shape is None:
-            self.subdomain_shape = self.get_subdomain_shape(prev_features.shape)
+            self.subdomain_shape = self.setup_subdomain_shape(prev_features.shape)
 
         # Check inputs, don't proceed if not validated
         prev_features, current_features = self._check_inputs(
@@ -163,16 +176,67 @@ class FlowSolver:
             interior_y_subdom_bounds,
             interior_x_subdom_bounds,
             subdomain_dy,
-            prev_features.shape,
+            input_shape,
         )
         x_flow = self.interpolate_subdomain_flows(
             interior_y_subdom_bounds,
             interior_x_subdom_bounds,
             subdomain_dx,
-            prev_features.shape,
+            input_shape,
         )
         return y_flow, x_flow
 
+    def pad_to_max_order_of_magnitude(self, arr: np.ndarray) -> np.ndarray:
+        """
+        Pad an array with zeros so each dimension is rounded up to the maximum order of
+        magnitude across all dimensions.
+        """
+
+        def _get_magnitude(n: int) -> int:
+            if n <= 1:
+                return 1
+            return 10 ** np.floor(np.log10(n))
+
+        def _round_to_magnitude(n: int, magnitude: int) -> int:
+            return int(np.ceil(n / magnitude) * magnitude)
+
+        # Get the maximum order of magnitude across all dimensions
+        magnitudes = [_get_magnitude(s) for s in arr.shape]
+        max_magnitude = max(magnitudes)
+
+        # Round each dimension to the next multiple of max_magnitude
+        target_shape = tuple(_round_to_magnitude(s, max_magnitude) for s in arr.shape)
+        pad_width = tuple(
+            (0, t - s) for s, t in zip(arr.shape, target_shape, strict=True)
+        )
+
+        return np.pad(arr, pad_width, mode="constant", constant_values=0)
+
+    def setup_subdomain_shape(self, feature_field_shape: np.ndarray) -> np.ndarray:
+        """
+        Set up the subdomain shape based on the feature field shape.
+        If the subdomain shape has already been set in init, this will
+        check that the subdomain shape can fit into the feature field shape.
+
+        Args:
+            feature_field_shape (np.ndarray): Shape of the feature field
+
+        Returns:
+            np.ndarray: The setup subdomain shape.
+        """
+        if self.subdomain_shape is None:
+            # Check input field shape
+            sd_shape = np.array(feature_field_shape) // 5
+        if not self.check_subdomain_size_fits_in_full_domain(
+            feature_field_shape, sd_shape
+        ):
+            # TODO: do something more intelligent here rather than just raise an error
+            # Try to find another subdomain shape that could fit
+            raise Exception(
+                f"Subdomain shape ({sd_shape}) cannot fit ({feature_field_shape})"
+            )
+        return sd_shape
+
     def get_subdomain_containment_arrays(
         self, full_domain_shape: NDArray, subdomain_shape: NDArray
     ) -> list[NDArray, NDArray]:
@@ -276,23 +340,6 @@ class FlowSolver:
         subdomain_vals[invalid_tolerance] = np.nan
         return subdomain_vals
 
-    def get_subdomain_shape(self, feature_field_shape):
-        # TODO: figure out some logic here for getting a good sd size
-        # if none is provided.
-        # Use this for now, but it won't work in all cases!
-        # TODO: this is entirely arbitrary. Check if this is sensible. It probably isnt
-        # TODO: what if domain is an odd shape?? What then??
-        sd_shape = np.array(feature_field_shape) // 5
-        if not self.check_subdomain_size_fits_in_full_domain(
-            feature_field_shape, sd_shape
-        ):
-            # TODO: do something more intelligent here rather than just raise an error
-            # Try to find another subdomain shape that could fit
-            raise Exception(
-                f"Subdomain shape ({sd_shape}) cannot fit ({feature_field_shape})"
-            )
-        return sd_shape
-
     def check_subdomain_size_fits_in_full_domain(
         self, feature_field_shape: NDArray, subdomain_shape: NDArray
     ) -> bool:
@@ -538,7 +585,7 @@ class FlowSolver:
         subdomain_count = np.prod(self.subdomain_shape)
         min_feature_coverage = subdomain_count * self.min_fractional_coverage
         if np.sum(arr1) < min_feature_coverage or np.sum(arr2) < min_feature_coverage:
-            print(f"Threshold for running optical flow: {self.min_fractional_coverage}")
+            print(f"Threshold for running optical flow: {min_feature_coverage}")
             print(f"Number of pixels above threshold in arr1: {np.sum(arr1)}")
             print(f"Number of pixels above threshold in arr2: {np.sum(arr2)}")
             print("Number of features in arr1 and/or arr2 less than threshold. ")

{simple_track-2.1.0 → simple_track-2.2.1}/src/simpletrack/frame.py

@@ -1,4 +1,5 @@
 import datetime as dt
+import warnings
 
 import numpy as np
 import scipy.ndimage as ndimage
@@ -280,15 +281,21 @@ class Frame:
         Update the feature_field to reflect provisional ids.
         """
         if self._feature_field is None:
-            raise FeaturesNotFoundError(
-                "Feature field is not set. Cannot update using provisional ids."
+            print(
+                UserWarning(
+                    "Feature field is not set. Cannot update using provisional ids."
+                )
             )
+            return
 
         if not self._features:
-            raise FeaturesNotFoundError(
-                "Features have not been loaded into this Frame. "
-                "Cannot update using provisional ids."
+            print(
+                UserWarning(
+                    "Features have not been loaded into this Frame. "
+                    "Cannot update using provisional ids."
+                )
             )
+            return
 
         updated_feature_field = np.zeros_like(self._feature_field)
         updated_lifetime_field = np.zeros_like(self._feature_field)

{simple_track-2.1.0 → simple_track-2.2.1}/src/simpletrack/frame_tracker.py

@@ -768,13 +768,13 @@ class FrameTracker:
         # Set the first value of the hist to 0 since this represents the background
         overlap_hist[0] = 0
 
-        # Normalise overlap histogram by size of each feature in advected field only
-        norm_sizes = np.array(
-            [
-                np.count_nonzero(advected_feature_field == idx)
-                for idx in range(len(overlap_hist))
-            ]
-        )
+        # Normalise overlap histogram by size of each feature in advected field only.
+        # bincount computes all per-id pixel counts in a single pass; the previous
+        # per-id np.count_nonzero loop was O(max_id * domain) and dominated runtime
+        # for long sequences (feature_field holds persistent ids, which grow large).
+        norm_sizes = np.bincount(
+            advected_feature_field.ravel(), minlength=len(overlap_hist)
+        )[: len(overlap_hist)]
         # Replace any zero sizes with 1 to avoid division by zero
         norm_sizes = np.where(norm_sizes == 0, 1, norm_sizes)
         overlap_normed = overlap_hist / norm_sizes

{simple_track-2.1.0 → simple_track-2.2.1}/src/simpletrack/load.py

@@ -43,16 +43,7 @@ class BaseLoader:
         # Check consistency of data shape
         if self.domain_shape is None:
             self.domain_shape = output_arr.shape
-            # Check that the domain sizes are even.
-            # This requirement will ideally be relaxed in future
-            # but currently required for flow_solver to work correctly.
-            if not all([size % 2 == 0 for size in self.domain_shape]):
-                msg = (
-                    "Simple-Track requires even domain sizes, "
-                    + f"input is shape {self.domain_shape}. Consider"
-                    + " padding or cropping your data to meet this requirement."
-                )
-                raise ValueError(msg)
+
         output_arr = check_arrays(output_arr, shape=self.domain_shape, ndim=2)
 
         # Check output time is a sensible type

{simple_track-2.1.0 → simple_track-2.2.1}/src/simpletrack/track.py

@@ -152,8 +152,15 @@ class Tracker:
 
             # Now run flow solver between previous and current frame
             prev_frame = self.timeline.get_previous_frame(frame.time)
-            # Set max id for assigning to new features
-            frame.max_id = prev_frame.max_id
+            # Set max id for assigning to new features.
+            # An all-quiet first frame leaves prev_frame.max_id None
+            # (identify_features returns early without setting it when no
+            # features are above threshold). Skip the carry-forward then;
+            # get_next_available_feature_id lazily initialises max_id from the
+            # frame's own feature_field, and there are no earlier ids to collide
+            # with.
+            if prev_frame.max_id is not None:
+                frame.max_id = prev_frame.max_id
             # Get the flow field that translates features between the two frames
             y_flow, x_flow = self.flow_solver.analyse_flow(prev_frame, frame)
 

{simple_track-2.1.0 → simple_track-2.2.1}/tests/test_flow_solver.py

@@ -573,7 +573,9 @@ def test_multiple_unequal_feature_unequal_flow_advection(
 @pytest.mark.parametrize(
     "test_dy_f0, test_dx_f0, test_dy_f1, test_dx_f1, f1_y_growth, expected_dy, expected_dx",
     [
-        [10, 0, 0, 0, 7, 7, 0],  # F0 advects, F1 grows by 7 -> expected dy = 7 (?)
+        # First test shows inconsistent behaviour between different architectures (Linux vs MacOS), needs further refinement
+        # [10, 0, 0, 0, 7, 7, 0],  # F0 advects, F1 grows by 7 -> expected dy = 7 (?)
+        # All other tests do not show the expected outcome on any architecture.
         # [10, 0, 10, 0, 7, 17, 0],  # F1 grows by 7 advects by 10, should get dy = 17, get 0
         # [0, 0, 0, 5, 7, 7, 5], # F1 grows by 7 and dx=5, expect dy=7 and dx=5. get dy=0
         # [0, 0, 5, 5, 7, 12, 5],  # Expect dy=12, get 0
@@ -621,7 +623,8 @@ def test_growing_feature(
         [10, 0, 15, 0, 10, 10, 0],  # F1 advects 15 but shrinks 10. Expect dy=10 from f0
         [0, 10, 0, 15, 5, 0, 10],  # Similar behaviour if just dx rather than just dy
         [10, 10, 15, 15, 5, 10, 10],  # Also works if features move in diagonal
-        [0, 0, 10, 10, 5, 0, 0],  # If f0 is stationary but f1 moves, solver picks f0
+        # Inconsistent behaviour between different architectures (Linux vs MacOS), needs further refinement
+        # [0, 0, 10, 10, 5, 0, 0],  # If f0 is stationary but f1 moves, solver picks f0
         [10, 10, 0, 0, 5, 10, 10],  # If f0 moves and f1 is stationary, solver picks f0
     ],
 )
@@ -720,3 +723,43 @@ def test_subdomain_iter(
         assert result == expected_subdomain_iter
     except expected_subdomain_iter:
         pass
+
+
+@pytest.mark.parametrize(
+    "subdomain_size, expected_error",
+    [
+        [9, ValueError],  # Odd subdomain size
+        [10.5, TypeError],  # Non-integer subdomain size
+        [-10, ValueError],  # Negative subdomain size
+        ["10", TypeError],  # Non-numeric subdomain size
+    ],
+)
+def test_init_catches_invalid_subdomain_size(subdomain_size, expected_error):
+    try:
+        FlowSolver(subdomain_size=subdomain_size)
+    except expected_error:
+        pass
+
+
+def test_init_accepts_valid_subdomain_size():
+    try:
+        solver = FlowSolver(subdomain_size=10)
+        np.testing.assert_array_equal(solver.subdomain_shape, np.array([10, 10]))
+    except Exception as e:
+        pytest.fail(f"Unexpected exception raised: {e}")
+
+
+@pytest.mark.parametrize(
+    "input_array, expected_output",
+    [
+        [np.zeros((10, 10)), np.zeros((10, 10))],
+        [np.zeros((5, 5)), np.zeros((5, 5))],
+        [np.zeros((21, 140)), np.zeros((100, 200))],
+        [np.zeros((230, 410)), np.zeros((300, 500))],
+        [np.zeros((3, 78)), np.zeros((10, 80))],
+        [np.zeros((4, 140)), np.zeros((100, 200))],
+    ],
+)
+def test_pad_to_max_order_of_magnitude(input_array, expected_output):
+    result = of_solver.pad_to_max_order_of_magnitude(input_array)
+    np.testing.assert_array_equal(result, expected_output)

{simple_track-2.1.0 → simple_track-2.2.1}/tests/test_frame.py

@@ -394,10 +394,8 @@ def test_update_fields_using_provisional_ids_with_no_feature_field():
     test_frame.populate_features()  # No feature field set, so no features populated
 
     # Update the feature field without setting any provisional ids
-    try:
-        test_frame.update_fields_using_provisional_ids()
-    except FeaturesNotFoundError:
-        pass
+    # Just prints a warning and returns without error
+    test_frame.update_fields_using_provisional_ids()
 
 
 def test_update_fields_using_provisional_ids_with_no_features():
@@ -406,11 +404,8 @@ def test_update_fields_using_provisional_ids_with_no_features():
     test_frame.feature_field = test_feature_field
     test_frame.populate_features()  # No features populated as feature field is all zeros
 
-    # Update the feature field without any features
-    try:
-        test_frame.update_fields_using_provisional_ids()
-    except FeaturesNotFoundError:
-        pass
+    # Update the feature field without any features. Just prints a warning
+    test_frame.update_fields_using_provisional_ids()
 
 
 def test_get_new_features():

{simple_track-2.1.0 → simple_track-2.2.1}/tests/test_frame_tracker.py

@@ -446,7 +446,8 @@ def test_overlap_histogram_with_multiple_overlaps_and_different_labels(
         ],
         [np.zeros((10), dtype=int), np.zeros((10), dtype=int), 1, 0, ArrayShapeError],
         [np.zeros((5, 10), dtype=int), zero_arr, 1, 0, ArrayShapeError],
-        [np.zeros((10, 10), dtype=float), np.zeros((10, 10)), 1, 0, ArrayTypeError],
+        # This test should pass now that check_arrays converts to int type if values don't change
+        # [np.zeros((10, 10), dtype=float), np.zeros((10, 10)), 1, 0, ArrayTypeError],
         [zero_arr, zero_arr, -1, 0, NegativeIDError],
         [zero_arr, zero_arr, 1.5, 0, FloatIDError],
         [zero_arr, zero_arr, 0, 0, ZeroIDError],

{simple_track-2.1.0 → simple_track-2.2.1}/tests/test_mwe_output.py

@@ -50,6 +50,12 @@ def generate_mwe_files(save_path=None):
     # Cells merge
     mwe_dt8[35:60, 50:70] = 1
 
+    # Ninth timestep: no features
+    mwe_dt9 = mwe_domain.copy()
+
+    # Tenth timestep: tracking when both frames contain no features
+    mwe_dt10 = mwe_domain.copy()
+
     mwe_fields = [
         mwe_dt1,
         mwe_dt2,
@@ -59,13 +65,15 @@ def generate_mwe_files(save_path=None):
         mwe_dt6,
         mwe_dt7,
         mwe_dt8,
+        mwe_dt9,
+        mwe_dt10,
     ]
     if save_path is not None:
         # Make containing directory if it doesn't exist
         Path(save_path).mkdir(parents=True, exist_ok=True)
 
         for mwe_idx, mwe in enumerate(mwe_fields):
-            np.savetxt(f"{save_path}/mwe_dt{mwe_idx + 1}.field", mwe)
+            np.savetxt(f"{save_path}/mwe_dt{str(mwe_idx + 1).zfill(2)}.field", mwe)
     return mwe_fields
 
 
@@ -349,6 +357,19 @@ def test_seventh_mwe_outputs(mwe_timeline):
     assert np.all(frame.get_flow()) is not None
 
 
+def test_ninth_mwe_outputs(mwe_timeline):
+    """
+    Test that there are no features in the ninth timestep
+    """
+    base_time = dt.datetime(2024, 1, 1, 0, 0, 0)
+    mwe_idx = 8
+    frame_time = base_time + dt.timedelta(minutes=5 * int(mwe_idx))
+    frame = mwe_timeline.get_frame(frame_time)
+
+    # test there we are back to one feature
+    assert len(frame.features) == 0
+
+
 if __name__ == "__main__":
     mwe_file_path = "./mwe_test_files"
     Path(mwe_file_path).mkdir(parents=True, exist_ok=True)