---
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 LiNGER](assets/linger_overview.png)

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

![Replay tool](assets/replay_busy.png)

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`.