Advanced Image Processing Suite: Efficient Architectures & Algorithms

Concept and Motivation

In the context of computer architecture, we set ourselves a demanding challenge: design and implement, from scratch, an extensible, high-efficiency image processing framework in C++. The goal was not just to solve algorithmic problems, but to create a professional-grade tool where architecture, optimization, automation, and validation go hand in hand.

Architecture and Design

We approached the system by identifying all functionalities shared by our two processing strategies: Array of Structures (AOS) and Structure of Arrays (SOA). Leveraging OOP, we encapsulated common behaviors in a shared Image class and developed specialized modules for binary I/O, RGB struct layouts, and bitwise manipulation.

The software design prioritized modularity and clarity:

  • Functions branch early based on input/output format, separating responsibilities into identifiable code blocks.
  • Each function anticipates all possible use cases, creating a robust base for further extension.

Performance and Optimization

Delivering an efficient solution required not just algorithmic correctness, but deep optimization—at the code, compilation, and architectural level:

  • Advanced Compilation Flags:
    We leveraged -march=native, -mtune=native, -O3, -funroll-loops, -ffast-math, and -fstrict-aliasing to exploit hardware-specific instructions, maximize CPU pipeline efficiency, and minimize execution time.
  • Algorithmic Complexity:
    Every major function—maxlevel, resize, cutfreq, compress—was carefully analyzed and tuned for optimal asymptotic complexity and real-world performance.
  • Data Structure Choices:
    We utilized both native arrays and modern containers (unordered_map as a high-performance hash map) to balance memory use and speed, prioritizing time-to-solution for large images.

Highlighted Algorithms

  • Maxlevel:
    Direct pixel-by-pixel operations without memory overhead, optimized for images of any size.

  • Resize:
    Dynamic memory allocation and datatype optimization for color channels, adapting to input format (3 or 6 bytes per pixel) to reduce memory footprint.

  • Cutfreq:
    A two-phase approach—first, statistical analysis and selection of colors to eliminate; second, efficient substitution by proximity in the RGB color space, innovatively using graph-based subspace partitioning to dramatically cut search time.

  • Compress:
    Double-pass image scan and use of hash maps for efficient color cataloging, sacrificing some memory for a significant speedup—a conscious engineering trade-off justified by benchmarks.

Automation, Validation, and Testing

Professional engineering is not just about coding—it’s about reliability.

  • Unit Testing:
    Comprehensive test suites for every core function, validating both success and failure cases.
  • Functional Testing:
    Automated scripts in Python for cross-comparison against reference images, supporting reproducible and robust validation.
  • Performance & Energy Benchmarking:
    Systematic evaluation on both local machines and HPC nodes (e.g., Avignon cluster), measuring execution time, instruction throughput, branch prediction accuracy, and energy consumption.

Collaboration & Project Management

  • Version Control:
    All development coordinated through GitHub, enforcing clean commits and traceable task division.
  • Role Assignment:
    Task breakdown by functionality and testing, with clear tracking of effort and individual contributions.
  • Iterative Problem Solving:
    The team adapted quickly to incomplete or inconsistent external references, proactively communicating with course coordinators and iteratively refining the solution.

Results and Insights

  • Performance:
    Both AOS and SOA achieved near-identical instruction-per-cycle rates and extremely low branch misprediction rates. Notably, AOS showed a temporal edge in certain resize scenarios, while SOA was slightly more energy-efficient in maxlevel operations.
  • Scalability:
    The system remained robust even as image sizes and complexity grew, with clear evidence that our data structure choices delivered real performance gains where it mattered.
  • Real-World Engineering:
    Dealing with ambiguous specifications and shifting test data mirrored real software engineering environments—requiring communication, flexibility, and persistent troubleshooting.

Professional Skills Developed

  • Advanced C++ Development:
    OOP, low-level memory management, bitwise operations, and performance profiling.
  • Automated Testing & Benchmarking:
    Python-based automation for functional and regression testing.
  • Collaborative Project Management:
    Distributed team coordination, effective task division, and rigorous version control.
  • Analytical Rigor:
    Interpreting complex performance data and making trade-offs between memory use, speed, and maintainability.

Reflections

This project was both technically and logistically demanding. Beyond the technical stack, it sharpened my ability to operate as part of a high-performing team under ambiguous requirements and tight deadlines. The resulting tool is not just a solution to a coursework challenge, but a showcase of real software engineering best practices—from concept, to optimization, to delivery.

If you’re interested in the codebase, benchmarks, or would like to discuss high-performance systems engineering, feel free to get in touch.