COP3504C Lab 06 Image Scaling Tutorial: C++ Pixel Manipulation Guide

Introduction: Why Image Scaling Matters in 2026

In the age of AI-generated visuals and real-time video processing, image scaling is a fundamental skill every C++ programmer needs. Whether you're building a photo editor app, a game engine, or a machine learning pipeline, understanding how to resize images at the pixel level gives you control over performance and quality. This tutorial walks you through the COP3504C Lab 06 assignment on image scaling, focusing on the Image class and the scaledImage function. We'll use a trend-inspired example: imagine you're developing a feature for a viral social media app that lets users upscale their profile pictures by 4x. The same principles apply!

Understanding the Assignment Structure

The lab requires you to build a program with a classless main() function and an Image class. The main function handles user interaction, while the Image class encapsulates the image data. You'll also write a standalone function scaledImage that performs the actual scaling. Let's break down each component.

The Image Class: Your Data Container

The Image class should have a single constructor that takes an unsigned char* pointer to raw image data. This data includes header information (width and height) followed by pixel data. The class must provide methods to get the raw data, pixel data, width, height, and to set new image data. No default constructor is allowed—this enforces that every Image object is initialized with valid data.

Think of it like a gaming leaderboard: each player (image) has a unique ID (pointer) and stats (width, height). You can't create a player without their stats!

The scaledImage Function: Core Logic

The scaledImage function takes the raw image data and an orders integer (range -4 to 4). Positive values enlarge, negative shrink. Scaling is by powers of two: orders=1 doubles size, orders=-1 halves it. The function must allocate memory for the new image and return it. Important constraints:

Never scale width or height above 256 or below 1.
For reduction, use most common color in each block. Tie-break by earliest pixel (row-major order).
Do not use recursive or iterative doubling—allocate the final size once.

This is like AI image upscaling where you need to generate new pixels without blowing up memory. Efficient allocation is key!

Step-by-Step Implementation

Step 1: Parsing the Image Header

The raw image data starts with two bytes: width and height. For example, if the first byte is 14 and the second is 6, the image is 14x6 pixels. After that, each byte represents a pixel (likely grayscale or indexed color). In your constructor, extract these values:

Image::Image(unsigned char *imageData) {
    width = imageData[0];
    height = imageData[1];
    // Store pointer or copy data?
    // The spec says getImageData returns the pointer, not a copy.
    // So we can just store the pointer.
    this->data = imageData;
}

But careful: the caller allocates the data, and you must not delete it unless you're replacing it. The setImageData method should handle deallocation of old data if needed.

Step 2: Implementing getWidth and getHeight

Simple accessors:

unsigned char Image::getWidth() { return width; }
unsigned char Image::getHeight() { return height; }

Step 3: The scaledImage Function

This is the heart of the lab. Let's implement it step by step.

Enlarging an Image

When orders > 0, you scale up by a factor of 2^orders. For each original pixel, you create a block of size factor x factor in the new image, all with the same color. For example, if original is 2x2 and factor=2, new is 4x4. Allocate new array: new width = min(original width * factor, 256), new height = min(original height * factor, 256). Then loop through original pixels and fill blocks.

Shrinking an Image

When orders < 0, you scale down by a factor of 2^(-orders). For each block of size factor x factor in the original, you produce one pixel in the new image. The color is the most common color in that block. To find the most common, you can use a frequency array (since pixel values are likely 0-255). If there's a tie, pick the pixel that appears first in row-major order within the block.

Example: For a 2x2 block with colors [0, 0, 1, 1], both 0 and 1 appear twice. The earliest pixel (top-left) is 0, so output 0.

Here's a skeleton:

unsigned char* scaledImage(unsigned char *imageData, int orders) {
    unsigned char oldW = imageData[0];
    unsigned char oldH = imageData[1];
    int factor = 1 << abs(orders); // 2^|orders|
    unsigned char newW, newH;
    if (orders > 0) {
        newW = min(oldW * factor, 256);
        newH = min(oldH * factor, 256);
    } else {
        newW = max(oldW / factor, 1);
        newH = max(oldH / factor, 1);
    }
    unsigned char* newData = new unsigned char[2 + newW * newH];
    newData[0] = newW;
    newData[1] = newH;
    // Fill pixel data...
    return newData;
}

Step 4: Memory Management

Always remember: the caller of scaledImage must delete the returned array. In main(), when you load a file, you get a pointer that must be deleted after use. Similarly, when you enlarge/shrink, you get new data and must delete the old. The Image class's setImageData should delete the old data before storing the new one.

Testing and Debugging Tips

Use the provided test image (rainbow) to verify your scaling. The menu options let you load, display properties, and scale. Check that dimensions are correct and that the image displays without artifacts. For reduction, manually compute a small block to ensure your tie-breaking logic works.

Consider this real-world scenario: you're building a thumbnail generator for a video streaming platform like Netflix. You need to downscale 4K frames to 256x256 thumbnails. Your algorithm must be fast and accurate—just like your lab!

Common Pitfalls

Off-by-one errors: Remember that width and height are stored as bytes (0-255). If width is 256, it wraps to 0? Actually, the spec says width/height are unsigned char (0-255), but images are limited to 256. So width=256 is represented as 0? Probably not; the lab likely uses values <256. But be careful.
Memory leaks: Always pair new[] with delete[]. Use valgrind or similar tools.
Inefficient scaling: Don't call scaledImage repeatedly; allocate once.

Connecting to Trends: AI and Gaming

In 2026, image scaling is more relevant than ever. AI models like Stable Diffusion generate images at low resolutions and then upscale them. Game engines use mipmapping to downscale textures for performance. Your lab teaches the foundational math behind these technologies. By mastering pixel-level operations, you're building skills for advanced graphics programming and computer vision.

Conclusion

This lab is a rite of passage for C++ programmers. You'll learn memory management, pointer arithmetic, and algorithm design—all essential for systems programming. Follow the steps, test thoroughly, and you'll have a working image scaler. Good luck!