alphaIfier.cpp

// AlphaIfier.cpp : This file contains the 'main' function. Program execution begins and ends there.
//

#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"
#define STB_IMAGE_WRITE_IMPLEMENTATION
#include "stb_image_write.h"
#include <iostream>
#include <filesystem>
#include <vector>
#include <string>
#include <algorithm> // For min/max functions

namespace fs = std::filesystem;
using namespace std;

vector<vector<unsigned char>> createAlphaMask(int width, int height, int featherWidth) {
    vector<vector<unsigned char>> mask(height, vector<unsigned char>(width));
    for (int y = 0; y < height; y++) {
        for (int x = 0; x < width; x++) {
            int distanceToEdge = min({ x, y, width - 1 - x, height - 1 - y });
            if (distanceToEdge < featherWidth) {
                float alphaFactor = static_cast<float>(distanceToEdge) / featherWidth;
                mask[y][x] = static_cast<unsigned char>(255 * alphaFactor);
            }
            else {
                mask[y][x] = 255; // Fully opaque
            }
        }
    }
    return mask;
}

vector<string> verifyDimensionsAndListFiles(const string& path, int& commonWidth, int& commonHeight) {
    vector<string> files;
    bool first = true;

    for (const auto& entry : fs::directory_iterator(path)) {
        if (entry.path().extension() == ".png") {
            int width, height, channels;
            stbi_info(entry.path().string().c_str(), &width, &height, &channels);
            if (first) {
                commonWidth = width;
                commonHeight = height;
                first = false;
            }
            else if (width != commonWidth || height != commonHeight) {
                cout << "Dimension mismatch found in file: " << entry.path().filename() << endl;
                continue;
            }
            files.push_back(entry.path().string());
        }
    }

    return files;
}


void applyAlphaFeathering(const string& filePath, const vector<vector<unsigned char>>& alphaMask) {
    int width, height, channels;
    unsigned char* image = stbi_load(filePath.c_str(), &width, &height, &channels, 4); // Force RGBA

    if (!image) {
        cout << "Failed to load image: " << filePath << endl;
        return;
    }

    for (int y = 0; y < height; y++) {
        for (int x = 0; x < width; x++) {
            unsigned char* pixel = image + (y * width + x) * 4;
            // Apply precomputed alpha value from the mask
            pixel[3] = alphaMask[y][x];
        }
    }

    // Ensure "output" directory exists
    fs::create_directory("output");
    string outputPath = "output/" + fs::path(filePath).filename().string();
    // Write the modified image with applied alpha feathering to the output path
    stbi_write_png(outputPath.c_str(), width, height, 4, image, width * 4);

    stbi_image_free(image);
}

int main(int argc, char* argv[]) {
    int featherWidth = 2; // Default value for feathering width
    string path;
    bool pathSet = false;

    // Parse command line arguments
    for (int i = 1; i < argc; ++i) {
        string arg = argv[i];
        if (arg == "-featherwidth" && i + 1 < argc) {
            featherWidth = std::max(0, std::atoi(argv[++i])); // Ensure non-negative
        }
        else {
            // Assume any non-flag argument is the path
            path = arg;
            pathSet = true;
        }
    }

    // Validate path
    if (!pathSet) {
        cout << "Usage: " << argv[0] << " [-featherwidth N] <path to PNG or folder>" << endl;
        return 1;
    }

    if (fs::is_directory(path)) {
        int commonWidth = 0, commonHeight = 0;
        auto files = verifyDimensionsAndListFiles(path, commonWidth, commonHeight);
        if (!files.empty()) {
            // Create alpha mask based on the first image's dimensions and the specified featherWidth
            auto alphaMask = createAlphaMask(commonWidth, commonHeight, featherWidth);
            for (const auto& file : files) {
                cout << "Processing file: " << file << endl; // Log the file being processed
                applyAlphaFeathering(file, alphaMask);
            }
        }
    }
    else if (fs::path(path).extension() == ".png") {
        int width, height, channels;
        // Use stbi_info to get the image dimensions
        stbi_info(path.c_str(), &width, &height, &channels);
        auto alphaMask = createAlphaMask(width, height, featherWidth);
        cout << "Processing file: " << path << endl; // Log the file being processed
        applyAlphaFeathering(path, alphaMask);
    }
    else {
        cout << "Invalid input. Please provide a path to a PNG file or a directory." << endl;
        return 1;
    }

    cout << "Processing completed." << endl;
    return 0;
}