anonymous-uploader's picture
Add review sample
527fb6f verified
Raw History Blame Contribute Delete
6.82 kB
# SPDX-License-Identifier: MIT
"""Loaders for the LiNGER release (standard library and NumPy only).
Coordinates are in the shared coordinate frame, the frame of node N2: x and y horizontal, z up, in meters. The floor is
near z = -2.65 m. Field names follow the appendix table "Fields of the released files".
All timestamps are UTC and shifted by a whole number of weeks; see the README.
"""
import csv
import gzip
import io
import json
import os
import numpy as np
__all__ = ["load_tracklets", "load_segment", "iter_frames", "load_static_map", "load_furniture",
"load_study_area", "track_runs", "LIVE_FIELDS", "OFFLINE_FIELDS"]
__version__ = "0.1.0"
LIVE_FIELDS = ("stamp", "received_at", "id", "x", "y", "z", "w", "l", "h", "state")
OFFLINE_FIELDS = ("t_unix", "track_id", "x", "y", "state")
def _open_text(path):
return io.TextIOWrapper(gzip.open(path, "rb"), encoding="utf-8") if str(path).endswith(".gz") else open(path, encoding="utf-8")
def _window(session):
"""session is None, a two-item sequence (start, stop), or a dict with 'start' and 'stop'; times in Unix seconds."""
if session is None:
return None
if isinstance(session, dict):
return float(session["start"]), float(session["stop"])
a, b = session
return float(a), float(b)
def load_tracklets(path, session=None):
"""Read a live log or an offline track file into a dict of equal-length NumPy columns, one row per track and frame.
Args:
path: live log (``.jsonl`` or ``.jsonl.gz``) or offline file (``.csv`` or ``.csv.gz``).
session: optional time window in Unix seconds: a two-item sequence ``(start, stop)`` or a dict
``{"start": .., "stop": ..}``; rows with ``start <= t < stop`` are kept.
Returns:
Live logs give the columns in LIVE_FIELDS, offline files those in OFFLINE_FIELDS. Both also get a boolean
``coasting`` column, true where the state ends in ``~coasting`` (predicted, no detection). Live IDs are
valid within one tracker run only (see track_runs).
"""
win = _window(session)
p = str(path)
if p.endswith((".jsonl", ".jsonl.gz")):
cols = {k: [] for k in LIVE_FIELDS}
with _open_text(p) as fh:
try:
for line in fh:
try:
msg = json.loads(line).get("msg", {})
except ValueError:
continue
if msg.get("type") != "frame":
continue
t = float(msg["stamp"])
if win and not (win[0] <= t < win[1]):
continue
for tr in msg.get("tracks", []):
cols["stamp"].append(t)
cols["received_at"].append(float(msg.get("received_at", np.nan)))
for k in ("id", "x", "y", "z", "w", "l", "h", "state"):
cols[k].append(tr.get(k))
except EOFError:
# A log that is still being written ends in a truncated gzip member; keep what was read.
pass
out = {k: np.asarray(cols[k], dtype=float) for k in ("stamp", "received_at", "x", "y", "z", "w", "l", "h")}
out["id"] = np.asarray(cols["id"], dtype=np.int64)
out["state"] = np.asarray(cols["state"], dtype=object)
elif p.endswith((".csv", ".csv.gz")):
cols = {k: [] for k in OFFLINE_FIELDS}
with _open_text(p) as fh:
for r in csv.DictReader(fh):
t = float(r["t_unix"])
if win and not (win[0] <= t < win[1]):
continue
for k in OFFLINE_FIELDS:
cols[k].append(r[k])
out = {"t_unix": np.asarray(cols["t_unix"], dtype=float), "track_id": np.asarray(cols["track_id"], dtype=np.int64),
"x": np.asarray(cols["x"], dtype=float), "y": np.asarray(cols["y"], dtype=float),
"state": np.asarray(cols["state"], dtype=object)}
else:
raise ValueError(f"unknown tracklet format: {p}")
out["coasting"] = np.array([str(s).endswith("~coasting") for s in out["state"]], dtype=bool)
return out
def track_runs(stamp, run_starts):
"""Index of the tracker run each row belongs to, so that live tracks can be keyed as (run, id).
The live tracker restarts daily and its IDs restart with it. ``run_starts`` holds the Unix times of the restarts:
the started_unix values in metadata/tracker_runs.csv.
"""
return np.searchsorted(np.sort(np.asarray(run_starts, dtype=float)), np.asarray(stamp, dtype=float), side="right")
def load_segment(path):
"""Read one recorded segment directory (``frames.npz`` and ``meta.json``, format cloudframes-v1).
Returns:
dict with ``points`` (N x 3 float32, shared coordinate frame), ``offsets`` (int64, index of each frame's first point,
frames + 1 entries), ``t_ms`` (int64, Unix milliseconds per frame) and ``meta`` (the parsed meta.json).
"""
with np.load(os.path.join(path, "frames.npz")) as z:
seg = {"points": z["points"], "offsets": z["offsets"], "t_ms": z["t_ms"]}
with open(os.path.join(path, "meta.json"), encoding="utf-8") as fh:
seg["meta"] = json.load(fh)
if seg["meta"].get("format") != "cloudframes-v1":
raise ValueError(f"unexpected segment format {seg['meta'].get('format')!r} in {path}")
return seg
def iter_frames(segment):
"""Yield ``(t_ms, points)`` for each frame of a segment from load_segment."""
P, off = segment["points"], segment["offsets"]
for i, t in enumerate(segment["t_ms"]):
yield int(t), P[off[i]:off[i + 1]]
def load_static_map(path):
"""Read the static map, which is stored in centimeters.
Returns:
dict with ``points`` (N x 3 float64, meters, shared coordinate frame), ``node`` (the node, 1-7, that observed each
point) and ``floor_z`` (meters).
"""
with np.load(path) as z:
return {"points": z["xyz"].astype(np.float64) / 100.0, "node": z["node"].astype(np.int16),
"floor_z": float(z["floor_z_m"])}
def load_furniture(path):
"""Read the furniture layer as a list of dicts with id, label, center x and y, footprint len_m and wid_m,
heading yaw_rad and shape (shared coordinate frame)."""
with open(path, encoding="utf-8") as fh:
d = json.load(fh)
keep = ("id", "label", "x", "y", "len_m", "wid_m", "yaw_rad", "shape")
return [{k: e.get(k) for k in keep} for e in (d["entries"] if isinstance(d, dict) else d)]
def load_study_area(path):
"""Read the study-area polygon as an n x 2 array of vertices in meters."""
with open(path, encoding="utf-8") as fh:
return np.asarray(json.load(fh)["polygon_xy_m"], dtype=float)