trajectopy 5.1.4__tar.gz → 6.0.0__tar.gz

{trajectopy-5.1.4 → trajectopy-6.0.0}/.pre-commit-config.yaml

@@ -1,23 +1,32 @@
-repos:
-  - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.14.0
-    hooks:
-      - id: ruff-check
-        args: [--fix]
-      - id: ruff-format
-
-  - repo: https://github.com/astral-sh/uv-pre-commit
-    rev: 0.7.6
-    hooks:
-      - id: uv-lock
-      - id: uv-export
-
-  - repo: local
-    hooks:
-      - id: pytest
-        name: Run unit tests
-        entry: uv run pytest -q
-        language: system
-        pass_filenames: false
-        stages: [pre-commit]
-        always_run: true
+repos:
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.14.0
+    hooks:
+      - id: ruff-check
+        args: [--fix]
+      - id: ruff-format
+
+  - repo: https://github.com/astral-sh/uv-pre-commit
+    rev: 0.7.6
+    hooks:
+      - id: uv-lock
+      - id: uv-export
+
+  - repo: local
+    hooks:
+      # same check as the CI lint job: the whole package with the GUI packages, whose types trajectopy.gui needs
+      - id: mypy
+        name: Type check (mypy)
+        entry: uv run --extra gui mypy
+        language: system
+        pass_filenames: false
+        types: [python]
+        stages: [pre-commit]
+
+      - id: pytest
+        name: Run unit tests
+        entry: uv run pytest -q
+        language: system
+        pass_filenames: false
+        stages: [pre-commit]
+        always_run: true

{trajectopy-5.1.4 → trajectopy-6.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: trajectopy
-Version: 5.1.4
+Version: 6.0.0
 Summary: Trajectory Evaluation in Python
 Project-URL: Homepage, https://gereon-t.github.io/trajectopy/
 Project-URL: Documentation, https://gereon-t.github.io/trajectopy/

{trajectopy-5.1.4 → trajectopy-6.0.0}/test/test_alignment.py

@@ -8,6 +8,7 @@ from trajectopy.core.parameters import AlignmentParameters
 from trajectopy.core.rotations import Rotations
 from trajectopy.core.settings import (
     AlignmentEstimationSettings,
+    AlignmentPreprocessing,
     AlignmentSettings,
     AlignmentStochastics,
     MatchingSettings,
@@ -17,6 +18,7 @@ from trajectopy.processing.alignment import (
     estimate_alignment,
     manual_alignment,
 )
+from trajectopy.processing.lib.alignment.data import AlignmentData
 from trajectopy.processing.lib.alignment.direct import align_rotations
 
 
@@ -141,14 +143,14 @@ class TestAlignment(unittest.TestCase):
             angles=[np.random.randint(-360, 360), np.random.randint(-360, 360), np.random.randint(-360, 360)],
             degrees=True,
         )
-        trajectory_rotated.rotations = random_rot * trajectory_rotated.rotations
+        trajectory_rotated.rotations = trajectory_rotated.rotations * random_rot
 
         sensor_alignment = align_rotations(trajectory_rotated.rotations, trajectory.rotations)
 
         trajectory_rotated_back = trajectory_rotated.copy()
 
-        # apply as in Trajectory.apply_alignment()
-        trajectory_rotated_back.rotations = sensor_alignment.rotation_set * trajectory_rotated_back.rotations
+        # apply as in apply_alignment()
+        trajectory_rotated_back.rotations = trajectory_rotated_back.rotations * sensor_alignment.rotation_set
         alignment_between_back_and_original = align_rotations(trajectory_rotated_back.rotations, trajectory.rotations)
 
         np.testing.assert_allclose(
@@ -159,23 +161,80 @@ class TestAlignment(unittest.TestCase):
         )
 
     def test_rotation_alignment(self):
-        """Test alignment of rotation sets and verification of transformation accuracy."""
+        """The sensor rotation is a constant rotation in the body frame, also with changing orientations."""
         rotations_1 = Rotations.from_euler(seq="xyz", angles=np.random.rand(100, 3) * 360, degrees=True)
-        rotations_2 = (
-            Rotations.from_euler(
-                seq="xyz",
-                angles=[np.random.randint(-360, 360), np.random.randint(-360, 360), np.random.randint(-360, 360)],
-                degrees=True,
-            )
-            * rotations_1
+        sensor_rotation = Rotations.from_euler(seq="xyz", angles=[2.0, -3.0, 5.0], degrees=True)
+        rotations_2 = rotations_1 * sensor_rotation
+
+        sensor_rot_params = align_rotations(rot_from=rotations_1, rot_to=rotations_2)
+
+        np.testing.assert_allclose(np.rad2deg(sensor_rot_params.rotation), [2.0, -3.0, 5.0], atol=1e-8)
+        rotations_1_to_2 = rotations_1 * sensor_rot_params.rotation_set
+        np.testing.assert_allclose((rotations_2 - rotations_1_to_2).rotangle, 0, atol=1e-8)
+
+    def test_sensor_rotation_with_similarity_transformation(self):
+        """A mounting rotation is recovered after the similarity transformation and removed when applied."""
+        transformed, _ = transform_randomly(
+            open_loop_trajectory, similarity_enabled=True, time_shift_enabled=False, lever_enabled=False
+        )
+        sensor_rotation = Rotations.from_euler(seq="xyz", angles=[2.0, -3.0, 5.0], degrees=True)
+        transformed.rotations = transformed.rotations * sensor_rotation
+
+        settings = AlignmentSettings(
+            estimation_settings=AlignmentEstimationSettings.from_components(similarity=True, sensor_rotation=True)
+        )
+        result = estimate_alignment(open_loop_trajectory.copy(), transformed, settings, MatchingSettings())
+        np.testing.assert_allclose(np.rad2deg(result.rotation_parameters.rotation), [2.0, -3.0, 5.0], atol=1e-3)
+
+        aligned = apply_alignment(open_loop_trajectory, result, inplace=False)
+        np.testing.assert_allclose((transformed.rotations - aligned.rotations).rotangle, 0, atol=1e-5)
+
+    def test_robust_estimation_against_outliers(self):
+        """Outliers are down-weighted, so that they hardly affect the estimated parameters."""
+        transformed, groundtruth = transform_randomly(
+            open_loop_trajectory, similarity_enabled=True, time_shift_enabled=False, lever_enabled=False
         )
+        rng = np.random.default_rng(1)
+        transformed.positions.xyz += rng.normal(0, 0.02, transformed.positions.xyz.shape)
+        outliers = rng.choice(len(transformed), len(transformed) // 50, replace=False)
+        transformed.positions.xyz[outliers] += rng.normal(0, 3.0, (len(outliers), 3))
+
+        errors = {}
+        for robust in (False, True):
+            settings = AlignmentSettings(
+                estimation_settings=AlignmentEstimationSettings.from_components(similarity=True),
+                stochastics=AlignmentStochastics(robust_estimation=robust),
+                preprocessing=AlignmentPreprocessing(max_samples=0),
+            )
+            result = estimate_alignment(open_loop_trajectory.copy(), transformed, settings, MatchingSettings())
+            self.assertTrue(result.converged)
+            errors[robust] = np.max(
+                np.abs(result.position_parameters.helmert.translation - groundtruth.helmert.translation)
+            )
+        self.assertLess(errors[True], 0.005)
+        self.assertLess(errors[True], errors[False] / 5)
 
-        sensor_rot_params = align_rotations(rot_from=rotations_2, rot_to=rotations_1)
+    def test_time_window_relative_to_first_common_timestamp(self):
+        """time_start/time_end refer to the first common timestamp, not to the start of the aligned trajectory."""
+        reference = open_loop_trajectory.copy()
+        first_common = reference.timestamps[0] + 50.0
+        reference.mask(reference.timestamps >= first_common)
+        settings = AlignmentSettings(preprocessing=AlignmentPreprocessing(time_start=10.0, time_end=20.0))
 
-        rotations_2_to_1 = sensor_rot_params.rotation_set * rotations_2
-        rpy_trafo_diff = (rotations_2_to_1 - rotations_1).as_euler(seq="xyz", degrees=True)
+        data = AlignmentData(open_loop_trajectory.copy(), reference, settings, MatchingSettings())
 
-        np.testing.assert_allclose(rpy_trafo_diff, np.zeros_like(rpy_trafo_diff), atol=1e-8, rtol=1e-8)
+        self.assertGreaterEqual(data.tstamps.min(), first_common + 10.0)
+        self.assertLessEqual(data.tstamps.max(), first_common + 20.0)
+
+    def test_nothing_to_estimate_counts_as_converged(self):
+        """Without least squares parameters (e.g. only the sensor rotation), the result is not flagged."""
+        settings = AlignmentSettings(
+            estimation_settings=AlignmentEstimationSettings.from_components(similarity=False, sensor_rotation=True)
+        )
+        result = estimate_alignment(
+            open_loop_trajectory.copy(), open_loop_trajectory.copy(), settings, MatchingSettings()
+        )
+        self.assertTrue(result.converged)
 
     def _verify_alignment(
         self, target: AlignmentParameters, estimation: AlignmentParameters, lazy: bool = False

{trajectopy-5.1.4 → trajectopy-6.0.0}/test/test_comparison.py

@@ -72,7 +72,8 @@ class TestComparison(unittest.TestCase):
         deviations = compare_trajectories_abs(traj_ref=trajectory, traj_test=transformed)
 
         np.testing.assert_almost_equal(deviations.pos_bias_along, parameters.lever_x.value)
-        np.testing.assert_almost_equal(deviations.pos_bias_cross_h, parameters.lever_y.value)
+        # the body y axis points to the left, horizontal cross-track is positive to the right
+        np.testing.assert_almost_equal(deviations.pos_bias_cross_h, -parameters.lever_y.value)
         np.testing.assert_almost_equal(deviations.pos_bias_cross_v, parameters.lever_z.value)
 
     def test_xyz_deviations(self) -> None:
@@ -91,9 +92,10 @@ class TestComparison(unittest.TestCase):
 
         deviations = compare_trajectories_abs(traj_ref=trajectory, traj_test=transformed)
 
-        np.testing.assert_almost_equal(-deviations.pos_bias_x, parameters.sim_trans_x.value)
-        np.testing.assert_almost_equal(-deviations.pos_bias_y, parameters.sim_trans_y.value)
-        np.testing.assert_almost_equal(-deviations.pos_bias_z, parameters.sim_trans_z.value)
+        # test minus reference: the test trajectory is shifted by the translation
+        np.testing.assert_almost_equal(deviations.pos_bias_x, parameters.sim_trans_x.value)
+        np.testing.assert_almost_equal(deviations.pos_bias_y, parameters.sim_trans_y.value)
+        np.testing.assert_almost_equal(deviations.pos_bias_z, parameters.sim_trans_z.value)
 
     def test_cross_track_deviations_no_rot_no_slope(self) -> None:
         # reference trajectory positions in direction 1,0 without slope
@@ -118,7 +120,8 @@ class TestComparison(unittest.TestCase):
         test_trajectory_xyz = ref_trajectory_xyz + deviations
         dir_devs = _derive_dev_directions_no_rot(xyz_ref=ref_trajectory_xyz, xyz_test=test_trajectory_xyz)
         np.testing.assert_almost_equal(dir_devs[:, 0], deviations[:, 0])  # along-track
-        np.testing.assert_almost_equal(dir_devs[:, 1], deviations[:, 1])  # cross-track horizontal
+        # travelling along x, y points to the left and horizontal cross-track is positive to the right
+        np.testing.assert_almost_equal(dir_devs[:, 1], -deviations[:, 1])  # cross-track horizontal
         np.testing.assert_almost_equal(dir_devs[:, 2], deviations[:, 2])  # cross-track vertical
 
     def test_cross_track_deviations_no_rot_slope(self) -> None:
@@ -147,8 +150,8 @@ class TestComparison(unittest.TestCase):
         # with a slope of 45 degrees, the deviations are split equally into vertical and along-track components
         np.testing.assert_almost_equal(dir_devs[:, 0], -dir_devs[:, 2])
 
-        # horizontal cross-track deviations remain the same
-        np.testing.assert_almost_equal(dir_devs[:, 1], deviations[:, 1])
+        # horizontal cross-track deviations remain the same (positive to the right, i.e. -y)
+        np.testing.assert_almost_equal(dir_devs[:, 1], -deviations[:, 1])
 
         # in total, the deviations are the same as the input deviations
         np.testing.assert_almost_equal(np.linalg.norm(dir_devs, axis=1), np.linalg.norm(deviations, axis=1))

{trajectopy-5.1.4 → trajectopy-6.0.0}/test/test_context_menus.py

@@ -41,7 +41,7 @@ class TestContextMenus(unittest.TestCase):
     def test_reference_entries_explain_why_they_are_unavailable(self):
         self.menu.populate(self._selection(self.trajectory))
         actions = self._actions()
-        for text in ("Absolute Error (ATE), Aligned First", "Estimate Alignment", "Interactive Alignment…"):
+        for text in ("Absolute Error (ATE), with Alignment", "Estimate Alignment", "Interactive Alignment…"):
             self.assertFalse(actions[text].isEnabled(), text)
             self.assertIn("Set a reference first", actions[text].toolTip())
         self.assertTrue(any(text.startswith("ⓘ") for text in actions))  # visible note in the submenu
@@ -52,6 +52,33 @@ class TestContextMenus(unittest.TestCase):
         self.assertTrue(actions["Estimate Alignment"].isEnabled())
         self.assertFalse(any(text.startswith("ⓘ") for text in actions))
 
+    def test_laps_need_a_spatially_sorted_trajectory(self):
+        from trajectopy.utils.definitions import Sorting
+
+        self.menu.populate(self._selection(self.trajectory))
+        self.assertFalse(self._actions()["Divide into Laps"].isEnabled())
+
+        self.trajectory.trajectory.path_lengths = self.trajectory.trajectory.path_lengths[::-1].copy()
+        self.trajectory.trajectory.set_sorting(Sorting.PATH_LENGTH)
+        self.menu.populate(self._selection(self.trajectory))
+        self.assertTrue(self._actions()["Divide into Laps"].isEnabled())
+
+    def test_kml_export_of_local_positions_with_a_known_frame(self):
+        import numpy as np
+
+        from trajectopy.core.trajectory import Trajectory
+        from trajectopy.gui.models.entries import TrajectoryEntry
+
+        xyz = np.c_[np.linspace(364000, 364100, 10), np.full(10, 5621000.0), np.full(10, 100.0)]
+        trajectory = Trajectory.from_arrays(xyz, epsg=25832)
+        trajectory.positions.to_local()  # EPSG 0, but the frame is known
+        self.menu.populate(self._selection(TrajectoryEntry(full_filename="", trajectory=trajectory)))
+        self.assertTrue(self._actions()["Export to Google Earth (KML)…"].isEnabled())
+
+        unknown = Trajectory.from_arrays(xyz)  # EPSG 0 without a frame
+        self.menu.populate(self._selection(TrajectoryEntry(full_filename="", trajectory=unknown)))
+        self.assertFalse(self._actions()["Export to Google Earth (KML)…"].isEnabled())
+
     def test_selection_size(self):
         self.menu.populate(self._selection(self.trajectory))
         actions = self._actions()
@@ -116,6 +143,40 @@ class TestContextMenus(unittest.TestCase):
         self.assertTrue(actions["Plot"].isEnabled())  # deviations are plotted together
         self.assertFalse(actions["Export…"].isEnabled())
         self.assertIn("single result", actions["Export…"].toolTip())
+        self.assertFalse(actions["Switch Order: Time ↔ Path"].isEnabled())  # chronological trajectory
+        self.assertIn("spatially sorted", actions["Switch Order: Time ↔ Path"].toolTip())
+
+    def test_switch_order_of_spatially_sorted_ate_result(self):
+        from trajectopy.gui.managers.requests import ResultModelRequest, ResultModelRequestType
+        from trajectopy.gui.models.entries import AbsoluteDeviationEntry
+        from trajectopy.gui.models.result_model import ResultTableModel
+        from trajectopy.gui.models.selection import ResultSelection
+        from trajectopy.gui.views.menu_helpers import iter_actions
+        from trajectopy.gui.views.result_context_menu import ResultContextMenu
+        from trajectopy.processing import evaluation
+        from trajectopy.processing.sorting import sort_spatially
+        from trajectopy.utils.definitions import Sorting
+
+        sorted_trajectory = sort_spatially(self.trajectory.trajectory, inplace=False)
+        entry = AbsoluteDeviationEntry(
+            deviations=evaluation.ate(trajectory=sorted_trajectory, other=sorted_trajectory, align=False)
+        )
+        selection = ResultSelection(entries=[entry])
+        menu = ResultContextMenu()
+        received = []
+        menu.result_model_request.connect(received.append)
+        menu.populate(selection)
+        action = {action.text(): action for action in iter_actions(menu)}["Switch Order: Time ↔ Path"]
+        self.assertTrue(action.isEnabled())
+        action.trigger()
+        self.assertEqual([request.type for request in received], [ResultModelRequestType.SWITCH_SORTING])
+
+        model = ResultTableModel()
+        model.add_entries(ResultModelRequest(type=ResultModelRequestType.ADD, selection=selection))
+        model.handle_request(received[0])
+        self.assertEqual(entry.deviations.trajectory.sorting, Sorting.TIME)
+        model.handle_request(ResultModelRequest(type=ResultModelRequestType.SWITCH_SORTING, selection=selection))
+        self.assertEqual(entry.deviations.trajectory.sorting, Sorting.PATH_LENGTH)
 
 
 if __name__ == "__main__":

trajectopy-6.0.0/test/test_correlation.py

@@ -0,0 +1,151 @@
+"""Temporal correlation of deviations: known correlation times are found, gaps and irregular sampling are handled."""
+
+import unittest
+
+import numpy as np
+
+from trajectopy.core.trajectory import Trajectory
+from trajectopy.processing.evaluation import ate
+from trajectopy.utils.definitions import Sorting
+from trajectopy.utils.statistics import (
+    autocorrelation,
+    correlation_time,
+    effective_samples,
+    white_noise_split,
+    windowed_std,
+)
+
+
+def _gauss_markov(timestamps: np.ndarray, tau: float, rng: np.random.Generator) -> np.ndarray:
+    """First-order Gauss-Markov process (exponential autocorrelation with the correlation time tau)."""
+    values = np.empty(len(timestamps))
+    values[0] = rng.normal()
+    for i in range(1, len(timestamps)):
+        factor = np.exp(-(timestamps[i] - timestamps[i - 1]) / tau)
+        values[i] = factor * values[i - 1] + rng.normal(0, np.sqrt(1 - factor**2))
+    return values
+
+
+class TestAutocorrelation(unittest.TestCase):
+    def test_correlation_time_of_a_gauss_markov_process(self):
+        rng = np.random.default_rng(0)
+        timestamps = np.arange(0, 3600, 1 / 19)  # one hour at 19 Hz
+        for tau in (0.5, 5.0):
+            with self.subTest(tau=tau):
+                lags, rho, _ = autocorrelation(timestamps, _gauss_markov(timestamps, tau, rng), max_lag=60)
+                self.assertAlmostEqual(correlation_time(lags, rho), tau, delta=0.15 * tau)
+
+    def test_gaps_and_jitter(self):
+        rng = np.random.default_rng(1)
+        timestamps = np.arange(0, 3600, 1 / 19) + rng.normal(0, 0.002, 68400)
+        values = _gauss_markov(np.sort(timestamps), 5.0, rng)
+        keep = np.ones(len(timestamps), dtype=bool)
+        for start in rng.integers(0, len(timestamps), 20):
+            keep[start : start + 300] = False  # gaps of about 16 s, e.g. losses of lock
+
+        lags, rho, pairs = autocorrelation(np.sort(timestamps)[keep], values[keep], max_lag=60)
+
+        self.assertAlmostEqual(correlation_time(lags, rho), 5.0, delta=0.75)
+        self.assertTrue(np.all(pairs[1:] < pairs[0]))
+
+    def test_no_correlation_across_a_gap(self):
+        # 10 s blocks with alternating signs, separated by 20 s gaps: within a block, the values are perfectly
+        # correlated; empty grid cells of the gaps must not produce pairs
+        timestamps = np.concatenate([np.arange(0, 10, 0.1) + 30 * block for block in range(40)])
+        values = np.concatenate([np.full(100, (-1.0) ** block) for block in range(40)])
+
+        lags, rho, pairs = autocorrelation(timestamps, values)
+
+        np.testing.assert_allclose(rho[(lags > 0) & (lags < 9.95)], 1.0)
+        self.assertTrue(np.all(pairs[(lags > 10.05) & (lags < 19.95)] == 0))  # only gaps at these lags
+        self.assertTrue(np.all(rho[(lags > 20.05) & (lags < 29.95)] < 0))  # neighboring blocks, opposite signs
+
+    def test_lags_up_to_a_tenth_of_the_samples(self):
+        timestamps = np.arange(1000) * 0.1
+        lags, _, _ = autocorrelation(timestamps, np.random.default_rng(6).normal(size=1000), max_lag=600)
+        self.assertAlmostEqual(lags[-1], 10.0)  # 100 sampling intervals
+
+    def test_correlation_time_beyond_the_largest_lag(self):
+        timestamps = np.arange(1000) * 0.1
+        lags, rho, _ = autocorrelation(timestamps, np.linspace(-1, 1, 1000))  # a trend: correlated throughout
+        self.assertEqual(correlation_time(lags, rho), float("inf"))
+
+    def test_white_noise_and_correlated_part(self):
+        rng = np.random.default_rng(7)
+        timestamps = np.arange(0, 3600, 1 / 19)
+        correlated = _gauss_markov(timestamps, 5.0, rng)
+        white = rng.normal(size=len(timestamps))
+        for white_share in (0.0, 0.7):
+            with self.subTest(white_share=white_share):
+                values = np.sqrt(1 - white_share) * correlated + np.sqrt(white_share) * white
+                lags, rho, pairs = autocorrelation(timestamps, values, max_lag=60)
+                share = white_noise_split(lags, rho, pairs)
+
+                self.assertAlmostEqual(1 - share, white_share, delta=0.05)
+                self.assertAlmostEqual(correlation_time(lags, rho, level=share), 5.0, delta=0.75)
+
+        lags, rho, pairs = autocorrelation(timestamps, white, max_lag=60)
+        self.assertEqual(white_noise_split(lags, rho, pairs), 0.0)
+
+    def test_white_noise_is_not_correlated(self):
+        rng = np.random.default_rng(2)
+        timestamps = np.arange(5000) * 0.01
+        lags, rho, _ = autocorrelation(timestamps, rng.normal(size=5000))
+        self.assertLess(correlation_time(lags, rho), 0.01)
+
+    def test_effective_samples(self):
+        self.assertEqual(effective_samples(1000, 100.0, 5.0), 10.0)
+        self.assertEqual(effective_samples(1000, 100.0, 0.0), 1000.0)
+        self.assertEqual(effective_samples(1000, 100.0, np.inf), 1.0)
+
+    def test_windowed_std(self):
+        timestamps = np.arange(0, 20, 0.1)
+        values = np.r_[np.random.default_rng(3).normal(0, 1, 100), np.random.default_rng(4).normal(0, 3, 100)]
+        centers, stds = windowed_std(timestamps, values, window=10.0)
+        np.testing.assert_allclose(centers, [5.0, 15.0])
+        self.assertLess(stds[0], stds[1])
+
+
+class TestDeviationCorrelation(unittest.TestCase):
+    def _result(self, sorting: Sorting = Sorting.TIME):
+        rng = np.random.default_rng(5)
+        t = np.arange(0, 600, 0.1)
+        reference = Trajectory.from_arrays(np.c_[t, 0 * t, 0 * t], rpy=np.zeros((len(t), 3)), timestamps=t)
+        test = reference.copy()
+        # cross-track deviations correlated over 5 s, along-track white noise
+        test.positions.xyz += np.c_[rng.normal(0, 0.01, len(t)), _gauss_markov(t, 5.0, rng) * 0.02, 0 * t]
+        result = ate(test, reference, align=False)
+        if sorting == Sorting.PATH_LENGTH:
+            result.trajectory.path_lengths = result.trajectory.path_lengths[::-1].copy()
+            result.set_sorting(Sorting.PATH_LENGTH)
+        return result
+
+    def test_components_and_properties(self):
+        result = self._result()
+        correlation = result.correlation
+
+        self.assertAlmostEqual(correlation.components["cross_h"].correlation_time, 5.0, delta=1.5)
+        self.assertEqual(correlation.components["along"].correlation_time, 0.0)  # white noise
+        self.assertGreater(correlation.components["along"].white_noise_share, 0.9)
+        self.assertLess(correlation.components["cross_h"].white_noise_share, 0.1)
+        self.assertLess(correlation.components["cross_h"].effective_samples, 100)
+        self.assertIn("roll", correlation.components)
+        self.assertIn("Correlation Time Along / Cross-H / Cross-V [s]", result.property_dict)
+        self.assertIn("White Noise Along / Cross-H / Cross-V [%]", result.property_dict)
+
+    def test_spatially_sorted_results_are_analyzed_in_chronological_order(self):
+        by_time, by_path = self._result(), self._result(Sorting.PATH_LENGTH)
+        self.assertAlmostEqual(
+            by_time.correlation.components["cross_h"].correlation_time,
+            by_path.correlation.components["cross_h"].correlation_time,
+        )
+
+    def test_removing_deviations_updates_the_correlation(self):
+        result = self._result()
+        samples = result.correlation.num_samples
+        result.remove_ate_above(0.02)
+        self.assertLess(result.correlation.num_samples, samples)
+
+
+if __name__ == "__main__":
+    unittest.main()

{trajectopy-5.1.4 → trajectopy-6.0.0}/test/test_gui_models.py

@@ -136,6 +136,107 @@ class TestSubWindows(unittest.TestCase):
         self._process_deferred_deletes()
         self.assertEqual(self.main_window.findChildren(QtWidgets.QMainWindow), [])
 
+    def _visible_windows(self) -> list:
+        return [window for window in self.main_window.findChildren(QtWidgets.QMainWindow) if window.isVisible()]
+
+    def _close_all(self) -> None:
+        for window in self.main_window.findChildren(QtWidgets.QMainWindow):
+            window.close()
+        self._process_deferred_deletes()
+
+    def test_settings_of_a_trajectory_open_only_once(self):
+        manager = UIManager(parent=self.main_window)
+        request = UIRequest(type=UIRequestType.TRAJ_SETTINGS, trajectory_selection=self.selection)
+        manager.handle_request(request)
+        first = self._visible_windows()
+        manager.handle_request(request)
+
+        self.assertEqual(self._visible_windows(), first)
+        self.assertEqual(len(first), 1)
+
+        # once closed, it opens again
+        self._close_all()
+        manager.handle_request(request)
+        self.assertEqual(len(self._visible_windows()), 1)
+        self._close_all()
+
+    def test_a_window_for_the_current_selection_replaces_the_open_one(self):
+        manager = UIManager(parent=self.main_window)
+        request = UIRequest(type=UIRequestType.DOF_ORGANIZER, trajectory_selection=self.selection)
+        manager.handle_request(request)
+        first = self._visible_windows()
+        manager.handle_request(request)
+        second = self._visible_windows()
+
+        self.assertEqual(len(second), 1)
+        self.assertIsNot(second[0], first[0])
+        self._close_all()
+
+    def test_applying_settings_keeps_values_outside_of_the_usual_range(self):
+        from trajectopy.core.settings import ProcessingSettings
+        from trajectopy.gui.views.json_settings_view import JSONViewer
+
+        settings = ProcessingSettings()
+        settings.alignment.preprocessing.max_samples = 250_000
+        settings.alignment.preprocessing.time_start = -2.5
+        viewer = JSONViewer(parent=self.main_window, settings=settings)
+        viewer.apply_changes()
+        viewer.close()
+        self._process_deferred_deletes()
+
+        self.assertEqual(settings.alignment.preprocessing.max_samples, 250_000)
+        self.assertEqual(settings.alignment.preprocessing.time_start, -2.5)
+
+
+@unittest.skipIf(QtWidgets is None, "GUI dependencies not installed")
+class TestUniqueIds(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls) -> None:
+        cls.app = QtWidgets.QApplication.instance() or QtWidgets.QApplication([])
+
+    def test_a_result_file_opened_twice_gives_two_independent_entries(self):
+        import tempfile
+
+        from trajectopy.gui.models.entries import AbsoluteDeviationEntry
+        from trajectopy.gui.models.result_model import ResultTableModel
+        from trajectopy.processing.evaluation import ate
+
+        with tempfile.TemporaryDirectory() as directory:
+            filename = os.path.join(directory, "ate.result")
+            AbsoluteDeviationEntry(deviations=ate(noisy_trajectory, noisy_trajectory, align=False)).to_file(filename)
+            first, second = AbsoluteDeviationEntry.from_file(filename), AbsoluteDeviationEntry.from_file(filename)
+
+        model = ResultTableModel()
+        model.add(first)
+        model.add(second)
+        model.remove([second.entry_id])
+
+        self.assertEqual(model.items, [first])
+
+    def test_operation_results_keep_the_current_reference(self):
+        import copy
+
+        from trajectopy.gui.managers.requests import TrajectoryModelRequest, TrajectoryModelRequestType
+
+        model = TrajectoryTableModel()
+        first, second = _entry("first"), _entry("second")
+        first.set_as_reference = True
+        model.add(first)
+        model.add(second)
+        result = copy.deepcopy(first)  # e.g. an EPSG change, computed while the reference is changed
+        model.handle_request(
+            TrajectoryModelRequest(
+                type=TrajectoryModelRequestType.SET_REFERENCE, selection=TrajectorySelection(entries=[second])
+            )
+        )
+        model.handle_request(
+            TrajectoryModelRequest(
+                type=TrajectoryModelRequestType.UPDATE, selection=TrajectorySelection(entries=[result])
+            )
+        )
+
+        self.assertEqual([entry.set_as_reference for entry in model.items], [False, True])
+
 
 if __name__ == "__main__":
     unittest.main()