| --- |
| license: cc-by-nc-4.0 |
| pretty_name: "LiNGER review sample" |
| tags: |
| - lidar |
| - human-trajectories |
| - tracking |
| - built-environment |
| --- |
| |
| # LiNGER review sample |
|
|
| This is a review sample of **LiNGER**, a three-week dataset recorded by seven ceiling-mounted LiDAR sensors in a |
| university library and café. The full release (the live and offline tracklets, one hour of point clouds |
| from every session, the benchmark sessions with their full point clouds and ground truth, the room model, the loaders, |
| and the full point clouds of all sessions) will be hosted on Hugging Face upon acceptance. This sample holds a few complete days and windows in exactly the released formats, so that reviewers can |
| open the files and check what the paper describes. The loader package (`loaders/`), with the flicker filter and |
| the replay tool, is part of the dataset. |
|
|
|  |
|
|
| Overview of the recording. (a) The static map with the seven ceiling-mounted nodes N1 to N7. (b) One frame from the busy benchmark session, with the detected people in red. (c) Every live tracklet of one weekday, colored by hour. (d) A render of the 3DGS room model as scanned, from the same view as (a) and (b); the model in this sample is edited for anonymity. |
|
|
| No camera data is recorded. The point clouds hold only geometry (x, y, z) inside the study area, with the floor removed. |
| Tracklet IDs are valid within one tracker run and link to no person. |
|
|
| ## What the sample contains |
|
|
| | Folder / file | Contents | |
| |---|---| |
| | `sessions.csv` | One row per sampled session (day number, weekday, start and stop in UTC, hours, tracklets, occupancy level, tags, and what this sample holds of it) | |
| | `track_log/` | Live tracklets, two full days: `tracks_day8_000000.jsonl.gz` (a low-occupancy weekday) and `tracks_day15_000000.jsonl.gz` (a term weekday). One JSON line per tracker frame | |
| | `clouds/geo_day8_080011/` | Point clouds of all seven nodes for one hour of day 8, 19:00-20:00 UTC (the rotating sample hour), as `cloudframes-v1` segments | |
| | `benchmark/<level>/` | The three scripted-walk sessions: `busy` (day 15, 17:30-17:55 UTC), `quiet` (day 13, 16:02-16:41 UTC) and `moderate` (session of day 1, walked on day 2 00:39-01:26 UTC). Each holds the full point clouds of the window, live and offline tracklets, `ground_truth/` (routes as walked and the walk log) and `window.json`. Each benchmark's offline file covers the whole offline run, and `window.json` gives the benchmark window | |
| | `offline/<window>/` | The whole offline runs of the benchmark sessions (tracked at 10 Hz, stitched, exported at 5 Hz) | |
| | `environment/` | `static_map.npz` (de-peopled static point map), `furniture.json` (71 labeled objects), `study_area.json` (study-area polygon), `reconstruction/room_model_3dgs.ply` (room model, 3D Gaussian splatting) | |
| | `metadata/` | Recorder manifests and verifier intervals of the sampled sessions (`recorder/`), tracker runs, the trimmed cloud windows (`sample_windows.json`), experimental flicker flags for the sampled days with the session spans the filter reads (`flicker/`), and a short quality report | |
| | `loaders/` | The Python package `linger_loaders`: loaders for the tracklet, point-cloud, static-map, furniture and study-area files, the experimental flicker filter (`linger_loaders.flicker`), the replay tool (`linger_loaders.replay`) and a quickstart example (see below) | |
| | `CONFIG.json` | Frozen configuration the data were recorded under: detector checkpoint, calibration, study area, thresholds | |
| | `SHA256SUMS`, `VERSION`, `CHANGELOG.md`, `LICENSE` | Checksums, version, changes, license text | |
|
|
| ## Time stamps |
|
|
| All times are UTC, shifted by one fixed, undisclosed offset that is a whole number of weeks, so weekdays are kept. |
| The tracklet and cloud files hold Unix seconds or milliseconds; the metadata holds the same instants as Unix times and |
| as ISO 8601 strings in UTC (`+00:00`); clock times in `sessions.csv`, `window.json`, the walk logs and the quality |
| report are UTC as well. Days are numbered from day 1 to day 21 of the recording window, and a session keeps the |
| number of the day it started, so the evening of the day-1 session falls on day 2 in UTC. Folder and file names such |
| as `geo_day15_080014` are identifiers (day number and the recorder's start label); use the time fields, not the names. |
|
|
| ## Coordinates and formats |
|
|
| - **Shared coordinate frame.** All coordinates are in one shared coordinate frame (the frame of node N2): x and y horizontal, z up, |
| meters. The floor is near z = -2.65 m. |
| - **Static map** (`environment/static_map.npz`). Stored as int16 centimeters; the loader returns meters. It is not |
| cropped to the study area. |
| - **Room model** (`environment/reconstruction/room_model_3dgs.ply`). A standard 3D Gaussian splatting PLY (positions |
| in meters in the shared coordinate frame, scales, rotations, opacity and color) that opens in common 3DGS viewers. |
| The room model in this review sample has been edited for anonymity: it is cropped to the study area, and signage, |
| most personal belongings and remnants of people were removed, which leaves holes in those surfaces. The full release on |
| acceptance will include a more complete model. |
| - **Point clouds** (`cloudframes-v1`). Each `<node>__seg<nnn>/` folder holds `frames.npz` with `points` (N x 3, |
| float32, shared coordinate frame), `offsets` (the first point of each frame, length frames + 1) and `t_ms` (Unix ms per frame), |
| plus `meta.json` (format, source stream, first frame time, frame count). Segments are the recorder's 10-minute |
| segments, trimmed to the sampled window. Network addresses are redacted. The on-node filter removes points within |
| 0.10 m above the floor plane and points above z = -0.40 m (the ceiling cut), crops the cloud to the study area, and |
| drops points within 0.40 m of the columns. |
| - **Live tracklets** (`.jsonl.gz`). Each line is `{"rx": <logger receive time>, "msg": {...}}`. A `msg` of type |
| `frame` has `stamp` (tracker frame time), `received_at` and `tracks`, a list of `{id, x, y, z, w, l, h, state}` (box |
| center and size in meters; `state` is static, transitioning or moving, with the suffix `~coasting` when the tracklet is |
| predicted without a detection). Messages of type `feed_status` mark when the feed went offline or online. Key live |
| tracklets by (tracker run, id); runs are listed in `metadata/tracker_runs.csv`. |
| - **Offline tracklets** (`tracks_final_5hz.csv.gz`): `t_unix, track_id, x, y, state`. |
| - **Moderate benchmark, live tracklets.** No live log was recorded for this session. `tracks_live_replayed_*.csv.gz` |
| holds the live tracker replayed on the recorded clouds at the live tick cadence (about 1.3 Hz), every tick, with |
| extra columns (box, score, hits, age, detection flag, study-area gate). |
| - **Ground truth.** `routes_as_walked.json` gives each benchmark route (A, C, D, E) as walked, registered to the static |
| map. `walk_log.csv` gives each walk's logged start and end and the seated stops, to the minute. |
|
|
| ## Loaders, flicker filter and replay |
|
|
| `loaders/` holds the Python package `linger_loaders` (standard library and NumPy; see `loaders/README.md`). From the |
| folder that holds this README: |
|
|
| pip install "./loaders[quickstart]" # add ",replay" inside the brackets for the replay tool (rerun-sdk 0.38.1, needs Python 3.10 or newer) |
| python loaders/examples/quickstart.py . busy quickstart_busy.png |
| |
| ```python |
| import csv, json |
| from linger_loaders import load_tracklets, track_runs, load_segment, iter_frames, load_static_map, load_study_area |
| |
| off = load_tracklets("benchmark/busy/tracks_final_5hz.csv.gz") # t_unix, track_id, x, y, state, coasting |
| win = json.load(open("benchmark/busy/window.json"))["window_unix"] # [start, end) in Unix seconds |
| live = load_tracklets("track_log/tracks_day15_000000.jsonl.gz", session=win) |
| starts = [float(r["started_unix"]) for r in csv.DictReader(open("metadata/tracker_runs.csv"))] |
| run = track_runs(live["stamp"], starts) # key live tracks by (run[i], live["id"][i]) |
| seg = load_segment("benchmark/busy/clouds/geo_day15_080014/node1__seg033") |
| t_ms, pts = next(iter_frames(seg)) # one frame: Unix ms and n x 3 float32 points |
| sm = load_static_map("environment/static_map.npz") |
| area = load_study_area("environment/study_area.json") |
| ``` |
|
|
| The flicker filter writes flags and deletes nothing (`metadata/flicker/flags.tsv` holds its flags, rule revision 1.1, |
| for the tracklets born in this sample's live data): |
|
|
| python -m linger_loaders.flicker --logs track_log/tracks_day8_000000.jsonl.gz track_log/tracks_day15_000000.jsonl.gz \ |
| benchmark/quiet/tracks_live_day13_120200.jsonl.gz --runs metadata/tracker_runs.csv \ |
| --sessions metadata/flicker/session_spans.json --out flags.json |
| |
| The released flags were computed on the full logs, so running this command on the sample's logs gives nearly the same |
| set: a tracklet cut off at the edge of a sample log can count differently. With `--flagged-tsv`, the `tracker_run` column |
| holds the run's position in `metadata/tracker_runs.csv`. |
|
|
| The replay tool turns tracklet files into one Rerun recording each (static map, study area, node positions, tracklets |
| with IDs and trails, tracklets present per frame); give the live and offline files of a benchmark session together to |
| compare them: |
|
|
| python -m linger_loaders.replay . benchmark/busy/tracks_live_day15_133000.jsonl.gz \ |
| benchmark/busy/tracks_final_5hz.csv.gz -o busy.rrd --title "Day 15, busy benchmark" |
| rerun busy.rrd |
| |
|  |
|
|
| The replay tool on the busy benchmark session, showing live tracklets over the static map. The offline tracklets are a separate recording in the Sources panel. |
|
|
| ## Known issues |
|
|
| Node N1's calibration agrees less closely with the other nodes than they do with each other, so positions in N1's part |
| of the room are less reliable. |
|
|
| ## Not in this sample |
|
|
| The full release adds the remaining days' live tracklets, the remaining offline tracklets and the full point clouds of |
| all 21 days. It will be distributed under the same license, behind a short data-use agreement; this review sample needs |
| none. |
|
|
| ## License |
|
|
| The data are licensed under the Creative Commons Attribution-NonCommercial 4.0 International license |
| (CC BY-NC 4.0); see `LICENSE`. The code in `loaders/` is licensed under the MIT License; see `loaders/LICENSE`. |
|
|
