File size: 2,457 Bytes
dffbc1f | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 | """Dense action annotations (``annotations/vX/sY.json``, v1.1 human-reviewed).
Each file is ``{"segments": [{"timestamp": "HH:MM:SS-HH:MM:SS",
"action_annotation": {"action_name", "object_name", "hand_type", ...}}, ...]}``.
Timestamps are seconds from the start of the aligned recording. Malformed
timestamps raise instead of silently becoming 0.
"""
from __future__ import annotations
import json
from dataclasses import dataclass
from pathlib import Path
from typing import List, Optional, Tuple
from ..paths import DataRoot
class AnnotationError(ValueError):
pass
def parse_time(ts: str) -> float:
"""``'HH:MM:SS'``, ``'MM:SS'`` (fractional seconds allowed) -> seconds."""
parts = ts.strip().split(":")
try:
if len(parts) == 3:
return float(parts[0]) * 3600 + float(parts[1]) * 60 + float(parts[2])
if len(parts) == 2:
return float(parts[0]) * 60 + float(parts[1])
except ValueError:
pass
raise AnnotationError(f"malformed time {ts!r}")
def parse_range(ts_range: str) -> Tuple[float, float]:
if not isinstance(ts_range, str) or "-" not in ts_range:
raise AnnotationError(f"malformed timestamp range {ts_range!r}")
a, b = ts_range.split("-", 1)
start, end = parse_time(a), parse_time(b)
if end < start:
raise AnnotationError(f"timestamp range ends before it starts: {ts_range!r}")
return start, end
@dataclass(frozen=True)
class Segment:
rid: str
index: int
start_sec: float
end_sec: float
verb: Optional[str]
noun: Optional[str]
hand: Optional[str]
raw: dict
@property
def duration_sec(self) -> float:
return self.end_sec - self.start_sec
def load_segments_file(path: Path, rid: str) -> List[Segment]:
with open(path, encoding="utf-8") as f:
d = json.load(f)
if not isinstance(d, dict) or not isinstance(d.get("segments"), list):
raise AnnotationError(f"{path}: expected an object with a 'segments' list")
out = []
for i, s in enumerate(d["segments"]):
a = s.get("action_annotation") or {}
start, end = parse_range(s.get("timestamp", ""))
out.append(Segment(rid, i, start, end, a.get("action_name"), a.get("object_name"),
a.get("hand_type"), a))
return out
def load_segments(dr: DataRoot, rid: str) -> List[Segment]:
return load_segments_file(dr.annotation_path(rid, must_exist=True), rid)
|