Delete clip_library

moving to spaces repo

clip_library/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2024 Jenna Kline
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

clip_library/README.md

@@ -1,102 +0,0 @@
-# Drone Maneuver Clips — Test-Clip Library + Decision-Tree Replay Harness
-
-Dataset: **[imageomics/drone-maneuver-clips](https://huggingface.co/datasets/imageomics/drone-maneuver-clips)**
-
-A benchmark of **six-second aerial drone clips** (180 frames @ 30 fps), each
-indexed by the autonomous-flight **maneuver** it can test, plus a small
-**deterministic policy** that replays a formal maneuver decision tree over the
-clips to emit ground-truth drone actions. Together they let a learned navigation
-policy be scored, per maneuver, against an expert-calibrated reference.
-
-The initial release is **41 clips cut from the
-[KABR](https://huggingface.co/datasets/imageomics/KABR) wildlife dataset**;
-future releases will add clips from other sources, so the harness and schema are
-deliberately source-agnostic.
-
-- **Dataset**: per-frame-per-track labels (bbox, species, behaviour, vigilance,
-  track id, ground-truth pose where available, telemetry) —
-  `clips/<id>/labels.csv`, plus a `catalog/` of per-video and per-clip indices.
-- **Harness**: the maneuver decision tree
-  ([`clip_library/maneuver_decision_tree.md`](clip_library/maneuver_decision_tree.md))
-  executed deterministically → `clips/<id>/maneuver_labels.csv`.
-
-## Quick start
-
-Download the released clip library (~6 GB) into `./data/drone-maneuver-clips/`
-(or set `DRONE_CLIPS_ROOT` to wherever you put it), then generate / tweak
-maneuver labels — no raw video and no GPU required:
-
-```bash
-pip install -r requirements.txt          # pandas, numpy (pyarrow optional)
-
-# point the harness at the downloaded dataset (default: ./data/drone-maneuver-clips)
-export DRONE_CLIPS_ROOT=/path/to/drone-maneuver-clips
-
-# generate GT actions for every clip and the maneuvers it's tagged for
-python -m clip_library.maneuver_labels --all
-
-# tweak inputs: a stricter vigilance threshold, a different SoI, a pixel target
-python -m clip_library.maneuver_labels --clip 12_01_23-DJI_0002_000745 \
-       --maneuver behavior_adaptive --theta-s 0.3
-python -m clip_library.maneuver_labels --maneuver soi_aware --soi right --desired-pixels 100
-```
-
-Every threshold is reviewer-tunable: `--theta-s` (vigilance), `--desired-pixels`,
-`--soi`, plus the `Params` dataclass and module constants (`SMOOTH_WINDOW`,
-`KEEP_LO/HI`, `POSE_RING`) in [`clip_library/maneuver_labels.py`](clip_library/maneuver_labels.py).
-A tuned or single-maneuver "what-if" run writes a `maneuver_labels.custom.csv`
-sidecar and leaves the canonical `maneuver_labels.csv` untouched, so experiments
-never corrupt the release.
-
-## Minimum system & environment requirements
-
-| | requirement |
-|---|---|
-| OS | Linux or macOS |
-| Python | 3.9 (3.8+ works) |
-| CPU/GPU | **CPU only — no GPU required** |
-| RAM | ~2 GB (CSVs are small) |
-| Disk | **~6 GB** for the released clip library |
-| Runtime | the harness over all 41 clips: **seconds** |
-| Key deps | `pandas`, `numpy`; `pyarrow` optional (Parquet catalog I/O) |
-
-## Dataset layout
-
-```
-data/drone-maneuver-clips/      # (DRONE_CLIPS_ROOT)
-├── catalog/
-│   ├── video_index.csv         # one row per source video
-│   ├── clip_index.csv          # one row per clip
-│   ├── coverage_report.md      # species/size/maneuver coverage
-│   └── pose_audit.csv          # per-video GT-pose assignment audit
-├── clips/<clip_id>/
-│   ├── clip.mp4                # 6 s, 180 frames
-│   ├── labels.csv              # one row per frame per tracked individual
-│   └── maneuver_labels.csv     # per-frame GT action set, per maneuver
-└── DATASET_CARD.md
-```
-
-The `labels.csv` / `clip_index.csv` columns are documented in
-[`clip_library/schema.py`](clip_library/schema.py); the maneuver decision tree
-is in [`clip_library/maneuver_decision_tree.md`](clip_library/maneuver_decision_tree.md).
-
-## Limitations
-
-- **Label provenance** is a deliberate methodological position: perception
-  labels (detection / behaviour / pose) mirror what an autonomous system
-  receives at deployment, with session-level expert oversight — not a fully
-  hand-verified corpus.
-- **GT pose is sparse** (only frames with KABR pose crops), so the **SoI-aware**
-  maneuver is under-exercised on this initial release; with dense
-  model-generated pose it is fully exercised.
-- **Retrospective**, not field-validated closed-loop. The KABR-sourced clips
-  were flown lower than ideal tracking altitude, so TRACK range-control labels
-  skew toward "back".
-- Single-drone, single-view. Multi-view is future work.
-
-## License & citation
-
-Dataset: **CC-BY-4.0**. Code: see `LICENSE`. The current clips are derived from
-the KABR dataset (Kholiavchenko et al.) and KABR-poses; please cite those
-alongside this artifact. Clips from other sources in future releases carry their
-own upstream attribution — see the dataset card.

clip_library/__init__.py

@@ -1,16 +0,0 @@
-"""Drone-maneuver test-clip library — deterministic decision-tree replay harness.
-
-A benchmark of 6-second, maneuver-indexed aerial drone clips (initially sourced
-from the KABR wildlife dataset; more sources to come), each carrying
-per-frame-per-track labels, plus a small deterministic policy that replays a
-formal maneuver decision tree over the clips to emit ground-truth drone actions.
-
-Modules:
-    schema           -> dataset constants, vocabularies, and column sets
-    io_paths         -> CSV/Parquet table helpers
-    maneuver_labels  -> the decision-tree replay harness (entry point)
-
-Run the harness with:  python -m clip_library.maneuver_labels --all
-"""
-
-__all__ = ["schema", "io_paths"]

clip_library/io_paths.py

@@ -1,52 +0,0 @@
-"""Small table-I/O helpers for the clip library.
-
-The released harness only needs to read the catalog tables and write its
-per-clip maneuver labels. CSV is always written; Parquet is added when pyarrow
-is installed, and preferred on read when present.
-
-(The raw-video resolution and frame-extraction helpers used to rebuild the
-dataset from the source videos are part of the offline build pipeline and are
-not included in this public release.)
-"""
-
-from __future__ import annotations
-
-import os
-
-
-# --------------------------------------------------------------------------- #
-# Table I/O (CSV always; Parquet when pyarrow is present)
-# --------------------------------------------------------------------------- #
-def have_parquet() -> bool:
-    try:
-        import pyarrow  # noqa: F401
-
-        return True
-    except Exception:
-        return False
-
-
-def write_table(df, path_noext: str) -> list[str]:
-    """Write a DataFrame to `<path_noext>.csv` (+ `.parquet` if available)."""
-    os.makedirs(os.path.dirname(path_noext), exist_ok=True)
-    written = []
-    csv_path = path_noext + ".csv"
-    df.to_csv(csv_path, index=False)
-    written.append(csv_path)
-    if have_parquet():
-        pq_path = path_noext + ".parquet"
-        try:
-            df.to_parquet(pq_path, index=False)
-            written.append(pq_path)
-        except Exception:
-            pass
-    return written
-
-
-def read_table(path_noext: str):
-    """Read `<path_noext>.parquet` if present else `.csv`."""
-    import pandas as pd
-
-    if have_parquet() and os.path.exists(path_noext + ".parquet"):
-        return pd.read_parquet(path_noext + ".parquet")
-    return pd.read_csv(path_noext + ".csv", low_memory=False)

clip_library/maneuver_decision_tree.md

@@ -1,124 +0,0 @@
-# Maneuver Decision Tree — formal specification
-
-This document is both (a) the citable policy specification and (b) the exact
-logic that `maneuver_labels.py` executes deterministically over each clip's
-`labels.csv`. One row per branch: condition → action.
-
----
-
-## 0. Action space & output model
-
-Nine actions: `up, down, forward, back, left, right, yaw-left, yaw-right, hover`.
-
-- Per frame the generator emits a **set** of actions (e.g. `{forward, yaw-left}`);
-  `hover` is its own explicit token, emitted when the set is otherwise empty.
-- The raw per-frame sets are **smoothed** into the published action: each set is
-  decomposed onto four signed axes — `x ∈ {left −1, right +1}`,
-  `y ∈ {down −1, up +1}`, `z ∈ {back −1, forward +1}`, `yaw ∈ {yaw-left −1,
-  yaw-right +1}` — averaged with a trailing window of `W = 90` frames (3 s @ 30 fps),
-  then re-thresholded. An axis whose smoothed magnitude is within the dead-zone
-  (`|mean| ≤ 0.33`) emits no motion; all axes quiet → `hover`.
-
----
-
-## 1. Per-frame features
-
-**Keep-in zone:** the center 50% of the frame — trim ¼ off each edge →
-x ∈ [0.25, 0.75], y ∈ [0.25, 0.75] (frame 3840×2160). The herd is "centered"
-when its centroid is inside this box; corrections fire when it leaves.
-
-### Per-track (from `labels.csv`)
-| field | values (normalized) |
-|---|---|
-| `species` | Giraffe, Plains Zebra, Grevys Zebra (collapse `Grevy`→`Grevys Zebra`) |
-| `behaviour` | Head Up, Walk (collapse `Walking`→`Walk`), Graze, Browsing, Running, Trotting, Auto-Groom |
-| `vigilant` | True if behaviour ∈ {Head Up, Running, Trotting} |
-| `pose` | front, front-left, front-right, left, right, back-left, back-right, back |
-| bbox | `x_c, y_c`, `w, h`, `bbox_area_frac`, `bbox_size_class` ∈ {far, medium, close} |
-| telemetry | `latitude, longitude, altitude` (used by APPROACH only) |
-
-### Frame-level aggregates (derived)
-`n_tracks`, `centroid` (mean `x_c, y_c` over the followed animals, normalized),
-`mean_px` (mean longest bbox side over followed animals), `pct_vigilant`,
-`S_t` (trailing 90-frame mean of `pct_vigilant`), `majority_pose`.
-When `n_tracks` exceeds `max_animals`, only the `max_animals` largest bboxes are
-followed (this also subsumes herd fission/fusion: the larger subgroup wins).
-
----
-
-## 2. The four maneuvers
-
-### Maneuver 1 — APPROACH
-Objective: begin the mission and position the drone without spooking wildlife.
-**User params:** `launch_altitude` (50 m), `end_altitude` (30 m), `target_species`.
-
-| # | condition | action | note |
-|---|---|---|---|
-| 1 | target detected, centroid in keep-zone | `hover` | approach complete → handoff |
-| 2 | altitude < launch_altitude − 1 | `up` | climb to launch altitude |
-| 3 | altitude > end_altitude + 1 | `down` | descend toward end altitude |
-| 4 | otherwise (target not yet detected) | `forward` | search forward |
-
-### Maneuver 2 — TRACK
-Objective: keep the majority of the herd centroid in the center-50% keep-zone,
-at a desired apparent size. Range control acts in the X–Z plane only (no vertical).
-**User params:** `desired_pixels` (30), `pixel_band` (±0.25), `max_animals` (5).
-
-| # | condition | action | note |
-|---|---|---|---|
-| 1 | centroid.x right of keep-zone | `left` | recenter |
-| 2 | centroid.x left of keep-zone | `right` | recenter |
-| 3 | mean_px below `desired_pixels·(1−band)` | `forward` | too small → close in |
-| 4 | mean_px above `desired_pixels·(1+band)` | `back` | too large → back off |
-| – | no detection | `hover` | |
-
-### Maneuver 3 — BEHAVIOR-ADAPTIVE FLIGHT (BAF)
-Objective: detect and respond to disturbance. Evaluated as an **override** on the
-smoothed vigilance series `S_t`, with a hover hold after each trigger.
-**User params:** `theta_S` (0.5), `baf_response` ∈ {retreat, hover}.
-
-| # | condition | action | note |
-|---|---|---|---|
-| 1 | `S_t` ≥ theta_S | `retreat` = `{back, up}` (or `{hover}`) | override active maneuver |
-| 2 | a trigger fired within the last 150 frames (5 s) | `hover` | hysteresis hold |
-| 3 | otherwise | (no override; defer to active maneuver) | calm |
-
-### Maneuver 4 — SoI-AWARE
-Objective: maneuver to capture the desired Surface of Interest (pose) of the
-majority of the herd, then hold at a target apparent size. Two stages.
-**User params:** `soi` (desired pose, default `left`), `desired_pixels`
-(per objective: track 30, behavior 100, re-ID 500).
-
-The eight poses form a ring; one `yaw-left` step rotates apparent pose one
-position around it (front → front-right → right → …). To reach the desired pose
-the drone yaws the short way; `yaw-right` rotates the opposite direction.
-
-| # | stage | condition | action |
-|---|---|---|---|
-| 1 | rotate | majority_pose ≠ soi | `yaw-left` / `yaw-right` (short way around ring) |
-| 2 | range | majority_pose = soi, mean_px < target | `forward` |
-| 3 | range | majority_pose = soi, mean_px > target | `back` |
-| 4 | hold | majority_pose = soi, mean_px in band | `hover` |
-| – | no pose available | | `hover` |
-
----
-
-## 3. Composition (mission)
-A mission may run several maneuvers; the intended override priority is
-**BAF → APPROACH (until handoff) → TRACK → SoI**. This release generates labels
-per `(clip × maneuver × param-set)` independently; cross-maneuver composition is
-left to the consumer.
-
----
-
-## 4. Generator output
-Per `(clip × maneuver × param-set)`, long-format `maneuver_labels.csv` columns:
-`clip_id, frame_local, maneuver, action_set_raw, action_set_smoothed,
-triggering_branch, S_t, pct_vigilant, n_tracks, centroid_x, centroid_y, mean_px`.
-
----
-
-## 5. Data hygiene
-- Collapse `Walking`→`Walk`, `Grevy`→`Grevys Zebra` (applied at label-load and
-  re-emitted in the released dataset).
-- `vigilant` = behaviour ∈ {Head Up, Running, Trotting}.

clip_library/maneuver_labels.py

@@ -1,343 +0,0 @@
-"""Deterministic maneuver-label generator (the ACSOS replay harness).
-
-Given a clip's per-frame-per-track ``labels.csv`` and a maneuver + user params,
-this replays the formal decision tree in ``maneuver_decision_tree.md`` (shipped
-alongside this module) and emits one ground-truth drone action per frame. The
-action is a *set* drawn
-from the 9-action space, smoothed by a trailing rolling average so the GT track
-isn't jerky.
-
-This is the artifact's headline contribution: a small, inspectable policy
-specification executed deterministically over a labeled benchmark, so a learned
-navigation policy can be scored against an expert-calibrated reference.
-
-Action space (per frame, a set; empty -> {hover}):
-    up, down, forward, back, left, right, yaw-left, yaw-right, hover
-
-Usage:
-    # one clip, one maneuver
-    python -m clip_library.maneuver_labels --clip 12_01_23-DJI_0002_000745 --maneuver track
-    # all extracted clips, each maneuver it's tagged suitable for
-    python -m clip_library.maneuver_labels --all
-"""
-from __future__ import annotations
-
-import os
-import argparse
-from dataclasses import dataclass, field, asdict
-
-import numpy as np
-import pandas as pd
-
-from . import schema, io_paths
-
-# --------------------------------------------------------------------------- #
-# Frame geometry & the keep-in zone (center 50%)
-# --------------------------------------------------------------------------- #
-FRAME_W, FRAME_H = 3840, 2160
-KEEP_LO, KEEP_HI = 0.25, 0.75          # trim 1/4 off each edge
-
-# Smoothing: decompose actions onto signed axes, trailing-average over W frames,
-# then re-threshold. |mean| <= AXIS_DEADZONE -> no motion on that axis.
-SMOOTH_WINDOW = 90                      # frames (3 s @ 30 fps)
-AXIS_DEADZONE = 0.33
-
-# Behaviour -> vigilance (matches schema.VIGILANCE_BEHAVIOURS)
-VIGILANCE_WINDOW = 90                  # frames (3 s) for the smoothed S_t
-HOVER_HOLD = 150                       # frames (5 s) BAF hovers after a trigger
-
-# Pose ring, ordered so a +1 step == one 'yaw-left' increment of apparent pose
-# (front -> front-right -> right ...). To rotate toward a target SoI we take the
-# shortest signed distance around this ring; sign convention is OPEN ITEM 7.
-POSE_RING = ["front", "front-right", "right", "back-right",
-             "back", "back-left", "left", "front-left"]
-
-
-# --------------------------------------------------------------------------- #
-# User parameters (reviewer-tunable; defaults from the spec)
-# --------------------------------------------------------------------------- #
-@dataclass
-class Params:
-    # APPROACH
-    launch_altitude: float = 50.0
-    end_altitude: float = 30.0
-    target_species: str | None = None   # None = any species counts as "target"
-    # TRACK / SoI pixel targets (longest bbox side, px)
-    desired_pixels: float = 30.0        # TRACK default; SoI overrides per objective
-    pixel_band: float = 0.25            # +/- tolerance around desired_pixels
-    max_animals: int = 5                # follow the N largest bboxes
-    # BAF
-    theta_S: float = 0.5                # vigilance threshold on smoothed S_t
-    baf_response: str = "retreat"       # 'retreat' -> {back, up} | 'hover'
-    # SoI
-    soi: str = "left"                   # desired pose (broadside by default)
-
-    def with_objective(self, objective: str) -> "Params":
-        """SoI desired-pixel presets by downstream objective (cite prior work)."""
-        px = {"track": 30.0, "behavior": 100.0, "reid": 500.0}.get(objective)
-        if px is not None:
-            self.desired_pixels = px
-        return self
-
-
-# axis encoding: (dx, dy, dz, dyaw); +x right, +y up, +z forward, +yaw yaw-right
-_AXIS_TO_TOKENS = {
-    ("x", +1): "right", ("x", -1): "left",
-    ("y", +1): "up",    ("y", -1): "down",
-    ("z", +1): "forward", ("z", -1): "back",
-    ("yaw", +1): "yaw-right", ("yaw", -1): "yaw-left",
-}
-_TOKEN_TO_AXIS = {tok: (ax, s) for (ax, s), tok in _AXIS_TO_TOKENS.items()}
-
-
-def _tokens_to_vec(tokens: set[str]) -> np.ndarray:
-    """{action tokens} -> signed [x, y, z, yaw] vector ('hover' -> zeros)."""
-    idx = {"x": 0, "y": 1, "z": 2, "yaw": 3}
-    v = np.zeros(4)
-    for t in tokens:
-        if t in _TOKEN_TO_AXIS:
-            ax, s = _TOKEN_TO_AXIS[t]
-            v[idx[ax]] = s
-    return v
-
-
-def _vec_to_tokens(v: np.ndarray) -> set[str]:
-    """Signed [x, y, z, yaw] -> action token set ('hover' if all zero)."""
-    axes = ["x", "y", "z", "yaw"]
-    toks = {_AXIS_TO_TOKENS[(ax, int(np.sign(val)))]
-            for ax, val in zip(axes, v) if val != 0}
-    return toks or {"hover"}
-
-
-# --------------------------------------------------------------------------- #
-# Per-frame features
-# --------------------------------------------------------------------------- #
-@dataclass
-class FrameFeatures:
-    frame_local: int
-    n_tracks: int
-    centroid_x: float           # normalized 0..1
-    centroid_y: float
-    mean_px: float              # mean longest-side over followed animals
-    pct_vigilant: float
-    majority_pose: str
-    altitude: float
-
-
-def _bbox_px(row) -> float:
-    return float(max(row.w, row.h))
-
-
-def _frame_features(g: pd.DataFrame, params: Params) -> FrameFeatures:
-    """Compute frame-level aggregates from the visible tracks at one frame."""
-    vis = g[~g["outside"].astype(str).str.lower().isin(["true", "1"])]
-    n = len(vis)
-    if n == 0:
-        return FrameFeatures(int(g["frame_local"].iloc[0]), 0,
-                             0.5, 0.5, 0.0, 0.0, "", float("nan"))
-    # follow the N largest bboxes (subsumes fission/fusion: larger subgroup wins)
-    vis = vis.assign(_area=vis["w"] * vis["h"]).nlargest(params.max_animals, "_area")
-    cx = float(vis["x_c"].mean()) / FRAME_W
-    cy = float(vis["y_c"].mean()) / FRAME_H
-    mean_px = float(vis.apply(_bbox_px, axis=1).mean())
-    vig = vis["vigilant"].astype(str).str.lower().isin(["true", "1"]).mean()
-    poses = [p for p in vis["pose"].astype(str) if p and p != "nan"]
-    majority = max(set(poses), key=poses.count) if poses else ""
-    alt = float(vis["altitude"].iloc[0]) if "altitude" in vis else float("nan")
-    return FrameFeatures(int(g["frame_local"].iloc[0]), int(n),
-                         cx, cy, mean_px, float(vig), majority, alt)
-
-
-# --------------------------------------------------------------------------- #
-# Per-maneuver decision functions: features -> (token set, branch id)
-# --------------------------------------------------------------------------- #
-def decide_track(f: FrameFeatures, p: Params) -> tuple[set[str], str]:
-    if f.n_tracks == 0:
-        return {"hover"}, "no-detection"
-    toks: set[str] = set()
-    # horizontal recenter (keep herd centroid in center-50%)
-    if f.centroid_x > KEEP_HI:
-        toks.add("left")
-    elif f.centroid_x < KEEP_LO:
-        toks.add("right")
-    # range control by apparent pixel size (X-Z plane only; no vertical)
-    lo, hi = p.desired_pixels * (1 - p.pixel_band), p.desired_pixels * (1 + p.pixel_band)
-    if f.mean_px < lo:
-        toks.add("forward")
-    elif f.mean_px > hi:
-        toks.add("back")
-    return (toks or {"hover"}), "track"
-
-
-def decide_soi(f: FrameFeatures, p: Params) -> tuple[set[str], str]:
-    if f.n_tracks == 0 or not f.majority_pose:
-        return {"hover"}, "no-pose"
-    if f.majority_pose not in POSE_RING or p.soi not in POSE_RING:
-        return {"hover"}, "pose-unknown"
-    if f.majority_pose != p.soi:
-        # shortest signed rotation around the ring; +step == yaw-left
-        i, j = POSE_RING.index(f.majority_pose), POSE_RING.index(p.soi)
-        d = (j - i) % len(POSE_RING)
-        step = d if d <= len(POSE_RING) - d else d - len(POSE_RING)
-        return ({"yaw-left"} if step > 0 else {"yaw-right"}), "soi-rotate"
-    # pose achieved -> close/retreat to desired pixels
-    lo, hi = p.desired_pixels * (1 - p.pixel_band), p.desired_pixels * (1 + p.pixel_band)
-    if f.mean_px < lo:
-        return {"forward"}, "soi-range-in"
-    if f.mean_px > hi:
-        return {"back"}, "soi-range-out"
-    return {"hover"}, "soi-hold"
-
-
-def decide_approach(f: FrameFeatures, p: Params) -> tuple[set[str], str]:
-    detected = (f.n_tracks > 0 and KEEP_LO <= f.centroid_x <= KEEP_HI
-                and KEEP_LO <= f.centroid_y <= KEEP_HI)
-    if detected:
-        return {"hover"}, "approach-detected"   # handoff
-    if not np.isnan(f.altitude):
-        if f.altitude < p.launch_altitude - 1:
-            return {"up"}, "approach-climb"
-        if f.altitude > p.end_altitude + 1:
-            return {"down"}, "approach-descend"
-    return {"forward"}, "approach-search"
-
-
-def decide_baf(series_St: np.ndarray, idx: int, p: Params) -> tuple[set[str], str]:
-    """BAF is an override; evaluated on the smoothed S_t series with a hover hold."""
-    if series_St[idx] >= p.theta_S:
-        resp = {"back", "up"} if p.baf_response == "retreat" else {"hover"}
-        return resp, "baf-trigger"
-    # hover-hold: stay hovering for HOVER_HOLD frames after the last trigger
-    lo = max(0, idx - HOVER_HOLD)
-    if np.any(series_St[lo:idx] >= p.theta_S):
-        return {"hover"}, "baf-hold"
-    return set(), "baf-calm"     # empty -> no override
-
-
-# --------------------------------------------------------------------------- #
-# Driver
-# --------------------------------------------------------------------------- #
-def _smooth(raw_vecs: np.ndarray, window: int) -> np.ndarray:
-    """Trailing rolling-mean each axis, then re-threshold past the dead-zone."""
-    df = pd.DataFrame(raw_vecs, columns=["x", "y", "z", "yaw"])
-    sm = df.rolling(window, min_periods=1).mean()
-    out = np.where(sm.abs() <= AXIS_DEADZONE, 0, np.sign(sm))
-    return out
-
-
-def generate(labels_csv: str, maneuver: str, params: Params) -> pd.DataFrame:
-    df = pd.read_csv(labels_csv, low_memory=False)
-    frames = sorted(df["frame_local"].unique())
-    feats = [_frame_features(df[df["frame_local"] == fl], params) for fl in frames]
-
-    # BAF needs the smoothed S_t series first
-    pct_vig = np.array([f.pct_vigilant for f in feats])
-    St = pd.Series(pct_vig).rolling(VIGILANCE_WINDOW, min_periods=1).mean().to_numpy()
-
-    rows, raw_vecs = [], []
-    for i, f in enumerate(feats):
-        if maneuver == "track":
-            toks, branch = decide_track(f, params)
-        elif maneuver == "soi_aware":
-            toks, branch = decide_soi(f, params)
-        elif maneuver == "approach":
-            toks, branch = decide_approach(f, params)
-        elif maneuver == "behavior_adaptive":
-            toks, branch = decide_baf(St, i, params)
-            toks = toks or {"hover"}
-        else:
-            raise ValueError(f"unknown maneuver {maneuver!r}")
-        raw_vecs.append(_tokens_to_vec(toks))
-        rows.append((f, branch, toks))
-
-    smoothed = _smooth(np.array(raw_vecs), SMOOTH_WINDOW)
-
-    out = []
-    for (f, branch, raw_toks), sv in zip(rows, smoothed):
-        out.append({
-            "clip_id": os.path.basename(os.path.dirname(labels_csv)),
-            "frame_local": f.frame_local,
-            "maneuver": maneuver,
-            "action_set_raw": "|".join(sorted(raw_toks)),
-            "action_set_smoothed": "|".join(sorted(_vec_to_tokens(sv))),
-            "triggering_branch": branch,
-            "S_t": round(float(St[f.frame_local]) if f.frame_local < len(St) else 0.0, 3),
-            "pct_vigilant": round(f.pct_vigilant, 3),
-            "n_tracks": f.n_tracks,
-            "centroid_x": round(f.centroid_x, 3),
-            "centroid_y": round(f.centroid_y, 3),
-            "mean_px": round(f.mean_px, 1),
-        })
-    return pd.DataFrame(out)
-
-
-def _clip_dirs(out_root: str) -> list[str]:
-    clips = os.path.join(out_root, "clips")
-    return sorted(
-        os.path.join(clips, d) for d in os.listdir(clips)
-        if os.path.exists(os.path.join(clips, d, "labels.csv"))
-    ) if os.path.isdir(clips) else []
-
-
-def main():
-    ap = argparse.ArgumentParser(description="Generate deterministic maneuver-action labels")
-    ap.add_argument("--out", default=schema.OUTPUT_ROOT)
-    ap.add_argument("--clip", default=None, help="clip_id (default: all extracted)")
-    ap.add_argument("--maneuver", default=None,
-                    choices=["approach", "track", "behavior_adaptive", "soi_aware"],
-                    help="default: each clip's suitable_maneuvers")
-    ap.add_argument("--all", action="store_true")
-    # a few inline param overrides
-    ap.add_argument("--desired-pixels", type=float, default=None)
-    ap.add_argument("--theta-s", type=float, default=None)
-    ap.add_argument("--soi", default=None)
-    args = ap.parse_args()
-
-    clip_index = io_paths.read_table(os.path.join(args.out, "catalog", "clip_index"))
-    suitable = dict(zip(clip_index["clip_id"], clip_index["suitable_maneuvers"].fillna("")))
-    # map spec name 'launch' tag -> 'approach' maneuver
-    name_map = {"launch": "approach", "follow": "track",
-                "behavior_adaptive": "behavior_adaptive", "soi_aware": "soi_aware"}
-
-    dirs = _clip_dirs(args.out)
-    if args.clip:
-        dirs = [d for d in dirs if os.path.basename(d) == args.clip]
-        if not dirs:
-            raise SystemExit(f"no extracted clip {args.clip!r} (run extract_clips first)")
-
-    # A "what-if" run (maneuver subset or any tuned param) must NOT clobber the
-    # canonical, default-param maneuver_labels.csv -- it writes a sidecar instead.
-    is_tweak = bool(args.maneuver or args.desired_pixels is not None
-                    or args.theta_s is not None or args.soi is not None)
-    out_name = "maneuver_labels.custom.csv" if is_tweak else "maneuver_labels.csv"
-    if is_tweak:
-        print(f"[tweak run] writing {out_name} (canonical maneuver_labels.csv untouched)")
-
-    n_written = 0
-    for d in dirs:
-        cid = os.path.basename(d)
-        tags = [name_map.get(t, t) for t in str(suitable.get(cid, "")).split("|") if t]
-        maneuvers = [args.maneuver] if args.maneuver else tags
-        parts = []
-        for mv in maneuvers:
-            p = Params()
-            if args.desired_pixels is not None:
-                p.desired_pixels = args.desired_pixels
-            if args.theta_s is not None:
-                p.theta_S = args.theta_s
-            if args.soi is not None:
-                p.soi = args.soi
-            parts.append(generate(os.path.join(d, "labels.csv"), mv, p))
-        if not parts:
-            continue
-        res = pd.concat(parts, ignore_index=True)
-        res.to_csv(os.path.join(d, out_name), index=False)
-        n_written += 1
-        summ = res.groupby("maneuver")["action_set_smoothed"].agg(
-            lambda s: s.value_counts().idxmax())
-        print(f"  {cid}: {', '.join(f'{m}->{a}' for m, a in summ.items())}")
-    print(f"\nwrote {out_name} for {n_written} clip(s)")
-
-
-if __name__ == "__main__":
-    main()

clip_library/requirements.txt

@@ -1,6 +0,0 @@
-# Runtime dependencies for the drone-maneuver clip library + replay harness.
-# CPU-only; no GPU or deep-learning framework required.
-#   pip install -r requirements.txt
-pandas>=2.0
-numpy>=1.23
-pyarrow>=12.0   # optional: enables/prefers Parquet catalog I/O

clip_library/schema.py

@@ -1,164 +0,0 @@
-"""Shared constants and schema for the drone-maneuver test-clip library.
-
-One place for: clip geometry, the label/index column sets, bbox-size and
-vigilance thresholds, the four maneuver-suitability tags, and the pose taxonomy.
-
-Nothing here imports heavy deps (no pandas/cv2 at import time) so it can be
-pulled into any consumer cheaply.
-
-This is the released ("Mode A") subset: it documents the columns and
-vocabularies of the published dataset and configures where the harness reads
-and writes. The raw-video rebuild pipeline and its source-data paths are not
-part of this public release.
-"""
-
-from __future__ import annotations
-
-import os
-
-# --------------------------------------------------------------------------- #
-# Paths
-# --------------------------------------------------------------------------- #
-# Root of the released clip library (holds catalog/ and clips/). Override with
-# the DRONE_CLIPS_ROOT environment variable; defaults to ./data/drone-maneuver-clips,
-# relative to the current working directory, so it works straight out of a
-# Hugging Face download.
-OUTPUT_ROOT = os.environ.get(
-    "DRONE_CLIPS_ROOT", os.path.join("data", "drone-maneuver-clips")
-)
-
-# --------------------------------------------------------------------------- #
-# Clip geometry
-# --------------------------------------------------------------------------- #
-FPS = 30  # KABR occurrences are one row per native video frame @ 30 fps
-CLIP_SECONDS = 6
-CLIP_FRAMES = FPS * CLIP_SECONDS  # 180
-
-# --------------------------------------------------------------------------- #
-# Behaviour vocabulary
-# --------------------------------------------------------------------------- #
-# Behaviours that contribute to a vigilance signal.
-VIGILANCE_BEHAVIOURS = frozenset({"Head Up", "Running", "Trotting"})
-
-# Non-animal / non-informative behaviour markers seen in the source labels.
-NON_BEHAVIOUR = frozenset({"Out of Frame", "Out of Focus", "Occluded", ""})
-
-# --------------------------------------------------------------------------- #
-# Canonical token collapses (source labels are inconsistent)
-# --------------------------------------------------------------------------- #
-# Applied at label-load so the published dataset + catalog use one token each.
-SPECIES_CANONICAL = {"Grevy": "Grevys Zebra"}
-BEHAVIOUR_CANONICAL = {"Walking": "Walk"}
-
-
-def normalize_species(s) -> str:
-    s = ("" if s is None else str(s)).strip()
-    return SPECIES_CANONICAL.get(s, s)
-
-
-def normalize_behaviour(b) -> str:
-    b = ("" if b is None else str(b)).strip()
-    return BEHAVIOUR_CANONICAL.get(b, b)
-
-# --------------------------------------------------------------------------- #
-# Bounding-box size classes (fraction of frame area)
-# --------------------------------------------------------------------------- #
-# far  : bbox_area_frac <  BBOX_FAR_MAX
-# close: bbox_area_frac >= BBOX_CLOSE_MIN
-# medium: in between
-#
-# Thresholds are RELATIVE to this dataset's range. KABR is flown at 20-50 m, so
-# animals occupy a small frame fraction throughout (p99 of bbox area ~= 0.018).
-# These cut points (~p65 / ~p92 of the bbox-area distribution) give a usable
-# far/medium/close split; "close" here means close *for this survey*, not that
-# the animal fills the frame.
-BBOX_FAR_MAX = 0.001
-BBOX_CLOSE_MIN = 0.005
-
-
-def bbox_size_class(area_frac: float) -> str:
-    if area_frac < BBOX_FAR_MAX:
-        return "far"
-    if area_frac >= BBOX_CLOSE_MIN:
-        return "close"
-    return "medium"
-
-
-# --------------------------------------------------------------------------- #
-# Maneuver-suitability tags
-# --------------------------------------------------------------------------- #
-MANEUVERS = ("launch", "follow", "behavior_adaptive", "soi_aware")
-
-# --------------------------------------------------------------------------- #
-# Pose taxonomy (matches the KABR-poses folder names)
-# --------------------------------------------------------------------------- #
-POSE_CLASSES = (
-    "front",
-    "front-left",
-    "front-right",
-    "left",
-    "right",
-    "back-left",
-    "back-right",
-    "back",
-)
-
-# --------------------------------------------------------------------------- #
-# Column sets
-# --------------------------------------------------------------------------- #
-# One row per frame per track.
-LABEL_COLUMNS = [
-    "clip_id",
-    "video_id",
-    "session_id",
-    "frame_global",
-    "frame_local",
-    "time_s",
-    "track_id",
-    "species",
-    "behaviour",
-    "vigilant",
-    "pose",
-    "pose_provenance",
-    "pose_match_score",
-    "individual_id",
-    "xtl",
-    "ytl",
-    "xbr",
-    "ybr",
-    "x_c",
-    "y_c",
-    "w",
-    "h",
-    "bbox_area_frac",
-    "bbox_size_class",
-    "occluded",
-    "outside",
-    "latitude",
-    "longitude",
-    "altitude",
-    "date_time",
-]
-
-# One row per clip.
-CLIP_INDEX_COLUMNS = [
-    "clip_id",
-    "video_id",
-    "session_id",
-    "start_frame",
-    "end_frame",
-    "start_time",
-    "species_set",
-    "habitat",
-    "herd_size",
-    "n_tracks",
-    "behaviours_present",
-    "has_vigilance",
-    "bbox_size_classes",
-    "pose_set",
-    "suitable_maneuvers",
-    "fair2_video_eventID",
-    "fair2_session_eventID",
-    "source_video_path",
-    "label_provenance",
-]