🖼️ Image Processing in C++

A full implementation of core Digital Image Processing operations in C++, supporting grayscale conversion, image flipping, brightness & contrast adjustment, blur filtering, and 90-degree rotation — with no external dependencies.

📋 Table of Contents

Overview
Features
How It Works
Class Overview
Getting Started
Usage Examples
API Reference
Test Cases

Overview

This project implements a custom image processing library in pure C++ with no external dependencies. Images are represented internally as 3D matrices ([height][width][channel]) and are read from and written to the PPM (P3) format — a simple, human-readable pixel format.

It is commonly used as a foundation for understanding how image operations work at the pixel level, making it ideal for educational purposes, embedded systems, or any environment where library dependencies must be minimized.

✨ Features

✅ Grayscale Conversion — Converts RGB images using the standard luminance formula
✅ Horizontal Flip — Mirrors the image left to right
✅ Vertical Flip — Mirrors the image top to bottom
✅ Brightness Adjustment — Adds a fixed offset to all pixel values with clamping
✅ Contrast Adjustment — Scales pixel intensities around the midpoint (128)
✅ Blur Filter — Smooths the image using a 3×3 average kernel
✅ 90° Clockwise Rotation — Rotates the image with swapped dimensions
✅ PPM File I/O — Load and save images in the P3 PPM format
✅ No external libraries — Pure C++ with STL only
✅ Handles edge cases: border pixels in blur, clamping in brightness/contrast

🔧 How It Works

Each image is stored as a 3D vector<vector<vector<int>>> with dimensions [height][width][channels]. Operations are applied either point-wise (per pixel) or via convolution with a fixed kernel:

Original RGB Image (4×4)              3×3 Average Blur Kernel
┌──────────────────────────────┐      ┌───────────────────┐
│ (255,0,0)   (0,255,0)        │      │  1/9  1/9  1/9   │
│ (0,0,255)   (255,255,0)      │  *   │  1/9  1/9  1/9   │  →  Blurred Image
│ (255,0,255) (0,255,255)      │      │  1/9  1/9  1/9   │
│ (128,128,0) (0,0,0)          │      └───────────────────┘
└──────────────────────────────┘

Grayscale conversion applies the ITU-R BT.601 luminance formula per pixel:

gray = 0.299·R + 0.587·G + 0.114·B

Blur averages each pixel's 3×3 neighborhood. Border pixels are left unchanged since no padding is applied.

Contrast adjustment scales each pixel around the midpoint to expand or compress the intensity range:

newVal = factor × (pixel − 128) + 128   →   clamped to [0, 255]

🏗 Class Overview

`Image`

Member / Method	Type / Return	Description
`data[height][width][channel]`	`vector<...>`	Internal 3D pixel storage
`Image(int w, int h, int ch = 3)`	Constructor	Creates a blank image of given dimensions
`getWidth()` / `getHeight()` / `getChannels()`	`int`	Returns image dimensions and channel count
`operator()(int y, int x, int channel)`	`int&`	Pixel read/write access by row, column, and channel
`loadPPM(const string& filename)`	`bool`	Loads a P3 PPM file from disk
`savePPM(const string& filename)`	`bool`	Saves the image to a P3 PPM file on disk
`print()`	`void`	Prints pixel data to the console (for small images)

Free Functions

Function	Description
`convertToGrayscale(input)`	Converts a 3-channel image to a single-channel grayscale
`flipHorizontal(input)`	Mirrors the image along the vertical axis
`flipVertical(input)`	Mirrors the image along the horizontal axis
`adjustBrightness(input, value)`	Adds `value` to all pixel intensities, clamped to [0,255]
`adjustContrast(input, factor)`	Scales intensities around midpoint 128 by `factor`
`applyBlur(input)`	Applies a 3×3 uniform averaging filter
`rotate90(input)`	Rotates the image 90 degrees clockwise

🚀 Getting Started

Prerequisites

C++ compiler supporting C++11 or later (e.g. g++, MSVC, Clang)
No external libraries required — pure C++ STL only

Compilation

g++ -o image_processor main.cpp -std=c++11
./image_processor

Output Files

After running, the following PPM files will be generated in the working directory:

File	Description
`test_image.ppm`	The original 4×4 test input image
`gray_image.ppm`	Grayscale output
`flipped_horizontal.ppm`	Horizontally flipped output
`flipped_vertical.ppm`	Vertically flipped output
`bright_image.ppm`	Brightness-adjusted output (+50)
`contrast_image.ppm`	Contrast-adjusted output (×1.5)
`blurred_image.ppm`	Blurred output (3×3 average)
`rotated90_image.ppm`	90° clockwise rotated output

💡 Use an image viewer that supports PPM format, or convert to PNG/JPG using GIMP or ImageMagick:
convert output.ppm output.png

📖 Usage Examples

// Load an image
Image input;
input.loadPPM("test_image.ppm");

// Grayscale conversion
Image gray = convertToGrayscale(input);
gray.savePPM("gray_image.ppm");

// Flip operations
Image flippedH = flipHorizontal(input);
Image flippedV = flipVertical(input);
flippedH.savePPM("flipped_horizontal.ppm");
flippedV.savePPM("flipped_vertical.ppm");

// Brightness and contrast
Image bright   = adjustBrightness(input, 50);    // +50 to all channels
Image contrast = adjustContrast(input, 1.5f);    // 1.5x contrast boost
bright.savePPM("bright_image.ppm");
contrast.savePPM("contrast_image.ppm");

// Blur and rotation
Image blur    = applyBlur(input);
Image rotated = rotate90(input);
blur.savePPM("blurred_image.ppm");
rotated.savePPM("rotated90_image.ppm");

📚 API Reference

`Image convertToGrayscale(const Image& input)`

Converts each RGB pixel to a single intensity value using the ITU-R BT.601 luminance formula: gray = 0.299·R + 0.587·G + 0.114·B. Returns a new single-channel image.

Time Complexity: O(W × H)