flowtracks 1.5.2.dev2__tar.gz → 1.6.0__tar.gz

{flowtracks-1.5.2.dev2/flowtracks.egg-info → flowtracks-1.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flowtracks
-Version: 1.5.2.dev2
+Version: 1.6.0
 Summary: Library for handling 3D PTV trajectory databases and Lagrangian/Eulerian turbulence post-processing.
 Author-email: Yosef Meller <yosefm@gmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE

{flowtracks-1.5.2.dev2 → flowtracks-1.6.0}/flowtracks/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.5.2.dev2'
-__version_tuple__ = version_tuple = (1, 5, 2, 'dev2')
+__version__ = version = '1.6.0'
+__version_tuple__ = version_tuple = (1, 6, 0)
 
-__commit_id__ = commit_id = 'gd0fd559b2'
+__commit_id__ = commit_id = 'g0098b1fd3'

{flowtracks-1.5.2.dev2 → flowtracks-1.6.0}/flowtracks/an_scene.py

@@ -1,7 +1,11 @@
 # -*- coding: utf-8 -*-
 
 import numpy as np
-import tables
+
+try:
+    import tables
+except ImportError:  # optional legacy dependency; zarr paths do not need it
+    tables = None
 
 from .scene import gen_query_string, read_dual_scene
 from .trajectory import Trajectory
@@ -21,6 +25,12 @@ class AnalysedScene(object):
         Arguments:
         analysis_file - path to the HDF file containing analysis results.
         """
+        if tables is None:
+            raise ImportError(
+                "PyTables ('tables') is required for the legacy AnalysedScene. "
+                "The project now uses Zarr; install the 'legacy-io' extra "
+                "only if you need the old format."
+            )
         self._file = tables.open_file(analysis_file, "r")
         self._table = self._file.get_node('/analysis')
 

{flowtracks-1.5.2.dev2 → flowtracks-1.6.0}/flowtracks/analysis.py

@@ -14,7 +14,6 @@ fluid velocity around a particle from its surrounding tracers.
 """
 
 import numpy as np
-import tables
 
 
 def companion_indices(trids, companions):
@@ -132,6 +131,14 @@ def analysis(scene, analysis_file, conf_file, analysers, frame_range=-1):
         descr.extend(analyser.descr())
     descr = np.dtype(descr)
 
+    try:
+        import tables
+    except ImportError:
+        raise ImportError(
+            "PyTables ('tables') is required for analysis() HDF5 output. "
+            "The project now uses Zarr; install the 'legacy-io' extra only "
+            "if you need the old format."
+        )
     outfile = tables.open_file(analysis_file, "w", title="Analysis results.")
     table = outfile.create_table('/', 'analysis', descr)
     table.attrs['config'] = conf_file

{flowtracks-1.5.2.dev2 → flowtracks-1.6.0}/flowtracks/io.py

@@ -4,10 +4,11 @@
 """
 The main entry points for using the module are the :func:`trajectories`
 function (or its counterpart :func:`iter_trajectories`) for reading the data
-for a scene; and either :func:`save_trajectories` or
-:func:`save_particles_table` for saving scene data in, respectively, an obsolete
-format based on a directory of NPZ files, or in the newer, recommended, HDF5
-format.
+for a scene; and either :func:`save_zarr_trajectories` /
+:func:`read_zarr_trajectories` for the current Zarr format, or the legacy
+:func:`save_trajectories` (obsolete directory of NPZ files) and
+:func:`save_particles_table` (legacy PyTables HDF5, requires the optional
+``tables`` dependency).
 
 The trajectory reader, unless otherwise noted, will try to infer the format
 from the file name (see :func:`infer_format`).
@@ -24,7 +25,6 @@ from configparser import ConfigParser
 from io import StringIO
 
 import numpy as np
-import tables
 from scipy import io
 
 from .particle import Particle
@@ -37,6 +37,22 @@ from .trajectory import (
     trajectories_in_frame,
 )
 
+try:
+    import tables
+except ImportError:  # optional legacy dependency; zarr paths do not need it
+    tables = None
+
+
+def _require_tables():
+    if tables is None:
+        raise ImportError(
+            "PyTables ('tables') is required for legacy HDF5 I/O "
+            "(save_particles_table, save_frames_hdf, trajectories_table, "
+            "Scene with .h5 files). The project now uses Zarr "
+            "(save_zarr_trajectories, read_zarr_trajectories, ZarrScene); "
+            "install the 'legacy-io' extra only if you need the old format."
+        )
+
 
 class FramesIterator(object):
     def __init__(self, fname_tmpl, fmt, skip, first=None, last=None, usecols=None):
@@ -540,6 +556,7 @@ def trajectories(fname, first=None, last=None, frate=1.0, fmt=None, traj_min_len
             traj_min_len=traj_min_len)
 
     elif fmt == 'hdf':
+        _require_tables()
         scene = Scene(fname, (first, last))
         it = scene.iter_trajectories()
         if iter_allowed:
@@ -728,6 +745,10 @@ def save_particles_table(filename, trajects, trim=None):
     (frame number) and trajid - the last one may be indexed. Note that no extra
     (per-trajectory or meta) data is allowed here, unlike the npz save format.
 
+    .. deprecated::
+        Legacy PyTables/HDF5 format. Prefer
+        :func:`save_zarr_trajectories` + :class:`ZarrScene`.
+
     Arguments:
     filename - name of output PyTables HDF5 file to create. The 'h5' extension
         is recommended so that infer_format() knows what to do with it.
@@ -735,6 +756,7 @@ def save_particles_table(filename, trajects, trim=None):
     trim - if None, remove this many time points from each end of each
         trajectory before saving.
     """
+    _require_tables()
     table = None
     trim_len = 0 if trim is None else trim * 2
 
@@ -794,6 +816,7 @@ def save_frames_hdf(filename, frames):
         is recommended so that ``infer_format()`` knows what to do with it.
     frames - an iterable sequence of ParticleSnapshot objects to save.
     """
+    _require_tables()
     table = None
     outfile = tables.open_file(filename, mode='w')
     min_pos = np.full(3, np.inf)
@@ -862,6 +885,10 @@ def trajectories_table(fname, first=None, last=None):
     Reads trajectories from a PyTables HDF5 file, as saved by
     save_particles_table().
 
+    .. deprecated::
+        Legacy PyTables/HDF5 format. Prefer
+        :func:`read_zarr_trajectories` + :class:`ZarrScene`.
+
     Arguments:
     fname - path to file to read.
     first, last - inclusive range of frames to read.
@@ -869,6 +896,7 @@ def trajectories_table(fname, first=None, last=None):
     Returns:
     trajects - a list of Trajectory objects, each trimmed to the frame range.
     """
+    _require_tables()
     outfile = tables.open_file(fname, mode='r')
     table = outfile.get_node('/particles')
 

{flowtracks-1.5.2.dev2 → flowtracks-1.6.0}/flowtracks/scene.py

@@ -19,7 +19,11 @@ import itertools as it
 from configparser import ConfigParser
 
 import numpy as np
-import tables
+
+try:
+    import tables
+except ImportError:  # optional legacy dependency; ZarrScene needs no tables
+    tables = None
 
 from .particle import Particle
 from .trajectory import ParticleSnapshot, Trajectory
@@ -73,6 +77,11 @@ class Scene(object):
     This class is the programmer's interface to an HDF files containing
     particle trajectory data. It manages access by frames or trajectories,
     as well as by segments.
+
+    .. deprecated::
+        Legacy PyTables/HDF5 backend. Prefer
+        :class:`flowtracks.zarr_scene.ZarrScene` (duck-typed compatible)
+        and open stores via :func:`open_scene`.
     """
     def __init__(self, file_name, frame_range=None):
         """
@@ -81,6 +90,12 @@ class Scene(object):
         frame_range - use only frames in this range for iterating the data.
             the default is None, meaning to use all present frams.
         """
+        if tables is None:
+            raise ImportError(
+                "PyTables ('tables') is required for the legacy HDF5 Scene. "
+                "The project now uses Zarr (ZarrScene); install the "
+                "'legacy-io' extra only if you need the old format."
+            )
         self._file = tables.open_file(file_name)
         self._table = self._file.get_node('/particles')
         try:

{flowtracks-1.5.2.dev2 → flowtracks-1.6.0/flowtracks.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flowtracks
-Version: 1.5.2.dev2
+Version: 1.6.0
 Summary: Library for handling 3D PTV trajectory databases and Lagrangian/Eulerian turbulence post-processing.
 Author-email: Yosef Meller <yosefm@gmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE

flowtracks-1.6.0/flowtracks.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "1.6.0",
+  "distance": 0,
+  "node": "g0098b1fd3dca3e00bdbd04cf5c7505cb2f39a82e",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-09-29"
+}

{flowtracks-1.5.2.dev2 → flowtracks-1.6.0}/tests/test_io.py

@@ -68,23 +68,33 @@ class TestPtvis(unittest.TestCase):
         trjs = io.trajectories_ptvis(inName, xuap = True, traj_min_len = None)
         self.assertEqual(len(trjs), 332)
 
-    def test_trajectories_hdf(self):
-        """HDF reading works"""
-        outfile = 'tests/testing_fodder/table.h5'
-        io.save_particles_table(outfile, self.correct)
-        loaded = io.trajectories_table(outfile)
-        self.compare_trajectories(loaded, self.correct)
-        os.remove(outfile)
-
-    def test_trim_hdf(self):
-        """HDF trajectory trimming"""
-        correct = io.trajectories_ptvis(self.tmpl, self.first+1, self.last-1)
-
-        outfile = 'tests/testing_fodder/table.h5'
-        io.save_particles_table(outfile, self.correct, trim=1)
-
-        loaded = io.trajectories_table(outfile)
-        self.compare_trajectories(loaded, correct)
-
-        os.remove(outfile)
+    def test_trajectories_zarr(self):
+        """Zarr round-trip works"""
+        import tempfile
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            zarr_path = os.path.join(tmpdir, 'table.zarr')
+            io.save_zarr_trajectories(self.correct, zarr_path)
+            loaded = io.read_zarr_trajectories(zarr_path)
+            self.compare_trajectories(
+                sorted(loaded, key=lambda t: t.trajid()),
+                sorted(self.correct, key=lambda t: t.trajid()),
+            )
+
+    def test_trim_zarr(self):
+        """Zarr trajectory trimming via frame-range read"""
+        import tempfile
+
+        correct = io.trajectories_ptvis(self.tmpl, self.first + 1, self.last - 1)
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            zarr_path = os.path.join(tmpdir, 'table.zarr')
+            io.save_zarr_trajectories(self.correct, zarr_path)
+
+            loaded = io.read_zarr_trajectories(
+                zarr_path, first=self.first + 1, last=self.last - 1)
+            self.compare_trajectories(
+                sorted(loaded, key=lambda t: t.trajid()),
+                sorted(correct, key=lambda t: t.trajid()),
+            )
 

{flowtracks-1.5.2.dev2 → flowtracks-1.6.0}/tests/test_scene.py

@@ -1,15 +1,18 @@
 """
 Test the input/output routines in flowtracks: read/write files and verify
-correct results.
+correct results (Zarr backend).
 """
 
+import tempfile
 import unittest
 
 import numpy as np
 import numpy.testing as nptest
 
-from flowtracks.scene import Scene, gen_query_string
+from flowtracks.io import save_zarr_trajectories
+from flowtracks.scene import gen_query_string
 from flowtracks.trajectory import Trajectory, take_snapshot
+from flowtracks.zarr_scene import ZarrScene
 
 
 class TestScene(unittest.TestCase):
@@ -18,9 +21,6 @@ class TestScene(unittest.TestCase):
         There are 3 trajectories of 4 frames each, each going along a separate
         axis.
         """
-        tmpl = "tests/testing_fodder/three_trajects_simple.h5"
-        self.scene = Scene(tmpl)
-
         # ptv_is files are in [mm], [mm/s], etc.
         correct_pos = np.r_[0.1, 0.2, 0.3, 0.5] / 1000.
         correct_vel = np.r_[0.1, 0.1, 0.2, 0.] / 1000.
@@ -30,28 +30,38 @@ class TestScene(unittest.TestCase):
         self.correct = []
         for axis in [0, 1, 2]:
             pos = np.zeros((4, 3))
-            pos[:,axis] = correct_pos
+            pos[:, axis] = correct_pos
 
             vel = np.zeros((4, 3))
-            vel[:,axis] = correct_vel
+            vel[:, axis] = correct_vel
 
             accel = np.zeros((4, 3))
-            accel[:,axis] = correct_accel
+            accel[:, axis] = correct_accel
 
             self.correct.append(Trajectory(pos, vel, t, len(self.correct),
                 accel=accel))
 
+        self._tmpdir = tempfile.TemporaryDirectory()
+        self._zarr_path = self._tmpdir.name + "/three_trajects_simple.zarr"
+        save_zarr_trajectories(self.correct, self._zarr_path)
+        self.scene = ZarrScene(self._zarr_path)
+
+    def tearDown(self):
+        self._tmpdir.cleanup()
+
     def test_keys(self):
         """Reading known available keys with the needed exclusions"""
-        correct_keys = ['velocity', 'pos', 'accel']
-        self.assertEqual(list(self.scene.keys()), correct_keys)
+        self.assertEqual(set(self.scene.keys()), {'velocity', 'pos', 'accel'})
 
     def test_iter_trajectories(self):
         """Iterating trajectories and getting correct Trajectory objects"""
         trjs = [tr for tr in self.scene.iter_trajectories()]
         self.assertEqual(len(trjs), len(self.correct))
 
-        for trj, correct in zip(trjs, self.correct):
+        for trj, correct in zip(
+            sorted(trjs, key=lambda t: t.trajid()),
+            sorted(self.correct, key=lambda t: t.trajid()),
+        ):
             nptest.assert_array_almost_equal(trj.pos(), correct.pos())
             nptest.assert_array_almost_equal(trj.velocity(), correct.velocity())
             nptest.assert_array_almost_equal(trj.accel(), correct.accel())
@@ -64,7 +74,10 @@ class TestScene(unittest.TestCase):
         trjs = [tr for tr in self.scene.iter_trajectories()]
         self.assertEqual(len(trjs), len(self.correct))
 
-        for trj, correct in zip(trjs, self.correct):
+        for trj, correct in zip(
+            sorted(trjs, key=lambda t: t.trajid()),
+            sorted(self.correct, key=lambda t: t.trajid()),
+        ):
             nptest.assert_array_almost_equal(trj.pos(), correct.pos()[1:-1])
             nptest.assert_array_almost_equal(trj.velocity(), correct.velocity()[1:-1])
             nptest.assert_array_almost_equal(trj.accel(), correct.accel()[1:-1])
@@ -72,49 +85,65 @@ class TestScene(unittest.TestCase):
             self.assertEqual(trj.trajid(), correct.trajid())
 
     def test_iter_frames(self):
-        """Iterating the HDF files by frames, and getting correct ParticleSnapshot objects"""
+        """Iterating the store by frames, getting correct ParticleSnapshot objects"""
         schm = self.correct[0].schema()
-        correct_frames = [take_snapshot(self.correct, frm, schm) \
+        correct_frames = [take_snapshot(self.correct, frm, schm)
             for frm in range(10001, 10005)]
 
         frames = [frm for frm in self.scene.iter_frames()]
         self.assertEqual(len(frames), len(correct_frames))
 
         for frm, correct in zip(frames, correct_frames):
-            nptest.assert_array_almost_equal(frm.pos(), correct.pos())
-            nptest.assert_array_almost_equal(frm.velocity(), correct.velocity())
-            nptest.assert_array_almost_equal(frm.accel(), correct.accel())
-            nptest.assert_array_almost_equal(frm.trajid(), correct.trajid())
+            nptest.assert_array_almost_equal(
+                frm.pos()[np.argsort(frm.trajid())],
+                correct.pos()[np.argsort(correct.trajid())])
+            nptest.assert_array_almost_equal(
+                frm.velocity()[np.argsort(frm.trajid())],
+                correct.velocity()[np.argsort(correct.trajid())])
+            nptest.assert_array_almost_equal(
+                frm.accel()[np.argsort(frm.trajid())],
+                correct.accel()[np.argsort(correct.trajid())])
+            nptest.assert_array_equal(
+                np.sort(frm.trajid()), np.sort(correct.trajid()))
             self.assertEqual(frm.time(), correct.time())
 
     def test_iter_frames_subrange(self):
         """Iterating frames subrange"""
-        print(self.scene.__dict__)
         self.scene.set_frame_range((10002, 10004))
-        print(self.scene.__dict__)
 
         schm = self.correct[0].schema()
-        correct_frames = [take_snapshot(self.correct, frm, schm) \
+        correct_frames = [take_snapshot(self.correct, frm, schm)
             for frm in range(10002, 10004)]
 
         frames = [frm for frm in self.scene.iter_frames()]
         self.assertEqual(len(frames), len(correct_frames))
 
         for frm, correct in zip(frames, correct_frames):
-            nptest.assert_array_almost_equal(frm.pos(), correct.pos())
-            nptest.assert_array_almost_equal(frm.velocity(), correct.velocity())
-            nptest.assert_array_almost_equal(frm.accel(), correct.accel())
-            nptest.assert_array_almost_equal(frm.trajid(), correct.trajid())
+            nptest.assert_array_almost_equal(
+                frm.pos()[np.argsort(frm.trajid())],
+                correct.pos()[np.argsort(correct.trajid())])
+            nptest.assert_array_almost_equal(
+                frm.velocity()[np.argsort(frm.trajid())],
+                correct.velocity()[np.argsort(correct.trajid())])
+            nptest.assert_array_almost_equal(
+                frm.accel()[np.argsort(frm.trajid())],
+                correct.accel()[np.argsort(correct.trajid())])
+            nptest.assert_array_equal(
+                np.sort(frm.trajid()), np.sort(correct.trajid()))
             self.assertEqual(frm.time(), correct.time())
 
     def test_collect(self):
-        """Slicing the file by keys or expressions"""
+        """Slicing the store by keys or expressions"""
         v = self.scene.collect(['velocity'])[0]
-        self.assertEqual(v.shape, (12,3))
-
-        v = v.reshape(3,4,3)
-        nptest.assert_array_almost_equal(v[0,:,0], v[1,:,1])
-        nptest.assert_array_almost_equal(v[0,:,0], v[2,:,2])
+        self.assertEqual(v.shape, (12, 3))
+
+        by_id = {}
+        for trj in self.scene.iter_trajectories():
+            by_id[trj.trajid()] = trj.velocity()
+        v_stacked = np.stack(
+            [by_id[i] for i in sorted(by_id)], axis=0)
+        nptest.assert_array_almost_equal(v_stacked[0, :, 0], v_stacked[1, :, 1])
+        nptest.assert_array_almost_equal(v_stacked[0, :, 0], v_stacked[2, :, 2])
 
 class TestUtils(unittest.TestCase):
     def test_query_string(self):

flowtracks-1.6.0/tests/test_zarr_scene.py

@@ -0,0 +1,191 @@
+"""ZarrScene behaviour checks against Zarr stores written by
+:func:`flowtracks.io.save_zarr_trajectories` and against an openptv2
+RunStore-style Zarr layout (traj/ + trajectories/ groups)."""
+
+import numpy as np
+import pytest
+
+from flowtracks.io import save_zarr_trajectories
+from flowtracks.scene import open_scene
+from flowtracks.trajectory import Trajectory
+from flowtracks.zarr_scene import ZarrScene
+
+
+def _make_trajectories():
+    tr1 = Trajectory(
+        pos=np.array([[0.0, 0.0, 0.0], [1.0, 1.0, 1.0], [2.0, 2.0, 2.0]]),
+        velocity=np.array([[0.1, 0.1, 0.1], [0.2, 0.2, 0.2], [0.3, 0.3, 0.3]]),
+        time=np.array([10, 11, 12]),
+        trajid=1,
+        accel=np.array([[0.01, 0.01, 0.01], [0.02, 0.02, 0.02], [0.03, 0.03, 0.03]]),
+    )
+    tr2 = Trajectory(
+        pos=np.array([[5.0, 5.0, 5.0], [6.0, 6.0, 6.0], [7.0, 7.0, 7.0], [8.0, 8.0, 8.0]]),
+        velocity=np.array(
+            [[0.5, 0.5, 0.5], [0.6, 0.6, 0.6], [0.7, 0.7, 0.7], [0.8, 0.8, 0.8]]
+        ),
+        time=np.array([10, 11, 12, 13]),
+        trajid=2,
+        accel=np.array(
+            [[0.05] * 3, [0.06] * 3, [0.07] * 3, [0.08] * 3]
+        ),
+    )
+    tr3 = Trajectory(
+        pos=np.array([[9.0, 9.0, 9.0], [9.5, 9.5, 9.5]]),
+        velocity=np.array([[0.9, 0.9, 0.9], [0.95, 0.95, 0.95]]),
+        time=np.array([11, 12]),
+        trajid=3,
+        accel=np.array([[0.09] * 3, [0.095] * 3]),
+    )
+    return [tr1, tr2, tr3]
+
+
+@pytest.fixture
+def zarr_scene(tmp_path):
+    trajects = _make_trajectories()
+    zarr_path = tmp_path / "ref.zarr"
+    save_zarr_trajectories(trajects, zarr_path)
+    return ZarrScene(zarr_path), {t.trajid(): t for t in trajects}
+
+
+def _sorted_rows(arr):
+    return arr[np.lexsort(arr.T)]
+
+
+def test_keys_and_shapes(zarr_scene):
+    scene, _ = zarr_scene
+    assert set(scene.keys()) == {"pos", "velocity", "accel"}
+    assert dict(zip(scene.keys(), scene.shapes())) == {
+        "pos": 3, "velocity": 3, "accel": 3,
+    }
+
+
+def test_trajectory_ids_and_tags(zarr_scene):
+    scene, ref = zarr_scene
+    assert sorted(scene.trajectory_ids().tolist()) == [1, 2, 3]
+    tags = {int(r[0]): (int(r[1]), int(r[2])) for r in scene.trajectory_tags()}
+    assert tags == {1: (10, 12), 2: (10, 13), 3: (11, 12)}
+
+
+def test_trajectory_by_id_matches(zarr_scene):
+    scene, ref = zarr_scene
+    for trid in [1, 2, 3]:
+        z = scene.trajectory_by_id(trid)
+        h = ref[trid]
+        np.testing.assert_allclose(z.pos(), h.pos())
+        np.testing.assert_allclose(z.velocity(), h.velocity())
+        np.testing.assert_array_equal(z.time(), h.time())
+        assert z.trajid() == h.trajid()
+
+
+def test_iter_trajectories_matches(zarr_scene):
+    scene, ref = zarr_scene
+    z_by_id = {t.trajid(): t for t in scene.iter_trajectories()}
+    assert set(z_by_id) == set(ref)
+    for trid in ref:
+        np.testing.assert_allclose(z_by_id[trid].pos(), ref[trid].pos())
+        np.testing.assert_array_equal(z_by_id[trid].time(), ref[trid].time())
+
+
+def test_iter_frames_matches(zarr_scene):
+    scene, ref = zarr_scene
+    z_frames = {f.time(): f for f in scene.iter_frames()}
+    assert set(z_frames) == {10, 11, 12, 13}
+    assert sorted(z_frames[10].trajid().tolist()) == [1, 2]
+    assert sorted(z_frames[11].trajid().tolist()) == [1, 2, 3]
+    np.testing.assert_allclose(
+        _sorted_rows(z_frames[10].pos()),
+        _sorted_rows(np.array([[0.0, 0, 0], [5.0, 5, 5]])),
+    )
+
+
+def test_frame_by_time_matches(zarr_scene):
+    scene, _ = zarr_scene
+    z = scene.frame_by_time(11)
+    assert sorted(z.trajid().tolist()) == [1, 2, 3]
+
+
+def test_iter_segments_matches(zarr_scene):
+    scene, _ = zarr_scene
+    z_segs = list(scene.iter_segments())
+    # frames 10..13 -> 3 consecutive pairs
+    assert len(z_segs) == 3
+    (z_a, z_b) = z_segs[0]
+    assert z_a.time() == 10 and z_b.time() == 11
+    assert sorted(z_a.trajid().tolist()) == [1, 2]
+    assert sorted(z_b.trajid().tolist()) == [1, 2]
+
+
+def test_collect_matches(zarr_scene):
+    scene, _ = zarr_scene
+    z_pos, z_time = scene.collect(["pos", "time"])
+    assert z_pos.shape == (9, 3)
+    assert z_time.shape == (9,)
+    assert set(np.unique(z_time).tolist()) == {10, 11, 12, 13}
+
+
+def test_collect_with_where_matches(zarr_scene):
+    scene, _ = zarr_scene
+    where = {"time": (11, 13, False)}
+    z_pos = scene.collect(["pos"], where=where)[0]
+    assert len(z_pos) == 6  # frames 11, 12 across tr1 (2) + tr2 (2) + tr3 (2)
+
+
+def test_bounding_box_matches(zarr_scene):
+    scene, _ = zarr_scene
+    z_min, z_max = scene.bounding_box()
+    np.testing.assert_allclose(z_min, [0.0, 0, 0])
+    np.testing.assert_allclose(z_max, [9.5, 9.5, 9.5])
+
+
+def test_frame_range_filters(zarr_scene):
+    scene, _ = zarr_scene
+    scene.set_frame_range((11, 13))
+    assert scene.frame_range() == (11, 13)
+    z_pos = scene.collect(["time"])[0]
+    assert z_pos.min() >= 11 and z_pos.max() < 13
+
+
+def test_open_scene_dispatches_zarr(tmp_path):
+    trajects = _make_trajectories()
+    zarr_path = tmp_path / "d.zarr"
+    save_zarr_trajectories(trajects, zarr_path)
+
+    assert isinstance(open_scene(str(zarr_path)), ZarrScene)
+
+
+def test_reads_openptv2_run_store_layout(tmp_path):
+    """openptv2's RunStore.seal() writes traj/{trajid,first,last,length} and
+    trajectories/{pos,vel,accel,time,trajid} -- no /bounds table, just the
+    traj/ index. ZarrScene must read this directly, not just flowtracks'
+    own save_zarr_trajectories output."""
+    import zarr
+
+    store_path = tmp_path / "run.zarr"
+    root = zarr.open_group(str(store_path), mode="w")
+    traj_grp = root.create_group("traj")
+    traj_grp.create_array("trajid", data=np.array([7, 8], dtype=np.int32))
+    traj_grp.create_array("first", data=np.array([10, 10], dtype=np.int32))
+    traj_grp.create_array("last", data=np.array([11, 12], dtype=np.int32))
+    traj_grp.create_array("length", data=np.array([2, 3], dtype=np.int32))
+
+    trajectories_grp = root.create_group("trajectories")
+    trajectories_grp.create_array(
+        "pos",
+        data=np.array(
+            [[0.0, 0, 0], [0.1, 0, 0], [1.0, 1, 1], [1.1, 1, 1], [1.2, 1, 1]]
+        ),
+    )
+    trajectories_grp.create_array(
+        "vel", data=np.zeros((5, 3))
+    )
+    trajectories_grp.create_array("time", data=np.array([10, 11, 10, 11, 12]))
+    trajectories_grp.create_array("trajid", data=np.array([7, 7, 8, 8, 8]))
+
+    scene = ZarrScene(store_path)
+    assert sorted(scene.trajectory_ids().tolist()) == [7, 8]
+    tr7 = scene.trajectory_by_id(7)
+    assert len(tr7) == 2
+    tr8 = scene.trajectory_by_id(8)
+    assert len(tr8) == 3
+    assert "accel" not in scene.keys()

flowtracks-1.5.2.dev2/flowtracks.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "1.5.1",
-  "distance": 2,
-  "node": "gd0fd559b28f895d77ee63a74ae23275dc95d148b",
-  "dirty": false,
-  "branch": "master",
-  "node_date": "2026-09-29"
-}