{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime, timedelta\n",
    "from pathlib import Path\n",
    "from typing import Generator, Sequence, TypeAlias, TypedDict\n",
    "\n",
    "import awkward as ak\n",
    "import jax\n",
    "import jax.numpy as jnp\n",
    "import numpy as np\n",
    "from jaxtyping import Array, Num\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "from app.camera import Detection\n",
    "from app.camera import Camera, CameraParams\n",
    "\n",
    "NDArray: TypeAlias = np.ndarray"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre>[{name: &#x27;AE_01&#x27;, port: 5602, intrinsic: {...}, extrinsic: {...}, ...},\n",
       " {name: &#x27;AE_1A&#x27;, port: 5601, intrinsic: {...}, extrinsic: {...}, ...},\n",
       " {name: &#x27;AE_08&#x27;, port: 5600, intrinsic: {...}, extrinsic: {...}, ...}]\n",
       "------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
       "backend: cpu\n",
       "nbytes: 823 B\n",
       "type: 3 * {\n",
       "    name: string,\n",
       "    port: int64,\n",
       "    intrinsic: {\n",
       "        camera_matrix: var * var * var * float64,\n",
       "        distortion_coefficients: var * float64\n",
       "    },\n",
       "    extrinsic: {\n",
       "        rvec: var * float64,\n",
       "        tvec: var * float64\n",
       "    },\n",
       "    resolution: {\n",
       "        width: int64,\n",
       "        height: int64\n",
       "    }\n",
       "}</pre>"
      ],
      "text/plain": [
       "<Array [{name: 'AE_01', port: 5602, ...}, ...] type='3 * {name: string, por...'>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "DATASET_PATH = Path(\"samples\") / \"04_02\" \n",
    "AK_CAMERA_DATASET: ak.Array = ak.from_parquet(DATASET_PATH / \"camera_params.parquet\")\n",
    "display(AK_CAMERA_DATASET)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Resolution(TypedDict):\n",
    "    width: int\n",
    "    height: int\n",
    "\n",
    "class Intrinsic(TypedDict):\n",
    "    camera_matrix: Num[Array, \"3 3\"]\n",
    "    \"\"\"\n",
    "    K\n",
    "    \"\"\"\n",
    "    distortion_coefficients: Num[Array, \"N\"]\n",
    "    \"\"\"\n",
    "    distortion coefficients; usually 5\n",
    "    \"\"\"\n",
    "\n",
    "class Extrinsic(TypedDict):\n",
    "    rvec: Num[NDArray, \"3\"]\n",
    "    tvec: Num[NDArray, \"3\"]\n",
    "\n",
    "class ExternalCameraParams(TypedDict):\n",
    "    name: str\n",
    "    port: int\n",
    "    intrinsic: Intrinsic\n",
    "    extrinsic: Extrinsic\n",
    "    resolution: Resolution\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_dataset_by_port(port: int) -> ak.Array:\n",
    "    P = DATASET_PATH / f\"{port}.parquet\"\n",
    "    return ak.from_parquet(P)\n",
    "\n",
    "KEYPOINT_DATASET = {int(p): read_dataset_by_port(p) for p in ak.to_numpy(AK_CAMERA_DATASET[\"port\"])}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre>[{frame_index: 0, boxes: [[599, ...], [...]], kps: [...], kps_scores: ..., ...},\n",
       " {frame_index: 1, boxes: [[599, ...], [...]], kps: [...], kps_scores: ..., ...},\n",
       " {frame_index: 2, boxes: [[599, ...], [...]], kps: [...], kps_scores: ..., ...},\n",
       " {frame_index: 3, boxes: [[599, ...], [...]], kps: [...], kps_scores: ..., ...},\n",
       " {frame_index: 4, boxes: [[598, ...], [...]], kps: [...], kps_scores: ..., ...},\n",
       " {frame_index: 5, boxes: [[596, ...], [...]], kps: [...], kps_scores: ..., ...},\n",
       " {frame_index: 6, boxes: [[594, ...], [...]], kps: [...], kps_scores: ..., ...},\n",
       " {frame_index: 7, boxes: [[595, ...], [...]], kps: [...], kps_scores: ..., ...},\n",
       " {frame_index: 8, boxes: [[595, ...], [...]], kps: [...], kps_scores: ..., ...},\n",
       " {frame_index: 9, boxes: [[595, ...], [...]], kps: [...], kps_scores: ..., ...},\n",
       " ...,\n",
       " {frame_index: 520, boxes: [[1.09e+03, ...], ...], kps: [...], ...},\n",
       " {frame_index: 521, boxes: [[1.09e+03, ...], ...], kps: [...], ...},\n",
       " {frame_index: 522, boxes: [[1.09e+03, ...], ...], kps: [...], ...},\n",
       " {frame_index: 523, boxes: [[1.09e+03, ...], ...], kps: [...], ...},\n",
       " {frame_index: 524, boxes: [[1.09e+03, ...], ...], kps: [...], ...},\n",
       " {frame_index: 525, boxes: [[1.09e+03, ...], ...], kps: [...], ...},\n",
       " {frame_index: 526, boxes: [[1.09e+03, ...], ...], kps: [...], ...},\n",
       " {frame_index: 527, boxes: [[1.09e+03, ...], ...], kps: [...], ...},\n",
       " {frame_index: 528, boxes: [[1.09e+03, ...], ...], kps: [...], ...}]\n",
       "-----------------------------------------------------------------------------------------------------------------------------------------------\n",
       "backend: cpu\n",
       "nbytes: 4.6 MB\n",
       "type: 529 * {\n",
       "    frame_index: int64,\n",
       "    boxes: var * var * float64,\n",
       "    kps: var * var * var * float64,\n",
       "    kps_scores: var * var * float64\n",
       "}</pre>"
      ],
      "text/plain": [
       "<Array [{frame_index: 0, boxes: ..., ...}, ...] type='529 * {frame_index: i...'>"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "KEYPOINT_DATASET[5601]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.spatial.transform import Rotation as R"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "class KeypointDataset(TypedDict):\n",
    "    frame_index: int\n",
    "    boxes: Num[NDArray, \"N 4\"]\n",
    "    kps: Num[NDArray, \"N J 2\"]\n",
    "    kps_scores: Num[NDArray, \"N J\"]\n",
    "\n",
    "def to_transformation_matrix(rvec: Num[NDArray, \"3\"], tvec: Num[NDArray, \"3\"]) -> Num[NDArray, \"4 4\"]:\n",
    "    r = R.from_rotvec(rvec) # type: ignore\n",
    "    t = tvec.reshape(3, 1)\n",
    "    return np.concatenate([np.concatenate([r.as_matrix(), t], axis=1), np.array([[0, 0, 0, 1]])], axis=0)\n",
    "\n",
    "def from_camera_params(camera: ExternalCameraParams) -> Camera:\n",
    "    rt = jnp.array(to_transformation_matrix(ak.to_numpy(camera[\"extrinsic\"][\"rvec\"]), ak.to_numpy(camera[\"extrinsic\"][\"tvec\"])))\n",
    "    K = jnp.array(camera[\"intrinsic\"][\"camera_matrix\"]).reshape(3, 3)\n",
    "    dist_coeffs = jnp.array(camera[\"intrinsic\"][\"distortion_coefficients\"])\n",
    "    image_size = jnp.array((camera[\"resolution\"][\"width\"], camera[\"resolution\"][\"height\"]))\n",
    "    return Camera(\n",
    "        id=camera[\"name\"],\n",
    "        params=CameraParams(\n",
    "            K=K,\n",
    "            Rt=rt,\n",
    "            dist_coeffs=dist_coeffs,\n",
    "            image_size=image_size,\n",
    "        )\n",
    "    )\n",
    "\n",
    "def preprocess_keypoint_dataset(dataset: Sequence[KeypointDataset], camera: Camera,fps: float, start_timestamp: datetime) -> Generator[Detection, None, None]:\n",
    "    frame_interval_s = 1 / fps\n",
    "    for el in dataset:\n",
    "        frame_index = el[\"frame_index\"]\n",
    "        timestamp = start_timestamp + timedelta(seconds=frame_index * frame_interval_s)\n",
    "        for kp, kp_score in zip(el[\"kps\"], el[\"kps_scores\"]):\n",
    "            yield Detection(\n",
    "                keypoints=jnp.array(kp),\n",
    "                confidences=jnp.array(kp_score),\n",
    "                camera=camera,\n",
    "                timestamp=timestamp,\n",
    "            )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Optional\n",
    "from copy import deepcopy\n",
    "\n",
    "DetectionGenerator: TypeAlias = Generator[Detection, None, None]\n",
    "\n",
    "\n",
    "def sync_batch_gen(gens: list[DetectionGenerator], diff: timedelta):\n",
    "    \"\"\"\n",
    "    given a list of detection generators, return a generator that yields a batch of detections\n",
    "\n",
    "    Args:\n",
    "        gens: list of detection generators\n",
    "        diff: maximum timestamp difference between detections to consider them part of the same batch\n",
    "    \"\"\"\n",
    "    N = len(gens)\n",
    "    last_batch_timestamp: Optional[datetime] = None\n",
    "    next_batch_timestamp: Optional[datetime] = None\n",
    "    current_batch: list[Detection] = []\n",
    "    next_batch: list[Detection] = []\n",
    "    paused: list[bool] = [False] * N\n",
    "    finished: list[bool] = [False] * N\n",
    "\n",
    "    def reset_paused():\n",
    "        \"\"\"\n",
    "        reset paused list based on finished list\n",
    "        \"\"\"\n",
    "        for i in range(N):\n",
    "            if not finished[i]:\n",
    "                paused[i] = False\n",
    "            else:\n",
    "                paused[i] = True\n",
    "\n",
    "    EPS = 1e-6\n",
    "    # a small epsilon to avoid floating point precision issues\n",
    "    diff_esp = diff - timedelta(seconds=EPS)\n",
    "    while True:\n",
    "        for i, gen in enumerate(gens):\n",
    "            try:\n",
    "                if finished[i] or paused[i]:\n",
    "                    continue\n",
    "                val = next(gen)\n",
    "                if last_batch_timestamp is None:\n",
    "                    last_batch_timestamp = val.timestamp\n",
    "                    current_batch.append(val)\n",
    "                else:\n",
    "                    if abs(val.timestamp - last_batch_timestamp) >= diff_esp:\n",
    "                        next_batch.append(val)\n",
    "                        if next_batch_timestamp is None:\n",
    "                            next_batch_timestamp = val.timestamp\n",
    "                        paused[i] = True\n",
    "                        if all(paused):\n",
    "                            yield current_batch\n",
    "                            current_batch = next_batch\n",
    "                            next_batch = []\n",
    "                            last_batch_timestamp = next_batch_timestamp\n",
    "                            next_batch_timestamp = None\n",
    "                            reset_paused()\n",
    "                    else:\n",
    "                        current_batch.append(val)\n",
    "            except StopIteration:\n",
    "                finished[i] = True\n",
    "                paused[i] = True\n",
    "        if all(finished):\n",
    "            if len(current_batch) > 0:\n",
    "                # All generators exhausted, flush remaining batch and exit\n",
    "                yield current_batch\n",
    "            break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.041666666666666664"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "FPS = 24\n",
    "image_gen_5600 = preprocess_keypoint_dataset(KEYPOINT_DATASET[5600], from_camera_params(AK_CAMERA_DATASET[AK_CAMERA_DATASET[\"port\"] == 5600][0]), FPS, datetime(2024, 4, 2, 12, 0, 0))  # type: ignore\n",
    "image_gen_5601 = preprocess_keypoint_dataset(KEYPOINT_DATASET[5601], from_camera_params(AK_CAMERA_DATASET[AK_CAMERA_DATASET[\"port\"] == 5601][0]), FPS, datetime(2024, 4, 2, 12, 0, 0))  # type: ignore\n",
    "image_gen_5602 = preprocess_keypoint_dataset(KEYPOINT_DATASET[5602], from_camera_params(AK_CAMERA_DATASET[AK_CAMERA_DATASET[\"port\"] == 5602][0]), FPS, datetime(2024, 4, 2, 12, 0, 0))  # type: ignore\n",
    "\n",
    "display(1/FPS)\n",
    "sync_gen = sync_batch_gen([image_gen_5600, image_gen_5601, image_gen_5602], timedelta(seconds=1/FPS))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "detections = next(sync_gen)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "from app.camera import calculate_affinity_matrix_by_epipolar_constraint\n",
    "\n",
    "sorted_detections, affinity_matrix = calculate_affinity_matrix_by_epipolar_constraint(detections, \n",
    "                                                                                      alpha_2d=1800)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'timestamp': '2024-04-02 12:00:00', 'camera': 'AE_08'},\n",
       " {'timestamp': '2024-04-02 12:00:00', 'camera': 'AE_08'},\n",
       " {'timestamp': '2024-04-02 12:00:00', 'camera': 'AE_1A'},\n",
       " {'timestamp': '2024-04-02 12:00:00', 'camera': 'AE_1A'},\n",
       " {'timestamp': '2024-04-02 12:00:00', 'camera': 'AE_01'},\n",
       " {'timestamp': '2024-04-02 12:00:00', 'camera': 'AE_01'}]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "Array([[  -inf,   -inf,  0.625,  0.321, -0.243,  0.018],\n",
       "       [  -inf,   -inf,  0.9  ,  0.795,  0.293,  0.568],\n",
       "       [ 0.625,  0.9  ,   -inf,   -inf,  0.211,  0.371],\n",
       "       [ 0.321,  0.795,   -inf,   -inf,  0.684,  0.793],\n",
       "       [-0.243,  0.293,  0.211,  0.684,   -inf,   -inf],\n",
       "       [ 0.018,  0.568,  0.371,  0.793,   -inf,   -inf]], dtype=float32)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "display(list(map(lambda x: {\"timestamp\": str(x.timestamp), \"camera\": x.camera.id}, sorted_detections)))\n",
    "with jnp.printoptions(precision=3, suppress=True):\n",
    "    display(affinity_matrix)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[0, 2, 5], [1, 3, 4]]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 1, 0, 0, 1],\n",
       "       [0, 0, 0, 1, 1, 0],\n",
       "       [1, 0, 0, 0, 0, 1],\n",
       "       [0, 1, 0, 0, 1, 0],\n",
       "       [0, 1, 0, 1, 0, 0],\n",
       "       [1, 0, 1, 0, 0, 0]])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from app.solver._old import GLPKSolver\n",
    "\n",
    "solver = GLPKSolver()\n",
    "aff_np = np.asarray(affinity_matrix).astype(np.float64)\n",
    "clusters, sol_matrix = solver.solve(aff_np)\n",
    "display(clusters)\n",
    "display(sol_matrix)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f903ff85550>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from app.visualize.whole_body import visualize_whole_body\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "WIDTH = 2560\n",
    "HEIGHT = 1440\n",
    "\n",
    "im = np.zeros((HEIGHT, WIDTH, 3), dtype=np.uint8)\n",
    "for i in clusters[0]:\n",
    "    el = sorted_detections[i]\n",
    "    im = visualize_whole_body(np.asarray(el.keypoints), im)\n",
    "\n",
    "p = plt.imshow(im)\n",
    "display(p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f903fef24b0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "im_prime = np.zeros((HEIGHT, WIDTH, 3), dtype=np.uint8)\n",
    "for i in clusters[1]:\n",
    "    el = sorted_detections[i]\n",
    "    im_prime = visualize_whole_body(np.asarray(el.keypoints), im_prime)\n",
    "\n",
    "p_prime= plt.imshow(im_prime)\n",
    "display(p_prime)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}