image_preprocessor.cpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
#include <entropic/inference/image_preprocessor.h>
#include <entropic/types/logging.h>
 
#include <algorithm>
#include <fstream>
#include <stdexcept>
 
// stb_image — use llama.cpp's vendored copy.
// STB_IMAGE_STATIC keeps symbols internal to this TU to avoid
// duplicate symbol conflicts with llama.cpp's own stb_image use.
#define STB_IMAGE_IMPLEMENTATION
#define STB_IMAGE_STATIC
#define STBI_ONLY_PNG
#define STBI_ONLY_JPEG
#define STBI_ONLY_BMP
#define STBI_ONLY_GIF
#include <stb/stb_image.h>
 
static auto logger = entropic::log::get("inference.image_preprocessor");
 
namespace {
 
float lerp_channel(const uint8_t* data, int w,
                   int x0, int y0, int x1, int y1,
                   float fx, float fy, int ch) {
    auto px = [data, w, ch](int x, int y) -> float {
        return static_cast<float>(
            data[(static_cast<size_t>(y) * static_cast<size_t>(w)
                  + static_cast<size_t>(x)) * 3
                 + static_cast<size_t>(ch)]);
    };
    float top = px(x0, y0) * (1.0f - fx) + px(x1, y0) * fx;
    float bot = px(x0, y1) * (1.0f - fx) + px(x1, y1) * fx;
    return top * (1.0f - fy) + bot * fy;
}
 
void interpolate_pixel(const uint8_t* src, int src_w, int src_h,
                       uint8_t* dst,
                       float src_x, float src_y) {
    int x0 = std::max(0, static_cast<int>(src_x));
    int x1 = std::min(src_w - 1, x0 + 1);
    int y0 = std::max(0, static_cast<int>(src_y));
    int y1 = std::min(src_h - 1, y0 + 1);
    float fx = src_x - static_cast<float>(x0);
    float fy = src_y - static_cast<float>(y0);
 
    for (int ch = 0; ch < 3; ++ch) {
        float val = lerp_channel(src, src_w, x0, y0, x1, y1, fx, fy, ch);
        dst[ch] = static_cast<uint8_t>(std::clamp(val, 0.0f, 255.0f));
    }
}
 
void bilinear_resize(entropic::PreprocessedImage& img,
                     int new_w, int new_h) {
    std::vector<uint8_t> out(
        static_cast<size_t>(new_w) * static_cast<size_t>(new_h) * 3);
 
    float x_ratio = static_cast<float>(img.width) / static_cast<float>(new_w);
    float y_ratio = static_cast<float>(img.height) / static_cast<float>(new_h);
 
    for (int y = 0; y < new_h; ++y) {
        float sy = (static_cast<float>(y) + 0.5f) * y_ratio - 0.5f;
        for (int x = 0; x < new_w; ++x) {
            float sx = (static_cast<float>(x) + 0.5f) * x_ratio - 0.5f;
            size_t dst_off = (static_cast<size_t>(y)
                              * static_cast<size_t>(new_w)
                              + static_cast<size_t>(x)) * 3;
            interpolate_pixel(img.pixel_data.data(),
                              img.width, img.height,
                              out.data() + dst_off, sx, sy);
        }
    }
 
    img.pixel_data = std::move(out);
    img.width = new_w;
    img.height = new_h;
}
 
} // anonymous namespace
 
namespace entropic {
 
ImagePreprocessor::ImagePreprocessor(const ImagePreprocessConfig& config)
    : config_(config) {}
 
static std::vector<uint8_t> read_image_bytes(
    const std::filesystem::path& path, size_t max_file_size) {
    if (!std::filesystem::exists(path)) {
        logger->error("Image file not found: {}", path.string());
        throw std::runtime_error("Image file not found: " + path.string());
    }
    auto file_size = std::filesystem::file_size(path);
    if (file_size > max_file_size) {
        logger->error("Image file too large: {} bytes (max {})",
                      file_size, max_file_size);
        throw std::runtime_error(
            "Image exceeds max file size ("
            + std::to_string(file_size) + " > "
            + std::to_string(max_file_size) + ")");
    }
    std::ifstream file(path, std::ios::binary);
    if (!file) {
        throw std::runtime_error("Cannot open image file: " + path.string());
    }
    std::vector<uint8_t> buf(static_cast<size_t>(file_size));
    file.read(reinterpret_cast<char*>(buf.data()),
              static_cast<std::streamsize>(file_size));
    return buf;
}
 
PreprocessedImage ImagePreprocessor::preprocess_file(
    const std::filesystem::path& path) {
    auto buf = read_image_bytes(path, config_.max_file_size);
    auto img = decode(buf.data(), buf.size(), path.string());
    img.source_path = path.string();
    resize_if_needed(img);
 
    logger->info("Preprocessed image {}: {}x{} ({} bytes)",
                 path.string(), img.width, img.height,
                 img.pixel_data.size());
    return img;
}
 
PreprocessedImage ImagePreprocessor::preprocess_buffer(
    const uint8_t* data,
    size_t len,
    const std::string& source_label) {
    auto img = decode(data, len, source_label);
    img.source_path = source_label;
    resize_if_needed(img);
 
    logger->info("Preprocessed buffer '{}': {}x{}",
                 source_label, img.width, img.height);
    return img;
}
 
PreprocessedImage ImagePreprocessor::decode(
    const uint8_t* data, size_t len,
    const std::string& source) {
    int w = 0;
    int h = 0;
    int ch = 0;
    auto* pixels = stbi_load_from_memory(
        data, static_cast<int>(len), &w, &h, &ch, 3);
 
    if (pixels == nullptr) {
        logger->error("Failed to decode image '{}': {}",
                      source, stbi_failure_reason());
        throw std::runtime_error(
            "Unsupported image format or decode error: " + source);
    }
 
    PreprocessedImage img;
    img.width = w;
    img.height = h;
    img.channels = 3;
    size_t data_size = static_cast<size_t>(w) * static_cast<size_t>(h) * 3;
    img.pixel_data.assign(pixels, pixels + data_size);
    stbi_image_free(pixels);
 
    return img;
}
 
void ImagePreprocessor::resize_if_needed(PreprocessedImage& img) {
    if (img.width <= config_.max_width
        && img.height <= config_.max_height) {
        return;
    }
 
    float scale_w = static_cast<float>(config_.max_width)
                  / static_cast<float>(img.width);
    float scale_h = static_cast<float>(config_.max_height)
                  / static_cast<float>(img.height);
 
    float scale = config_.preserve_aspect
        ? std::min(scale_w, scale_h)
        : 1.0f; // unused, but satisfies compiler
 
    if (!config_.preserve_aspect) {
        scale_w = std::min(scale_w, 1.0f);
        scale_h = std::min(scale_h, 1.0f);
    } else {
        scale_w = scale;
        scale_h = scale;
    }
 
    int new_w = std::max(1, static_cast<int>(
        static_cast<float>(img.width) * scale_w));
    int new_h = std::max(1, static_cast<int>(
        static_cast<float>(img.height) * scale_h));
 
    bilinear_resize(img, new_w, new_h);
}
 
} // namespace entropic