G21-2023

h1=. <pre>

Coding</pre>

---

*[[Wiki]]*   |  *[[About Us]]*  |  *[[Regarding Our Project]]* | *[[Coding]]*  |  *[[UML Diagrams]]*  |  *[[Results]]*  |

---

h2. main.py: creates objects and variables necessary for the another file.

<pre><code class="python">

#!/usr/bin/env python3

#-*- coding: utf-8 -*-

#˅

from MaskCreator import MaskCreator

from ConfigReader import ConfigReader

from MainDisplay import MainDisplay

# creating object for MainDisplay, ConfigReader classes

# change to config_left.ini or config_right.ini when necessary

CReader = ConfigReader("config_left.ini")

# CReader = ConfigReader("config_right.ini")

MDisplay = MainDisplay()

# initializing variables

mask_width = CReader.getProjectedOverlapWidth()

image_width = CReader.getProjectedImageWidth()

gamma = CReader.getGamma()

image_side = CReader.getImageSide()

image_path = CReader.getImageName()

if image_side == 0:

    image_name = 'left'

elif image_side == 1:

    image_name = 'right'

else:

    print("Invalid ImageSide value in config.ini. Use 0 for left image, 1 for right image.")

# loading image

image = MDisplay.readImage(image_path)

result_image = MDisplay.setImage(image)

if image is not None:

    # creating object for MaskCreator class

    MCreator = MaskCreator(image)

    # image modification

    MCreator.create_mask(image_side, mask_width, image_width)

    MCreator.gammaCorrection(gamma)

    MCreator.result_image = result_image

    MCreator.alpha_blending(image_side)

    MCreator.mod_intensity(image_side)

    # saving image

    MDisplay.saveImage()

else:

    print(f"Failed to read the image (ImageSide={image_side}).")

</code></pre>

h2. MaskCreator.py: 

<pre><code class="python">

import cv2

import numpy as np

class MaskCreator:

    """

    @brief The MaskCreator class performs image modification, including creating masks, gamma correction, alpha blending, and intensity modification.

    @details

    The class includes methods for:

    - Creating masks based on specified parameters.

    - Applying gamma correction to the image.

    - Performing alpha blending on the image based on the image side.

    - Modifying image intensity based on the image side.

    @note

    Ensure that the OpenCV library is installed (`pip install opencv-python`) before using this class.

    @date January 18, 2024

    """

    def __init__(self, image):

        """

        @brief Initializes a MaskCreator object.

        @param image: The input image on which modifications will be applied.

        """

        self.__image = image

        self.__alpha_gradient = None

        self.__gamma_corrected = None

        self.result_image = None

        self.__mask = None

    def create_mask(self, image_side, mask_width, image_width):

        """

        @brief Creates a mask based on specified parameters.

        @param image_side: The side of the image (0 for left, 1 for right).

        @param mask_width: The width of the mask.

        @param image_width: The width of the input image.

        """

        self.__mask = self.__image.shape[1] * mask_width // image_width

        if image_side == 1:

            self.__alpha_gradient = np.linspace(1, 0, self.__mask)

        elif image_side == 0:

            self.__alpha_gradient = np.linspace(0, 1, self.__mask)

    def gammaCorrection(self, gamma):

        """

        @brief Applies gamma correction to the image.

        @param gamma: The gamma value for correction.

        """

        self.__gamma_corrected = np.uint8(cv2.pow(self.__image / 255.0, gamma) * 255)

    def alpha_blending(self, image_side):

        """

        @brief Performs alpha blending on the image based on the image side.

        @param image_side: The side of the image (0 for left, 1 for right).

        """

        if image_side == 1:

            for col in range(self.__mask):

                alpha = self.__alpha_gradient[-self.__mask + col]

                self.result_image[:, col] = alpha * self.__gamma_corrected[:, col] + (1 - alpha) * self.result_image[:, col]

        elif image_side == 0:

            for col in range(self.__mask):

                alpha = self.__alpha_gradient[-self.__mask + col]

                self.result_image[:, -self.__mask + col] = alpha * self.__gamma_corrected[:, -self.__mask + col] + (1 - alpha) * self.result_image[:, -self.__mask + col]

    def mod_intensity(self, image_side):

        """

        @brief Modifies image intensity based on the image side.

        @param image_side: The side of the image (0 for left, 1 for right).

        """

        if image_side == 1:

            for col in range(self.__mask):

                intensity_factor = 1.0 - (self.__mask - col) / self.__mask

                self.result_image[:, col] = (self.result_image[:, col] * intensity_factor).astype(np.uint8)

        elif image_side == 0:

            for col in range(self.__mask):

                intensity_factor = 1.0 - col / self.__mask

                self.result_image[:, -self.__mask + col] = (self.result_image[:, -self.__mask + col] * intensity_factor).astype(np.uint8)

</code></pre>

h2. mainDisplay.py:  Displays the result

<pre><code class="python">

#!/usr/bin/env python3

#-*- coding: utf-8 -*-

import cv2

class MainDisplay:

    def __init__(self):

        self.result_image = None

    def readImage(self, image_path):

        image = cv2.imread(image_path)

        return image

    def setImage(self, image):

        self.result_image = image

        return self.result_image

    def saveImage(self):

        # display image. (window name, image to display)

        cv2.imshow(f"Displaying {self.result_image}", self.result_image)

        cv2.waitKey(0)

        cv2.destroyAllWindows()

</code></pre>