G12-2025-Final Project

h1. 💡 About Project

---

h2. I. Project Overview

Our project focuses on developing a high-quality image composition system capable of seamlessly merging two or more projected images into a single, visually uniform display. The goal is to ensure that the combined image appears continuous and free from visible seams, color shifts, or brightness inconsistencies.

Built using Python and OpenCV, the system applies a series of advanced image-processing techniques including gamma correction, alpha blending, and intensity adjustment to harmonize overlapping areas. These methods allow us to dynamically compensate for lighting variations and surface irregularities, resulting in a more accurate and visually pleasing projection output.

The project team is divided into multiple sub-groups, each focusing on specific responsibilities such as software development, UML design, testing, and wiki management. This structure encourages effective collaboration, clear communication, and consistent progress across all development phases.

To maintain transparency and ensure reproducibility, we integrate Doxygen for detailed source-code documentation and Redmine for structured task tracking and project coordination. Together, these tools support a development environment that prioritizes scalability, maintainability, and long-term usability.

Ultimately, the project aims to deliver a robust framework for real-time image correction and blending, serving as a foundation for future extensions in projection mapping, interactive displays, and multi-screen visualization systems.

---

h2. II. Motivation & Problem Statement

When using multiple projectors to display a single image, visible seams or brightness inconsistencies often occur in overlapping regions. These inconsistencies degrade image quality and make the final projection appear uneven.  

Manual calibration methods are time-consuming and prone to human error.  

Our motivation is to develop a software-based approach that automates the alignment and blending process, ensuring seamless image projection.  

By leveraging the **OpenCV** library, the system can detect overlapping areas, apply brightness corrections, and blend images smoothly — eliminating the need for costly hardware-based calibration systems.

---

h2. III. Objectives

* To develop an automated image blending system capable of merging two or more projections into a single seamless image.  

* To apply *gamma correction* and *intensity modification* techniques to balance color and brightness across overlapping regions.  

* To implement *alpha blending* for smooth transitions between images.  

* To design and visualize the system architecture using **UML diagrams**.  

* To document the entire project using **Doxygen** and manage tasks via **Redmine**.

---

h2. IV. Key Features

*1. Automated Image Blending*

Uses OpenCV and user-defined parameters to automatically blend two projected images, ensuring accurate overlap and alignment.

*2. Gamma Correction and Intensity Adjustment*

Employs advanced color and brightness correction algorithms to maintain consistent luminance across blended areas, effectively removing visible seams and mismatches.

*3. Video Blending*

Leverages GPU acceleration through PyTorch to calculate per-pixel brightness for video streams, enabling real-time blending and correction.

*4. User-Friendly Graphical Interface*

Provides an intuitive GUI that allows users to select interpolation modes, specify overlap pixels, and control blending parameters easily.

*5. Modular System Architecture*

Designed using UML-based class structures that divide the project into smaller, manageable components, improving scalability and ease of feature expansion.

*6. Comprehensive Documentation and Project Management*

Integrates Doxygen for automated code documentation and Redmine for task tracking, ensuring transparent collaboration and efficient workflow management.

---

h2. V. Algorithm and Theoretical Framework

h3. Technologies to be used

We plan to use a single projection surface illuminated by two projectors, each connected to separate computers. Both projectors will display synchronized images or videos, which are combined into a single, seamless projection.

To accomplish this, we will apply the following theoratical technologies:

* *Linear and Quadratic Mixing*  

* *Gamma Correction*  

* *Alpha Blending*  

* *Intensity Adjustment for Edge Blending*  

* *Video Frame Synchronization*  

---

h3. Linear and Quadratic Mixing

This project introduces two blending functions, that are linear and quadratic. These are used to control brightness and transition smoothness between overlapping projection zones.

*+Linear Mixing+*

Linear mixing provides a constant-rate interpolation between two projected frames:  

                                                    p=. *@I(blended) = (1 - α) × I₁ + α × I₂@*  

This method creates a direct and proportionate blend, suitable for small overlaps and real-time applications with limited motion.

*+Quadratic Mixing+*

Quadratic mixing introduces a *non-linear weight curve* that reduces edge artifacts by applying a quadratic power to alpha:  

                                                    p=. *@I(blended) = (1 − α²) × I₁ + (α²) × I₂@*

This gives more emphasis to the central region and smoother gradients at the edges, producing results visually similar to gamma-based perceptual blending.

---

h2. Gamma Correction Method

Gamma correction modifies each pixel’s luminance through a non-linear power-law transformatio* to align brightness with human perception: 

                                                    p=. *@Iₒ = 255 × (Iₗ / 255)¹ᐟᵞ@*

* *γ > 1 → darkens the image*  

* *γ < 1 → brightens the image*  

In this project, gamma correction ensures the luminance from both projectors matches across the surface, preventing brightness mismatches when mixing video frames.

p=. !{width:600px}gamm_correction.png!

---

h2. Alpha Blending

Alpha blending merges two visual layers based on a defined transparency coefficient (alpha).  

p=. !alpha_blend_equation.png ! 

By controlling alpha spatially, we can fade one projection into another projection.

In our system:

* Dynamic alpha masks are generated based on projector overlap geometry  

* Linear and quadratic variations of alpha allow adaptive blending for different edge behaviors  

p=. !Alpha_compositing..png!

*Diagram to show α blending*

---

h2. Intensity Modification

To achieve seamless edge blending, intensity modification is applied using positional control and mixing curves.

* If projector_side = 1 → intensity decreases toward the left edge  

* If projector_side = 0 → intensity decreases toward the right edge  

* Quadratic falloff is used at boundary regions to mimic human perceptual smoothness  

The blending intensity is dynamically modulated using:  

p=. !intensity_equation.png ! 

where *f(x)* follows a linear or quadratic curve depending on the region and overlap type.

p=. !{width:500px}edge_intensity.png!

Shows the intensity modification being applied

---

h2. Video Support and Frame Synchronization

Unlike static blending, our system supports *real-time video* by:

* Reading synchronized frames from two video sources using OpenCV  

* Applying blending and gamma correction on each frame in real time  

* Displaying processed frames via a graphical interface  

---

h2. VI. System Architecture

!http://www.dh.is.ritsumei.ac.jp/redmine/attachments/download/1859/Class_Diagram.png!

h3. The system is split into four classes: ConfigReader for configuration, VideoProcessing for video input and frames, ProjectionSplit for splitting and blending images, and ImageDisplayApp as the Tk GUI that coordinates everything.

Here are the descriptions of each class:

*ConfigReader*

Reads/writes config.ini and holds parameters such as file paths, overlap, and blend mode, which provides simple getters  so other classes can use the settings without editing code, and keeps configuration separate from code for easy reuse.

*VideoProcessing*

Opens a video and reads frames with cv2.VideoCapture, when the stream ends it returns None and releases resources, keeping all video I/O inside this class so the GUI and processing stay clean.

*ProjectionSplit*

Performs the core image operations by splitting into main/left/right with the chosen overlap and blend, while accepting still images or video frames and returning NumPy arrays using settings from ConfigReader.

*ImageDisplayApp*

Tk GUI manages ProjectionSplit and VideoProcessing class, lets users set overlap, blend, runs processing, and displays results (including fullscreen) while updating on screen labels.

---

h2. VII. Requirement Analysis

This defines the functional requirement of the project and outlining what the system needs to accomplish 

*- Image Input and Processing*

-The system must accept image files and video files as input.

-The system must split a given image into two sub-images (left and right) with a specific overlap region

-The system must allow users to choose a one out of the three blending mode (linear, quadratic, or gaussian).

-The system must apply blending algorithms using OpenCV and PyTorch for GPU-accelerated computation for videos.

-The system must save the blended images (left.png, right.png) locally after processing.

*- Graphical User Interface (GUI)*

-The system must let the user select the overlap pixel value from the GUI.

-The system must let the user choose the blending algorithm from the GUI.

-The system must be able to run both image and video blending modes in the GUI.

-The system must let the user view the original, left, and right images in real-time in the GUI.

-The system must be able display the blended outputs in fullscreen mode from the GUI.

*- Error Handling and Feedback*

-The system must handle missing files and display warnings or error messages appropriately.

-The GUI must handle invalid user input without crashing the program.

---

h2. VIII. Technology Stack

h3. Python (OpenCV, NumPy)

*Python* is our primary programming language, chosen for its flexibility and extensive scientific computing libraries. *OpenCV* provides core image processing functions including filtering, color correction, and gamma adjustment. *NumPy* enhances performance through optimized numerical and matrix operations, enabling efficient multi-image blending, brightness calibration, and automated adjustments.

h3. Doxygen

*Doxygen* generates comprehensive documentation directly from our codebase, ensuring all functions, variables, and logic are clearly defined and cross-referenced. This maintains code transparency, consistency, and ease of maintenance for future developers.

h3. Redmine

*Redmine* serves as our project management hub, facilitating task tracking, deadline management, and team communication. Through Wiki pages, ticket tracking, and Gantt charts, it ensures alignment on goals, progress, and deliverables while integrating version control for seamless collaboration.

h3. Astah

*Astah* enables creation of UML diagrams—class, use case, and sequence diagrams—that visualize system architecture, component interactions, and data flow. This bridges conceptual design and implementation, making complex systems easier to understand and develop.

These tools form a *complete ecosystem* supporting every development phase—from planning and implementation to documentation and project management. This integrated stack enables our team to build a robust, well-documented, and scalable real-time image composition system.

---

h2. IX. Application & Impact

Our *image composition and blending system* enables diverse real-world applications by automating multi-projector alignment, delivering a *low-cost, scalable* alternative to expensive hardware solutions for creating seamless large-scale displays.

h3. Art & Exhibition Spaces

Perfect for *art galleries, museums, and exhibitions*, our system projects continuous, high-quality images across multiple surfaces for immersive installations. Artists and curators can use *affordable projectors* to achieve professionally blended visuals with minimal setup, replacing costly hardware and manual calibration.

h3. Education & Learning Environments

The system enables teachers to create *wide-format, high-resolution educational displays* using multiple projectors, enhancing *student engagement* through better visualization of 3D models, scientific simulations, and large datasets—all cost-effectively.

h3. Business, Simulation & Public Use

Applications extend to *business presentations, public events, gaming, and simulation systems*. Integration possibilities include *VR/AR setups*, projection mapping, and multi-screen environments, making professional-grade displays accessible to small organizations and community centers.

h3. Broader Impact

This project demonstrates how *computer vision, automation, and open-source tools* democratize professional visual experiences. It bridges creativity with affordability, enabling immersive large-scale projections through *smart algorithms* rather than expensive equipment.

> *"Innovation isn't always about new hardware — sometimes it's about making what we already have work smarter."*

---

h2. X. Limitation & Future Enhancements

While our image blending system achieves reliable and high-quality results, it still faces several *technical and practical limitations* that can be improved in future versions. Recognizing these challenges helps guide further development toward a more precise and efficient solution.

h3. Current Limitations

One key limitation lies in the *precision of projector calibration*.  

For accurate image blending, each projector must be positioned carefully with minimal angular error. Even slight misalignment or lens distortion can lead to *visible seams or overlapping inconsistencies* in the final projection.  

Lighting conditions also affect performance — excessive brightness, uneven wall surfaces, or reflective backgrounds may reduce blending accuracy. Additionally, our current system assumes a *fixed projection setup*; movement or vibration of the projector requires recalibration, which limits flexibility in dynamic environments.

Another limitation is *processing performance*. While Python and OpenCV provide excellent tools for image manipulation, real-time blending on larger resolutions may require higher computational power or GPU acceleration for smoother performance.

h3. Future Enhancements

In future iterations, we aim to develop an *automatic projector calibration system* using camera feedback or sensor-based alignment.  

By detecting geometric distortions automatically, the system could self-correct in real time, reducing the need for manual setup.  

We also plan to optimize the blending algorithm through *parallel processing and GPU acceleration*, enabling faster computation for high-resolution displays.  

Integrating a *user-friendly interface* will further simplify configuration, making the system accessible even to non-technical users.

Finally, expanding compatibility with *different projection hardware and AR/VR systems* could open new possibilities for interactive and immersive visual environments.

> *“Perfection is not the absence of flaws, but the pursuit of improvement.”*  

> — *G12-2025 Team*

---

!https://media.tenor.com/Q14Y3rSxX5wAAAAM/plan-roadmap.gif!