{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# PSET 3 Instructions\n",
        "\n",
        "**6.8300 Advances in Computer Vision, 2026**  \n",
        "\n",
        "1. Follow the instructions in this notebook and implement the required functions in the Structure from Motion (SfM) pipeline.\n",
        "2. Check your solutions with the local autograder: from this directory run `python student_autograder.py`.\n",
        "3. Submit your completed notebook `1_sfm_pipeline.ipynb` on Gradescope (PSET 3).\n",
        "\n",
        "---\n",
        "\n",
        "**Pipeline overview (Structure from Motion)**  \n",
        "SfM recovers 3D structure and camera poses from multiple 2D images. This notebook builds the pipeline in this order:\n",
        "\n",
        "- Images\n",
        "- Part 1 (edges)\n",
        "- Part 2 (calibration)\n",
        "- Part 3 (F matrix)\n",
        "- Part 4 (rectification + matching)\n",
        "- Part 5 (3D) \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Part 0: Environment and setup\n",
        "\n",
        "**Goal:** Ensure your environment and helper code are in place so all run cells below execute correctly.\n",
        "\n",
        "Run the cell(s) below if you are in a clean environment. Then run the rest of the notebook."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Note: you may need to restart the kernel to use updated packages.\n"
          ]
        }
      ],
      "source": [
        "# Install required packages (run once in a clean environment)\n",
        "%pip install -q numpy opencv-python matplotlib scikit-image Pillow scipy nbformat"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "import os\n",
        "import numpy as np\n",
        "from pathlib import Path\n",
        "from PIL import Image, ImageDraw\n",
        "import cv2\n",
        "import matplotlib.pyplot as plt\n",
        "import scipy.ndimage\n",
        "\n",
        "# Data: try ./data first (handout zip with data inside student_pset3), then ../data (repo layout).\n",
        "DATA_DIR = Path.cwd() / \"data\" if (Path.cwd() / \"data\").exists() else Path.cwd().parent / \"data\"\n",
        "OUTPUT_DIR = Path.cwd() / \"outputs\"\n",
        "OUTPUT_DIR.mkdir(exist_ok=True)\n",
        "\n",
        "# Example paths: DATA_DIR / \"p1_edge_identification\" / \"chessboard.png\", DATA_DIR / \"p3_fundamental_matrix\" / \"pts_1.txt\", etc.\n",
        "def load_image(path):\n",
        "    return np.array(Image.open(path))\n",
        "\n",
        "\n",
        "def load_points(filename):\n",
        "    with open(filename) as f:\n",
        "        lines = f.read().splitlines()\n",
        "    number_pts = int(lines[0])\n",
        "    points = np.ones((number_pts, 3))\n",
        "    for i in range(number_pts):\n",
        "        split_arr = lines[i + 1].split()\n",
        "        if len(split_arr) == 2:\n",
        "            x, y = split_arr\n",
        "        else:\n",
        "            x, y, z = split_arr\n",
        "            points[i, 2] = z\n",
        "        points[i, 0] = float(x)\n",
        "        points[i, 1] = float(y)\n",
        "    return points"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Part 0: helpers functions \n",
        "\n",
        "These helpers draw epipolar lines, points, SIFT matches, and 3D point clouds. They are used by the run cells in later parts—you can use them as-is without modifying them."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {},
      "outputs": [],
      "source": [
        "def draw_points(\n",
        "    img: np.ndarray, points: np.ndarray, color=(0, 255, 0), radius=5\n",
        ") -> np.ndarray:\n",
        "    img_pil = Image.fromarray(img)\n",
        "    draw = ImageDraw.Draw(img_pil)\n",
        "    for i in range(points.shape[0]):\n",
        "        x, y = points[i, 0], points[i, 1]\n",
        "        draw.ellipse(\n",
        "            [(x - radius, y - radius), (x + radius, y + radius)], outline=color, width=2\n",
        "        )\n",
        "    return np.array(img_pil)\n",
        "\n",
        "\n",
        "def draw_lines(\n",
        "    img: np.ndarray, lines: list, color=(255, 0, 0), thickness=3\n",
        ") -> np.ndarray:\n",
        "    img_pil = Image.fromarray(img)\n",
        "    draw = ImageDraw.Draw(img_pil)\n",
        "    w = img_pil.size[0]\n",
        "    for m, b in lines:\n",
        "        draw.line([(0, b), (w, m * w + b)], fill=color, width=thickness)\n",
        "    return np.array(img_pil)\n",
        "\n",
        "\n",
        "def get_epipolar_img(img: np.ndarray, lines: list, points: np.ndarray) -> np.ndarray:\n",
        "    out = draw_lines(img, lines)\n",
        "    return draw_points(out, points)\n",
        "\n",
        "\n",
        "def show_epipolar_imgs(\n",
        "    img1: np.ndarray,\n",
        "    img2: np.ndarray,\n",
        "    lines1: list,\n",
        "    lines2: list,\n",
        "    pts1: np.ndarray,\n",
        "    pts2: np.ndarray,\n",
        "    offset=0,\n",
        ") -> np.ndarray:\n",
        "    epi1 = get_epipolar_img(img1, lines1, pts1)\n",
        "    epi2 = get_epipolar_img(img2, lines2, pts2)\n",
        "    if offset != 0:\n",
        "        pad = np.zeros((abs(offset), epi1.shape[1], 3), dtype=epi1.dtype)\n",
        "        epi2 = np.vstack([pad, epi2]) if offset > 0 else np.vstack([epi2, pad])\n",
        "        epi1 = np.vstack([epi1, pad]) if offset <= 0 else np.vstack([pad, epi1])\n",
        "    max_h = max(epi1.shape[0], epi2.shape[0])\n",
        "    if epi1.shape[0] < max_h:\n",
        "        epi1 = np.vstack(\n",
        "            [\n",
        "                epi1,\n",
        "                np.zeros((max_h - epi1.shape[0], epi1.shape[1], 3), dtype=epi1.dtype),\n",
        "            ]\n",
        "        )\n",
        "    if epi2.shape[0] < max_h:\n",
        "        epi2 = np.vstack(\n",
        "            [\n",
        "                epi2,\n",
        "                np.zeros((max_h - epi2.shape[0], epi2.shape[1], 3), dtype=epi2.dtype),\n",
        "            ]\n",
        "        )\n",
        "    combined = np.hstack([epi1, epi2])\n",
        "    plt.figure(figsize=(12, 5))\n",
        "    plt.imshow(combined)\n",
        "    plt.title(\"Epipolar lines\")\n",
        "    plt.axis(\"off\")\n",
        "    plt.show()\n",
        "    return combined\n",
        "\n",
        "\n",
        "def show_matches(\n",
        "    img1: np.ndarray, img2: np.ndarray, kp1: list, kp2: list, matches: list\n",
        ") -> np.ndarray:\n",
        "    result = cv2.drawMatches(\n",
        "        img1,\n",
        "        kp1,\n",
        "        img2,\n",
        "        kp2,\n",
        "        matches,\n",
        "        None,\n",
        "        matchColor=(0, 255, 0),\n",
        "        singlePointColor=(255, 0, 0),\n",
        "        flags=cv2.DrawMatchesFlags_NOT_DRAW_SINGLE_POINTS,\n",
        "    )\n",
        "    plt.figure(figsize=(12, 5))\n",
        "    plt.imshow(result)\n",
        "    plt.title(\"SIFT matches\")\n",
        "    plt.axis(\"off\")\n",
        "    plt.show()\n",
        "    return result\n",
        "\n",
        "\n",
        "def show_points_matplotlib(points3D: np.ndarray) -> None:\n",
        "    fig = plt.figure()\n",
        "    ax = fig.add_subplot(111, projection=\"3d\")\n",
        "    ax.scatter(points3D[:, 0], points3D[:, 1], points3D[:, 2], c=\"r\", marker=\"o\", s=5)\n",
        "    ax.set_xlabel(\"X\")\n",
        "    ax.set_ylabel(\"Y\")\n",
        "    ax.set_zlabel(\"Z\")\n",
        "    plt.title(\"3D point cloud\")\n",
        "    plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Part 1 — Edge Detection (15 pts)\n",
        "\n",
        "**Goal:** Prepare for calibration by defining boundaries (contours) in the chessboard image.\n",
        "\n",
        "**Why contours?** Corners lie on edges; we'll use these boundaries when we detect chessboard corners. Implement contour detection by hand—**do not use OpenCV or similar for contour detection**—to see how boundaries are defined.\n",
        "\n",
        "**In this part you will:**\n",
        "- **1.a** — Binarize the image and zero the border so contours are not drawn along the frame.\n",
        "- **1.b** — Find boundary pixels (contours) by checking 8-neighbors; implement `is_boundary_neighbor`.\n",
        "\n",
        "---\n",
        "\n",
        "### 1.a — Image preparation (5 pts)\n",
        "\n",
        "A binary image separates foreground (chessboard) from background; cleaning the border avoids contours along the image frame.\n",
        "\n",
        "- **`binarize`:** Set `self.binarized_image` to (H×W) with values in {0, 1} (pixel ≥ 128 → 1).\n",
        "- **`fill_border`:** Set first/last row and first/last column to 0.\n",
        "\n",
        "**Before and after (1.a):** Example small image. Use `| - +` to think of the image as a grid; border rows/columns are zeroed so contours are not drawn along the frame.\n",
        "\n",
        "*Before (grayscale, . = dark &lt; 128, # = light ≥ 128):*\n",
        "\n",
        "```\n",
        "+---+---+---+---+---+\n",
        "| . | . | # | # | . |\n",
        "+---+---+---+---+---+\n",
        "| . | # | # | # | # |\n",
        "+---+---+---+---+---+\n",
        "| # | # | # | # | # |\n",
        "+---+---+---+---+---+\n",
        "| # | # | # | # | . |\n",
        "+---+---+---+---+---+\n",
        "| . | . | # | . | . |\n",
        "+---+---+---+---+---+\n",
        "```\n",
        "\n",
        "*After binarize* (pixel ≥ 128 → 1):\n",
        "\n",
        "```\n",
        "+---+---+---+---+---+\n",
        "| 0 | 0 | 1 | 1 | 0 |\n",
        "+---+---+---+---+---+\n",
        "| 0 | 1 | 1 | 1 | 1 |\n",
        "+---+---+---+---+---+\n",
        "| 1 | 1 | 1 | 1 | 1 |\n",
        "+---+---+---+---+---+\n",
        "| 1 | 1 | 1 | 1 | 0 |\n",
        "+---+---+---+---+---+\n",
        "| 0 | 0 | 1 | 0 | 0 |\n",
        "+---+---+---+---+---+\n",
        "```\n",
        "\n",
        "*After fill_border* (first/last row and column set to 0):\n",
        "\n",
        "```\n",
        "+---+---+---+---+---+\n",
        "| 0 | 0 | 0 | 0 | 0 |\n",
        "+---+---+---+---+---+\n",
        "| 0 | 1 | 1 | 1 | 0 |\n",
        "+---+---+---+---+---+\n",
        "| 0 | 1 | 1 | 1 | 0 |\n",
        "+---+---+---+---+---+\n",
        "| 0 | 1 | 1 | 1 | 0 |\n",
        "+---+---+---+---+---+\n",
        "| 0 | 0 | 0 | 0 | 0 |\n",
        "+---+---+---+---+---+\n",
        "```\n",
        "\n",
        "**Hint:** `np.mean(..., axis=2)` for grayscale; `np.where` for binarization. Complete the `ContourImage` class: `binarize(self)` and `fill_border(self)`.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {},
      "outputs": [],
      "source": [
        "def get_foreground_components(binary_image: np.ndarray, foreground: int = 1) -> list:\n",
        "    \"\"\"Return list of connected components; each component is a list of (row, col) pixels. (Provided.)\"\"\"\n",
        "    num_rows, num_cols = binary_image.shape\n",
        "    visited = np.zeros_like(binary_image, dtype=bool)\n",
        "    components = []\n",
        "\n",
        "    def in_bounds(row, col):\n",
        "        return 0 <= row < num_rows and 0 <= col < num_cols\n",
        "\n",
        "    def dfs(row, col):\n",
        "        stack = [(row, col)]\n",
        "        component = []\n",
        "        while stack:\n",
        "            i, j = stack.pop()\n",
        "            if visited[i, j]:\n",
        "                continue\n",
        "            visited[i, j] = True\n",
        "            component.append((i, j))\n",
        "            for dr in (-1, 0, 1):\n",
        "                for dc in (-1, 0, 1):\n",
        "                    nr, nc = i + dr, j + dc\n",
        "                    if (\n",
        "                        in_bounds(nr, nc)\n",
        "                        and not visited[nr, nc]\n",
        "                        and binary_image[nr, nc] == foreground\n",
        "                    ):\n",
        "                        stack.append((nr, nc))\n",
        "        return component\n",
        "\n",
        "    for r in range(num_rows):\n",
        "        for c in range(num_cols):\n",
        "            if not visited[r, c] and binary_image[r, c] == foreground:\n",
        "                components.append(dfs(r, c))\n",
        "    return components\n",
        "\n",
        "\n",
        "class ContourImage:\n",
        "    def __init__(self, image: Image.Image):\n",
        "        self.image = image\n",
        "        self.binarized_image = None\n",
        "\n",
        "    def binarize(self, threshold=128) -> None:\n",
        "        np_image = np.array(self.image)\n",
        "\n",
        "        # TODO: STUDENT CODE HERE (1a)\n",
        "        raise NotImplementedError\n",
        "        # END STUDENT CODE\n",
        "\n",
        "    def fill_border(self) -> None:\n",
        "        # TODO: STUDENT CODE HERE (1a)\n",
        "        raise NotImplementedError\n",
        "        # END STUDENT CODE\n",
        "\n",
        "    def to_PIL(self) -> Image.Image:\n",
        "        color_array = np.stack([self.binarized_image] * 3, axis=-1) * 255\n",
        "        return Image.fromarray(color_array.astype(np.uint8))\n",
        "\n",
        "    def prepare(self) -> np.ndarray:\n",
        "        self.binarize()\n",
        "        self.fill_border()\n",
        "        return self.binarized_image"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 1.b — Find contours (10 pts)\n",
        "\n",
        "We want **boundary pixels**: foreground pixels that touch at least one background pixel or the image edge. The functions `get_foreground_components` and the full `find_contours` loop are provided; you implement the helper **`is_boundary_neighbor`**.\n",
        "\n",
        "---\n",
        "\n",
        "#### 8-neighborhood\n",
        "\n",
        "For each foreground pixel at `(i, j)` we check its **8 neighbors** (same as the loop `dr, dc in (-1,0,1)` with `ni = i+dr`, `nj = j+dc`; the center is the current pixel):\n",
        "\n",
        "```\n",
        "         col:  j-1    j    j+1\n",
        "row i-1:   N     N     N\n",
        "row i:     N     C     N     (C = current pixel at (i,j))\n",
        "row i+1:   N     N     N\n",
        "```\n",
        "\n",
        "---\n",
        "\n",
        "#### Boundary pixels: before and after (1.b)\n",
        "\n",
        "A foreground pixel is on the **boundary** if at least one of its 8 neighbors is background (0) or out-of-bounds. Below: **before** = binary image (0/1); **after** = same grid with boundary pixels marked as `B` (foreground pixels that have ≥1 neighbor that is 0 or OOB). Interior foreground pixels stay `1`.\n",
        "\n",
        "*Before (binary after 1.a):*\n",
        "\n",
        "```\n",
        "+---+---+---+---+---+\n",
        "| 0 | 0 | 1 | 1 | 0 |\n",
        "+---+---+---+---+---+\n",
        "| 0 | 1 | 1 | 1 | 1 |\n",
        "+---+---+---+---+---+\n",
        "| 1 | 1 | 1 | 1 | 1 |\n",
        "+---+---+---+---+---+\n",
        "| 1 | 1 | 1 | 1 | 0 |\n",
        "+---+---+---+---+---+\n",
        "| 0 | 0 | 1 | 0 | 0 |\n",
        "+---+---+---+---+---+\n",
        "```\n",
        "\n",
        "*After find_contours* (boundary pixels = contours; marked as B):\n",
        "\n",
        "```\n",
        "+---+---+---+---+---+\n",
        "| 0 | 0 | B | B | 0 |\n",
        "+---+---+---+---+---+\n",
        "| 0 | B | 1 | B | B |\n",
        "+---+---+---+---+---+\n",
        "| B | 1 | 1 | 1 | B |\n",
        "+---+---+---+---+---+\n",
        "| B | B | 1 | B | 0 |\n",
        "+---+---+---+---+---+\n",
        "| 0 | 0 | B | 0 | 0 |\n",
        "+---+---+---+---+---+\n",
        "```\n",
        "\n",
        "The result list is the set of `(row, col)` for every `B` (and the center `1` is not in the result).\n",
        "\n",
        "---\n",
        "\n",
        "#### Your task: `is_boundary_neighbor`\n",
        "\n",
        "**Role:** Returns `True` when the neighbor at `(ni, nj)` indicates that the **current** pixel is on the boundary.\n",
        "\n",
        "**When to return True:**\n",
        "\n",
        "| Condition | Return |\n",
        "|-----------|--------|\n",
        "| `(ni, nj)` is **out-of-bounds** (e.g. `ni < 0`, `ni >= num_rows`, `nj < 0`, `nj >= num_cols`) | `True` |\n",
        "| `(ni, nj)` is in-bounds and `binary_image[ni, nj] != foreground` | `True` |\n",
        "| Otherwise (in-bounds and same as foreground) | `False` |\n",
        "\n",
        "**Logic summary:**  \n",
        "`is_boundary_neighbor` returns True when:  \n",
        "**out_of_bounds(ni, nj)** OR **(in_bounds(ni, nj) AND image[ni,nj] != foreground)**\n",
        "\n",
        "**Hint:** Return `True` when the neighbor is out-of-bounds **or** (when in-bounds) `binary_image[ni, nj] != foreground`. Complete `is_boundary_neighbor` (marked STUDENT CODE HERE).\n",
        "\n",
        "---\n",
        "\n",
        "#### Algorithm summary\n",
        "\n",
        "1. `find_contours` gets foreground components via `get_foreground_components`.\n",
        "2. For each foreground pixel `(i, j)`, it checks all 8 neighbors with `is_boundary_neighbor`.\n",
        "3. If **any** neighbor returns `True`, the pixel is a boundary pixel and is added to the result.\n",
        "\n",
        "Your final output will look similar to the image below.\n",
        "\n",
        "![Contours on chessboard](../data/figures/find_contours.png)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {},
      "outputs": [],
      "source": [
        "def is_boundary_neighbor(binary_image, ni, nj, num_rows, num_cols, foreground):\n",
        "    \"\"\"Return True when neighbor (ni, nj) indicates the current pixel is on the boundary.\n",
        "    That is: (ni, nj) is out-of-bounds, or (when in bounds) binary_image[ni, nj] != foreground.\n",
        "    \"\"\"\n",
        "    # TODO: STUDENT CODE HERE (1b)\n",
        "    raise NotImplementedError\n",
        "    # END STUDENT CODE\n",
        "\n",
        "\n",
        "def find_contours(binary_image: np.ndarray, foreground: int = 1) -> list:\n",
        "    components = get_foreground_components(binary_image, foreground)\n",
        "    num_rows, num_cols = binary_image.shape\n",
        "    result = []\n",
        "    for component in components:\n",
        "        for i, j in component:\n",
        "            is_boundary = False\n",
        "            for dr in (-1, 0, 1):\n",
        "                for dc in (-1, 0, 1):\n",
        "                    ni, nj = i + dr, j + dc\n",
        "                    if is_boundary_neighbor(binary_image, ni, nj, num_rows, num_cols, foreground):\n",
        "                        is_boundary = True\n",
        "                        break\n",
        "                if is_boundary:\n",
        "                    break\n",
        "            if is_boundary:\n",
        "                result.append((i, j))\n",
        "    return result\n",
        "\n",
        "\n",
        "def find_chessboard_contours(image: Image.Image) -> list:\n",
        "    ci = ContourImage(image)\n",
        "    return find_contours(ci.prepare())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {},
      "outputs": [],
      "source": [
        "def draw_corners(pil_img, corners, color=(255, 0, 0), radius=5):\n",
        "    img = pil_img.copy()\n",
        "    d = ImageDraw.Draw(img)\n",
        "    for y, x in corners:\n",
        "        d.ellipse(\n",
        "            [(x - radius, y - radius), (x + radius, y + radius)], outline=color, width=2\n",
        "        )\n",
        "    return img"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Part 1 not fully implemented yet — fix the step below and re-run this cell.\n",
            "  Error: NotImplementedError: \n",
            "  → Implement Part 1: ContourImage (binarize, fill_border), find_contours (is_boundary_neighbor), find_chessboard_contours, draw_corners\n"
          ]
        }
      ],
      "source": [
        "# Run Part 1: chessboard contours and draw corners\n",
        "try:\n",
        "    from PIL import Image\n",
        "\n",
        "    path = DATA_DIR / \"p1_edge_identification\" / \"chessboard.png\"\n",
        "    img = Image.open(path)\n",
        "    contours = find_chessboard_contours(img)\n",
        "    result = draw_corners(img, contours)\n",
        "    plt.figure(figsize=(8, 5))\n",
        "    plt.imshow(result)\n",
        "    plt.title(\"Chessboard contours\")\n",
        "    plt.axis(\"off\")\n",
        "    plt.show()\n",
        "    result.save(OUTPUT_DIR / \"p1_corners.png\")\n",
        "except Exception as e:\n",
        "    err = type(e).__name__\n",
        "    msg = str(e).split(\"\\n\")[0][:80]\n",
        "    print(\"Part 1 not fully implemented yet — fix the step below and re-run this cell.\")\n",
        "    print(f\"  Error: {err}: {msg}\")\n",
        "    if err == \"NotImplementedError\":\n",
        "        print(\"  → Implement Part 1: ContourImage (binarize, fill_border), find_contours (is_boundary_neighbor), find_chessboard_contours, draw_corners\")\n",
        "    elif \"find_chessboard_contours\" in str(e) or \"draw_corners\" in str(e):\n",
        "        print(\"  → Implement find_chessboard_contours and/or draw_corners (Part 1).\")\n",
        "    elif \"find_contours\" in str(e) or \"is_boundary\" in str(e):\n",
        "        print(\"  → Implement find_contours and is_boundary_neighbor (Part 1).\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Part 2 — Camera Calibration (20 pts)\n",
        "\n",
        "**Goal:** Recover the camera intrinsics (matrix **K**) and distortion coefficients so we can (1) map 3D points to pixels and (2) **undistort** images—removing lens distortion so that later steps (matching, triangulation) work on idealized pinhole geometry.\n",
        "\n",
        "We use a known chessboard to get 2D–3D correspondences, then solve for K and distortion. The **code order** below follows this flow:\n",
        "\n",
        "- **2.a** — Define ideal K and chessboard size (provided).\n",
        "- **2.b** — Detect 2D corners in the image (provided helpers + run cell). Our provided script will do the camera calibration for you.\n",
        "- **2.c** — Implement `get_3D_object_points` so we have 3D points for each corner. \n",
        "- **2.d** — Implement `distort_point`; with it, the provided `build_undistort_maps` and `undistort_image` produce the undistorted image.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 2.a — Intrinsic matrix K\n",
        "\n",
        "**K** maps 3D camera coordinates to 2D pixels (focal lengths + principal point). We recover the real K from calibration and use it for projection and undistortion in (2.d). \n",
        "\n",
        "Below: ideal K (45° FOV) and `chessboard_size`—**no code to write**; run the cell to display them.\n",
        "\n",
        "![Intrinsic matrix K](../data/figures/IntrinsicMatrix.png)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Ideal K (2.a):\n",
            "[[579.41125497   0.         320.        ]\n",
            " [  0.         579.41125497 240.        ]\n",
            " [  0.           0.           1.        ]]\n",
            "chessboard_size (inner corners): (16, 9)\n"
          ]
        }
      ],
      "source": [
        "# 2.a — Ideal intrinsic matrix K and chessboard size (provided)\n",
        "fov_rad = np.deg2rad(45)\n",
        "f_r = 1.0 / (2 * np.tan(fov_rad / 2))\n",
        "ideal_intrinsic_matrix = np.array(\n",
        "    [[f_r * min(640, 480), 0, 640 / 2], [0, f_r * min(640, 480), 480 / 2], [0, 0, 1]],\n",
        "    dtype=np.float64,\n",
        ")\n",
        "chessboard_size = (16, 9)  # inner corners (cols, rows); must match chessboard.png\n",
        "print(\"Ideal K (2.a):\")\n",
        "print(ideal_intrinsic_matrix)\n",
        "print(\"chessboard_size (inner corners):\", chessboard_size)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 2.b — Find corners\n",
        "\n",
        "- OpenCV finds the **inner corners** of the chessboard (where four squares meet).\n",
        "- These are the **2D image measurements** we need for calibration: paired with 3D object points (2.c), they let us solve for K and distortion, then undistort in 2.d.\n",
        "- `chessboard_size` is (number of inner corners in x, number in y)—one less than the number of squares per side.\n",
        "\n",
        "**Inner corners only** (example 2×2 inner corners = 3×3 squares):\n",
        "\n",
        "```\n",
        "+-------+-------+-------+\n",
        "|       |       |       |\n",
        "|   +---+---+---+---+   |     + = inner corner (detected)\n",
        "+---+   |   |   |   +---+\n",
        "|       |   |   |       |\n",
        "+---+   +---+---+   +---+\n",
        "|       |       |       |\n",
        "|   +---+---+---+---+   |\n",
        "+-------+-------+-------+\n",
        "```\n",
        "\n",
        "**Run the next two cells** to load the corner-finding helpers and visualize detected corners on the chessboard image.\n",
        "\n",
        "![Find corners on chessboard](../data/figures/find_corners.png)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {},
      "outputs": [],
      "source": [
        "# 2.b — Helpers to find and refine chessboard corners (provided)\n",
        "def load_grayscale_image(image):\n",
        "    return np.mean(image, axis=2).astype(np.uint8)\n",
        "\n",
        "\n",
        "def find_chessboard_corners(image, chessboard_size):\n",
        "    ret, corners = cv2.findChessboardCorners(image, chessboard_size, None)\n",
        "    if not ret:\n",
        "        raise ValueError(\"Verify correct dimensions of chessboard\")\n",
        "    return corners\n",
        "\n",
        "\n",
        "def refine_corners(image, corners):\n",
        "    return cv2.cornerSubPix(\n",
        "        image,\n",
        "        corners,\n",
        "        (11, 11),\n",
        "        (-1, -1),\n",
        "        (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001),\n",
        "    )"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 800x500 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Run 2.b: find corners on the chessboard image and visualize\n",
        "try:\n",
        "    path = DATA_DIR / \"p1_edge_identification\" / \"chessboard.png\"\n",
        "    image = load_image(path)\n",
        "    gray = load_grayscale_image(image)\n",
        "    corners = find_chessboard_corners(gray, chessboard_size)\n",
        "    corners = refine_corners(gray, corners)\n",
        "    corners_img = image.copy()\n",
        "    cv2.drawChessboardCorners(corners_img, chessboard_size, corners, True)\n",
        "    plt.figure(figsize=(8, 5))\n",
        "    plt.imshow(corners_img)\n",
        "    plt.title(\"Chessboard corners (2.b)\")\n",
        "    plt.axis(\"off\")\n",
        "    plt.show()\n",
        "except Exception as e:\n",
        "    err = type(e).__name__\n",
        "    msg = str(e).split(\"\\n\")[0][:80]\n",
        "    print(\"2.b (find corners) failed — fix and re-run this cell.\")\n",
        "    print(f\"  Error: {err}: {msg}\")\n",
        "    if \"chessboard\" in str(e).lower() and \"Verify\" in str(e):\n",
        "        print(\"  → Check chessboard_size in 2.a matches the image (e.g. (16, 9)).\")\n",
        "    elif \"not found\" in str(e).lower() or \"No such file\" in str(e):\n",
        "        print(\"  → Ensure DATA_DIR points to data/ and chessboard.png exists under p1_edge_identification/.\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 2.c — 3D object points\n",
        "\n",
        "We need **3D coordinates** for each detected corner so we can calibrate: with 2D corners from 2.b and these 3D object points, we solve for K and the distortion coefficients, then use them in 2.d to undistort. The chessboard is flat, so every point has **z = 0**. The ordering of points must match OpenCV’s corner order (e.g. left-to-right, top-to-bottom).\n",
        "\n",
        "---\n",
        "\n",
        "#### Before and after\n",
        "\n",
        "| Stage | What you have |\n",
        "|-------|----------------|\n",
        "| **Before** | 2D corner positions from OpenCV (one per inner corner). |\n",
        "| **After** | Same ordering, but each row is (x, y, 0) in object space. |\n",
        "\n",
        "Output shape: **(N, 3)** with **N = cols × rows** (e.g. `chessboard_size = (2, 2)` → 4 points).\n",
        "\n",
        "---\n",
        "\n",
        "#### Object-space grid (example)\n",
        "\n",
        "For **2×2 inner corners** (cols=2, rows=2), object points in a flat grid:\n",
        "\n",
        "```text\n",
        "+-----------+-----------+\n",
        "| (0,0,0)   | (1,0,0)   |   row 0\n",
        "+-----------+-----------+\n",
        "| (0,1,0)   | (1,1,0)   |   row 1\n",
        "+-----------+-----------+\n",
        "  col 0       col 1\n",
        "\n",
        "z = 0 for all. Order matches OpenCV (e.g. row-major).\n",
        "```\n",
        "\n",
        "Your function returns an array of shape (N, 3) in this order.\n",
        "\n",
        "---\n",
        "\n",
        "#### Your task\n",
        "\n",
        "Implement **`get_3D_object_points(chessboard_size)`** so that:\n",
        "\n",
        "- `chessboard_size` is (number of inner corners in x, number in y).\n",
        "- Fill `object_points` with (x, y, 0) in the same order OpenCV uses for corners.\n",
        "\n",
        "**Hint:** `np.mgrid` or a double loop over the grid; output shape (N, 3) with N = cols × rows.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {},
      "outputs": [],
      "source": [
        "def get_3D_object_points(chessboard_size):\n",
        "    object_points = np.zeros((chessboard_size[0] * chessboard_size[1], 3), np.float32)\n",
        "\n",
        "    # TODO: STUDENT CODE HERE (2c)\n",
        "    raise NotImplementedError\n",
        "    # END STUDENT CODE"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 2.d — Undistortion\n",
        "\n",
        "With **K** and **distortion coefficients** from calibration (2.a–2.c), we can now produce an undistorted image. **Goal:** Remove lens distortion so the image obeys the pinhole model. Real lenses introduce **radial** (and sometimes **tangential**) distortion. We use the calibrated coefficients to build an inverse map: for each pixel in the **output** (undistorted) image, we find where it came from in the **distorted** image and sample there. The provided code does the mapping; you implement the **forward distortion** model **`distort_point`**.\n",
        "\n",
        "**Why implement \"distort\"?** To know *where to sample* in the distorted image for each output pixel, we take the ideal (undistorted) normalized coordinates and apply the **forward** distortion formula—that gives the corresponding location in the distorted image. So the one function you implement is the distortion model; the rest of the pipeline uses it to produce the undistorted result.\n",
        "\n",
        "---\n",
        "\n",
        "#### Pipeline (what the provided code does)\n",
        "\n",
        "For each **output** pixel (u, v) in the undistorted image, one straight flow (top to bottom):\n",
        "\n",
        "```text\n",
        "+------------------------------------------+\n",
        "|  output pixel (u, v)                     |\n",
        "+------------------------------------------+\n",
        "                    |\n",
        "                    v\n",
        "+------------------------------------------+\n",
        "|  1. Normalize                            |\n",
        "|     (x_norm, y_norm) = ((u-cx)/fx, ...)  |\n",
        "+------------------------------------------+\n",
        "                    |\n",
        "                    v\n",
        "+------------------------------------------+\n",
        "|  2. Distort  <-- YOU IMPLEMENT THIS      |\n",
        "|     (x_dist, y_dist) = distort_point(...)|\n",
        "+------------------------------------------+\n",
        "                    |\n",
        "                    v\n",
        "+------------------------------------------+\n",
        "|  3. Map (x_dist, y_dist) to pixel;      |\n",
        "|     sample original image there          |\n",
        "+------------------------------------------+\n",
        "```\n",
        "\n",
        "So you only implement **`distort_point`**; **`build_undistort_maps`** and **`undistort_image`** are provided.\n",
        "\n",
        "---\n",
        "\n",
        "#### Your task: `distort_point` (used to build the undistort map)\n",
        "\n",
        "Implement **`distort_point(x_norm, y_norm, k1, k2, p1, p2, k3)`** so that it returns **(xd, yd)** using the OpenCV model.\n",
        "\n",
        "**Radial distortion** (use normalized coordinates $x$, $y$):\n",
        "\n",
        "$$r^2 = x^2 + y^2, \\qquad \\text{radial} = 1 + k_1 r^2 + k_2 r^4 + k_3 r^6$$\n",
        "\n",
        "(Here $r^4$ and $r^6$ are the second and third powers of $r^2$.)\n",
        "\n",
        "**Tangential distortion** (add these to the radially distorted coordinates):\n",
        "\n",
        "$$x_d = x \\cdot \\text{radial} + 2 p_1 x y + p_2 (r^2 + 2 x^2)$$\n",
        "\n",
        "$$y_d = y \\cdot \\text{radial} + p_1 (r^2 + 2 y^2) + 2 p_2 x y$$\n",
        "\n",
        "**Hints:**\n",
        "- Coefficient order in OpenCV: (k₁, k₂, p₁, p₂, k₃). Use the inputs `x_norm`, `y_norm` as $x$ and $y$ in the formulas above.\n",
        "- Compute $r^2$ first from the normalized coordinates; then compute the radial factor (it depends only on $r^2$ and the $k$'s).\n",
        "- Each of $x_d$ and $y_d$ is the coordinate times the radial factor, plus two tangential terms—the docstring in the code cell spells out exactly which terms go into $x_d$ vs $y_d$.\n",
        "- The rest of the pipeline is provided; you only need to implement `distort_point`.\n",
        "\n",
        "![Distortion coefficients](../data/figures/distortions.png)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "def calibrate_camera(object_points, corners, image_size):\n",
        "    \"\"\"Solve for K and distortion from 2D–3D correspondences. (Provided.)\"\"\"\n",
        "    ret, camera_matrix, dist_coeffs, rvecs, tvecs = cv2.calibrateCamera(\n",
        "        [object_points], [corners], image_size, None, None\n",
        "    )\n",
        "    return camera_matrix, dist_coeffs\n",
        "\n",
        "\n",
        "def distort_point(x_norm, y_norm, k1, k2, p1, p2, k3=0.0):\n",
        "    \"\"\"\n",
        "    Apply radial and tangential distortion to normalized coordinates.\n",
        "    Used by build_undistort_maps to find where to sample in the distorted image\n",
        "    for each output pixel (so the pipeline produces an undistorted image).\n",
        "    Returns (xd, yd).\n",
        "\n",
        "    OpenCV model (use x_norm as x, y_norm as y):\n",
        "      r2 = x^2 + y^2\n",
        "      radial = 1 + k1*r2 + k2*r2^2 + k3*r2^3\n",
        "      xd = x*radial + 2*p1*x*y + p2*(r2 + 2*x^2)\n",
        "      yd = y*radial + p1*(r2 + 2*y^2) + 2*p2*x*y\n",
        "\n",
        "    Hint: compute r2 first, then radial, then xd and yd (each has one radial\n",
        "    term and two tangential terms as above).\n",
        "    \"\"\"\n",
        "\n",
        "    # TODO: STUDENT CODE HERE (2d)\n",
        "    raise NotImplementedError\n",
        "    # END STUDENT CODE\n",
        "\n",
        "\n",
        "def build_undistort_maps(h, w, camera_matrix, dist_coeffs):\n",
        "    \"\"\"Build mapx, mapy so that remapping gives undistorted image. (Provided.)\"\"\"\n",
        "    fx, fy = camera_matrix[0, 0], camera_matrix[1, 1]\n",
        "    cx, cy = camera_matrix[0, 2], camera_matrix[1, 2]\n",
        "    dc = dist_coeffs.ravel()\n",
        "    k1, k2, p1, p2 = dc[0], dc[1], dc[2], dc[3]\n",
        "    k3 = dc[4] if len(dc) > 4 else 0.0\n",
        "    mapx = np.zeros((h, w), np.float32)\n",
        "    mapy = np.zeros((h, w), np.float32)\n",
        "    for v in range(h):\n",
        "        for u in range(w):\n",
        "            x_norm = (u - cx) / fx\n",
        "            y_norm = (v - cy) / fy\n",
        "            xd, yd = distort_point(x_norm, y_norm, k1, k2, p1, p2, k3)\n",
        "            mapx[v, u] = fx * xd + cx\n",
        "            mapy[v, u] = fy * yd + cy\n",
        "    return mapx, mapy\n",
        "\n",
        "\n",
        "def undistort_image(image, camera_matrix, dist_coeffs):\n",
        "    \"\"\"Remap image using inverse distortion; uses build_undistort_maps and map_coordinates. (Provided.)\"\"\"\n",
        "    h, w = image.shape[:2]\n",
        "    mapx, mapy = build_undistort_maps(h, w, camera_matrix, dist_coeffs)\n",
        "    channels = [\n",
        "        scipy.ndimage.map_coordinates(\n",
        "            image[..., c],\n",
        "            np.vstack([mapy.ravel(), mapx.ravel()]),\n",
        "            order=1,\n",
        "            mode=\"constant\",\n",
        "            cval=0.0,\n",
        "        ).reshape(h, w)\n",
        "        for c in range(image.shape[2])\n",
        "    ]\n",
        "    return np.dstack(channels).astype(np.uint8)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 800x500 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Part 2 not fully implemented yet — fix the step below and re-run this cell.\n",
            "  Error: NotImplementedError: \n",
            "  → Implement 2.c: get_3D_object_points(chessboard_size)\n",
            "  → Implement 2.d: distort_point(x_norm, y_norm, k1, k2, p1, p2, k3)\n"
          ]
        }
      ],
      "source": [
        "# Run Part 2: calibrate camera and undistort\n",
        "try:\n",
        "    path = DATA_DIR / \"p1_edge_identification\" / \"chessboard.png\"\n",
        "    image = load_image(path)\n",
        "    gray = load_grayscale_image(image)\n",
        "    corners = find_chessboard_corners(gray, chessboard_size)\n",
        "    corners = refine_corners(gray, corners)\n",
        "    corners_img = image.copy()\n",
        "    cv2.drawChessboardCorners(corners_img, chessboard_size, corners, True)\n",
        "    plt.figure(figsize=(8, 5))\n",
        "    plt.imshow(corners_img)\n",
        "    plt.title(\"Chessboard corners\")\n",
        "    plt.axis(\"off\")\n",
        "    plt.show()\n",
        "    object_points = get_3D_object_points(chessboard_size)\n",
        "    camera_matrix, dist_coeffs = calibrate_camera(\n",
        "        object_points, corners, gray.shape[::-1]\n",
        "    )\n",
        "    undistorted = undistort_image(image, camera_matrix, dist_coeffs)\n",
        "    plt.figure(figsize=(8, 5))\n",
        "    plt.imshow(undistorted)\n",
        "    plt.title(\"Undistorted image\")\n",
        "    plt.axis(\"off\")\n",
        "    plt.show()\n",
        "    Image.fromarray(undistorted).save(OUTPUT_DIR / \"p2_undistorted.png\")\n",
        "except Exception as e:\n",
        "    err = type(e).__name__\n",
        "    msg = str(e).split(\"\\n\")[0][:80]\n",
        "    print(\"Part 2 not fully implemented yet — fix the step below and re-run this cell.\")\n",
        "    print(f\"  Error: {err}: {msg}\")\n",
        "    if err == \"NotImplementedError\":\n",
        "        print(\"  → Implement 2.c: get_3D_object_points(chessboard_size)\")\n",
        "        print(\"  → Implement 2.d: distort_point(x_norm, y_norm, k1, k2, p1, p2, k3)\")\n",
        "    else:\n",
        "        if \"get_3D_object_points\" in str(e):\n",
        "            print(\"  → Implement 2.c: get_3D_object_points(chessboard_size)\")\n",
        "        if \"distort_point\" in str(e) or \"undistort\" in str(e).lower():\n",
        "            print(\"  → Implement 2.d: distort_point(x_norm, y_norm, k1, k2, p1, p2, k3)\")\n",
        "    if \"chessboard\" in str(e).lower() and \"Verify\" in str(e):\n",
        "        print(\"  → Check that chessboard_size in 2.a matches the image (e.g. (16, 9)).\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Part 3 — Epipolar Geometry (20 pts)\n",
        "\n",
        "From two views and point correspondences, compute the fundamental matrix **F** and the epipolar lines. A point in one image has its match on a line in the other—the **epipolar line**; F encodes this constraint.\n",
        "\n",
        "![Epipolar geometry](../data/figures/epipolar_diagram.png)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 3.a — Least-squares eight-point algorithm\n",
        "\n",
        "**Goal:** Compute the fundamental matrix **F** from point correspondences (p, p') between two images. Each correspondence satisfies the epipolar constraint $\\mathbf{p}'^\\top F \\mathbf{p} = 0$, which is one linear equation in the 9 entries of F. With 8 or more correspondences we can solve for F (up to scale). F must have rank 2; the provided **`enforce_rank2(F)`** enforces this after you form F.\n",
        "\n",
        "---\n",
        "\n",
        "#### Setting up the linear system\n",
        "\n",
        "Stack the unknowns into a 9-vector **f** (e.g. row-major order of F). Then all constraints become **W f = 0**, where **W** is N×9: one row per correspondence.\n",
        "\n",
        "For point $(u, v, 1)$ in image 1 and $(u', v', 1)$ in image 2, expanding $\\mathbf{p}'^\\top F \\mathbf{p} = 0$ gives one row of W:\n",
        "\n",
        "$$\\text{row} = [\\, u'u,\\ u'v,\\ u',\\ v'u,\\ v'v,\\ v',\\ u,\\ v,\\ 1\\,]$$\n",
        "\n",
        "So **W** is N×9; each row encodes one equation in the 9 unknowns.\n",
        "\n",
        "---\n",
        "\n",
        "#### Solving W f = 0\n",
        "\n",
        "The solution **f** lies in the **null space** of W. With 8 points the null space is 1D (unique up to scale); with more points, use the direction that best satisfies the equations (minimum singular value). Reshape the 9-vector to a 3×3 matrix to get F, then return **`enforce_rank2(F)`**.\n",
        "\n",
        "**Hints (without giving the answer):** Build the N×9 matrix W from `points1` and `points2` using the row form above. Use **`np.linalg.svd`** on W; the null-space vector corresponds to a specific singular value. Reshape that vector to 3×3 and pass the result to `enforce_rank2`.\n",
        "\n",
        "---\n",
        "\n",
        "**Your task:** Implement **`lstsq_eight_point_alg(points1, points2)`** returning a 3×3 fundamental matrix F.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {},
      "outputs": [],
      "source": [
        "def enforce_rank2(F):\n",
        "    \"\"\"Given 3×3 F, return rank-2 F by zeroing the smallest singular value. (Provided.)\"\"\"\n",
        "    U, s, Vh = np.linalg.svd(F)\n",
        "    s[-1] = 0\n",
        "    return U.dot(np.diag(s)).dot(Vh)\n",
        "\n",
        "\n",
        "def normalize_points(points):\n",
        "    \"\"\"\n",
        "    Normalize so centroid is at origin and mean distance to origin is sqrt(2).\n",
        "    points: (N, 3) homogeneous. Returns (normalized_points (N,3), T (3,3)).\n",
        "    \"\"\"\n",
        "    mean = np.mean(points, axis=0)\n",
        "    pts_centered = points - mean\n",
        "    scale = np.sqrt(2) / np.mean(np.sqrt(np.sum(pts_centered[:, :2] ** 2, axis=1)))\n",
        "    T = np.array(\n",
        "        [[scale, 0, -scale * mean[0]], [0, scale, -scale * mean[1]], [0, 0, 1]]\n",
        "    )\n",
        "    normalized = (T.dot(points.T)).T\n",
        "    return normalized, T\n",
        "\n",
        "\n",
        "def lstsq_eight_point_alg(points1, points2):\n",
        "    # TODO: STUDENT CODE HERE (3a)\n",
        "    # Build the N×9 matrix from point correspondences, solve for F (e.g. via SVD), enforce rank 2, and return F.\n",
        "    raise NotImplementedError\n",
        "    # END STUDENT CODE"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 3.b — Normalized eight-point algorithm\n",
        "\n",
        "**Goal:** Improve numerical stability by normalizing point coordinates before solving for F, then converting the result back to the original coordinate system. Normalization: translate so the centroid is at the origin and scale so the mean distance to the origin is $\\sqrt{2}$.\n",
        "\n",
        "---\n",
        "\n",
        "#### Pipeline\n",
        "\n",
        "- Normalize **points1** and **points2** using the provided **`normalize_points(points)`**, which returns `(normalized_points, T)` where T is the 3×3 transformation matrix.\n",
        "- Run your **`lstsq_eight_point_alg`** on the normalized point sets to get **F_norm** (fundamental matrix in normalized coordinates).\n",
        "- **Denormalize:** The fundamental matrix in the original coordinates is related to F_norm by the normalization matrices T₁ and T₂. The formula is $F = T_2^\\top F_{\\text{norm}} T_1$ (so that the constraint $\\mathbf{p}'^\\top F \\mathbf{p} = 0$ holds when points are transformed by T₁ and T₂).\n",
        "\n",
        "**Flow:**\n",
        "\n",
        "- Normalize points1 to get (p1_norm, T1); normalize points2 to get (p2_norm, T2).\n",
        "- Compute F_norm = lstsq_eight_point_alg(p1_norm, p2_norm).\n",
        "- Combine F_norm with T1 and T2 to obtain F in original coordinates.\n",
        "\n",
        "**Hints:** Use the provided `normalize_points` for each set. Call your 3.a implementation on the normalized points. Denormalize using the two matrices returned by `normalize_points` and the formula above.\n",
        "\n",
        "---\n",
        "\n",
        "**Your task:** Implement **`normalized_eight_point_alg(points1, points2)`** returning a 3×3 fundamental matrix F in original coordinates.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "def normalized_eight_point_alg(points1, points2):\n",
        "    # TODO: STUDENT CODE HERE (3b)\n",
        "    raise NotImplementedError\n",
        "    # END STUDENT CODE"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 3.c — Epipolar lines\n",
        "\n",
        "**Goal:** For each point **p** in one image, the corresponding **epipolar line** in the other image is $\\mathbf{l} = F \\mathbf{p}$. The drawing helper **`draw_lines`** expects each line in slope–intercept form $y = mx + b$, i.e. a pair **(m, b)**.\n",
        "\n",
        "---\n",
        "\n",
        "#### From F and p to line l\n",
        "\n",
        "- Compute $\\mathbf{l} = F \\mathbf{p}$ for all points at once: **l = F @ points.T** gives a **(3, N)** array (one column per point). Each column is $[A, B, C]^\\top$.\n",
        "- The line in the image is the set of $(x, y)$ satisfying **Ax + By + C = 0**.\n",
        "- Convert to **y = mx + b** when **B ≠ 0**: $m = -A/B$, $b = -C/B$.\n",
        "- When **B ≈ 0** the line is (nearly) vertical. **`draw_lines`** still expects **(m, b)** for every line—use a consistent convention (e.g. a sentinel for m or a special (m, b)) that **`draw_lines`** can interpret (check its docstring).\n",
        "\n",
        "#### Pseudocode\n",
        "\n",
        "```\n",
        "l = F @ points.T   # (3, N): each column is (A, B, C) for one point\n",
        "out = []\n",
        "for i in range(N):\n",
        "    A, B, C = l[0,i], l[1,i], l[2,i]\n",
        "    if abs(B) > EPS:\n",
        "        m = -A / B\n",
        "        b = -C / B\n",
        "        out.append((m, b))\n",
        "    else:\n",
        "        # vertical or near-vertical: choose (m, b) so draw_lines draws correctly\n",
        "        out.append(...)\n",
        "return out\n",
        "```\n",
        "\n",
        "---\n",
        "\n",
        "**Your task:** Implement **`compute_epipolar_lines(points, F)`** returning a list of **(m, b)** pairs, one per point.\n",
        "\n",
        "![Epipolar lines test](../data/figures/epipolar_test.png)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {},
      "outputs": [],
      "source": [
        "def compute_epipolar_lines(points, F):\n",
        "    # TODO: STUDENT CODE HERE (3c)\n",
        "    raise NotImplementedError\n",
        "\n",
        "\n",
        "def compute_distance_to_epipolar_lines(points1, points2, F):\n",
        "    l = F.T.dot(points2.T)\n",
        "    return np.mean(\n",
        "        np.abs(np.sum(l * points1.T, axis=0)) / np.sqrt(l[0, :] ** 2 + l[1, :] ** 2)\n",
        "    )"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Part 3 not fully implemented yet — fix the step below and re-run this cell.\n",
            "  Error: NotImplementedError: \n",
            "  → Implement 3.a: lstsq_eight_point_alg and normalized_eight_point_alg\n",
            "  → Implement 3.b: compute_distance_to_epipolar_lines\n",
            "  → Implement 3.c: compute_epipolar_lines\n"
          ]
        }
      ],
      "source": [
        "# Run Part 3: fundamental matrix and epipolar lines\n",
        "try:\n",
        "    p3_dir = DATA_DIR / \"p3_fundamental_matrix\"\n",
        "    pts1 = load_points(p3_dir / \"pts_1.txt\")\n",
        "    pts2 = load_points(p3_dir / \"pts_2.txt\")\n",
        "    im1 = load_image(p3_dir / \"const_im1.png\")\n",
        "    im2 = load_image(p3_dir / \"const_im2.png\")\n",
        "    F_lls = lstsq_eight_point_alg(pts1, pts2)\n",
        "    F_norm = normalized_eight_point_alg(pts1, pts2)\n",
        "    d1 = compute_distance_to_epipolar_lines(pts1, pts2, F_norm)\n",
        "    d2 = compute_distance_to_epipolar_lines(pts2, pts1, F_norm.T)\n",
        "    print(\"Mean distance to epipolar lines (im1):\", d1, \"(im2):\", d2)\n",
        "    lines1 = compute_epipolar_lines(pts2, F_norm.T)\n",
        "    lines2 = compute_epipolar_lines(pts1, F_norm)\n",
        "    show_epipolar_imgs(im1, im2, lines1, lines2, pts1, pts2)\n",
        "except Exception as e:\n",
        "    err = type(e).__name__\n",
        "    msg = str(e).split(\"\\n\")[0][:80]\n",
        "    print(\"Part 3 not fully implemented yet — fix the step below and re-run this cell.\")\n",
        "    print(f\"  Error: {err}: {msg}\")\n",
        "    if err == \"NotImplementedError\":\n",
        "        print(\"  → Implement 3.a: lstsq_eight_point_alg and normalized_eight_point_alg\")\n",
        "        print(\"  → Implement 3.b: compute_distance_to_epipolar_lines\")\n",
        "        print(\"  → Implement 3.c: compute_epipolar_lines\")\n",
        "    else:\n",
        "        if \"lstsq\" in str(e) or \"eight_point\" in str(e) or \"normalized\" in str(e):\n",
        "            print(\"  → Implement lstsq_eight_point_alg and/or normalized_eight_point_alg (3.a)\")\n",
        "        if \"distance\" in str(e) or \"epipolar\" in str(e):\n",
        "            print(\"  → Implement compute_distance_to_epipolar_lines (3.b) and compute_epipolar_lines (3.c)\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Part 4 — Image Rectification (15 pts)\n",
        "\n",
        "**Goal:** Warp the two images so that **epipolar lines become horizontal scanlines**. Then corresponding points lie on the same row and stereo matching reduces to a 1D search along rows.\n",
        "\n",
        "**Flow:**\n",
        "\n",
        "- 4.a — compute the **epipole** in each image (where all epipolar lines meet)\n",
        "- 4.b — compute two **homographies** H₁, H₂ so that in the rectified images epipolar lines are horizontal\n",
        "- 4.c — **warp** each image by the corresponding homography to get the rectified pair\n",
        "- 4.d — **feature matching** (SIFT + FLANN) to find correspondences automatically for use in Part 5\n",
        "\n",
        "![Rectified stereo pair](../data/figures/rectified.png)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 4.a — Epipole\n",
        "\n",
        "**Goal:** The **epipole** in one image is the point where all epipolar lines from the other image meet (it is the projection of the other camera center). We need to compute it from F and the point correspondences.\n",
        "\n",
        "**Geometry:** In image 2, every epipolar line coming from a point in image 1 passes through the same point **e₂** (the epipole in image 2):\n",
        "\n",
        "```\n",
        "    \\    |    /\n",
        "     \\   |   /\n",
        "      \\  |  /\n",
        "       \\ | /\n",
        "        \\|/\n",
        "  -------e-------   e = epipole\n",
        "        /|\\\n",
        "       / | \\\n",
        "      /  |  \\\n",
        "```\n",
        "\n",
        "**Setting up the problem:**\n",
        "\n",
        "- For points **p'** in image 2, the epipolar lines in image 1 are $\\mathbf{l} = F^\\top \\mathbf{p}'$ (one line per point).\n",
        "- The epipole **e** in image 1 lies on every such line, so $\\mathbf{l}^\\top \\mathbf{e} = 0$ for every line.\n",
        "- Stack the lines as rows into a matrix **L**; then **L e = 0**, so **e** is in the null space of L.\n",
        "- Solve for **e** (e.g. via SVD of L); the solution is unique up to scale.\n",
        "- **Normalize** so the third coordinate is 1 (homogeneous coordinates).\n",
        "\n",
        "**Hints:**\n",
        "\n",
        "- Build **L** with one row per point in the *other* image: for each point **p'** in `points2`, compute $\\mathbf{l} = F^\\top \\mathbf{p}'$ and append **l** as a row. Use matrix multiplication (e.g. **`F.T @ points2.T`** if `points2` is N×3) so that each column is a line; then take **L = that result.T** so each *row* is a line (L is N×3).\n",
        "- The epipole **e** is the right singular vector corresponding to the **smallest** singular value of **L**. Use **`np.linalg.svd(L)`**; the rows of **Vh** are the right singular vectors, so the last row of **Vh** (index -1) is the null-space direction. Extract it and reshape to a 3-vector.\n",
        "- Normalize **e** so the third coordinate is 1: divide by **e[2]** (e.g. **`e = e / e[2]`**). Return as a 1D array of shape (3,) with last entry 1.\n",
        "\n",
        "---\n",
        "\n",
        "**Your task:** Implement **`compute_epipole(points1, points2, F)`** returning the epipole in image 1 as a 3-vector (e.g. shape (3,) or (3,1)) with last coordinate 1.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "def build_H2_rectification(e2, height, width):\n",
        "    \"\"\"\n",
        "    Build H2 so that the epipole in image 2 goes to infinity on the x-axis.\n",
        "    Translate to center, rotate epipole to x-axis, then projective map to infinity. (Provided.)\n",
        "    \"\"\"\n",
        "    h, w = height, width\n",
        "    T = np.array([[1, 0, -w / 2], [0, 1, -h / 2], [0, 0, 1]])\n",
        "    e2p = (T.dot(e2) / e2[2]).copy()\n",
        "    e2p[2] = 1\n",
        "    e2x, e2y = e2p[0], e2p[1]\n",
        "    a = 1 if e2x >= 0 else -1\n",
        "    denom = np.sqrt(e2x**2 + e2y**2)\n",
        "    R1 = a * e2x / denom\n",
        "    R2 = a * e2y / denom\n",
        "    R = np.array([[R1, R2, 0], [-R2, R1, 0], [0, 0, 1]])\n",
        "    e2p = R.dot(e2p)\n",
        "    f = e2p[0]\n",
        "    G = np.array([[1, 0, 0], [0, 1, 0], [-1 / f, 0, 1]])\n",
        "    H2 = np.linalg.inv(T).dot(G).dot(R).dot(T)\n",
        "    return H2\n",
        "\n",
        "\n",
        "def warp_image_with_inverse_map(im, mapx, mapy):\n",
        "    \"\"\"Remap image using mapx, mapy (source coords for each output pixel). (Provided.)\"\"\"\n",
        "    channels = [\n",
        "        scipy.ndimage.map_coordinates(\n",
        "            im[..., c],\n",
        "            np.vstack([mapy.ravel(), mapx.ravel()]),\n",
        "            order=1,\n",
        "            mode=\"constant\",\n",
        "            cval=0.0,\n",
        "        ).reshape(mapx.shape)\n",
        "        for c in range(im.shape[2])\n",
        "    ]\n",
        "    return np.dstack(channels).astype(np.uint8)\n",
        "\n",
        "\n",
        "def compute_epipole(points1, points2, F):\n",
        "    # TODO: STUDENT CODE HERE (4a)\n",
        "    raise NotImplementedError\n",
        "    # END STUDENT CODE"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 4.b — Matching homographies\n",
        "\n",
        "**Goal:** Compute two homographies **H₁** and **H₂** so that when we warp the two images by them, **epipolar lines become horizontal** (corresponding points lie on the same row).\n",
        "\n",
        "---\n",
        "\n",
        "#### Strategy\n",
        "\n",
        "- **H₂ (image 2):** Map the image so that the **epipole e₂** goes to a point at **infinity** in the horizontal direction (e.g. $(1, 0, 0)^\\top$ in homogeneous coordinates). Then all epipolar lines in the rectified image 2 become horizontal. The provided **`build_H2_rectification(e2, height, width)`** returns an H₂ that does this (translate to center, rotate so epipole aligns with x-axis, then a projective step that sends it to infinity).\n",
        "\n",
        "- **H₁ (image 1):** Choose H₁ so that the **fundamental constraint** still holds in the rectified space: corresponding points in the two rectified images must satisfy the new fundamental matrix induced by H₁ and H₂. Use the point correspondences **(points1, points2)** and **F** to set up linear constraints on the entries of H₁; then solve (e.g. least-squares) for H₁. The rectified correspondence condition (same row, etc.) gives the constraints.\n",
        "\n",
        "**Hints:** Get H₂ from `build_H2_rectification(e2, im2.shape[0], im2.shape[1])`. For H₁, express the constraint that rectified points are in correspondence (using F, e2, and the known form of H₂); you get a linear system in the entries of H₁. Solve with `np.linalg.lstsq` or similar. Return (H1, H2) as 3×3 matrices.\n",
        "\n",
        "---\n",
        "\n",
        "**Your task:** Implement **`compute_matching_homographies(e2, F, im2, points1, points2)`** returning (H1, H2).\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "def compute_matching_homographies(e2, F, im2, points1, points2):\n",
        "    # TODO: STUDENT CODE HERE (4b)\n",
        "    raise NotImplementedError\n",
        "    # END STUDENT CODE"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 4.c — Rectified image\n",
        "\n",
        "**Goal:** Warp a single image by a homography **H** to produce the **rectified** image. We fill the *output* image by **inverse mapping**: for each output pixel, find which *input* pixel it came from using $H^{-1}$, then sample the input there (the provided helper does the sampling with interpolation).\n",
        "\n",
        "---\n",
        "\n",
        "#### Inverse mapping\n",
        "\n",
        "- **Output pixel (u, v)** comes from the point in the input image at $\\mathbf{p}_{src} = H^{-1} (u, v, 1)^\\top$. In homogeneous form $(x, y, w)$, the source coordinates are **(x/w, y/w)**.\n",
        "- The provided **`warp_image_with_inverse_map(im, mapx, mapy)`** does the sampling. It expects two arrays **mapx**, **mapy** (same shape as the desired output) such that **output[v, u] = sample of im at (mapx[v,u], mapy[v,u])**. So for each output index (v, u), set **mapx[v,u] = x/w** and **mapy[v,u] = y/w** from $H^{-1}(u, v, 1)^\\top$.\n",
        "\n",
        "#### Output size and offset\n",
        "\n",
        "- The rectified image can have a different size than the input. A simple approach: transform the **four corners** of the input image by **H** to get their positions in the *output* (rectified) space; take the **bounding box** of those four points to get the output width, height, and **offset (offset_x, offset_y)** (e.g. the min x and min y of the box).\n",
        "- Build a grid of output coordinates (u, v) covering that box. For each (u, v), apply $H^{-1}$ to get source (x/w, y/w) and store in **mapx**, **mapy**. Call **`warp_image_with_inverse_map(im, mapx, mapy)`** to get the rectified image.\n",
        "\n",
        "#### Return value\n",
        "\n",
        "Return **(rectified_image, (offset_x, offset_y))** so the caller can align the two rectified images. **offset_x**, **offset_y** are the origin of your output grid in the rectified coordinate system (e.g. the left and top of the bounding box).\n",
        "\n",
        "---\n",
        "\n",
        "**Your task:** Implement **`compute_rectified_image(im, H)`** returning **(rectified_image, (offset_x, offset_y))**.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "def compute_rectified_image(im, H):\n",
        "    # TODO: STUDENT CODE HERE (4c)\n",
        "    raise NotImplementedError\n",
        "    # END STUDENT CODE"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 4.d — Feature detection (SIFT + FLANN)\n",
        "\n",
        "**Goal:** Automatically find **point correspondences** between two images (keypoints + descriptors, then matching). These matches will be used in Part 5 to estimate F and recover pose. You will use **SIFT** for detection/description and **FLANN** for matching, with a **ratio test** to filter weak matches.\n",
        "\n",
        "---\n",
        "\n",
        "#### Pipeline\n",
        "\n",
        "1. **Detect and describe:** Run a **SIFT** detector/descriptor on both images to get keypoints and their descriptors (e.g. 128-dimensional vectors per keypoint). OpenCV provides a SIFT implementation.\n",
        "2. **Match:** Use a **FLANN**-based matcher (fast approximate nearest neighbors) to find candidate matches between descriptors. For each keypoint in image 1, get the two nearest neighbors in image 2.\n",
        "3. **Ratio test:** Keep a match only if the distance to the nearest neighbor is sufficiently smaller than the distance to the second nearest (e.g. ratio threshold **0.75**). This rejects many ambiguous matches.\n",
        "4. Return **(kp1, kp2, good_matches)** in the format expected by the run cell and by Part 5 (e.g. keypoints as lists and matches as a list of `cv2.DMatch` or similar).\n",
        "\n",
        "**Hints:** Create a SIFT object to detect and compute descriptors on both images. Build a FLANN index from the descriptors of one image and search with the other; apply the ratio test (0.75) to obtain a list of good matches. Return keypoints and matches in the type/shape that the rest of the pipeline expects (check the run cell or Part 5 for the expected format).\n",
        "\n",
        "---\n",
        "\n",
        "**Your task:** Implement **`find_matches(img1, img2)`** returning (kp1, kp2, good_matches).\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "def find_matches(img1, img2):\n",
        "    # TODO: STUDENT CODE HERE (4d)\n",
        "    raise NotImplementedError\n",
        "    # END STUDENT CODE"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Part 4 not fully implemented yet — fix the step below and re-run this cell.\n",
            "  Error: NotImplementedError: \n",
            "  → Implement 4.a: compute_epipole\n",
            "  → Implement 4.b: compute_matching_homographies\n",
            "  → Implement 4.c: compute_rectified_image\n",
            "  → Implement 4.d: find_matches\n"
          ]
        }
      ],
      "source": [
        "# Run Part 4: rectification and optional SIFT matches\n",
        "try:\n",
        "    p3_dir = DATA_DIR / \"p3_fundamental_matrix\"\n",
        "    pts1 = load_points(p3_dir / \"pts_1.txt\")\n",
        "    pts2 = load_points(p3_dir / \"pts_2.txt\")\n",
        "    im1 = load_image(p3_dir / \"const_im1.png\")\n",
        "    im2 = load_image(p3_dir / \"const_im2.png\")\n",
        "    F = normalized_eight_point_alg(pts1, pts2)\n",
        "    e1 = compute_epipole(pts1, pts2, F)\n",
        "    e2 = compute_epipole(pts2, pts1, F.T)\n",
        "    H1, H2 = compute_matching_homographies(e2, F, im2, pts1, pts2)\n",
        "    rect1, off1 = compute_rectified_image(im1, H1)\n",
        "    rect2, off2 = compute_rectified_image(im2, H2)\n",
        "    plt.figure(figsize=(12, 5))\n",
        "    plt.subplot(1, 2, 1)\n",
        "    plt.imshow(rect1)\n",
        "    plt.title(\"Rectified 1\")\n",
        "    plt.axis(\"off\")\n",
        "    plt.subplot(1, 2, 2)\n",
        "    plt.imshow(rect2)\n",
        "    plt.title(\"Rectified 2\")\n",
        "    plt.axis(\"off\")\n",
        "    plt.show()\n",
        "    kp1, kp2, good_matches = find_matches(im1, im2)\n",
        "    show_matches(im1, im2, kp1, kp2, good_matches)\n",
        "except Exception as e:\n",
        "    err = type(e).__name__\n",
        "    msg = str(e).split(\"\\n\")[0][:80]\n",
        "    print(\"Part 4 not fully implemented yet — fix the step below and re-run this cell.\")\n",
        "    print(f\"  Error: {err}: {msg}\")\n",
        "    if err == \"NotImplementedError\":\n",
        "        print(\"  → Implement 4.a: compute_epipole\")\n",
        "        print(\"  → Implement 4.b: compute_matching_homographies\")\n",
        "        print(\"  → Implement 4.c: compute_rectified_image\")\n",
        "        print(\"  → Implement 4.d: find_matches\")\n",
        "    else:\n",
        "        if \"epipole\" in str(e):\n",
        "            print(\"  → Implement compute_epipole (4.a)\")\n",
        "        if \"homograph\" in str(e).lower() or \"matching\" in str(e):\n",
        "            print(\"  → Implement compute_matching_homographies (4.b)\")\n",
        "        if \"rectif\" in str(e).lower():\n",
        "            print(\"  → Implement compute_rectified_image (4.c)\")\n",
        "        if \"find_matches\" in str(e) or \"match\" in str(e).lower():\n",
        "            print(\"  → Implement find_matches (4.d)\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Part 5 — 3D Reconstruction (30 pts)\n",
        "\n",
        "**Goal:** From two **calibrated** views and point correspondences, compute the **relative camera pose (R, T)** and **triangulate** to get a 3D point cloud. The pipeline: estimate **F** from matches (with RANSAC), convert to the **essential matrix E** using K, decompose E into **candidate (R, T)** pairs, pick the correct one using **cheirality** (points must be in front of both cameras), then form **projection matrices** and triangulate.\n",
        "\n",
        "**Flow:**\n",
        "\n",
        "- 5.a — **F** from matches (RANSAC)\n",
        "- 5.b — **E = Kᵀ F K**\n",
        "- 5.c — **Four (R, T) candidates** from E via SVD\n",
        "- 5.d — **Best (R, T)** by cheirality\n",
        "- 5.e — **P₁, P₂** and triangulation\n",
        "\n",
        "![SIFT matching](../data/figures/sift.png)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 5.a — Fundamental matrix from matches\n",
        "\n",
        "**Goal:** Estimate the **fundamental matrix F** from matched keypoints in two images. Matches from SIFT/FLANN contain **outliers**; use **RANSAC** (or an equivalent robust method) so that outliers do not dominate the estimate. OpenCV provides a function that estimates F from point pairs with a RANSAC option.\n",
        "\n",
        "---\n",
        "\n",
        "#### Pipeline\n",
        "\n",
        "1. Convert keypoints and matches into two **N×2** arrays of point coordinates **(pts1, pts2)** (one row per match). The provided **`points_from_matches(kp1, kp2, good_matches)`** does this and returns (pts1, pts2) as float32.\n",
        "2. Call a **robust** F-estimation routine (e.g. OpenCV’s fundamental matrix solver with **RANSAC**). It will return **F** and a **mask** indicating which points were inliers.\n",
        "3. Return **F**, **mask**, and **pts1**, **pts2** in the format expected by the rest of Part 5 (so inliers can be extracted and used for E and pose).\n",
        "\n",
        "**Hints:** Use the provided helper to get (pts1, pts2). Look up the OpenCV function that computes the fundamental matrix from point correspondences with a RANSAC method; it returns F and an inlier mask. Return F, mask, pts1, pts2 so that downstream code can use the mask to select inlier pairs.\n",
        "\n",
        "---\n",
        "\n",
        "**Your task:** Implement **`recover_fundamental_matrix(kp1, kp2, good_matches)`** returning (F, mask, pts1, pts2).\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "from typing import List, Tuple\n",
        "\n",
        "\n",
        "def points_from_matches(kp1, kp2, good_matches):\n",
        "    \"\"\"Extract (N, 2) point arrays from keypoints and matches. (Provided.)\"\"\"\n",
        "    pts1 = np.float32([kp1[m.queryIdx].pt for m in good_matches])\n",
        "    pts2 = np.float32([kp2[m.trainIdx].pt for m in good_matches])\n",
        "    return pts1, pts2\n",
        "\n",
        "\n",
        "def recover_fundamental_matrix(kp1, kp2, good_matches):\n",
        "    # TODO: STUDENT CODE HERE (5a)\n",
        "    raise NotImplementedError\n",
        "    # END STUDENT CODE"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 5.b — Essential matrix\n",
        "\n",
        "**Goal:** The **fundamental matrix F** relates **pixel** coordinates in the two images. The **essential matrix E** relates the same geometry in **normalized camera coordinates** (after undoing the intrinsics). E has the form $E = [t]_\\times R$ and is used to recover the relative pose (R, T) between the two cameras.\n",
        "\n",
        "---\n",
        "\n",
        "**Relation:** If **K** is the intrinsic matrix (same for both views here), then\n",
        "\n",
        "$$E = K^\\top F K.$$\n",
        "\n",
        "F is in pixel space; E is in normalized space. Implement this conversion.\n",
        "\n",
        "---\n",
        "\n",
        "**Your task:** Implement **`compute_essential_matrix(camera_matrix, fundamental_matrix)`** returning the 3×3 essential matrix E.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "def compute_essential_matrix(camera_matrix, fundamental_matrix):\n",
        "    # TODO: STUDENT CODE HERE (5b)\n",
        "    raise NotImplementedError\n",
        "    # END STUDENT CODE"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 5.c — Camera pose from E\n",
        "\n",
        "**Goal:** From the **essential matrix E**, recover the **relative rotation R** and **translation t** between the two cameras. Part 5.d will pick the correct one among four candidates using cheirality.\n",
        "\n",
        "---\n",
        "\n",
        "#### Setting up the problem\n",
        "\n",
        "- The standard approach (Hartley–Zisserman) uses the **SVD** of E: $E = U \\Sigma V^\\top$. Use **`np.linalg.svd(E)`** to get **U**, singular values, and **Vh** (the $V^\\top$ matrix; in NumPy the third return value is already “V transposed”).\n",
        "- **Translation** (up to scale) is the **last column of U** (index 2). There are **two** valid directions: that column and its negative. Store them as two 3-vectors (e.g. **`U[:, 2]`** and **`-U[:, 2]`**, or keep shape (3, 1) if needed).\n",
        "- **Rotation** has **two** candidates, derived from U, V, and a fixed **90° rotation matrix W** about the z-axis (e.g. $W$ with zeros and ±1 such that the rotation axis is z). The formulas combine **U**, **W** (or $W^\\top$), and **V** (recover from **Vh** as **Vh.T** if needed). Build two 3×3 rotation matrices.\n",
        "- Ensure each rotation has **determinant +1** (proper rotation): use **`np.linalg.det(R)`** and if negative, multiply the matrix by −1.\n",
        "- You get **four** (R, T) pairs: two R’s × two t’s.\n",
        "\n",
        "#### Four candidates\n",
        "\n",
        "|           | t₁       | t₂       |\n",
        "|-----------|----------|----------|\n",
        "| **R₁**    | (R₁, t₁) | (R₁, t₂) |\n",
        "| **R₂**    | (R₂, t₁) | (R₂, t₂) |\n",
        "\n",
        "**Output:** Return **(candidate_Rs, candidate_ts)** where each is a **list or array of length 2**: two 3×3 rotation matrices and two 3-vectors (translation directions). For example, **`np.array([R1, R2])`** and **`np.array([T1, T2])`** with **T1**, **T2** of shape (3,) or (3, 1).\n",
        "\n",
        "**Hints:**\n",
        "\n",
        "- **`np.linalg.svd(E)`** returns **U**, a 1D array of singular values, and **Vh** (3×3). Translation candidates: **`U[:, 2]`** and **`-U[:, 2]`**.\n",
        "- Define a 3×3 matrix **W** that represents a 90° rotation around the z-axis (only 0, 1, −1 in entries). The two rotation candidates are **U @ W @ Vh** and **U @ W.T @ Vh** (or equivalent using **Vh.T**). Then enforce **det(R) = 1** using **`np.linalg.det`** and multiply the matrix by **np.linalg.det(R)** so that the result has determinant +1.\n",
        "- Return **(candidate_Rs, candidate_ts)** so that the rest of the pipeline can iterate over the four (R, T) pairs (e.g. list of two arrays, or **np.array([R1, R2])** and **np.array([T1, T2])**).\n",
        "\n",
        "---\n",
        "\n",
        "**Your task:** Implement **`estimate_initial_RT(E)`** returning (candidate_Rs, candidate_ts).\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "def triangulate_and_get_depths(P1, P2, pts1, pts2):\n",
        "    \"\"\"Triangulate and return (pts3D (3,N), depth_cam1 (N,), depth_cam2 (N,)). (Provided.)\"\"\"\n",
        "    pts4D = cv2.triangulatePoints(P1, P2, pts1, pts2)\n",
        "    pts3D = pts4D[:3, :] / pts4D[3, :]\n",
        "    depth_cam1 = pts3D[2, :]\n",
        "    R2, t2 = P2[:, :3], P2[:, 3]\n",
        "    pts3D_c2 = R2.dot(pts3D) + t2.reshape(3, 1)\n",
        "    depth_cam2 = pts3D_c2[2, :]\n",
        "    return pts3D, depth_cam1, depth_cam2\n",
        "\n",
        "\n",
        "def estimate_initial_RT(E):\n",
        "    # TODO: STUDENT CODE HERE (5c)\n",
        "    raise NotImplementedError\n",
        "    # END STUDENT CODE"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 5.d — Best pose\n",
        "\n",
        "**Goal:** Among the four (R, T) candidates from 5.c, pick the one for which **most** triangulated points have **positive depth in both cameras** (cheirality). Use the provided **`triangulate_and_get_depths(P1, P2, pts1, pts2)`**, which returns (pts3D, depth_cam1, depth_cam2).\n",
        "\n",
        "---\n",
        "\n",
        "#### Strategy\n",
        "\n",
        "- P₁ = [I | 0] (identity 3×4). P₂ = [R | t] for each candidate (R, t).\n",
        "- For each (R, t): triangulate inliers, count how many points have depth_cam1 > 0 and depth_cam2 > 0. Keep the (R, t) with the largest count.\n",
        "\n",
        "#### Pseudocode\n",
        "\n",
        "```\n",
        "P1 = [I | 0]   # 3×4, e.g. np.hstack((np.eye(3), np.zeros((3,1))))\n",
        "best_count = -1\n",
        "best_R, best_t = None, None\n",
        "\n",
        "for each R in candidate_Rs:\n",
        "    for each t in candidate_ts:\n",
        "        P2 = [R | t]   # 3×4\n",
        "        _, depth1, depth2 = triangulate_and_get_depths(P1, P2, inlier_pts1, inlier_pts2)\n",
        "        count = number of i where depth1[i] > 0 and depth2[i] > 0\n",
        "        if count > best_count:\n",
        "            best_count, best_R, best_t = count, R, t\n",
        "\n",
        "return best_R, best_t\n",
        "```\n",
        "\n",
        "---\n",
        "\n",
        "**Your task:** Implement **`find_best_RT(candidate_Rs, candidate_ts, inlier_pts1, inlier_pts2)`** returning the best (R, T).\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "def find_best_RT(candidate_Rs, candidate_ts, inlier_pts1, inlier_pts2):\n",
        "    # TODO: STUDENT CODE HERE (5d)\n",
        "    raise NotImplementedError\n",
        "    # END STUDENT CODE"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 5.e — Projection matrices and triangulation\n",
        "\n",
        "**Goal:** Build the 3×4 **projection matrices** P₁ and P₂ so we can **triangulate** 2D correspondences into 3D points. P maps a 3D point **X** to a 2D point **x** (in homogeneous form): $\\mathbf{x} = P \\mathbf{X}$.\n",
        "\n",
        "---\n",
        "\n",
        "#### Convention\n",
        "\n",
        "- **Camera 1** is at the origin (identity pose). Its projection is $P_1 = K [I \\mid \\mathbf{0}]$:\n",
        "  - Build the 3×4 matrix **[I | 0]** (identity 3×3 plus a zero 3×1 column). Use **`np.hstack((np.eye(3), np.zeros((3, 1))))`**.\n",
        "  - Then **P₁ = K @ [I | 0]** (matrix multiply **camera_matrix** by that 3×4). Result shape: 3×4.\n",
        "- **Camera 2** is at relative pose (R, t). Its projection is $P_2 = K [R \\mid \\mathbf{t}]$:\n",
        "  - Build the 3×4 matrix **[R | t]** from the 3×3 rotation **R** and the 3-vector **t** (as a column). Use **`np.hstack((R, np.asarray(T).reshape(3, 1)))`** so **t** is 3×1.\n",
        "  - Then **P₂ = K @ [R | t]**.\n",
        "\n",
        "Both functions return a **3×4** NumPy array. The run cell passes them to **`cv2.triangulatePoints(P1, P2, pts1, pts2)`**, where **pts1**, **pts2** are in OpenCV format (e.g. 2×N arrays of pixel coordinates).\n",
        "\n",
        "---\n",
        "\n",
        "**Your task:** Implement **`get_identity_projection_matrix(camera_matrix)`** and **`get_local_projection_matrix(camera_matrix, R, T)`**, each returning a 3×4 matrix.\n",
        "\n",
        "![Point cloud](../data/figures/pointcloud.png)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 48,
      "metadata": {},
      "outputs": [],
      "source": [
        "def get_identity_projection_matrix(camera_matrix):\n",
        "    # TODO: STUDENT CODE HERE (5e)\n",
        "    raise NotImplementedError\n",
        "    # END STUDENT CODE\n",
        "\n",
        "\n",
        "def get_local_projection_matrix(camera_matrix, R, T):\n",
        "    # TODO: STUDENT CODE HERE (5e)\n",
        "    raise NotImplementedError\n",
        "    # END STUDENT CODE\n",
        "\n",
        "\n",
        "def parse_matches(kp1, kp2, good_matches):\n",
        "    return np.float32([kp1[m.queryIdx].pt for m in good_matches]), np.float32(\n",
        "        [kp2[m.trainIdx].pt for m in good_matches]\n",
        "    )\n",
        "\n",
        "\n",
        "def get_inliers(mask, pts1, pts2):\n",
        "    i1 = pts1[mask.ravel() == 1]\n",
        "    i2 = pts2[mask.ravel() == 1]\n",
        "    return i1.reshape(-1, 2).T, i2.reshape(-1, 2).T"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 49,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Part 5 not fully implemented yet — fix the step below and re-run this cell.\n",
            "  Error: ValueError: Verify correct dimensions of chessboard\n"
          ]
        }
      ],
      "source": [
        "# Run Part 5: 3D reconstruction from two views\n",
        "try:\n",
        "    p5_dir = DATA_DIR / \"p5_3D_reconstruction\"\n",
        "    chess_path = p5_dir / \"chessboard.png\"\n",
        "    im1 = load_image(p5_dir / \"raw_images\" / \"object_0.png\")\n",
        "    im2 = load_image(p5_dir / \"raw_images\" / \"object_1.png\")\n",
        "    # Calibrate from dedicated chessboard image (p5 chessboard has (16, 10) inner corners)\n",
        "    chessboard_size_p5 = (16, 10)\n",
        "    chess_img = load_image(chess_path)\n",
        "    gray_chess = load_grayscale_image(chess_img)\n",
        "    corners_chess = find_chessboard_corners(gray_chess, chessboard_size_p5)\n",
        "    corners_chess = refine_corners(gray_chess, corners_chess)\n",
        "    object_points = get_3D_object_points(chessboard_size_p5)\n",
        "    camera_matrix, dist_coeffs = calibrate_camera(\n",
        "        object_points, corners_chess, gray_chess.shape[::-1]\n",
        "    )\n",
        "    kp1, kp2, good_matches = find_matches(im1, im2)\n",
        "    F, mask, pts1_pt, pts2_pt = recover_fundamental_matrix(kp1, kp2, good_matches)\n",
        "    inlier_pts1, inlier_pts2 = get_inliers(mask, pts1_pt, pts2_pt)\n",
        "    E = compute_essential_matrix(camera_matrix, F)\n",
        "    candidate_Rs, candidate_ts = estimate_initial_RT(E)\n",
        "    R, T = find_best_RT(candidate_Rs, candidate_ts, inlier_pts1, inlier_pts2)\n",
        "    P1 = get_identity_projection_matrix(camera_matrix)\n",
        "    P2 = get_local_projection_matrix(camera_matrix, R, T)\n",
        "    pts4D = cv2.triangulatePoints(P1, P2, inlier_pts1, inlier_pts2)\n",
        "    pts3D = (pts4D[:3] / pts4D[3]).T\n",
        "    show_points_matplotlib(pts3D)\n",
        "except Exception as e:\n",
        "    err = type(e).__name__\n",
        "    msg = str(e).split(\"\\n\")[0][:80]\n",
        "    print(\"Part 5 not fully implemented yet — fix the step below and re-run this cell.\")\n",
        "    print(f\"  Error: {err}: {msg}\")\n",
        "    if err == \"NotImplementedError\":\n",
        "        print(\"  → Implement Part 5: compute_essential_matrix, estimate_initial_RT, find_best_RT,\")\n",
        "        print(\"    get_identity_projection_matrix, get_local_projection_matrix; plus P2/P3/P4 for the pipeline.\")\n",
        "    else:\n",
        "        s = str(e)\n",
        "        if \"essential\" in s or \"compute_E\" in s: print(\"  → Implement compute_essential_matrix (5.a)\")\n",
        "        if \"estimate_initial_RT\" in s or \"estimate_RT\" in s: print(\"  → Implement estimate_initial_RT (5.b)\")\n",
        "        if \"find_best_RT\" in s: print(\"  → Implement find_best_RT (5.c)\")\n",
        "        if \"projection_matrix\" in s or \"identity\" in s or \"local\" in s: print(\"  → Implement get_identity_projection_matrix and get_local_projection_matrix (5.d)\")\n",
        "        if \"recover_fundamental\" in s or \"get_inliers\" in s: print(\"  → Implement recover_fundamental_matrix and get_inliers (uses P3/P4)\")\n"
      ]
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "cv2026",
      "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.11.14"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 4
}