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 = 0

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.create_image(0, 0, anchor=tk.NW, image=img_tk)

        canvas.image = img_tk

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.io.show_image(self.shared_data.left_image, 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.io.show_image(self.shared_data.right_image, 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}")

 # \class GUI

 # \brief This class creates a graphical user interface for the image projector.

 #

 # The GUI class is responsible for initializing the main window and setting up the control window. It provides

 # a canvas for displaying images and buttons for loading and displaying images. 

 #

 # \author

 # \date 2024-10-27

class GUI:

    # \brief Constructor for the GUI class.

    #

    # This constructor initializes the main window and sets up the control window.

    #

    # \param master the parent window

    def __init__(self, master):

        self.master = master

        # \brief Set the title of the main window

        self.master.title("Image Projector")

        # \brief Create a canvas for displaying images

        #

        # The canvas is used to project images loaded through the control window. It is set to black.

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

        # \brief Pack the canvas to fill the window.

        #

        # The canvas is packed to fill the window. The "fill = tk.BOTH" parameter stretches the canvas both horizontally and vertically.

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

        # \brief Initialize the shared data class.

        #

        # Holds information about the images and overlap region.

        self.shared_data = SharedData()

        # \brief Initialize the commands class.

        #

        # Handles the commands for loading and displaying images.

        # \param self the object pointer

        # \param self.shared_data the shared data class

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

        self.control_window()

    # \brief Call the function to set up the control window.

    #

    # A seperate window which allows loading and setting up images and overlap region. It contains buttons and entry

    # fields for loading images, setting the overlap region and control the display of images.

    def control_window(self):

        # \brief Initalize the control window.

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

        # \brief Set the title of the control window.

        self.control_window.title("Controls")

        # \brief Initialize the overlap variable to store the overlap region width.

        #

        # The overlap variable will determine the region of overlap between the left and right images.

        self.overlap = tk.IntVar()

        # \brief Create a label for overlap region input box.

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

        # \brief Create an entry box for user to input the overlap region width.

        #

        # The entry box will take the user input for the overlap region width.

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

        # \brief Pack the label and entry box into the control window.

        self.label.pack()

        self.overlapBox.pack()

        # \brief Create a button to set the overlap region based on user input.

        #

        # This button will call the set_overlap_region function from the commands class.

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

        self.set_overlap_button.pack()

        # \brief Create a button to load the left image.

        #

        # This button will call the load_left_image function from the commands class.

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

        self.button_load_left.pack()

        # \brief Create a button to load the right image.

        #

        # This button will call the load_right_image function from the commands class.

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

        self.button_load_right.pack()

        # \brief Create a button to display the left image.

        #

        # This button will call the show_left_image function from the commands class.

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

        self.button_show_left.pack()

        # \brief Create a button to display the right image.

        #

        # This button will call the show_right_image function from the commands class.

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

        self.button_show_right.pack()

# \brief Main program entry point.

#

# This block initializes the tkinter root window, sets the window size and initializes the GUI class.

if __name__ == "__main__":

# \brief Initialize the tkinter root window.

    root = tk.Tk()

    # \brief Set the window size to 1280x800.

    root.geometry("1280x800")

    # \brief Create an instance of the GUI class passing the root window.

    app = GUI(root)

    # \brief Start the tkinter main loop to display the window and handle events.

    root.mainloop()