PBL Group 21

Loading...
Searching...
No Matches
Public Member Functions | List of all members
main_alpha_blender.MainAlphaBlender Class Reference
Inheritance diagram for main_alpha_blender.MainAlphaBlender:

## Public Member Functions
| __init__ (self)
| run (self)

## Detailed Description

    @brief Main controller class for executing the gamma-corrected alpha-blending pipeline.
    @details
    This class performs an end-to-end pipeline:
      - Reads configuration values (input image path, blending side, physical setup, gamma).
      - Loads a PNG image (ensuring BGRA so alpha can be modified safely).
      - Computes the overlap width in pixels based on the physical projector setup.
      - Builds an alpha mask curve (linear ramp) for the overlap region.
      - Applies gamma correction to the mask curve.
      - Multiplies the image alpha channel by the mask in the overlap region.
      - Saves a new PNG with adjusted transparency.

## Constructor & Destructor Documentation

## ◆ __init__()

main_alpha_blender.MainAlphaBlender.__init__ | ( |  | self | ) |

    @brief Constructor for MainAlphaBlender.
    @details
    Initializes a ConfigReader instance to retrieve blending parameters.
    The config reader is expected to provide:
      - input image filename
      - which side of the overlap this projector corresponds to ("left" or "right")
      - physical projected image width
      - physical distance between two projectors
      - gamma value used for correction
    @see config_reader.py

## Member Function Documentation

## ◆ run()

main_alpha_blender.MainAlphaBlender.run | ( |  | self | ) |

    @brief Executes the full alpha blending process (gamma corrected).
    @details
    steps:
    1) Load configuration parameters:
       - image_name: input image file (ideally PNG with alpha)
       - side: "left" or "right" indicating which projector image this is
       - proj_width_phys: physical width of one projected image
       - dist_phys: physical distance between projector centers (or image origins depending on setup)
       - gamma: projector gamma value (> 0)

    2) Load image using OpenCV:
       - cv2.IMREAD_UNCHANGED preserves alpha if present.
       - If the image is BGR (3 channels), it is converted to BGRA (4 channels)
         so we can write an alpha mask safely.

    3) Compute overlap ratio and overlap width (pixels):
       - overlap_ratio = 1 - (dist_phys / proj_width_phys)
         Example:
           dist_phys == proj_width_phys  -> overlap_ratio = 0 (no overlap)
           dist_phys <  proj_width_phys  -> overlap_ratio > 0 (overlap exists)
       - overlap_pixels = int(width * overlap_ratio)

    4) Generate a base linear ramp across the overlap region:
       - linear_ramp is always 0 → 1 across overlap_pixels.
       - For the left image: fade out (1 → 0) in the overlap.
       - For the right image: fade in  (0 → 1) in the overlap.

    5) Gamma correction:
       - Projector brightness response is non-linear.
       - We compensate by applying:
           mask_curve = base_curve^(1/gamma)
       - This helps produce a visually smoother blend once projected.

    6) Apply the mask to the alpha channel:
       - Convert alpha to float in [0, 1].
       - Expand mask_curve vertically to match image height.
       - Multiply only the overlap region of alpha.

    7) Save output image:
       - Writes output_left.png or output_right.png depending on side.

    Error / early-exit conditions:
    - If the input image cannot be loaded, the process stops.
    - If overlap_ratio <= 0, there is no overlap (or invalid physical config), so it stops.
    - If side is not "left" or "right", it stops.

    @return This returns None.
    @see config_reader.py

The documentation for this class was generated from the following file:

- /Users/kaungzinthu/Desktop/projectpbl2/main_alpha_blender.py