README.md

metadata

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

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.