G22-2025-Final Project

import cv2

import numpy as np

import time

from typing import Tuple, Optional

class CalibrationManager:

    """!

    @brief Handles auto-calibration of projector overlap using a camera.

    This class provides methods to capture images from a camera, detect features,

    calculate the overlap between two projected images, and simulate the calibration process.

    """

    def __init__(self, camera_index: int = 0):

        """!

        @brief Initializes the CalibrationManager.

        Sets up the SIFT detector and FLANN matcher for feature matching.

        @param camera_index The index of the camera to use. Default is 0.

        """

        self.camera_index = camera_index

        self.sift = cv2.SIFT_create()

        # FLANN parameters for matcher

        FLANN_INDEX_KDTREE = 1

        index_params = dict(algorithm=FLANN_INDEX_KDTREE, trees=5)

        search_params = dict(checks=50)

        self.flann = cv2.FlannBasedMatcher(index_params, search_params)

    def capture_image(self) -> Optional[np.ndarray]:

        """!

        @brief Captures a single frame from the camera.

        Attempts to open the camera, warm it up, and capture a frame.

        @return The captured frame as a numpy array, or None if capture fails.

        """

        cap = cv2.VideoCapture(self.camera_index)

        if not cap.isOpened():

            print(f"Error: Could not open camera {self.camera_index}")

            return None

        # Warmup

        for _ in range(10):

            cap.read()

        ret, frame = cap.read()

        cap.release()

        if not ret:

            print("Error: Could not read frame")

            return None

        return frame

    def calculate_overlap(self, img_left: np.ndarray, img_right: np.ndarray) -> Optional[int]:

        """!

        @brief Calculates the horizontal overlap between two images using SIFT features.

        Detects SIFT features in both images, matches them using FLANN, filters matches

        using Lowe's ratio test, and calculates the average horizontal shift.

        @param img_left The captured image when ONLY the left projector is on.

        @param img_right The captured image when ONLY the right projector is on.

        @return The calculated average horizontal shift (overlap) in pixels, or None if calculation fails.

        """

        # Convert to grayscale

        gray_left = cv2.cvtColor(img_left, cv2.COLOR_BGR2GRAY)

        gray_right = cv2.cvtColor(img_right, cv2.COLOR_BGR2GRAY)

        # Detect keypoints and descriptors

        kp1, des1 = self.sift.detectAndCompute(gray_left, None)

        kp2, des2 = self.sift.detectAndCompute(gray_right, None)

        if des1 is None or des2 is None or len(kp1) < 2 or len(kp2) < 2:

            print("Not enough features detected.")

            return None

        # Match descriptors

        matches = self.flann.knnMatch(des1, des2, k=2)

        # Lowe's ratio test

        good_matches = []

        for m, n in matches:

            if m.distance < 0.7 * n.distance:

                good_matches.append(m)

        if len(good_matches) < 4:

            print("Not enough good matches found.")

            return None

        # Extract location of good matches

        pts_left = np.float32([kp1[m.queryIdx].pt for m in good_matches]).reshape(-1, 1, 2)

        pts_right = np.float32([kp2[m.trainIdx].pt for m in good_matches]).reshape(-1, 1, 2)

        # Find Homography

        H, mask = cv2.findHomography(pts_left, pts_right, cv2.RANSAC, 5.0)

        if H is None:

            print("Could not find homography.")

            return None

        # Let's calculate the average horizontal shift of the matches.

        matches_mask = mask.ravel().tolist()

        dx_list = []

        for i, match in enumerate(good_matches):

            if matches_mask[i]:

                # pt_left is the position of the feature in the Left-Projector-Only capture

                # pt_right is the position of the feature in the Right-Projector-Only capture

                p1 = kp1[match.queryIdx].pt

                p2 = kp2[match.trainIdx].pt

                # We want p1 and p2 to be the same if aligned.

                dx = p2[0] - p1[0]

                dx_list.append(dx)

        if not dx_list:

            return 0

        avg_dx = np.median(dx_list)

        return avg_dx

    def simulate_calibration(self, image_width: int, current_overlap: int) -> int:

        """!

        @brief Simulates the calibration process.

        Calculates a simulated adjustment to the overlap based on a target overlap

        and some random noise.

        @param image_width The width of the image.

        @param current_overlap The current overlap value.

        @return The suggested adjustment to the overlap (positive or negative integer).

        """

        # Simulation logic:

        # Assume the "perfect" overlap is 100 pixels.

        # If current is 75, we are off by 25.

        # We return the error.

        target = 100

        error = target - current_overlap

        # Add some noise

        noise = np.random.randint(-2, 3)

        return error + noise