G11-2024

import cv2 as cv

import numpy as np

import tkinter as tk

from tkinter import filedialog, messagebox

import os

from PIL import Image, ImageTk

class SharedData:

    def __init__(self):

        self.left_image = None

        self.right_image = None

        self.overlap_region = 200

        self.alpha = 0

        self.leftSide = True

        # Methods to implement

        # Load config function

        # Write to config file 

class ImageIO:

    def __init__(self, shared_data):

        self.shared_data = shared_data

    def load_image(self, path):

        return cv.imread(path, cv.IMREAD_COLOR)

    def write_image(self, img, fileName="image.png"):

        if cv.imwrite(fileName, img):

            print(f"File {fileName} Written Successfully")

        else:

            print("File writing failed")

    def show_image(self, img, title="Image Title", canvas=None):

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

        img_pil = Image.fromarray(img_rgb)

        img_tk = ImageTk.PhotoImage(img_pil)

        canvas.update_idletasks()  # Force the canvas to update its dimensions

        canvas_width = canvas.winfo_width()  # Get the updated canvas width

        if self.shared_data.isLeft:

            # Align image to the top-right corner

            canvas.create_image(canvas_width, 0, anchor=tk.NE, image=img_tk)

        else:

            # Align image to the top-left corner

            canvas.create_image(0, 0, anchor=tk.NW, image=img_tk)

        canvas.image = img_tk  # Prevent image from being garbage collected

class Commands:

    def __init__(self, gui, shared_data):

        self.gui = gui

        self.shared_data = shared_data

        self.io = ImageIO(shared_data)

    def load_left_image(self):

        filepath = filedialog.askopenfilename(title="Select Left Image")

        if filepath:

            self.shared_data.left_image = self.io.load_image(filepath)

            print("Left image loaded.")

    def load_right_image(self):

        filepath = filedialog.askopenfilename(title="Select Right Image")

        if filepath:

            self.shared_data.right_image = self.io.load_image(filepath)

            print("Right image loaded.")

    def show_left_image(self):

        if self.shared_data.left_image is not None:

            self.shared_data.isLeft = True

            left = self.shared_data.left_image.copy()

            height = left.shape[0]

            left_overlap_start = left.shape[1] - self.shared_data.overlap_region

            # Create a gradient alpha mask for the left image (1 to 0)

            gradient_alpha = np.linspace(1, 0, self.shared_data.overlap_region).astype(np.float32)

            gradient_alpha = np.tile(gradient_alpha, (height, 1))  # Repeat to match height

            # Ensure the gradient is clipped to avoid any unexpected behavior

            gradient_alpha = np.clip(gradient_alpha, 0, 1)

            # Apply the alpha gradient to the overlapping region

            left_overlap = left[:, left_overlap_start:, :].copy()

            left_overlap[:, :, :3] = cv.convertScaleAbs(left_overlap[:, :, :3], alpha=1)  # Keep original brightness

            left_overlap = (left_overlap * gradient_alpha[..., np.newaxis]).astype(np.uint8)

            # Replace the modified overlapping region back into the original left image

            left[:, left_overlap_start:, :] = left_overlap

            # Show the modified image

            self.io.show_image(left, canvas=self.gui.canvas)

            print("Left image displayed.")

        else:

            messagebox.showerror("Error", "No left image loaded!")

    def show_right_image(self):

        if self.shared_data.right_image is not None:

            self.shared_data.isLeft = False

            right = self.shared_data.right_image.copy()

            height = right.shape[0]

            right_overlap_end = self.shared_data.overlap_region

            # Create a gradient alpha mask for the right image (0 to 1)

            gradient_alpha = np.linspace(0, 1, right_overlap_end * self.shared_data.alpha).astype(np.float32)

            gradient_alpha = np.tile(gradient_alpha, (height, 1))  # Repeat to match height

            # Ensure the gradient is clipped to avoid any unexpected behavior

            gradient_alpha = np.clip(gradient_alpha, 0, 1)

            # Apply the alpha gradient to the overlapping region

            right_overlap = right[:, :right_overlap_end, :].copy()

            right_overlap[:, :, :3] = cv.convertScaleAbs(right_overlap[:, :, :3], alpha=1)  # Keep original brightness

            right_overlap = (right_overlap * gradient_alpha[..., np.newaxis]).astype(np.uint8)

            # Replace the modified overlapping region back into the original right image

            right[:, :right_overlap_end, :] = right_overlap

            # Show the modified image

            self.io.show_image(right, canvas=self.gui.canvas)

            print("Right image displayed.")

        else:

            messagebox.showerror("Error", "No right image loaded!")

    def set_overlap_region(self):

        self.shared_data.overlap_region = self.gui.overlap.get()

        print(f"Overlap region set to {self.shared_data.overlap_region}")

    def set_alpha_value(self):

        alpha = self.gui.alpha.get()

        if(alpha > 1.0):

            alpha = 1

        if(alpha < 0.0):

            alpha = 0

        self.shared_data.alpha = alpha

        print(f"Alpha value set to {self.shared_data.alpha}")

class GUI:

    def __init__(self, master):

        self.master = master

        self.master.title("Image Projector")

        self.canvas = tk.Canvas(self.master, bg="black")

        self.canvas.pack(fill=tk.BOTH, expand=True)

        self.shared_data = SharedData()

        self.commands = Commands(self, self.shared_data)

        self.control_window()

    def control_window(self):

        self.control_window = tk.Toplevel(self.master)

        self.control_window.title("Controls")

        self.overlap = tk.IntVar(value=200)

        self.alpha = tk.DoubleVar(value=0.5)

        self.alphaLabel = tk.Label(self.control_window, text='Alpha value', font=('calibre', 10, 'bold'))

        self.alphaBox = tk.Entry(self.control_window, textvariable=self.alpha)

        self.alphaLabel.pack()

        self.alphaBox.pack()

        self.set_alpha_button = tk.Button(self.control_window, text="Set Alpha", command=self.commands.set_alpha_value)

        self.set_alpha_button.pack()

        self.overlapLabel = tk.Label(self.control_window, text='Overlap region Width', font=('calibre', 10, 'bold'))

        self.overlapBox = tk.Entry(self.control_window, textvariable=self.overlap)

        self.overlapLabel.pack()

        self.overlapBox.pack()

        self.set_overlap_button = tk.Button(self.control_window, text="Set Overlap Region", command=self.commands.set_overlap_region)

        self.set_overlap_button.pack()

        self.button_load_left = tk.Button(self.control_window, text="Load Left Image", command=self.commands.load_left_image)

        self.button_load_left.pack()

        self.button_load_right = tk.Button(self.control_window, text="Load Right Image", command=self.commands.load_right_image)

        self.button_load_right.pack()

        self.button_show_left = tk.Button(self.control_window, text="Show Left Image", command=self.commands.show_left_image)

        self.button_show_left.pack()

        self.button_show_right = tk.Button(self.control_window, text="Show Right Image", command=self.commands.show_right_image)

        self.button_show_right.pack()

if __name__ == "__main__":

    root = tk.Tk()

    root.geometry("1280x800")

    app = GUI(root)

    root.mainloop()