G21-2023

Coding » History » Revision 6

Revision 5 (Satya Sai Abhiram OGGU , 01/18/2024 01:48 PM) → Revision 6/10 (Satya Sai Abhiram OGGU , 01/18/2024 01:48 PM)

 
 h1=. <pre> 
 Coding</pre> 

 --- 

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

 --- 

 
 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>