Project

General

Profile

History

Coding » History » Revision 8

Revision 7 (Satya Sai Abhiram OGGU , 01/18/2024 01:52 PM) → Revision 8/10 (Ayato KOTSUGI , 01/18/2024 02:22 PM) 

 
 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 -*- 
 """ 
 @file 
 @brief This script performs image modification and processing based on configurations specified in the "config_left.ini" or "config_right.ini" file. 

 @details 
 The script utilizes the following classes: 
 - `MaskCreator`: Responsible for creating masks and applying image modifications. 
 - `ConfigReader`: Reads configuration settings from the specified configuration file ("config_left.ini" or "config_right.ini"). 
 - `MainDisplay`: Handles the main display functionalities. 

 @note 
 Make sure to change the configuration file path (`CReader = ConfigReader("config_left.ini")`) accordingly based on the image side. 

 @date January 18, 2024 
 """ 

 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: creates objects and variables necessary for the other 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. mainDisplay.py:    Displays the result 

 MaskCreator.py:  
 <pre><code class="python"> 
 #!/usr/bin/env python3 import cv2 
 #-*- coding: utf-8 -*- 
 #!/usr/bin/env python3 
 # -*- coding: utf-8 -*- 
 """ 
 @file 
 @brief This script defines the MainDisplay class, which handles reading, setting, and displaying images using the OpenCV library. 

 @date January 18, 2024 
 """ 

 import cv2 numpy as np 

 class MainDisplay: MaskCreator: 
     """ 
     @brief The MainDisplay MaskCreator class provides functionalities for performs image handling modification, including creating masks, gamma correction, alpha blending, and display. intensity modification. 

     @details 
     The class includes methods for: 
     - Reading an image from a Creating masks based on specified path. parameters. 
     - Setting Applying gamma correction to the result image. 
     - Displaying Performing alpha blending on the result image using based on the OpenCV library. 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): __init__(self, image): 
         """ 
         @brief Initializes a MainDisplay MaskCreator object. 

         @details 
         @param image: The result_image attribute is initialized to None. 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 readImage(self, image_path): create_mask(self, image_side, mask_width, image_width): 
         """ 
         @brief Reads an image from the Creates a mask based on specified path. parameters. 

         @param image_path: image_side: The path to side of the image file. 

         @return (0 for left, 1 for right). 
         @param mask_width: The read width of the mask. 
         @param image_width: The width of the input image. 
         """ 
         image self.__mask = cv2.imread(image_path) self.__image.shape[1] * mask_width // image_width 
         return image 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 setImage(self, image): gammaCorrection(self, gamma): 
         """ 
         @brief Sets Applies gamma correction to the result image. 

         @param image: 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 to set as based on the result image. image side. 

         @return @param image_side: The set result image. side of the image (0 for left, 1 for right). 
         """ 
         self.result_image if image_side == 1: 
             for col in range(self.__mask): 
                 alpha = image self.__alpha_gradient[-self.__mask + col] 
                 self.result_image[:, col] = alpha * self.__gamma_corrected[:, col] + (1 - alpha) * self.result_image[:, col] 
         return self.result_image 

     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 saveImage(self): mod_intensity(self, image_side): 
         """ 
         @brief Displays and saves Modifies image intensity based on the result image. image side. 

         @details 
         @param image_side: The result side of the image is displayed (0 for left, 1 for right). 
         """ 
         if image_side == 1: 
             for col in a window with the window name indicating the displayed image. 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) 
         The window remains open until a key is pressed. Then, it is closed, and 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 program continues. 

         @note result 

 <pre><code class="python"> 
 #!/usr/bin/env python3 
 #-*- coding: utf-8 -*- 

 import cv2 

 class MainDisplay: 

     def __init__(self): 
         Ensure that the OpenCV window is closed before proceeding with the execution of other code. 

         @warning self.result_image = None 

     def readImage(self, image_path): 
         This method uses blocking code (cv2.waitKey(0)) that might lead to issues in certain scenarios. 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>