Skip to content

Latest commit

 

History

History
142 lines (102 loc) · 5.33 KB

README.md

File metadata and controls

142 lines (102 loc) · 5.33 KB
Raw

imgRCC Image Processing Library

Purpose of the Project

This project is a fun and educational venture designed to explore the interoperability of multiple programming languages—namely C++, CUDA, and Rust—and to understand how we can utilize the strengths of each language in a multi-module, cross-language setting. The aim is to build a high-performance image processing library with GPU acceleration using CUDA, organized modularly in C++, with high-level safe bindings in Rust. Eventually, the library will also offer bindings for Python and Go, making it versatile and usable across various programming ecosystems.

Through this project, I'm learning:

  • How to implement parallel algorithms using CUDA for GPU processing.
  • The process of writing C++ code for CPU-bound processing.
  • How to build Rust bindings for C++/CUDA code using FFI (Foreign Function Interface).
  • The modular design and project organization for a multi-language project.
  • Optimizing performance through parallelism and comparing CPU vs. GPU execution times.
  • How to extend the library to other languages like Python and Go.

Current Features

  • Image Loading and Saving:

    • Implemented image loading and saving using stb_image and stb_image_write headers, allowing support for multiple image formats (PNG, JPEG, BMP).

  • Grayscale Conversion:

    • Implemented both as a CPU-based function (in C++) and as a GPU-based function (in CUDA).
    • Usable via Rust bindings.

  • Benchmarking Tools:

    • Tools to compare the performance of CPU vs. GPU implementations, so users can evaluate the best option based on their use case.

Upcoming Features (Planned Functions)

  1. Image Convolution:

    • Implement a flexible convolution function to apply various filters (e.g., sharpening, blurring) to images.
    • Versions will be written in both C++ (CPU) and CUDA (GPU).

  2. Gaussian Blur:

    • A popular technique for smoothing images, implemented with both CPU and GPU versions.
    • This will demonstrate how algorithms can benefit from GPU acceleration on large images.

  3. Sobel Edge Detection:

    • Detect edges in an image using the Sobel operator.
    • Parallelized GPU version to significantly speed up this computation.

  4. Color Conversion (RGB to HSV/YCbCr):

    • Functions to convert images between color spaces, useful for more advanced image processing operations.

  5. Thresholding:

    • Binary thresholding of images to help with segmentation tasks.
    • Fast, parallelizable version using CUDA.

Features to Implement in Other Languages

  1. Python Bindings:

    • Provide easy-to-use bindings for Python using PyO3 or cffi, so the library can be used in Python-based applications.

  2. Go Bindings:

    • Implement Go bindings using cgo to expose the image processing library to the Go programming community.

Project Structure

The project is organized into several modules:

  • /include/: Contains C++ header files.
  • /src/cpp/ and /src/cuda/: Source files for C++ and CUDA code.
  • /src/: The Rust bindings that interface with C++/CUDA via FFI.
  • /tests/: Unit tests for C++ and Rust components.
  • /benchmarks/: Benchmarking code for comparing CPU vs. GPU performance.

Example Project Structure

/parallel_image_processing_lib/
├── include/                        # C++ headers
├── src/                            # Rust bindings
├──── cpp/                          # C++ source files
├──── cuda/                         # CUDA source files           
├── tests/                          # Unit tests
├── benchmarks/                     # Performance benchmarks
├── cmake/                          # CMake modules
├── build.rs                        # Rust build script
├── CMakeLists.txt                  # CMake build configuration
├── Cargo.toml                      # Rust project configuration
└── README.md                       # This file

How to Build and Use the Library

Building

  1. Clone the repository:

    https://github.com/ndranathunga/imgRCC.git
cd imgRCC

  2. Build the project using CMake for the C++/CUDA part:

    mkdir build
cd build
cmake ..
make

  3. Build the Rust bindings:

    cargo build

Usage (via Rust)

You can use the library within a Rust project by adding it as a dependency in your Cargo.toml:

[dependencies]
img_rcc = { path = "../path/to/imgRCC" }

Then, use it in your Rust code:

use img_rcc::grayscale_cpu;

fn main() {
    let image = load_image_("input.jpg"); // Function to load image (not yet implemented)
    let grayscale_image = grayscale_cpu(image);
    save_image_(grayscale_image, "output.jpg"); // Function to save image (not yet implemented)
}

Testing

The project includes unit tests for both C++ and Rust components. To run the Rust tests:

cargo test

For C++ tests, run the make test command after building the project using CMake.