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.5

        self.leftSide = True

        # Methods to implement

        # Load config function

        # Write to config file 

##

# @class This class is in charge of imput and output

#

class ImageIO:

    ##

    # @breif

    # initializator for whole method.

    # get parsed config.cfg data from the class 'SharedData'

    # 

    # @param self the class itself

    # @param shared_data parsed config.cfg data

    # @return None

    def __init__(self, shared_data):

        self.shared_data = shared_data

    ##

    # @breif function for loading image

    # @param path path of the image

    # @return numpy array, image

    def load_image(self, path):

        return cv.imread(path, cv.IMREAD_COLOR)

    ##

    # @brief function to manipulate the image

    # @param img, loaded image, numpy matrix

    # @param fileName, name of the image. "image.png" will be the default value if there are no input

    # @return None

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

        if cv.imwrite(fileName, img):

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

        else:

            print("File writing failed")

    ## 

    # @breif function to print image through the projector

    # @param img numpy array, image matrix

    # @param title title of the window. 'Image Title' will be the default value when there is no input.

    # @param canvas parameter needed for library 'Tinker Canvas'. None is default value.

    # @return None

    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

            # Create a copy of the original left image

            left = self.shared_data.left_image.copy()

            # Assuming both images have the same height

            height = left.shape[0]

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

            # Extract the overlapping region

            left_overlap = left[0:height, left_overlap_start:, :]

            # Adjust the alpha value

            left_overlap_mod = cv.convertScaleAbs(left_overlap, alpha=self.shared_data.alpha, beta=0)  # Adjust brightness

            # Replace the modified blue channel back into the original right image

            left[0:height, left_overlap_start:, :] = left_overlap_mod

            # 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

            # Create a copy of the original right image

            right = self.shared_data.right_image.copy()

            # Assuming both images have the same height

            height = right.shape[0]

            right_overlap_start = 0

            right_overlap_end = self.shared_data.overlap_region

            # Extract the overlapping region

            right_overlap = right[0:height, right_overlap_start:right_overlap_end, :]

            # Adjust the alpha value

            right_overlap_mod = cv.convertScaleAbs(right_overlap, alpha=self.shared_data.alpha, beta=0)  # Adjust brightness

            # Replace the modified blue channel back into the original right image

            right[0:height, right_overlap_start:right_overlap_end, :] = right_overlap_mod

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