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 This class is in charge of image input 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:

    ## \brief A class to handle various commands related to image processing.

    #

    # The Commands class provides methods to load, display, and set overlap regions

    # for images using a graphical user interface (GUI) and shared data. It integrates

    # with an ImageIO class to handle image input and output operations.

    #

    # \author 

    # \version 1.0

    # \date 2024-10-24

    def __init__(self, gui, shared_data):

        ## \brief Initializes the Commands instance.

        #

        # Sets up the GUI interface and shared data. It also initializes

        # an ImageIO instance for handling image operations.

        #

        # \param gui The GUI instance used for displaying images and getting user input.

        # \param shared_data The shared data structure that stores images and other state information.

        self.gui = gui

        self.shared_data = shared_data

        self.io = ImageIO(shared_data)

    def load_left_image(self):

        ## \brief Loads the left image from a file.

        #

        # Opens a file dialog for the user to select a left image file. If a valid file path

        # is provided, the left image is loaded into the shared data. A message is printed

        # to confirm the loading process.

        # 

        # \warning This method does not check the file format or image content.

        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):

        ## \brief Loads the right image from a file.

        #

        # Opens a file dialog for the user to select a right image file. If a valid file path

        # is provided, the right image is loaded into the shared data. A message is printed

        # to confirm the loading process.

        #

        # \warning This method does not check the file format or image content.

        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):

        ## \brief Displays the left image on the GUI.

        #

        # If the left image is available in the shared data, it is shown on the GUI canvas.

        # Otherwise, an error message is displayed to the user.

        #

        # \exception Shows a message box error if no left image is loaded.

        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):

        ## \brief Displays the right image on the GUI.

        #

        # If the right image is available in the shared data, it is shown on the GUI canvas.

        # Otherwise, an error message is displayed to the user.

        #

        # \exception Shows a message box error if no right image is loaded.

        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):

        ## \brief Sets the overlap region for image processing.

        #

        # Retrieves the overlap region value from the GUI input and updates the shared data

        # accordingly. A message is printed to confirm the overlap region setting.

        #

        # \note This method assumes that the GUI input is a valid overlap region value.

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