{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# v33da Dataset Explorer\n",
        "\n",
        "Standalone exploration notebook for `v33da`.\n",
        "\n",
        "This notebook mirrors the old `v33dl` dataset explorer style, but targets the standalone `v33da` package directly. It walks through:\n",
        "\n",
        "1. Loading pooled parquet shards\n",
        "2. Picking a sample\n",
        "3. Audio and accelerometer signals\n",
        "4. Video clips\n",
        "5. 3D pose and 2D keypoints\n",
        "6. Camera calibration and reprojection\n",
        "7. Radio telemetry"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 0. Setup\n",
        "\n",
        "If you already have the standalone dataset locally, just run the next cell. The notebook resolves the dataset root automatically."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "from __future__ import annotations\n",
        "\n",
        "import io\n",
        "import pickle\n",
        "from pathlib import Path\n",
        "\n",
        "import cv2\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import pyarrow.parquet as pq\n",
        "import soundfile as sf\n",
        "\n",
        "R_ZUP = np.array([[1, 0, 0], [0, 0, -1], [0, 1, 0]], dtype=np.float64)\n",
        "KEYPOINT_NAMES = [\"beak\", \"head\", \"backpack\", \"tailbe\", \"tailend\"]\n",
        "RADIO_KEYS = [\n",
        "    \"frq\", \"thetaS\", \"thetaA\", \"thetaB\", \"thetaC\", \"thetaD\",\n",
        "    \"phiA\", \"phiB\", \"phiC\", \"phiD\", \"phiM\",\n",
        "    \"powRA\", \"powRB\", \"powRC\", \"powRD\", \"powRM\",\n",
        "    \"powNA\", \"powNB\", \"powNC\", \"powND\", \"powNM\",\n",
        "]\n",
        "\n",
        "def resolve_dataset_root() -> Path:\n",
        "    cwd = Path.cwd()\n",
        "    if (cwd / 'metadata.json').exists() and (cwd / 'audio').exists():\n",
        "        return cwd\n",
        "    candidate = Path('/home/songbird/code/v33da/data/v33da')\n",
        "    if candidate.exists():\n",
        "        return candidate\n",
        "    raise FileNotFoundError('Could not locate the standalone v33da dataset root.')\n",
        "\n",
        "DATASET_ROOT = resolve_dataset_root()\n",
        "DATASET_ROOT"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 1. Load & Inspect the Pooled Parquet Shards"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "pooled_shards = sorted(DATASET_ROOT.glob('v33da-*.parquet'))\n",
        "len(pooled_shards), pooled_shards[:3]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "first_table = pq.read_table(pooled_shards[0])\n",
        "first_table.schema"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 2. Pick a Sample"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "def decode_array(blob: bytes) -> np.ndarray:\n",
        "    return np.load(io.BytesIO(blob))\n",
        "\n",
        "def resolve_media_path(path_str: str) -> Path:\n",
        "    path = Path(path_str)\n",
        "    if path.is_absolute():\n",
        "        return path\n",
        "    return DATASET_ROOT / path\n",
        "\n",
        "def load_sample(shard_index: int = 0, row_index: int = 0):\n",
        "    row = pq.read_table(pooled_shards[shard_index]).slice(row_index, 1).to_pylist()[0]\n",
        "    row['keypoints_3d'] = decode_array(row['keypoints_3d'])\n",
        "    row['keypoints_2d_top'] = decode_array(row['keypoints_2d_top'])\n",
        "    row['keypoints_2d_back'] = decode_array(row['keypoints_2d_back'])\n",
        "    radio = {}\n",
        "    for key in RADIO_KEYS:\n",
        "        radio[key] = decode_array(row[f'radio_{key}'])\n",
        "    row['radio'] = radio\n",
        "    row['audio_file'] = resolve_media_path(row['audio_path'])\n",
        "    row['accelerometer_file'] = resolve_media_path(row['accelerometer_path'])\n",
        "    row['video_file'] = resolve_media_path(row['video_path'])\n",
        "    return row\n",
        "\n",
        "sample = load_sample(shard_index=0, row_index=0)\n",
        "sample['id'], sample['experiment'], sample['bird_color'], sample['video_file'].name"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 3. Audio and Accelerometer"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "audio, sr_audio = sf.read(sample['audio_file'])\n",
        "accel, sr_accel = sf.read(sample['accelerometer_file'])\n",
        "audio.shape, sr_audio, accel.shape, sr_accel"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "fig, axes = plt.subplots(2, 1, figsize=(14, 6), sharex=False)\n",
        "axes[0].plot(audio)\n",
        "axes[0].set_title('Microphone audio (all channels)')\n",
        "axes[1].plot(accel)\n",
        "axes[1].set_title('Accelerometer audio (all channels)')\n",
        "plt.tight_layout()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 4. Video"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "cap = cv2.VideoCapture(str(sample['video_file']))\n",
        "ok, frame_bgr = cap.read()\n",
        "cap.release()\n",
        "frame = cv2.cvtColor(frame_bgr, cv2.COLOR_BGR2RGB) if ok else None\n",
        "frame.shape if frame is not None else None"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "plt.figure(figsize=(12, 8))\n",
        "plt.imshow(frame)\n",
        "plt.title(sample['video_file'].name)\n",
        "plt.axis('off')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 5. 3D Pose and 2D Keypoints"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "kp3d = sample['keypoints_3d']\n",
        "kp2d_top = sample['keypoints_2d_top']\n",
        "kp2d_back = sample['keypoints_2d_back']\n",
        "kp3d.shape, kp2d_top.shape, kp2d_back.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "mid = kp3d.shape[0] // 2\n",
        "mid_beaks = kp3d[mid, :, 0]\n",
        "\n",
        "fig = plt.figure(figsize=(7, 6))\n",
        "ax = fig.add_subplot(111, projection='3d')\n",
        "ax.scatter(mid_beaks[:, 0], mid_beaks[:, 1], mid_beaks[:, 2], s=60)\n",
        "for bird_idx, pt in enumerate(mid_beaks):\n",
        "    ax.text(pt[0], pt[1], pt[2], str(bird_idx))\n",
        "ax.set_xlabel('X (mm)')\n",
        "ax.set_ylabel('Y (mm)')\n",
        "ax.set_zlabel('Z (mm)')\n",
        "ax.set_title('Mid-frame beak positions')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 6. Camera Calibration and Reprojection"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "def load_calibration(experiment: str, view: str):\n",
        "    exp_dir = DATASET_ROOT / 'calibrations' / experiment\n",
        "    npz = np.load(exp_dir / f'calibration_{view}.npz')\n",
        "    with open(exp_dir / f'camera_pose_{view}.pkl', 'rb') as handle:\n",
        "        pose = pickle.load(handle)\n",
        "    return {\n",
        "        'K': npz['mtx'],\n",
        "        'dist': npz['dist'],\n",
        "        'rvec': pose['rvec'],\n",
        "        'tvec': pose['tvec'],\n",
        "    }\n",
        "\n",
        "def project_zup(points_xyz_mm: np.ndarray, calibration: dict) -> np.ndarray:\n",
        "    pts = np.asarray(points_xyz_mm, dtype=np.float64)\n",
        "    pts_cam = (R_ZUP @ pts.T).T\n",
        "    proj, _ = cv2.projectPoints(pts_cam, calibration['rvec'], calibration['tvec'], calibration['K'], calibration['dist'])\n",
        "    return proj.reshape(-1, 2)\n",
        "\n",
        "def reproject_view(row, view: str):\n",
        "    cal = load_calibration(row['experiment'], view)\n",
        "    kp3d_mid = row['keypoints_3d'][mid]\n",
        "    kp2d_mid = row[f'keypoints_2d_{view}'][mid]\n",
        "    projected = np.full_like(kp2d_mid, np.nan, dtype=np.float64)\n",
        "    errors = np.full(kp2d_mid.shape[:2], np.nan, dtype=np.float64)\n",
        "    for bird_idx in range(kp3d_mid.shape[0]):\n",
        "        valid3d = ~np.any(np.isnan(kp3d_mid[bird_idx]), axis=1)\n",
        "        valid2d = ~np.any(np.isnan(kp2d_mid[bird_idx]), axis=1)\n",
        "        if valid3d.any():\n",
        "            projected[bird_idx, valid3d] = project_zup(kp3d_mid[bird_idx, valid3d], cal)\n",
        "        valid = valid2d & valid3d\n",
        "        if valid.any():\n",
        "            errors[bird_idx, valid] = np.linalg.norm(projected[bird_idx, valid] - kp2d_mid[bird_idx, valid], axis=1)\n",
        "    return kp2d_mid, projected, errors\n",
        "\n",
        "top_obs, top_proj, top_err = reproject_view(sample, 'top')\n",
        "back_obs, back_proj, back_err = reproject_view(sample, 'back')\n",
        "np.nanmedian(top_err), np.nanmedian(back_err)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "def plot_reprojection(ax, observed, projected, title):\n",
        "    colors = ['tab:red', 'tab:orange', 'tab:blue', 'tab:green']\n",
        "    for bird_idx in range(observed.shape[0]):\n",
        "        obs = observed[bird_idx]\n",
        "        proj = projected[bird_idx]\n",
        "        valid_obs = ~np.any(np.isnan(obs), axis=1)\n",
        "        valid_proj = ~np.any(np.isnan(proj), axis=1)\n",
        "        if valid_obs.any():\n",
        "            ax.scatter(obs[valid_obs, 0], obs[valid_obs, 1], c=colors[bird_idx % len(colors)], marker='o', alpha=0.8)\n",
        "        if valid_proj.any():\n",
        "            ax.scatter(proj[valid_proj, 0], proj[valid_proj, 1], c=colors[bird_idx % len(colors)], marker='x', alpha=0.8)\n",
        "        valid = valid_obs & valid_proj\n",
        "        for kp_idx in np.where(valid)[0]:\n",
        "            ax.plot([obs[kp_idx, 0], proj[kp_idx, 0]], [obs[kp_idx, 1], proj[kp_idx, 1]], color=colors[bird_idx % len(colors)], alpha=0.35)\n",
        "    ax.set_title(title)\n",
        "    ax.invert_yaxis()\n",
        "    ax.set_aspect('equal')\n",
        "    ax.grid(alpha=0.2)\n",
        "\n",
        "fig, axes = plt.subplots(1, 2, figsize=(14, 6))\n",
        "plot_reprojection(axes[0], top_obs, top_proj, f'top | median reproj = {np.nanmedian(top_err):.2f}px')\n",
        "plot_reprojection(axes[1], back_obs, back_proj, f'back | median reproj = {np.nanmedian(back_err):.2f}px')\n",
        "plt.tight_layout()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 7. Radio Telemetry"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "sample['radio']['powRA'].shape, sample['radio']['thetaS'].shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "fig, axes = plt.subplots(2, 1, figsize=(14, 6), sharex=True)\n",
        "axes[0].plot(sample['radio']['powRA'].T)\n",
        "axes[0].set_title('radio powRA per bird')\n",
        "axes[1].plot(sample['radio']['thetaS'].T)\n",
        "axes[1].set_title('radio thetaS per bird')\n",
        "plt.tight_layout()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 8. Iterate Efficiently\n",
        "\n",
        "Use this pattern if you want to scan pooled shards without loading everything into RAM."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "for shard in pooled_shards[:2]:\n",
        "    table = pq.read_table(shard, columns=['experiment', 'bird_color'])\n",
        "    print(shard.name, table.num_rows)"
      ]
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.12"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}