diff --git "a/src/vis_labels.ipynb" "b/src/vis_labels.ipynb"
new file mode 100644--- /dev/null
+++ "b/src/vis_labels.ipynb"
@@ -0,0 +1,431 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 28,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import numpy as np\n",
+ "\n",
+ "class FootballPitch:\n",
+ " \"\"\"\n",
+ " Standard football field with coordinates centered at the field center.\n",
+ " All internal dimensions are in METERS.\n",
+ " \"\"\"\n",
+ "\n",
+ " # Landmarks ----- X ----->\n",
+ " #\n",
+ " # 0 __________________________ 4 __________________________ 1 |\n",
+ " # | | | |\n",
+ " # 8 _________ 9 | 19 _________ 18 |\n",
+ " # | | | | | Y\n",
+ " # 14 ___ 15 12 6 22 25 ___ 24 |\n",
+ " # | | |\\ / | \\ /| | | |\n",
+ " # | | | \\ / | \\ / | | | ▼\n",
+ " # | | | / \\ | / \\ | | |\n",
+ " # | | |/ \\ | / \\| | |\n",
+ " # 17 ___ 16 13 7 23 26 ___ 27\n",
+ " # | | | | |\n",
+ " # 11 _________ 10 | 20 _________ 21\n",
+ " # | | |\n",
+ " # 3 __________________________ 5 __________________________ 2\n",
+ "\n",
+ "\n",
+ " RADIUS = 9.15\n",
+ " GOAL_W = 7.32 # football goal\n",
+ " GOAL_AREA_LENGTH = 5.5\n",
+ " GOAL_AREA_WIDTH = GOAL_AREA_LENGTH*2+GOAL_W # 18.32\n",
+ " PENALTY_POINT = 11.0\n",
+ " PENALTY_LENGTH = 16.5\n",
+ " PENALTY_WIDTH = PENALTY_LENGTH*2+GOAL_W # 40.32\n",
+ " \n",
+ " \n",
+ " def __init__(self, length=105, width=68):\n",
+ " self.length = length\n",
+ " self.width = width\n",
+ "\n",
+ " self.penalty_circle_width = 2 * np.sqrt(self.RADIUS ** 2 - (self.PENALTY_LENGTH - self.PENALTY_POINT) ** 2)\n",
+ "\n",
+ " self.keypoints = self.compute_keypoints()\n",
+ "\n",
+ " def compute_keypoints(self):\n",
+ " \"\"\"\n",
+ " Computes field keypoints with the origin set at the center.\n",
+ " \"\"\"\n",
+ " HALF_L = self.length / 2\n",
+ " HALF_W = self.width / 2\n",
+ " kpts = [\n",
+ " # Field edge\n",
+ " [-HALF_L, -HALF_W], # 0\n",
+ " [HALF_L, -HALF_W], # 1\n",
+ " [HALF_L, HALF_W], # 2\n",
+ " [-HALF_L, HALF_W], # 3\n",
+ "\n",
+ " # Mid line\n",
+ " [0, -HALF_W], # 4\n",
+ " [0, HALF_W], # 5\n",
+ " [0, -self.RADIUS], # 6\n",
+ " [0, self.RADIUS], # 7\n",
+ "\n",
+ " # Left penalty area\n",
+ " [-HALF_L, -self.PENALTY_WIDTH/2], # 8\n",
+ " [-(HALF_L-self.PENALTY_LENGTH), -self.PENALTY_WIDTH/2], # 9\n",
+ " [-(HALF_L-self.PENALTY_LENGTH), self.PENALTY_WIDTH/2], # 10\n",
+ " [-HALF_L, self.PENALTY_WIDTH/2], # 11\n",
+ " [-(HALF_L-self.PENALTY_LENGTH), -self.penalty_circle_width], # 12\n",
+ " [-(HALF_L-self.PENALTY_LENGTH), self.penalty_circle_width], # 13\n",
+ "\n",
+ " # Left goalie area\n",
+ " [-HALF_L, -self.GOAL_AREA_WIDTH/2], # 14\n",
+ " [-(HALF_L-self.GOAL_AREA_LENGTH), -self.GOAL_AREA_WIDTH/2], # 15\n",
+ " [-(HALF_L-self.GOAL_AREA_LENGTH), self.GOAL_AREA_WIDTH/2], # 16\n",
+ " [-HALF_L, self.GOAL_AREA_WIDTH/2], # 17\n",
+ "\n",
+ " # Right penalty area\n",
+ " [HALF_L, -self.PENALTY_WIDTH/2], # 18\n",
+ " [(HALF_L-self.PENALTY_LENGTH), -self.PENALTY_WIDTH/2], # 19\n",
+ " [(HALF_L-self.PENALTY_LENGTH), self.PENALTY_WIDTH/2], # 20\n",
+ " [HALF_L, self.PENALTY_WIDTH/2], # 21\n",
+ " [(HALF_L-self.PENALTY_LENGTH), -self.penalty_circle_width], # 22\n",
+ " [(HALF_L-self.PENALTY_LENGTH), self.penalty_circle_width], # 23\n",
+ "\n",
+ " # Right goalie area\n",
+ " [HALF_L, -self.GOAL_AREA_WIDTH/2], # 24\n",
+ " [(HALF_L-self.GOAL_AREA_LENGTH), -self.GOAL_AREA_WIDTH/2], # 25\n",
+ " [(HALF_L-self.GOAL_AREA_LENGTH), self.GOAL_AREA_WIDTH/2], # 26\n",
+ " [HALF_L, self.GOAL_AREA_WIDTH/2], # 27\n",
+ " ]\n",
+ " return kpts\n",
+ " \n",
+ " def lines_points_idx(self):\n",
+ " return [\n",
+ " [0,1], [1,2], [2,3], [3,0], # Main rectangle\n",
+ " [4,5], # Midfield line\n",
+ " [8,9], [9,10], [10,11], # Left penalty area\n",
+ " [18,19], [19,20], [20,21], # Right penalty area\n",
+ " [14,15], [15,16], [16,17], # Left goalie area\n",
+ " [24,25], [25,26], [26,27], # Right goalie area\n",
+ " ]\n",
+ " \n",
+ " def get_lines_homogeneous_coords(self):\n",
+ " \"\"\"\n",
+ " Get homogeneous coordinates for each line segment.\n",
+ " \"\"\"\n",
+ " lines_list = [[self.keypoints[st], self.keypoints[fin]] for st, fin in self.lines_points_idx()]\n",
+ " lines_m = np.zeros((len(lines_list), 2, 4))\n",
+ " lines_m[:, :, :2] = np.array(lines_list)\n",
+ " lines_m[:, :, -1] = 1\n",
+ " return lines_m\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 29,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import numpy as np\n",
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "class CameraHomography(object):\n",
+ " def __init__(self, camera_params):\n",
+ " self.aov = camera_params['aov'].item()\n",
+ " self.c_x = camera_params['c_x'].item()\n",
+ " self.c_y = camera_params['c_y'].item()\n",
+ " self.c_z = camera_params['c_z'].item()\n",
+ " self.pan = camera_params['pan'].item()\n",
+ " self.tilt = camera_params['tilt'].item()\n",
+ " self.roll = camera_params['roll'].item()\n",
+ " self.img_height = camera_params['h'].item()\n",
+ " self.img_width = camera_params['w'].item()\n",
+ " self.position = np.array([self.c_x, self.c_y, self.c_z])\n",
+ "\n",
+ " self.intrinsics_m = self.get_intrinsics()\n",
+ " self.rotation_m = self.get_rotation_matrix()\n",
+ " self.extrinsics_m = self.get_extrinsics()\n",
+ " self.projection_m = self.construct_projection_matrix()\n",
+ "\n",
+ " @staticmethod\n",
+ " def get_focal_length(fov_rad: float, d: float):\n",
+ " return (d * 0.5) / np.tan(fov_rad * 0.5)\n",
+ "\n",
+ " def get_intrinsics(self):\n",
+ " focal_length = self.get_focal_length(self.aov, self.img_width)\n",
+ " return np.array([\n",
+ " [focal_length, 0, self.img_width / 2],\n",
+ " [0, focal_length, self.img_height / 2],\n",
+ " [0, 0, 1]\n",
+ " ], dtype=np.float32)\n",
+ "\n",
+ " def get_rotation_matrix(self):\n",
+ " R_pan = np.array([\n",
+ " [np.cos(self.pan), -np.sin(self.pan), 0],\n",
+ " [np.sin(self.pan), np.cos(self.pan), 0],\n",
+ " [0, 0, 1]\n",
+ " ], dtype=np.float32)\n",
+ " R_tilt = np.array([\n",
+ " [1, 0, 0],\n",
+ " [0, np.cos(self.tilt), -np.sin(self.tilt)],\n",
+ " [0, np.sin(self.tilt), np.cos(self.tilt)]\n",
+ " ], dtype=np.float32)\n",
+ " R_roll = np.array([\n",
+ " [np.cos(self.roll), 0, np.sin(self.roll)],\n",
+ " [0, 1, 0],\n",
+ " [-np.sin(self.roll), 0, np.cos(self.roll)]\n",
+ " ], dtype=np.float32)\n",
+ " return R_pan @ R_tilt @ R_roll\n",
+ "\n",
+ " def get_translation_matrix(self):\n",
+ " return self.position.reshape(3, 1)\n",
+ "\n",
+ " def get_extrinsics(self):\n",
+ " It = np.eye(3,4,dtype=np.float32)\n",
+ " It[:,-1] = -self.position\n",
+ " return self.rotation_m.T @ It\n",
+ "\n",
+ " def construct_projection_matrix(self):\n",
+ " It = np.eye(3,4,dtype=np.float32)\n",
+ " It[:,-1] = -self.position\n",
+ "\n",
+ " return self.intrinsics_m @ self.extrinsics_m\n",
+ " \n",
+ " @staticmethod\n",
+ " def clip_line_to_image_plane(line):\n",
+ " \"\"\"\n",
+ " Clips a line segment to the image plane (z == 1).\n",
+ " If one of the endpoints is behind the camera (z < 0), it calculates the intersection\n",
+ " with the image plane and replaces the endpoint.\n",
+ " \"\"\"\n",
+ " start, end = line\n",
+ " if start[2] < 0 and end[2] < 0:\n",
+ " # Both points are behind the camera, discard the line\n",
+ " return None\n",
+ " elif start[2] < 0 or end[2] < 0:\n",
+ " # One point is behind the camera, calculate intersection with z == 1\n",
+ " if start[2] < 0:\n",
+ " start, end = end, start # Ensure start is in front of the camera\n",
+ "\n",
+ " # Parametric line equation: p = start + t * (end - start)\n",
+ " # Solve for t where z == 1: start[2] + t * (end[2] - start[2]) = 1\n",
+ " t = (1 - start[2]) / (end[2] - start[2])\n",
+ " intersection = start + t * (end - start)\n",
+ " return np.array([start, intersection])\n",
+ " else:\n",
+ " # Both points are in front of the camera, keep the line\n",
+ " return line\n",
+ "\n",
+ " def project_points(self, points_array: np.ndarray):\n",
+ " \"\"\"\n",
+ " Projects 3D points onto the image plane using the camera projection matrix.\n",
+ " If a line segment has one endpoint behind the camera, it is clipped at the image plane (z = 1).\n",
+ "\n",
+ " Parameters:\n",
+ " -----------\n",
+ " points_array : np.ndarray\n",
+ " An array of 3D points representing line segments in homogeneous coordinates.\n",
+ " Shape: (N, 2, 4), where N is the number of line segments, each defined by two endpoints.\n",
+ "\n",
+ " Returns:\n",
+ " --------\n",
+ " clipped_lines_normalized : list of np.ndarray\n",
+ " A list of clipped and projected line segments in 2D image coordinates.\n",
+ " Each entry is an array of shape (2, 3), where the last column is 1 after normalization.\n",
+ " \"\"\"\n",
+ " \n",
+ " projected = points_array @ self.projection_m.T\n",
+ "\n",
+ " # Apply clipping to all lines using the \"projected\" matrix\n",
+ " clipped_lines = []\n",
+ " for line in projected:\n",
+ " clipped_line = self.clip_line_to_image_plane(line)\n",
+ " if clipped_line is not None:\n",
+ " clipped_lines.append(clipped_line)\n",
+ "\n",
+ " # Normalize the clipped lines for plotting\n",
+ " clipped_lines_normalized = [line / line[:, 2:3] for line in clipped_lines]\n",
+ " return clipped_lines_normalized"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " aov | \n",
+ " c_x | \n",
+ " c_y | \n",
+ " c_z | \n",
+ " pan | \n",
+ " roll | \n",
+ " tilt | \n",
+ " h | \n",
+ " w | \n",
+ " image_name | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " | 1 | \n",
+ " 0.745562 | \n",
+ " 13.933299 | \n",
+ " 89.794722 | \n",
+ " -37.807205 | \n",
+ " -0.784021 | \n",
+ " 0.0 | \n",
+ " 1.14597 | \n",
+ " 1080 | \n",
+ " 1920 | \n",
+ " 000000001.jpg | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "