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

import configparser

class SharedData:

    def __init__(self):

        self.left_image = None

        self.right_image = None

        self.overlap_region = 200

        self.leftSide = True

    def write_to_config(self, filename='config.ini'):

        config = configparser.ConfigParser()

        config['DEFAULT'] = {

            'overlap_region': str(self.overlap_region),

            'leftSide': str(self.leftSide)

        }

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

            config.write(configfile)

    def read_from_config(self, filename='config.ini'):

        config = configparser.ConfigParser()

        config.read(filename)

        self.overlap_region = config['DEFAULT'].getint('overlap_region', self.overlap_region)

        self.leftSide = config['DEFAULT'].getboolean('leftSide', self.leftSide)

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

        if(self.shared_data.isLeft):

            self.show_left_image()

        else:

            self.show_right_image()

    def increase_overlap(self):

        current_overlap = self.gui.overlap.get()

        self.gui.overlap.set(current_overlap + 1)

        self.set_overlap_region()

        if(self.shared_data.isLeft):

            self.show_left_image()

        else:

            self.show_right_image()

    def decrease_overlap(self):

        current_overlap = self.gui.overlap.get()

        self.gui.overlap.set(max(0, current_overlap - 1))  # Prevents negative overlap

        self.set_overlap_region()

        if(self.shared_data.isLeft):

            self.show_left_image()

        else:

            self.show_right_image()

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)

        # Label and entry for overlap region width

        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.grid(row=0, column=0, padx=5, pady=5)

        self.overlapBox.grid(row=0, column=1, padx=5, pady=5)

        # Button to set overlap region

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

        self.set_overlap_button.grid(row=1, column=0, columnspan=2, padx=5, pady=5)

        # New buttons for increasing and decreasing the overlap region

        self.increase_overlap_button = tk.Button(self.control_window, text="Increase Overlap", command=self.commands.increase_overlap)

        self.increase_overlap_button.grid(row=2, column=0, padx=5, pady=5)

        self.decrease_overlap_button = tk.Button(self.control_window, text="Decrease Overlap", command=self.commands.decrease_overlap)

        self.decrease_overlap_button.grid(row=2, column=1, padx=5, pady=5)

        # Load left and right image buttons

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

        self.button_load_left.grid(row=3, column=0, padx=5, pady=5)

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

        self.button_load_right.grid(row=3, column=1, padx=5, pady=5)

        # Show left and right image buttons

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

        self.button_show_left.grid(row=4, column=0, padx=5, pady=5)

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

        self.button_show_right.grid(row=4, column=1, padx=5, pady=5)

        # Show original left and right image buttons

        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.grid(row=5, column=0, padx=5, pady=5)

        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.grid(row=5, column=1, padx=5, pady=5)

        self.save_config = tk.Button(self.control_window, text="Save Config", command=self.shared_data.write_to_config)

        self.save_config.grid(row=6, column=0, padx=5, pady=5)

        self.load_config = tk.Button(self.control_window, text="Load Config", command=self.shared_data.read_from_config)

        self.load_config.grid(row=6, column=1, padx=5, pady=5)

if __name__ == "__main__":

    root = tk.Tk()

    root.geometry("1280x800")

    app = GUI(root)

    root.mainloop()