From 40f315041751fd5ce9289706e4b767247c891621 Mon Sep 17 00:00:00 2001 From: crosstyan Date: Thu, 17 Apr 2025 11:48:53 +0800 Subject: [PATCH] feat: Enhance play notebook and camera module with new functionalities - Updated play notebook with additional imports and new functions for point triangulation and undistortion. - Introduced `triangulate_one_point_from_multiple_views_linear` and `triangulate_points_from_multiple_views_linear` for batch triangulation of points. - Added `triangle_from_cluster` function to facilitate triangulation from detection clusters. - Enhanced `CameraParams` and `Detection` dataclasses with a projection matrix property for improved usability. - Cleaned up imports and execution counts in the notebook for better organization. --- .vscode/settings.json | 3 - app/camera/__init__.py | 20 ++- play.ipynb | 350 ++++++++++++++++++++++++++++++++++------- 3 files changed, 308 insertions(+), 65 deletions(-) diff --git a/.vscode/settings.json b/.vscode/settings.json index af2c612..02df7cc 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -1,7 +1,4 @@ { "python.analysis.typeCheckingMode": "basic", "python.analysis.autoImportCompletions": true, - "cSpell.words": [ - "triu" - ] } \ No newline at end of file diff --git a/app/camera/__init__.py b/app/camera/__init__.py index 0924610..91bbf35 100644 --- a/app/camera/__init__.py +++ b/app/camera/__init__.py @@ -13,7 +13,7 @@ CameraID: TypeAlias = str # pylint: disable=invalid-name @jaxtyped(typechecker=beartype) -@dataclass +@dataclass(frozen=True) class CameraParams: """ Camera parameters: intrinsic matrix, extrinsic matrix, and distortion coefficients @@ -42,9 +42,23 @@ class CameraParams: The size of image plane (width, height) """ + @property + def projection_matrix(self) -> Num[Array, "3 4"]: + """ + Returns the 3x4 projection matrix K @ [R|t]. + + The result is cached on first access. (lazy evaluation) + """ + pm = getattr(self, "_proj", None) + if pm is None: + pm = self.K @ self.Rt[:3, :] + # object.__setattr__ bypasses the frozen‐dataclass blocker + object.__setattr__(self, "_proj", pm) + return pm + @jaxtyped(typechecker=beartype) -@dataclass +@dataclass(frozen=True) class Camera: """ a description of a camera @@ -61,7 +75,7 @@ class Camera: @jaxtyped(typechecker=beartype) -@dataclass +@dataclass(frozen=True) class Detection: """ One detection from a camera diff --git a/play.ipynb b/play.ipynb index dd18282..a6cdd16 100644 --- a/play.ipynb +++ b/play.ipynb @@ -2,30 +2,37 @@ "cells": [ { "cell_type": "code", - "execution_count": 34, + "execution_count": 32, "metadata": {}, "outputs": [], "source": [ + "from copy import deepcopy\n", "from datetime import datetime, timedelta\n", "from pathlib import Path\n", - "from typing import Generator, Sequence, TypeAlias, TypedDict\n", + "from typing import (Any, Generator, Optional, Sequence, TypeAlias, TypedDict,\n", + " cast, overload)\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", + "import orjson\n", + "from beartype import beartype\n", + "from cv2 import undistortPoints\n", + "from jaxtyping import Array, Float, Num, jaxtyped\n", "from matplotlib import pyplot as plt\n", + "from numpy.typing import ArrayLike\n", + "from scipy.spatial.transform import Rotation as R\n", "\n", - "from app.camera import Detection\n", - "from app.camera import Camera, CameraParams\n", + "from app.camera import Camera, CameraParams, Detection\n", + "from app.visualize.whole_body import visualize_whole_body\n", "\n", "NDArray: TypeAlias = np.ndarray" ] }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 33, "metadata": {}, "outputs": [ { @@ -70,7 +77,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 34, "metadata": {}, "outputs": [], "source": [ @@ -102,7 +109,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 35, "metadata": {}, "outputs": [], "source": [ @@ -115,7 +122,7 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 36, "metadata": {}, "outputs": [ { @@ -155,7 +162,7 @@ "" ] }, - "execution_count": 38, + "execution_count": 36, "metadata": {}, "output_type": "execute_result" } @@ -166,16 +173,7 @@ }, { "cell_type": "code", - "execution_count": 39, - "metadata": {}, - "outputs": [], - "source": [ - "from scipy.spatial.transform import Rotation as R" - ] - }, - { - "cell_type": "code", - "execution_count": 40, + "execution_count": 37, "metadata": {}, "outputs": [], "source": [ @@ -185,16 +183,41 @@ " 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", + "@jaxtyped(typechecker=beartype)\n", + "def to_transformation_matrix(\n", + " rvec: Num[NDArray, \"3\"], tvec: Num[NDArray, \"3\"]\n", + ") -> Num[NDArray, \"4 4\"]:\n", + " res = np.eye(4)\n", + " res[:3, :3] = R.from_rotvec(rvec).as_matrix()\n", + " res[:3, 3] = tvec\n", + " return res\n", + "\n", + "\n", + "@jaxtyped(typechecker=beartype)\n", + "def undistort_points(\n", + " points: Num[NDArray, \"M 2\"],\n", + " camera_matrix: Num[NDArray, \"3 3\"],\n", + " dist_coeffs: Num[NDArray, \"N\"],\n", + ") -> Num[NDArray, \"M 2\"]:\n", + " K = camera_matrix\n", + " dist = dist_coeffs\n", + " res = undistortPoints(points, K, dist, P=K) # type: ignore\n", + " return res.reshape(-1, 2)\n", + "\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", + " rt = jnp.array(\n", + " to_transformation_matrix(\n", + " ak.to_numpy(camera[\"extrinsic\"][\"rvec\"]),\n", + " ak.to_numpy(camera[\"extrinsic\"][\"tvec\"]),\n", + " )\n", + " )\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", + " image_size = jnp.array(\n", + " (camera[\"resolution\"][\"width\"], camera[\"resolution\"][\"height\"])\n", + " )\n", " return Camera(\n", " id=camera[\"name\"],\n", " params=CameraParams(\n", @@ -202,32 +225,38 @@ " Rt=rt,\n", " dist_coeffs=dist_coeffs,\n", " image_size=image_size,\n", - " )\n", + " ),\n", " )\n", "\n", - "def preprocess_keypoint_dataset(dataset: Sequence[KeypointDataset], camera: Camera,fps: float, start_timestamp: datetime) -> Generator[Detection, None, None]:\n", + "\n", + "def preprocess_keypoint_dataset(\n", + " dataset: Sequence[KeypointDataset],\n", + " camera: Camera,\n", + " fps: float,\n", + " start_timestamp: datetime,\n", + ") -> 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", + " kp = undistort_points(\n", + " np.asarray(kp), np.asarray(camera.params.K), np.asarray(camera.params.dist_coeffs)\n", + " )\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, + "execution_count": 38, "metadata": {}, "outputs": [], "source": [ - "from typing import Optional\n", - "from copy import deepcopy\n", - "\n", "DetectionGenerator: TypeAlias = Generator[Detection, None, None]\n", "\n", "\n", @@ -296,7 +325,85 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "@overload\n", + "def to_projection_matrix(\n", + " transformation_matrix: Num[NDArray, \"4 4\"], camera_matrix: Num[NDArray, \"3 3\"]\n", + ") -> Num[NDArray, \"3 4\"]: ...\n", + "\n", + "\n", + "@overload\n", + "def to_projection_matrix(\n", + " transformation_matrix: Num[Array, \"4 4\"], camera_matrix: Num[Array, \"3 3\"]\n", + ") -> Num[Array, \"3 4\"]: ...\n", + "\n", + "\n", + "@jaxtyped(typechecker=beartype)\n", + "def to_projection_matrix(\n", + " transformation_matrix: Num[Any, \"4 4\"],\n", + " camera_matrix: Num[Any, \"3 3\"],\n", + ") -> Num[Any, \"3 4\"]:\n", + " return camera_matrix @ transformation_matrix[:3, :]\n", + "\n", + "to_projection_matrix_jit = jax.jit(to_projection_matrix)\n", + "\n", + "\n", + "@jaxtyped(typechecker=beartype)\n", + "def dlt(\n", + " H1: Num[NDArray, \"3 4\"],\n", + " H2: Num[NDArray, \"3 4\"],\n", + " p1: Num[NDArray, \"2\"],\n", + " p2: Num[NDArray, \"2\"],\n", + ") -> Num[NDArray, \"3\"]:\n", + " \"\"\"\n", + " Direct Linear Transformation\n", + " \"\"\"\n", + " A = [\n", + " p1[1] * H1[2, :] - H1[1, :],\n", + " H1[0, :] - p1[0] * H1[2, :],\n", + " p2[1] * H2[2, :] - H2[1, :],\n", + " H2[0, :] - p2[0] * H2[2, :],\n", + " ]\n", + " A = np.array(A).reshape((4, 4))\n", + "\n", + " B = A.transpose() @ A\n", + " from scipy import linalg\n", + "\n", + " U, s, Vh = linalg.svd(B, full_matrices=False)\n", + " return Vh[3, 0:3] / Vh[3, 3]\n", + "\n", + "\n", + "@overload\n", + "def homogeneous_to_euclidean(points: Num[NDArray, \"N 4\"]) -> Num[NDArray, \"N 3\"]: ...\n", + "\n", + "\n", + "@overload\n", + "def homogeneous_to_euclidean(points: Num[Array, \"N 4\"]) -> Num[Array, \"N 3\"]: ...\n", + "\n", + "\n", + "@jaxtyped(typechecker=beartype)\n", + "def homogeneous_to_euclidean(\n", + " points: Num[Any, \"N 4\"],\n", + ") -> Num[Any, \"N 3\"]:\n", + " \"\"\"\n", + " 将齐次坐标转换为欧几里得坐标\n", + "\n", + " Args:\n", + " points: homogeneous coordinates (x, y, z, w) in numpy array or jax array\n", + "\n", + " Returns:\n", + " euclidean coordinates (x, y, z) in numpy array or jax array\n", + " \"\"\"\n", + " return points[..., :-1] / points[..., -1:]\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 40, "metadata": {}, "outputs": [ { @@ -321,7 +428,7 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 41, "metadata": {}, "outputs": [], "source": [ @@ -330,19 +437,19 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 42, "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)" + " alpha_2d=2000)" ] }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 43, "metadata": {}, "outputs": [ { @@ -362,12 +469,12 @@ { "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)" + "Array([[ -inf, -inf, 0.697, 0.451, -0.009, 0.2 ],\n", + " [ -inf, -inf, 0.919, 0.835, 0.43 , 0.65 ],\n", + " [ 0.697, 0.919, -inf, -inf, 0.362, 0.487],\n", + " [ 0.451, 0.835, -inf, -inf, 0.744, 0.827],\n", + " [-0.009, 0.43 , 0.362, 0.744, -inf, -inf],\n", + " [ 0.2 , 0.65 , 0.487, 0.827, -inf, -inf]], dtype=float32)" ] }, "metadata": {}, @@ -382,7 +489,7 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 44, "metadata": {}, "outputs": [ { @@ -412,6 +519,20 @@ "source": [ "from app.solver._old import GLPKSolver\n", "\n", + "def clusters_to_detections(clusters: list[list[int]], sorted_detections: list[Detection]) -> list[list[Detection]]:\n", + " \"\"\"\n", + " given a list of clusters (which is the indices of the detections in the sorted_detections list),\n", + " extract the detections from the sorted_detections list\n", + "\n", + " Args:\n", + " clusters: list of clusters, each cluster is a list of indices of the detections in the `sorted_detections` list\n", + " sorted_detections: list of SORTED detections\n", + "\n", + " Returns:\n", + " list of clusters, each cluster is a list of detections\n", + " \"\"\"\n", + " return [[sorted_detections[i] for i in cluster] for cluster in clusters]\n", + "\n", "solver = GLPKSolver()\n", "aff_np = np.asarray(affinity_matrix).astype(np.float64)\n", "clusters, sol_matrix = solver.solve(aff_np)\n", @@ -421,13 +542,13 @@ }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 45, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -435,7 +556,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -445,15 +566,12 @@ } ], "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", + "clusters_detections = clusters_to_detections(clusters, sorted_detections)\n", "im = np.zeros((HEIGHT, WIDTH, 3), dtype=np.uint8)\n", - "for i in clusters[0]:\n", - " el = sorted_detections[i]\n", + "for el in clusters_detections[0]:\n", " im = visualize_whole_body(np.asarray(el.keypoints), im)\n", "\n", "p = plt.imshow(im)\n", @@ -462,13 +580,13 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 46, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -476,7 +594,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -487,13 +605,127 @@ ], "source": [ "im_prime = np.zeros((HEIGHT, WIDTH, 3), dtype=np.uint8)\n", - "for i in clusters[1]:\n", - " el = sorted_detections[i]\n", + "for el in clusters_detections[1]:\n", " im_prime = visualize_whole_body(np.asarray(el.keypoints), im_prime)\n", "\n", - "p_prime= plt.imshow(im_prime)\n", + "p_prime = plt.imshow(im_prime)\n", "display(p_prime)" ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [], + "source": [ + "@jaxtyped(typechecker=beartype)\n", + "def triangulate_one_point_from_multiple_views_linear(\n", + " proj_matrices: Float[Array, \"N 3 4\"],\n", + " points: Num[Array, \"N 2\"],\n", + " confidences: Optional[Float[Array, \"N\"]] = None,\n", + ") -> Float[Array, \"3\"]:\n", + " \"\"\"\n", + " Args:\n", + " proj_matrices: 形状为(N, 3, 4)的投影矩阵序列\n", + " points: 形状为(N, 2)的点坐标序列\n", + " confidences: 形状为(N,)的置信度序列，范围[0.0, 1.0]\n", + "\n", + " Returns:\n", + " point_3d: 形状为(3,)的三角测量得到的3D点\n", + " \"\"\"\n", + " assert len(proj_matrices) == len(points)\n", + "\n", + " N = len(proj_matrices)\n", + " confi: Float[Array, \"N\"]\n", + " if confidences is None:\n", + " confi = jnp.ones(N, dtype=np.float32)\n", + " else:\n", + " # Use square root of confidences for weighting - more balanced approach\n", + " confi = jnp.sqrt(jnp.clip(confidences, 0, 1))\n", + "\n", + " A = jnp.zeros((N * 2, 4), dtype=np.float32)\n", + " for i in range(N):\n", + " x, y = points[i]\n", + " A = A.at[2 * i].set(proj_matrices[i, 2] * x - proj_matrices[i, 0])\n", + " A = A.at[2 * i + 1].set(proj_matrices[i, 2] * y - proj_matrices[i, 1])\n", + " A = A.at[2 * i].mul(confi[i])\n", + " A = A.at[2 * i + 1].mul(confi[i])\n", + "\n", + " # https://docs.jax.dev/en/latest/_autosummary/jax.numpy.linalg.svd.html\n", + " _, _, vh = jnp.linalg.svd(A, full_matrices=False)\n", + " point_3d_homo = vh[-1] # shape (4,)\n", + "\n", + " # replace the Python `if` with a jnp.where\n", + " point_3d_homo = jnp.where(\n", + " point_3d_homo[3] < 0, # predicate (scalar bool tracer)\n", + " -point_3d_homo, # if True\n", + " point_3d_homo, # if False\n", + " )\n", + "\n", + " point_3d = point_3d_homo[:3] / point_3d_homo[3]\n", + " return point_3d\n", + "\n", + "\n", + "@jaxtyped(typechecker=beartype)\n", + "def triangulate_points_from_multiple_views_linear(\n", + " proj_matrices: Float[Array, \"N 3 4\"],\n", + " points: Num[Array, \"N P 2\"],\n", + " confidences: Optional[Float[Array, \"N P\"]] = None,\n", + ") -> Float[Array, \"P 3\"]:\n", + " \"\"\"\n", + " Batch‐triangulate P points observed by N cameras, linearly via SVD.\n", + "\n", + " Args:\n", + " proj_matrices: (N, 3, 4) projection matrices\n", + " points: (N, P, 2) image-coordinates per view\n", + " confidences: (N, P, 1) optional per-view confidences in [0,1]\n", + "\n", + " Returns:\n", + " (P, 3) 3D point for each of the P tracks\n", + " \"\"\"\n", + " N, P, _ = points.shape\n", + " assert proj_matrices.shape[0] == N\n", + " if confidences is None:\n", + " conf = jnp.ones((N, P), dtype=jnp.float32)\n", + " else:\n", + " conf = jnp.sqrt(jnp.clip(confidences, 0.0, 1.0))\n", + "\n", + " # vectorize your one‐point routine over P\n", + " vmap_triangulate = jax.vmap(\n", + " triangulate_one_point_from_multiple_views_linear,\n", + " in_axes=(None, 1, 1), # proj_matrices static, map over points[:,p,:], conf[:,p]\n", + " out_axes=0,\n", + " )\n", + "\n", + " # returns (P, 3)\n", + " return vmap_triangulate(proj_matrices, points, conf)" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [], + "source": [ + "def triangle_from_cluster(cluster: list[Detection]) -> Float[Array, \"3\"]:\n", + " proj_matrices = jnp.array(\n", + " [\n", + " el.camera.params.projection_matrix\n", + " for el in cluster\n", + " ]\n", + " )\n", + " points = jnp.array([el.keypoints for el in cluster])\n", + " confidences = jnp.array([el.confidences for el in cluster])\n", + " return triangulate_points_from_multiple_views_linear(proj_matrices, points, confidences=confidences)\n", + "\n", + "\n", + "res = {\n", + " \"a\": triangle_from_cluster(clusters_detections[0]).tolist(),\n", + " \"b\": triangle_from_cluster(clusters_detections[1]).tolist(),\n", + "} \n", + "with open(\"samples/res.json\", \"wb\") as f:\n", + " f.write(orjson.dumps(res))" + ] } ], "metadata": {