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.leftSide = True

        #TBD

    def write_to_file(self):

        pass

    def load_from_file(self):

        pass

        # 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 smooth_gradient(self,length, rate):

        # Create a linear gradient that transitions from full brightness (1) to zero (0)

        x = np.linspace(0, 1, length)

        # Apply a non-linear function (e.g., quadratic) for a smoother transition

        gradient = 1 - (x ** 2)  # Quadratic falloff to create a smooth transition

        gradient = np.clip(gradient * rate, 0, 1)  # Scale the gradient by the rate

        return gradient

    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 smooth gradient alpha mask for the left image (1 to 0)

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

            gradient_alpha = np.tile(gradient_alpha, (height, 1))

            # Apply the alpha gradient to the overlapping region

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

            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 smooth gradient alpha mask for the right image (0 to 1)

            gradient_alpha = np.linspace(0, 1, right_overlap_end)

            gradient_alpha = np.tile(gradient_alpha, (height, 1))

            # Apply the alpha gradient to the overlapping region

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

            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 show_right_original(self):

        # Show original image

        if self.shared_data.right_image is not None:

            self.shared_data.isLeft = False

            right = self.shared_data.right_image.copy()

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

            print("Right image displayed.")

        else:

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

    def show_left_original(self):

        # Show original image

        if self.shared_data.left_image is not None:

            self.shared_data.isLeft = True

            left = self.shared_data.left_image.copy()

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

            print("Left image displayed.")

        else:

            messagebox.showerror("Error", "No left 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}")

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

        self.button_show_left_original = tk.Button(self.control_window, text="Show Left Original", command=self.commands.show_left_original)

        self.button_show_left_original.pack()

        self.button_show_right_original = tk.Button(self.control_window, text="Show Right Original", command=self.commands.show_right_original)

        self.button_show_right_original.pack()

if __name__ == "__main__":

    root = tk.Tk()

    root.geometry("1280x800")

    app = GUI(root)

    root.mainloop()