G11-2025-Final Project

#!/usr/bin/env python

# -*- coding: utf-8 -*-

import cv2

import numpy as np

import os

from config_reader import ConfigReader

class MainAlphaBlender(object):

    def __init__(self, config_path="config.json"):

        try:

            self.__config_reader = ConfigReader(config_path)

            self.blend_width = self.__config_reader.get_blend_width()

            self.gamma_value = self.__config_reader.get_gamma_value()

            self.method = self.__config_reader.get_blend_method()

            self.output_dir = self.__config_reader.get_output_dir()

            self.preview = self.__config_reader.get_preview()

            self.image_path = self.__config_reader.get_image_path()

        except FileNotFoundError:

            self.blend_width = 200

            self.gamma_value = 1.4

            self.method = "cosine"

            self.output_dir = "Results"

            self.preview = True

            self.image_path = "OriginalImages"

        self.update_paths()

    def update_paths(self):

        self.left_image_path = os.path.join(self.image_path, "Left.jpg")

        self.right_image_path = os.path.join(self.image_path, "Right.jpg")

    def create_alpha_gradient(self, blend_width, side, method="cosine"):

        if method == 'linear':

            alpha_gradient = np.linspace(0, 1, blend_width)

        elif method == 'cosine':

            t = np.linspace(0, np.pi, blend_width)

            alpha_gradient = (1 - np.cos(t**0.85)) / 2

        elif method == 'quadratic':

            t = np.linspace(0, 1, blend_width)

            alpha_gradient = t**2

        elif method == 'sqrt':

            t = np.linspace(0, 1, blend_width)

            alpha_gradient = np.sqrt(t)

        elif method == 'log':

            t = np.linspace(0, 1, blend_width)

            alpha_gradient = np.log1p(9 * t) / np.log1p(9)

        elif method == 'sigmoid':

            t = np.linspace(0, 1, blend_width)

            alpha_gradient = 1 / (1 + np.exp(-12 * (t - 0.5)))

            alpha_gradient = (alpha_gradient - alpha_gradient.min()) / (alpha_gradient.max() - alpha_gradient.min())

        else:

            raise ValueError("Invalid method: choose from 'linear', 'cosine', 'quadratic', 'sqrt', 'log', or 'sigmoid'")

        if side == 'right':

            alpha_gradient = 1 - alpha_gradient

        return alpha_gradient

    def gamma_correction(self, image, gamma):

        img_float = image.astype(np.float32) / 255.0

        mean_intensity = np.mean(img_float)

        adaptive_gamma = gamma * (0.5 / (mean_intensity + 1e-5))

        adaptive_gamma = np.clip(adaptive_gamma, 0.8, 2.0)

        corrected = np.power(img_float, 1.0 / adaptive_gamma)

        return np.uint8(np.clip(corrected * 255, 0, 255))

    def alpha_blend_edge(self, image, blend_width, side, method="cosine"):

        height, width, _ = image.shape

        blended_image = image.copy()

        alpha_gradient = self.create_alpha_gradient(blend_width, side, method)

        if side == 'right':

            roi = blended_image[:, width - blend_width:]

        elif side == 'left':

            roi = blended_image[:, :blend_width]

        else:

            raise ValueError("Side must be 'left' or 'right'")

        gradient_3d = alpha_gradient[np.newaxis, :, np.newaxis]

        gradient_3d = np.tile(gradient_3d, (height, 1, 3))

        if side == 'right':

            blended_image[:, width - blend_width:] = (roi * gradient_3d).astype(np.uint8)

        else:

            blended_image[:, :blend_width] = (roi * gradient_3d).astype(np.uint8)

        return blended_image

    def show_preview(self, left_image, right_image, scale=0.5):

        h = min(left_image.shape[0], right_image.shape[0])

        left_resized = cv2.resize(left_image, (int(left_image.shape[1]*scale), int(h*scale)))

        right_resized = cv2.resize(right_image, (int(right_image.shape[1]*scale), int(h*scale)))

        combined = np.hstack((left_resized, right_resized))

        cv2.imshow("Preview (Left + Right)", combined)

        cv2.waitKey(0)

        cv2.destroyAllWindows()

    def run(self):

        try:

            os.makedirs(self.output_dir, exist_ok=True)

            left_img = cv2.imread(self.left_image_path, cv2.IMREAD_COLOR)

            right_img = cv2.imread(self.right_image_path, cv2.IMREAD_COLOR)

            if left_img is None or right_img is None:

                raise FileNotFoundError(f"Could not read images from '{self.image_path}'. Check path.")

            left_blended = self.alpha_blend_edge(left_img, self.blend_width, side='right', method=self.method)

            right_blended = self.alpha_blend_edge(right_img, self.blend_width, side='left', method=self.method)

            left_gamma = self.gamma_correction(left_blended, self.gamma_value)

            right_gamma = self.gamma_correction(right_blended, self.gamma_value)

            left_output_path = os.path.join(self.output_dir, f"{self.method}_left_gamma.jpg")

            right_output_path = os.path.join(self.output_dir, f"{self.method}_right_gamma.jpg")

            cv2.imwrite(left_output_path, left_gamma)

            cv2.imwrite(right_output_path, right_gamma)

            if self.preview:

                self.show_preview(left_gamma, right_gamma)

            return (True, f"Images saved successfully in '{self.output_dir}'.")

        except (FileNotFoundError, ValueError) as e:

            return (False, str(e))

        except Exception as e:

            return (False, f"An unexpected error occurred: {e}")

        finally:

            cv2.destroyAllWindows()