load() [1/2]

std::optional< ImageData > MayaFlux::IO::ImageReader::load ( const std::filesystem::path &  path, int  desired_channels = 4, std::optional< Kakshya::Region >  region = std::nullopt  )

static

Load image from file (static utility)

Parameters

path	Image file path
desired_channels	Force channel count (0 = keep original, 4 = RGBA)
region	Optional source-pixel rectangle with inclusive end coordinates

Returns

Image data or nullopt on failure

Definition at line 469 of file ImageReader.cpp.

{
    auto resolved = std::filesystem::path(resolve_path(path.string()));
    if (!std::filesystem::exists(resolved)) {
        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
            "Image file not found: {}", resolved.string());
        return std::nullopt;
    }
 
    std::ifstream file(resolved, std::ios::binary | std::ios::ate);
    if (!file.is_open()) {
        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
            "Failed to open image file: {}", resolved.string());
        return std::nullopt;
    }
 
    std::streamsize file_size = file.tellg();
    file.seekg(0, std::ios::beg);
 
    std::vector<unsigned char> file_buffer(file_size);
    if (!file.read(reinterpret_cast<char*>(file_buffer.data()), file_size)) {
        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
            "Failed to read image file: {}", resolved.string());
        return std::nullopt;
    }
    file.close();
 
    if (extension_of(resolved) == "exr") {
        (void)desired_channels;
        auto image = load_exr_from_memory(file_buffer.data(), static_cast<size_t>(file_size));
        if (image && region) {
            return crop_image(*image, *region);
        }
        return image;
    }
 
    int width {}, height {}, channels {};
 
    if (desired_channels == 0) {
        stbi_info_from_memory(file_buffer.data(), static_cast<int>(file_buffer.size()),
            &width, &height, &channels);
        if (channels == 3) {
            desired_channels = 4;
        }
    }
 
    unsigned char* pixels = stbi_load_from_memory(
        file_buffer.data(),
        static_cast<int>(file_buffer.size()),
        &width, &height, &channels,
        desired_channels);
 
    if (!pixels) {
        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
            "Failed to decode image: {} - {}",
            path.string(), stbi_failure_reason());
        return std::nullopt;
    }
 
    int result_channels = (desired_channels != 0) ? desired_channels : channels;
 
    MF_INFO(Journal::Component::IO, Journal::Context::FileIO,
        "Loaded image: {} ({}x{}, {} channels{})",
        resolved.filename().string(), width, height, result_channels,
        (channels == 3 && result_channels == 4) ? " [RGB→RGBA]" : "");
 
    ImageData result;
    auto& buf = result.pixels.emplace<std::vector<uint8_t>>();
    size_t data_size = static_cast<size_t>(width) * height * result_channels;
    buf.resize(data_size);
    std::memcpy(buf.data(), pixels, data_size);
 
    result.width = width;
    result.height = height;
    result.channels = result_channels;
 
    switch (result_channels) {
    case 1:
        result.format = Portal::Graphics::ImageFormat::R8;
        break;
    case 2:
        result.format = Portal::Graphics::ImageFormat::RG8;
        break;
    case 4:
        result.format = Portal::Graphics::ImageFormat::RGBA8;
        break;
    default:
        MF_ERROR(Journal::Component::IO, Journal::Context::FileIO,
            "Unsupported channel count: {}", result_channels);
        stbi_image_free(pixels);
        return std::nullopt;
    }
 
    stbi_image_free(pixels);
    if (region) {
        return crop_image(result, *region);
    }
    return result;
}

References channels, MayaFlux::Journal::FileIO, height, image, MayaFlux::Journal::IO, MF_ERROR, MF_INFO, MayaFlux::Kakshya::ImageData::pixels, pixels, MayaFlux::IO::FileReader::resolve_path(), and width.

Here is the call graph for this function: