Image Resizer and Thumbnail Generator (cpp, written by Claude Code)

Claude Code wrote this cpp project from the task below. It does not run on a clean Ubuntu 22.04 machine as written.

Task given to the agent:

TASK: Image Resizer and Thumbnail Generator

Write a program that resizes images and generates thumbnails at multiple configurable sizes, supporting different resampling algorithms, crop modes, and batch processing of entire directories.

FUNCTIONAL REQUIREMENTS:
- Accept an image file path as a command-line argument
- Resize to exact dimensions via --size flag (WxH format, e.g., --size 1920x1080)
- Resize by percentage via --scale flag (e.g., --scale 50 for 50% of original size)
- Support multiple resampling algorithms selectable via --algorithm flag: nearest neighbor, bilinear, bicubic, and Lanczos
- Support three resize modes via --mode flag: fit (scale within bounds preserving aspect ratio), fill (scale to cover bounds then center-crop), and stretch (distort to exact dimensions)
- Generate a set of standard thumbnails via --thumbnails flag: small (150x150), medium (300x300), large (600x600), all center-cropped squares
- Support custom thumbnail sizes via --thumb-sizes flag (comma-separated, e.g., --thumb-sizes 64x64,128x128,256x256)
- Add optional padding/border around resized images via --padding flag (pixels) and --border-color flag (hex color)
- Support batch processing of all images in a directory via --batch flag, with --recursive to include subdirectories
- Print processing details to console: original dimensions, new dimensions, algorithm used, output file path, processing time per image
- Save resized images to a directory specified by --output flag (default: resized/ subdirectory)
- If no input is given, generate a sample 2000x1500 test image with fine details (grid lines, text at various sizes, gradient bands), then resize it using each algorithm and each mode to demonstrate the visual differences
- Handle errors: invalid dimensions, unsupported image formats, memory limits for very large images

Create a complete C++ project for a clean Ubuntu 22.04 machine with only G++ 12+ and CMake 3.22+ installed. Include:
- Source code
- CMakeLists.txt with all dependencies (direct and transitive) pinned to exact versions
- README.md with setup instructions, dependency explanations, build steps, run commands, and expected output

[]

cmake_minimum_required(VERSION 3.16)
project(ImageResizer VERSION 1.0.0 LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

# Find OpenCV 4.9.0
find_package(OpenCV 4.9.0 REQUIRED COMPONENTS core imgproc imgcodecs)

add_executable(image_resizer main.cpp)

target_link_libraries(image_resizer PRIVATE ${OpenCV_LIBS})
target_include_directories(image_resizer PRIVATE ${OpenCV_INCLUDE_DIRS})

# Print OpenCV version for verification
message(STATUS "OpenCV version: ${OpenCV_VERSION}")
message(STATUS "OpenCV libraries: ${OpenCV_LIBS}")

/**
 * Image Resizer and Thumbnail Generator
 *
 * Resizes images using multiple algorithms (bilinear, bicubic, Lanczos),
 * supports crop modes, and batch processing of directories.
 *
 * Dependencies: OpenCV 4.9.0
 */

#include <opencv2/opencv.hpp>
#include <opencv2/imgproc.hpp>
#include <opencv2/imgcodecs.hpp>

#include <iostream>
#include <string>
#include <vector>
#include <filesystem>
#include <algorithm>
#include <map>
#include <cmath>

namespace fs = std::filesystem;

// Supported image extensions
static const std::vector<std::string> SUPPORTED_EXTENSIONS = {
    ".jpg", ".jpeg", ".png", ".bmp", ".tiff", ".tif", ".webp"
};

// Algorithm name to OpenCV interpolation flag mapping
static const std::map<std::string, int> ALGORITHMS = {
    {"nearest",  cv::INTER_NEAREST},
    {"bilinear", cv::INTER_LINEAR},
    {"bicubic",  cv::INTER_CUBIC},
    {"lanczos",  cv::INTER_LANCZOS4},
};

enum class CropMode {
    NONE,
    CENTER,
    TOP_LEFT,
    TOP_RIGHT,
    BOTTOM_LEFT,
    BOTTOM_RIGHT,
    SMART
};

static const std::map<std::string, CropMode> CROP_MODES = {
    {"none",         CropMode::NONE},
    {"center",       CropMode::CENTER},
    {"top-left",     CropMode::TOP_LEFT},
    {"top-right",    CropMode::TOP_RIGHT},
    {"bottom-left",  CropMode::BOTTOM_LEFT},
    {"bottom-right", CropMode::BOTTOM_RIGHT},
    {"smart",        CropMode::SMART},
};

struct ResizeResult {
    std::string inputPath;
    std::string outputPath;
    int origWidth;
    int origHeight;
    int newWidth;
    int newHeight;
    uintmax_t originalSize;
    uintmax_t newSize;
    std::string algorithm;
};

/**
 * Check if a file extension is a supported image format.
 */
bool isSupportedImage(const fs::path& filePath) {
    std::string ext = filePath.extension().string();
    std::transform(ext.begin(), ext.end(), ext.begin(), ::tolower);
    for (const auto& supported : SUPPORTED_EXTENSIONS) {
        if (ext == supported) return true;
    }
    return false;
}

/**
 * Get all supported images from a directory.
 */
std::vector<fs::path> getSupportedImages(const std::string& directory) {
    std::vector<fs::path> images;
    for (const auto& entry : fs::directory_iterator(directory)) {
        if (entry.is_regular_file() && isSupportedImage(entry.path())) {
            images.push_back(entry.path());
        }
    }
    std::sort(images.begin(), images.end());
    return images;
}

/**
 * Calculate crop region based on crop mode.
 */
cv::Rect calculateCropBox(int imgWidth, int imgHeight,
                           int targetWidth, int targetHeight,
                           CropMode mode) {
    int left = 0, top = 0;

    switch (mode) {
        case CropMode::CENTER:
            left = (imgWidth - targetWidth) / 2;
            top = (imgHeight - targetHeight) / 2;
            break;
        case CropMode::TOP_LEFT:
            left = 0;
            top = 0;
            break;
        case CropMode::TOP_RIGHT:
            left = imgWidth - targetWidth;
            top = 0;
            break;
        case CropMode::BOTTOM_LEFT:
            left = 0;
            top = imgHeight - targetHeight;
            break;
        case CropMode::BOTTOM_RIGHT:
            left = imgWidth - targetWidth;
            top = imgHeight - targetHeight;
            break;
        case CropMode::SMART:
            left = (imgWidth - targetWidth) / 2;
            top = std::max(0, (imgHeight - targetHeight) / 3);
            break;
        default:
            left = (imgWidth - targetWidth) / 2;
            top = (imgHeight - targetHeight) / 2;
    }

    left = std::max(0, left);
    top = std::max(0, top);

    return cv::Rect(left, top, targetWidth, targetHeight);
}

/**
 * Format file size in human-readable form.
 */
std::string formatSize(uintmax_t bytes) {
    const char* units[] = {"B", "KB", "MB", "GB"};
    double size = static_cast<double>(bytes);
    int unitIndex = 0;
    while (size >= 1024.0 && unitIndex < 3) {
        size /= 1024.0;
        unitIndex++;
    }
    char buf[64];
    std::snprintf(buf, sizeof(buf), "%.1f %s", size, units[unitIndex]);
    return std::string(buf);
}

/**
 * Resize a single image.
 */
ResizeResult resizeImage(const std::string& inputPath, const std::string& outputPath,
                          int targetWidth, int targetHeight,
                          const std::string& algorithm = "lanczos",
                          CropMode cropMode = CropMode::NONE,
                          bool maintainAspect = true,
                          int quality = 90) {
    auto it = ALGORITHMS.find(algorithm);
    if (it == ALGORITHMS.end()) {
        throw std::runtime_error("Unsupported algorithm: " + algorithm);
    }
    int interpolation = it->second;

    cv::Mat img = cv::imread(inputPath, cv::IMREAD_UNCHANGED);
    if (img.empty()) {
        throw std::runtime_error("Could not read image: " + inputPath);
    }

    uintmax_t originalSize = fs::file_size(inputPath);
    int origWidth = img.cols;
    int origHeight = img.rows;

    cv::Mat result;

    if (cropMode != CropMode::NONE) {
        // Resize to cover the target area, then crop
        double scaleW = static_cast<double>(targetWidth) / origWidth;
        double scaleH = static_cast<double>(targetHeight) / origHeight;
        double scale = std::max(scaleW, scaleH);

        int interimW = std::max(targetWidth, static_cast<int>(origWidth * scale));
        int interimH = std::max(targetHeight, static_cast<int>(origHeight * scale));

        cv::Mat resized;
        cv::resize(img, resized, cv::Size(interimW, interimH), 0, 0, interpolation);

        cv::Rect cropBox = calculateCropBox(resized.cols, resized.rows,
                                             targetWidth, targetHeight, cropMode);
        result = resized(cropBox).clone();
    } else if (maintainAspect) {
        // Fit within target dimensions while maintaining aspect ratio
        double scaleW = static_cast<double>(targetWidth) / origWidth;
        double scaleH = static_cast<double>(targetHeight) / origHeight;
        double scale = std::min(scaleW, scaleH);

        int newW = static_cast<int>(origWidth * scale);
        int newH = static_cast<int>(origHeight * scale);

        cv::resize(img, result, cv::Size(newW, newH), 0, 0, interpolation);
    } else {
        // Stretch to exact dimensions
        cv::resize(img, result, cv::Size(targetWidth, targetHeight), 0, 0, interpolation);
    }

    // Ensure output directory exists
    fs::path outPath(outputPath);
    if (outPath.has_parent_path()) {
        fs::create_directories(outPath.parent_path());
    }

    // Set compression parameters
    std::vector<int> params;
    std::string ext = outPath.extension().string();
    std::transform(ext.begin(), ext.end(), ext.begin(), ::tolower);

    if (ext == ".jpg" || ext == ".jpeg") {
        params = {cv::IMWRITE_JPEG_QUALITY, quality};
    } else if (ext == ".png") {
        params = {cv::IMWRITE_PNG_COMPRESSION, 6};
    } else if (ext == ".webp") {
        params = {cv::IMWRITE_WEBP_QUALITY, quality};
    }

    if (!cv::imwrite(outputPath, result, params)) {
        throw std::runtime_error("Failed to write image: " + outputPath);
    }

    uintmax_t newSize = fs::file_size(outputPath);

    return ResizeResult{
        inputPath, outputPath,
        origWidth, origHeight,
        result.cols, result.rows,
        originalSize, newSize,
        algorithm
    };
}

/**
 * Generate a square thumbnail from an image.
 */
ResizeResult generateThumbnail(const std::string& inputPath,
                                const std::string& outputPath,
                                int size = 150,
                                const std::string& algorithm = "lanczos",
                                int quality = 85) {
    return resizeImage(inputPath, outputPath, size, size, algorithm,
                       CropMode::CENTER, false, quality);
}

/**
 * Print usage information.
 */
void printUsage(const char* progName) {
    std::cout << "Image Resizer and Thumbnail Generator\n\n"
              << "Usage:\n"
              << "  " << progName << " resize <input> <output> <width> <height> [algorithm] [crop-mode]\n"
              << "  " << progName << " thumbnail <input> <output> [size] [algorithm]\n"
              << "  " << progName << " batch <input-dir> <output-dir> <width> <height> [algorithm] [crop-mode]\n"
              << "  " << progName << " batch-thumbnails <input-dir> <output-dir> [size] [algorithm]\n\n"
              << "Algorithms: nearest, bilinear, bicubic, lanczos (default)\n"
              << "Crop modes: center, top-left, top-right, bottom-left, bottom-right, smart\n";
}

int main(int argc, char* argv[]) {
    if (argc < 2) {
        printUsage(argv[0]);
        return 0;
    }

    std::string command = argv[1];

    try {
        if (command == "resize") {
            if (argc < 6) {
                std::cerr << "Usage: resize <input> <output> <width> <height> [algorithm] [crop-mode]\n";
                return 1;
            }
            std::string input = argv[2];
            std::string output = argv[3];
            int width = std::stoi(argv[4]);
            int height = std::stoi(argv[5]);
            std::string algo = (argc > 6) ? argv[6] : "lanczos";

            CropMode crop = CropMode::NONE;
            if (argc > 7) {
                auto it = CROP_MODES.find(argv[7]);
                if (it != CROP_MODES.end()) {
                    crop = it->second;
                }
            }

            auto result = resizeImage(input, output, width, height, algo, crop, crop == CropMode::NONE);
            std::cout << "Resized: " << result.inputPath << "\n"
                      << "  " << result.origWidth << "x" << result.origHeight
                      << " -> " << result.newWidth << "x" << result.newHeight << "\n"
                      << "  Size: " << formatSize(result.originalSize)
                      << " -> " << formatSize(result.newSize) << "\n"
                      << "  Algorithm: " << result.algorithm << "\n"
                      << "  Output: " << result.outputPath << "\n";

        } else if (command == "thumbnail") {
            if (argc < 4) {
                std::cerr << "Usage: thumbnail <input> <output> [size] [algorithm]\n";
                return 1;
            }
            std::string input = argv[2];
            std::string output = argv[3];
            int size = (argc > 4) ? std::stoi(argv[4]) : 150;
            std::string algo = (argc > 5) ? argv[5] : "lanczos";

            auto result = generateThumbnail(input, output, size, algo);
            std::cout << "Thumbnail created: " << result.outputPath << "\n"
                      << "  Size: " << result.newWidth << "x" << result.newHeight << "\n";

        } else if (command == "batch") {
            if (argc < 6) {
                std::cerr << "Usage: batch <input-dir> <output-dir> <width> <height> [algorithm] [crop-mode]\n";
                return 1;
            }
            std::string inputDir = argv[2];
            std::string outputDir = argv[3];
            int width = std::stoi(argv[4]);
            int height = std::stoi(argv[5]);
            std::string algo = (argc > 6) ? argv[6] : "lanczos";

            CropMode crop = CropMode::NONE;
            if (argc > 7) {
                auto it = CROP_MODES.find(argv[7]);
                if (it != CROP_MODES.end()) {
                    crop = it->second;
                }
            }

            auto images = getSupportedImages(inputDir);
            std::cout << "Found " << images.size() << " image(s) to process.\n";

            int success = 0, errors = 0;
            for (const auto& imgPath : images) {
                try {
                    std::string outPath = (fs::path(outputDir) / imgPath.filename()).string();
                    auto result = resizeImage(imgPath.string(), outPath, width, height,
                                              algo, crop, crop == CropMode::NONE);
                    success++;
                    std::cout << "  Resized: " << imgPath.filename().string()
                              << " (" << result.origWidth << "x" << result.origHeight
                              << " -> " << result.newWidth << "x" << result.newHeight << ")\n";
                } catch (const std::exception& e) {
                    errors++;
                    std::cerr << "  Error: " << imgPath.filename().string()
                              << ": " << e.what() << "\n";
                }
            }

            std::cout << "\nDone! " << success << " succeeded, " << errors << " failed.\n";

        } else if (command == "batch-thumbnails") {
            if (argc < 4) {
                std::cerr << "Usage: batch-thumbnails <input-dir> <output-dir> [size] [algorithm]\n";
                return 1;
            }
            std::string inputDir = argv[2];
            std::string outputDir = argv[3];
            int size = (argc > 4) ? std::stoi(argv[4]) : 150;
            std::string algo = (argc > 5) ? argv[5] : "lanczos";

            auto images = getSupportedImages(inputDir);
            std::cout << "Generating thumbnails for " << images.size() << " image(s)...\n";

            int success = 0;
            for (const auto& imgPath : images) {
                try {
                    std::string outName = "thumb_" + imgPath.filename().string();
                    std::string outPath = (fs::path(outputDir) / outName).string();
                    auto result = generateThumbnail(imgPath.string(), outPath, size, algo);
                    success++;
                    std::cout << "  Thumbnail: " << imgPath.filename().string()
                              << " (" << result.newWidth << "x" << result.newHeight << ")\n";
                } catch (const std::exception& e) {
                    std::cerr << "  Error: " << imgPath.filename().string()
                              << ": " << e.what() << "\n";
                }
            }

            std::cout << "\nGenerated " << success << " thumbnail(s) in " << outputDir << "\n";

        } else {
            std::cerr << "Unknown command: " << command << "\n";
            printUsage(argv[0]);
            return 1;
        }
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << "\n";
        return 1;
    }

    return 0;
}

# Image Resizer and Thumbnail Generator (C++ / OpenCV)

A command-line tool for resizing images and generating thumbnails using OpenCV
with multiple interpolation algorithms, crop modes, and batch processing.

## Dependencies

- **OpenCV 4.9.0** - Computer vision library providing image I/O, resizing, and processing.

## Build

```bash
mkdir build && cd build
cmake ..
cmake --build .
```

## Usage

### Resize a single image

```bash
./image_resizer resize input.jpg output.jpg 800 600 lanczos
```

### Generate a thumbnail

```bash
./image_resizer thumbnail input.jpg thumb.jpg 150
```

### Batch resize

```bash
./image_resizer batch ./input_dir ./output_dir 1024 768 bicubic
```

### Batch thumbnails

```bash
./image_resizer batch-thumbnails ./input_dir ./thumbs 200
```

## Algorithms

| Algorithm  | OpenCV Flag        | Description                    |
|------------|--------------------|--------------------------------|
| `nearest`  | INTER_NEAREST      | Nearest-neighbor (fastest)     |
| `bilinear` | INTER_LINEAR       | Bilinear interpolation         |
| `bicubic`  | INTER_CUBIC        | Bicubic interpolation          |
| `lanczos`  | INTER_LANCZOS4     | Lanczos (best quality)         |

## Crop Modes

center, top-left, top-right, bottom-left, bottom-right, smart