G12-2024

---

*[[/|Home]]*   |   *[[Team Members]]*   |   *[[Project Description]]*   |   *[[Code]]*   |   *[[UML Diagrams]]*   |   *[[Results]]*   |

---

h1=. <pre>

Code </pre>

h2. alpha_blending_v2.py: everything

<pre><code class="python">

import tkinter as tk

from tkinter import filedialog, messagebox

from tkinter import ttk

import configparser

import cv2

import numpy as np

import os

import logging

from PIL import Image, ImageTk

# Setup logging

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

# ConfigReader class definition

class ConfigReader:

    def __init__(self, config_path=None):

        # Assume some initialization using config_path

        self.config_path = config_path

        # Add other initialization logic here

        self.config_parser = configparser.ConfigParser()

        if config_path is not None and os.path.exists(config_path):

            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))

    def setParameters(self, parameters):

        # The parameters is a dictionary with key-value pairs

        if 'DEFAULT' not in self.config_parser:

            self.config_parser['DEFAULT'] = {}

        for key, value in parameters.items():

            self.config_parser['DEFAULT'][key] = str(value)

    def save_config(self, path):

        with open(path, 'w') as configfile:

            self.config_parser.write(configfile)

# 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):

        """

        Applies alpha blending on the gamma-corrected image.

        Combines the gamma-corrected part of the image with a black background using the alpha gradient mask.

        """

        # Initialize result_image to be the gamma-corrected image

        self.result_image = self.__gamma_corrected.copy()

        if image_side == 1:  # Right side

            # Create a region of interest (ROI) where blending will occur (right side of the image)

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

            # Create black background for blending

            black_background = np.zeros_like(roi, dtype=np.float32)

            # Apply the alpha mask to blend gamma-corrected image with black background

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

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

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

            # Place the blended region back in the result image

            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

            # Create a region of interest (ROI) where blending will occur (left side of the image)

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

            # Create black background for blending

            black_background = np.zeros_like(roi, dtype=np.float32)

            # Apply the alpha mask to blend gamma-corrected image with black background

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

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

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

            # Place the blended region back in the result image

            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(image_path, params, main_display):

    """

    Processes an image based on the provided parameters.

    Args:

        image_path (str): Path to the image file.

        params (dict): Parameters for image processing.

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

    Returns:

        tuple: Processed image and its corresponding name.

    """

    # Retrieve parameters from params dictionary

    mask_width = params.get('projected_overlap_width')

    image_width = params.get('projected_image_width')

    gamma = params.get('gamma')

    image_side = params.get('image_side')

    transparency_factor = params.get('transparency_factor')

    # 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. 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}")

# GUI Application class definition

class ImageProcessingApp:

    def __init__(self, root):

        self.root = root

        self.root.title("Image Processing Application")

        # Initialize variables

        self.left_image_path = "" 

        self.right_image_path = "" 

        self.left_params = {}

        self.right_params = {}

        self.processed_images = {}

        # Create notebook (tabs)

        self.notebook = ttk.Notebook(root)

        self.notebook.pack(expand=True, fill='both')

        # Create frames for each tab

        self.tab_left = ttk.Frame(self.notebook)

        self.tab_right = ttk.Frame(self.notebook)

        self.tab_settings = ttk.Frame(self.notebook)

        self.tab_preview = ttk.Frame(self.notebook)

        self.notebook.add(self.tab_left, text='Left Image')

        self.notebook.add(self.tab_right, text='Right Image')

        self.notebook.add(self.tab_settings, text='Settings')

        self.notebook.add(self.tab_preview, text='Preview')

        # Setup each tab

        self.setup_left_tab()

        self.setup_right_tab()

        self.setup_settings_tab()

        self.setup_preview_tab()

        # Process and Save Button

        self.process_button = tk.Button(root, text="Process and Save Images", command=self.process_and_save)

        self.process_button.pack(pady=10)

        # Progress Bar

        self.progress_bar = ttk.Progressbar(root, orient="horizontal", length=400, mode="determinate")

        self.progress_bar.pack(pady=10)

    def setup_left_tab(self):

        frame = self.tab_left

        # Select Image Button

        btn_select = tk.Button(frame, text="Select Left Image", command=self.select_left_image)

        btn_select.pack(pady=5)

        # Display selected image path

        self.left_image_label = tk.Label(frame, text="No image selected", wraplength=300, anchor="w", justify="left")

        self.left_image_label.pack(padx=10, pady=5)

        # Parameters for left image

        params_frame = tk.LabelFrame(frame, text="Left Image Parameters", padx=10, pady=10)

        params_frame.pack(padx=10, pady=10, fill="x")

        # Projected Image Width

        tk.Label(params_frame, text="Projected Image Width:").grid(row=0, column=0, sticky="e")

        self.left_projected_image_width = tk.Entry(params_frame)

        self.left_projected_image_width.insert(0, "800")

        self.left_projected_image_width.grid(row=0, column=1, pady=2, sticky="w")

        # Projected Overlap Width

        tk.Label(params_frame, text="Projected Overlap Width:").grid(row=1, column=0, sticky="e")

        self.left_projected_overlap_width = tk.Entry(params_frame)

        self.left_projected_overlap_width.insert(0, "100")

        self.left_projected_overlap_width.grid(row=1, column=1, pady=2, sticky="w")

        # Gamma

        tk.Label(params_frame, text="Gamma:").grid(row=2, column=0, sticky="e")

        self.left_gamma = tk.Entry(params_frame)

        self.left_gamma.insert(0, "1.0")

        self.left_gamma.grid(row=2, column=1, pady=2, sticky="w")

        # Image Side

        tk.Label(params_frame, text="Image Side:").grid(row=3, column=0, sticky="e")

        self.left_image_side = tk.IntVar(value=0)  # Default to left

        tk.Radiobutton(params_frame, text="Left", variable=self.left_image_side, value=0).grid(row=3, column=1, sticky="w")

        tk.Radiobutton(params_frame, text="Right", variable=self.left_image_side, value=1).grid(row=3, column=1, padx=60, sticky="w")

        # Transparency Factor

        tk.Label(params_frame, text="Transparency Factor:").grid(row=4, column=0, sticky="e")

        self.left_transparency_factor = tk.Entry(params_frame)

        self.left_transparency_factor.insert(0, "1.0")

        self.left_transparency_factor.grid(row=4, column=1, pady=2, sticky="w")

    def setup_right_tab(self):

        frame = self.tab_right

        # Select Image Button

        btn_select = tk.Button(frame, text="Select Right Image", command=self.select_right_image)

        btn_select.pack(pady=5)

        # Display selected image path

        self.right_image_label = tk.Label(frame, text="No image selected", wraplength=300, anchor="w", justify="left")

        self.right_image_label.pack(padx=10, pady=5)

        # Parameters for right image

        params_frame = tk.LabelFrame(frame, text="Right Image Parameters", padx=10, pady=10)

        params_frame.pack(padx=10, pady=10, fill="x")

        # Projected Image Width

        tk.Label(params_frame, text="Projected Image Width:").grid(row=0, column=0, sticky="e")

        self.right_projected_image_width = tk.Entry(params_frame)

        self.right_projected_image_width.insert(0, "800")

        self.right_projected_image_width.grid(row=0, column=1, pady=2, sticky="w")

        # Projected Overlap Width

        tk.Label(params_frame, text="Projected Overlap Width:").grid(row=1, column=0, sticky="e")

        self.right_projected_overlap_width = tk.Entry(params_frame)

        self.right_projected_overlap_width.insert(0, "100")

        self.right_projected_overlap_width.grid(row=1, column=1, pady=2, sticky="w")

        # Gamma

        tk.Label(params_frame, text="Gamma:").grid(row=2, column=0, sticky="e")

        self.right_gamma = tk.Entry(params_frame)

        self.right_gamma.insert(0, "1.0")

        self.right_gamma.grid(row=2, column=1, pady=2, sticky="w")

        # Image Side

        tk.Label(params_frame, text="Image Side:").grid(row=3, column=0, sticky="e")

        self.right_image_side = tk.IntVar(value=1)  # Default to right

        tk.Radiobutton(params_frame, text="Left", variable=self.right_image_side, value=0).grid(row=3, column=1, sticky="w")

        tk.Radiobutton(params_frame, text="Right", variable=self.right_image_side, value=1).grid(row=3, column=1, padx=60, sticky="w")

        # Transparency Factor

        tk.Label(params_frame, text="Transparency Factor:").grid(row=4, column=0, sticky="e")

        self.right_transparency_factor = tk.Entry(params_frame)

        self.right_transparency_factor.insert(0, "1.0")

        self.right_transparency_factor.grid(row=4, column=1, pady=2, sticky="w")

    def setup_settings_tab(self):

        frame = self.tab_settings

        # Configurations can be saved or loaded here

        save_config_btn = tk.Button(frame, text="Save Configuration", command=self.save_configuration)

        save_config_btn.pack(pady=10)

        load_config_btn = tk.Button(frame, text="Load Configuration", command=self.load_configuration)

        load_config_btn.pack(pady=10)

    def setup_preview_tab(self):

        frame = self.tab_preview

        # Labels to display images

        self.original_image_label = tk.Label(frame, text="Original Image")

        self.original_image_label.pack(side="left", padx=10, pady=10)

        self.processed_image_label = tk.Label(frame, text="Processed Image")

        self.processed_image_label.pack(side="right", padx=10, pady=10)

    def select_left_image(self):

        path = filedialog.askopenfilename(title="Select Left Image",

                                          filetypes=[("Image files", "*.png *.jpg *.jpeg *.bmp")])

        if path:

            self.left_image_path = path

            self.left_image_label.config(text=os.path.basename(path))

            logging.info(f"Selected left image: {path}")

    def select_right_image(self):

        path = filedialog.askopenfilename(title="Select Right Image",

                                          filetypes=[("Image files", "*.png *.jpg *.jpeg *.bmp")])

        if path:

            self.right_image_path = path

            self.right_image_label.config(text=os.path.basename(path))

            logging.info(f"Selected right image: {path}")

    def save_configuration(self):

        config = ConfigReader()

        # Left Image Parameters

        if self.left_image_path:

            config.setParameters({

                'image_name': self.left_image_path,

                'projected_image_width': self.left_projected_image_width.get(),

                'projected_overlap_width': self.left_projected_overlap_width.get(),

                'gamma': self.left_gamma.get(),

                'image_side': self.left_image_side.get(),

                'transparency_factor': self.left_transparency_factor.get()

            })

        # Right Image Parameters

        if self.right_image_path:

            config.setParameters({

                'image_name': self.right_image_path,

                'projected_image_width': self.right_projected_image_width.get(),

                'projected_overlap_width': self.right_projected_overlap_width.get(),

                'gamma': self.right_gamma.get(),

                'image_side': self.right_image_side.get(),

                'transparency_factor': self.right_transparency_factor.get()

            })

        # Save to file

        save_path = filedialog.asksaveasfilename(title="Save Configuration",

                                                 defaultextension=".ini",

                                                 filetypes=[("INI files", "*.ini")])

        if save_path:

            config.save_config(save_path)

            messagebox.showinfo("Success", f"Configuration saved to {save_path}")

            logging.info(f"Configuration saved to {save_path}")

    def load_configuration(self):

        load_path = filedialog.askopenfilename(title="Load Configuration",

                                               filetypes=[("INI files", "*.ini")])

        if load_path and os.path.exists(load_path):

            config = ConfigReader(load_path)

            # Load left image parameters

            self.left_image_path = config.getImageName()

            if self.left_image_path and os.path.exists(self.left_image_path):

                self.left_image_label.config(text=os.path.basename(self.left_image_path))

            self.left_projected_image_width.delete(0, tk.END)

            self.left_projected_image_width.insert(0, config.getProjectedImageWidth())

            self.left_projected_overlap_width.delete(0, tk.END)

            self.left_projected_overlap_width.insert(0, config.getProjectedOverlapWidth())

            self.left_gamma.delete(0, tk.END)

            self.left_gamma.insert(0, config.getGamma())

            self.left_image_side.set(config.getImageSide())

            self.left_transparency_factor.delete(0, tk.END)

            self.left_transparency_factor.insert(0, config.getTransparencyFactor())

            # Load right image parameters

            self.right_image_path = config.getImageName()

            if self.right_image_path and os.path.exists(self.right_image_path):

                self.right_image_label.config(text=os.path.basename(self.right_image_path))

            self.right_projected_image_width.delete(0, tk.END)

            self.right_projected_image_width.insert(0, config.getProjectedImageWidth())

            self.right_projected_overlap_width.delete(0, tk.END)

            self.right_projected_overlap_width.insert(0, config.getProjectedOverlapWidth())

            self.right_gamma.delete(0, tk.END)

            self.right_gamma.insert(0, config.getGamma())

            self.right_image_side.set(config.getImageSide())

            self.right_transparency_factor.delete(0, tk.END)

            self.right_transparency_factor.insert(0, config.getTransparencyFactor())

            messagebox.showinfo("Success", f"Configuration loaded from {load_path}")

            logging.info(f"Configuration loaded from {load_path}")

        else:

            messagebox.showerror("Error", "Failed to load configuration.")

    def process_and_save(self):

        # Validate inputs

        if not self.left_image_path or not self.right_image_path:

            messagebox.showerror("Error", "Please select both left and right images.")

            return

        # Collect parameters for left image

        left_params = {

            'image_name': self.left_image_path,

            'projected_image_width': int(self.left_projected_image_width.get()),

            'projected_overlap_width': int(self.left_projected_overlap_width.get()),

            'gamma': float(self.left_gamma.get()),

            'image_side': self.left_image_side.get(),

            'transparency_factor': float(self.left_transparency_factor.get())

        }

        # Collect parameters for right image

        right_params = {

            'image_name': self.right_image_path,

            'projected_image_width': int(self.right_projected_image_width.get()),

            'projected_overlap_width': int(self.right_projected_overlap_width.get()),

            'gamma': float(self.right_gamma.get()),

            'image_side': self.right_image_side.get(),

            'transparency_factor': float(self.right_transparency_factor.get())

        }

        # Initialize main display

        main_display = MainDisplay()

        # Process left image

        self.progress_bar["value"] = 0

        self.root.update_idletasks()

        left_processed, left_name = process_image(self.left_image_path, left_params, main_display)

        if left_processed is not None and left_name is not None:

            self.processed_images[left_name] = left_processed

            save_image(left_processed, left_name)

            self.progress_bar["value"] += 50

            self.root.update_idletasks()

        # Process right image

        right_processed, right_name = process_image(self.right_image_path, right_params, main_display)

        if right_processed is not None and right_name is not None:

            self.processed_images[right_name] = right_processed

            save_image(right_processed, right_name)

            self.progress_bar["value"] += 50

            self.root.update_idletasks()

        # Display images

        self.display_preview()

        # Finalize progress

        self.progress_bar["value"] = 100

        self.root.update_idletasks()

        messagebox.showinfo("Processing Complete", "Images processed and saved successfully.")

    def display_preview(self):

        # Display the first processed image as preview

        if self.processed_images:

            # For simplicity, display the first image

            name, img = next(iter(self.processed_images.items()))

            img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

            pil_img = Image.fromarray(img_rgb)

            pil_img = pil_img.resize((400, 300), Image.ANTIALIAS)

            img_tk = ImageTk.PhotoImage(pil_img)

            self.processed_image_label.config(image=img_tk)

            self.processed_image_label.image = img_tk

            # Load and display original image

            original_img = cv2.imread(self.left_image_path if name == 'left' else self.right_image_path, cv2.IMREAD_COLOR)

            if original_img is not None:

                original_rgb = cv2.cvtColor(original_img, cv2.COLOR_BGR2RGB)

                pil_original = Image.fromarray(original_rgb)

                pil_original = pil_original.resize((400, 300), Image.ANTIALIAS)

                original_tk = ImageTk.PhotoImage(pil_original)

                self.original_image_label.config(image=original_tk)

                self.original_image_label.image = original_tk

    def display_image(self, processed_images):

        # This method can be expanded to display multiple images if needed

        pass

def main():

    root = tk.Tk()

    app = ImageProcessingApp(root)

    root.mainloop()

if __name__ == "__main__":

    main()

</code></pre>