G12-2024 » G12-Learning-2024

#!/usr/bin/env python3

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

import configparser

import cv2

import numpy as np

import os

import logging

# Setup logging

logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

# ConfigReader class definition

class ConfigReader:

    def __init__(self, config_path):

        self.config_parser = configparser.ConfigParser()

        self.config_parser.read(config_path)

    def getImageName(self):

        return str(self.config_parser['DEFAULT']['image_name'])

    def getProjectedImageWidth(self):

        return int(self.config_parser['DEFAULT']['projected_image_width'])

    def getProjectedOverlapWidth(self):

        return int(self.config_parser['DEFAULT']['projected_overlap_width'])

    def getGamma(self):

        return float(self.config_parser['DEFAULT']['gamma'])

    def getImageSide(self):

        return int(self.config_parser['DEFAULT']['image_side'])

    def getTransparencyFactor(self):

        return float(self.config_parser['DEFAULT'].get('transparency_factor', 1.0))

# MainDisplay class definition

class MainDisplay:

    def readImage(self, image_path):

        # Loads an image from the specified path with 3 channels (BGR)

        image = cv2.imread(image_path, cv2.IMREAD_COLOR)

        if image is None:

            logging.error(f"Error loading image at {image_path}")

        else:

            logging.info(f"Loaded image {image_path} with shape: {image.shape}")

        return image

    def setImage(self, image):

        # Placeholder for image processing if necessary

        # Here you can modify or prepare the image before displaying

        logging.info(f"Setting image with shape: {image.shape}")

        return image

# MaskCreator class definition

class MaskCreator:

    def __init__(self, image, transparency_factor):

        self.__image = image

        self.__alpha_gradient = None

        self.__gamma_corrected = None

        self.result_image = None

        self.__mask = None

        self.transparency_factor = transparency_factor

    def smoothstep(self, edge0, edge1, x):

        # Smoothstep function for smoother transition (non-linear gradient)

        x = np.clip((x - edge0) / (edge1 - edge0), 0, 1)

        return x * x * (3 - 2 * x)

    def create_mask(self, image_side, mask_width, image_width):

        self.__mask = self.__image.shape[1] * mask_width // image_width

        gradient = np.linspace(0, 1, self.__mask)

        # Apply smoothstep to create a smoother gradient

        smooth_gradient = self.smoothstep(0, 1, gradient)

        # Apply transparency factor to adjust the strength of the blending

        smooth_gradient = smooth_gradient * self.transparency_factor

        if image_side == 1:

            # Gradient from transparent to opaque (middle to right)

            self.__alpha_gradient = smooth_gradient

        elif image_side == 0:

            # Gradient from opaque to transparent (left to middle)

            self.__alpha_gradient = smooth_gradient[::-1]  # Reverse for the left side

    def gammaCorrection(self, gamma):

        # Apply gamma correction

        inv_gamma = 1.0 / gamma

        table = np.array([((i / 255.0) ** inv_gamma) * 255

                          for i in np.arange(256)]).astype("uint8")

        self.__gamma_corrected = cv2.LUT(self.__image, table)

        logging.info(f"Applied gamma correction with gamma={gamma}")

        # Save gamma corrected image for inspection

        cv2.imwrite("gamma_corrected.png", self.__gamma_corrected)

    def alpha_blending(self, image_side):

        # Ensure the result image is a black background before blending

        if image_side == 1:  # Right side

            # Set the area where blending will happen to black

            self.result_image[:, :self.__mask] = 0  # Set the ROI to black

            roi = self.result_image[:, :self.__mask].astype(np.float32)

            gamma_corrected = self.__gamma_corrected[:, :self.__mask].astype(np.float32)

            alpha = self.__alpha_gradient.reshape(1, -1, 1).astype(np.float32)

            blended = (alpha * gamma_corrected + (1 - alpha) * roi)

            blended = np.clip(blended, 0, 255).astype(np.uint8)

            self.result_image[:, :self.__mask] = blended

            logging.info(f"Applied alpha blending on the right side with mask width {self.__mask}")

            # Save blended region for debugging

            cv2.imwrite("blended_right_side.png", blended)

        elif image_side == 0:  # Left side

            # Set the area where blending will happen to black

            self.result_image[:, -self.__mask:] = 0  # Set the ROI to black

            roi = self.result_image[:, -self.__mask:].astype(np.float32)

            gamma_corrected = self.__gamma_corrected[:, -self.__mask:].astype(np.float32)

            alpha = self.__alpha_gradient.reshape(1, -1, 1).astype(np.float32)

            blended = (alpha * gamma_corrected + (1 - alpha) * roi)

            blended = np.clip(blended, 0, 255).astype(np.uint8)

            self.result_image[:, -self.__mask:] = blended

            logging.info(f"Applied alpha blending on the left side with mask width {self.__mask}")

            # Save blended region for debugging

            cv2.imwrite("blended_left_side.png", blended)

def process_image(config_path, main_display):

    """

    Processes an image based on the provided configuration.

    Args:

        config_path (str): Path to the configuration file.

        main_display (MainDisplay): Instance of MainDisplay for image operations.

    Returns:

        tuple: Processed image and its corresponding name.

    """

    # Load configuration

    config_reader = ConfigReader(config_path)

    # Retrieve configuration parameters

    mask_width = config_reader.getProjectedOverlapWidth()

    image_width = config_reader.getProjectedImageWidth()

    gamma = config_reader.getGamma()

    image_side = config_reader.getImageSide()

    image_path = config_reader.getImageName()

    transparency_factor = config_reader.getTransparencyFactor()

    # Determine image side name

    if image_side == 0:

        image_name = 'left'

    elif image_side == 1:

        image_name = 'right'

    else:

        logging.error(f"Invalid ImageSide value in {config_path}. Use 0 for left image, 1 for right image.")

        return None, None

    # Load image

    image = main_display.readImage(image_path)

    if image is None:

        logging.error(f"Image loading failed for {image_path}. Skipping...")

        return None, None

    # Initialize result image

    result_image = main_display.setImage(image).copy()

    cv2.imwrite("initial_result_image.png", result_image)  # Save initial image

    # Initialize MaskCreator

    mask_creator = MaskCreator(image, transparency_factor)

    # Apply image modifications

    mask_creator.create_mask(image_side, mask_width, image_width)

    mask_creator.gammaCorrection(gamma)

    mask_creator.result_image = result_image

    mask_creator.alpha_blending(image_side)

    # Save final result for inspection

    cv2.imwrite("final_result_image.png", mask_creator.result_image)

    return mask_creator.result_image, image_name

def save_image(image, name):

    """

    Save the processed image to the project folder.

    Args:

        image (np.ndarray): The image to be saved.

        name (str): Name of the image (left or right).

    """

    # Define the output path

    output_dir = os.path.join(os.getcwd(), "processed_images")

    os.makedirs(output_dir, exist_ok=True)

    # Create the output file name

    output_path = os.path.join(output_dir, f"processed_image_{name}.png")

    # Save the image

    cv2.imwrite(output_path, image)

    logging.info(f"Saved processed image: {output_path}")

def main():

    # Initialize MainDisplay

    main_display = MainDisplay()

    # Define configuration files for left and right images

    config_files = ["config_left.ini", "config_right.ini"]

    # Dictionary to store processed images

    processed_images = {}

    # Process each configuration

    for config_file in config_files:

        processed_image, image_name = process_image(config_file, main_display)

        if processed_image is not None and image_name is not None:

            processed_images[image_name] = processed_image

    # Save all processed images to the project folder

    for name, img in processed_images.items():

        save_image(img, name)

if __name__ == "__main__":

    main()