hdr_image.cpp

#include "hdr_image.h"
#include "../lib/log.h"

#include <sf_libs/stb_image.h>
#include <sf_libs/tinyexr.h>

HDR_Image::HDR_Image() : w(0), h(0) {}

HDR_Image::HDR_Image(size_t w, size_t h) : w(w), h(h) {
    assert(w > 0 && h > 0);
    pixels.resize(w * h);
}

HDR_Image HDR_Image::copy() const {
    HDR_Image ret;
    ret.resize(w, h);
    ret.pixels.insert(ret.pixels.begin(), pixels.begin(), pixels.end());
    ret.last_path = last_path;
    ret.dirty = true;
    ret.exposure = exposure;
    return ret;
}

std::pair<size_t,size_t> HDR_Image::dimension() const {
    return {w,h};
}

void HDR_Image::resize(size_t _w, size_t _h) {
    w = _w;
    h = _h;
    pixels.clear();
    pixels.resize(w * h);
    dirty = true;
}

void HDR_Image::clear(Spectrum color) {
    for(auto& s : pixels) s = color;
    dirty = true;
}

Spectrum& HDR_Image::at(size_t i) {
    assert(i < w * h);
    dirty = true;
    return pixels[i];
}

Spectrum HDR_Image::at(size_t i) const {
    assert(i < w * h);
    return pixels[i];
}

Spectrum& HDR_Image::at(size_t x, size_t y) {
    assert(x < w && y < h);
    size_t idx = y * w + x;
    dirty = true;
    return pixels[idx];
}

Spectrum HDR_Image::at(size_t x, size_t y) const {
    assert(x < w && y < h);
    size_t idx = y * w + x;
    return pixels[idx];
}

std::string HDR_Image::load_from(std::string file) {

    if(IsEXR(file.c_str()) == TINYEXR_SUCCESS) {

        int n_w, n_h;
        float* data;
        const char* err = nullptr;

        int ret = LoadEXR(&data, &n_w, &n_h, file.c_str(), &err);

        if (ret != TINYEXR_SUCCESS) {

            if (err) {
                std::string err_s(err);
                FreeEXRErrorMessage(err);
                return err_s;
            } else return "Unknown failure.";

        } else {

            resize(n_w, n_h);

            for(size_t j = 0; j < h; j++) {
                for(size_t i = 0; i < w; i++) {
                    size_t didx = 4 * (j * w + i);
                    size_t pidx = (h - j - 1) * w + i;
                    pixels[pidx] = Spectrum(data[didx],data[didx+1],data[didx+2]);
                }
            }

            free(data);
        }

    } else {

        stbi_set_flip_vertically_on_load(true);
        
        int n_w, n_h, channels;
        unsigned char *data = stbi_load(file.c_str(), &n_w, &n_h, &channels, 0);

        if(!data) return std::string(stbi_failure_reason());
        if(channels < 3) return "Image has less than 3 color channels.";

        resize(n_w, n_h);

        for(size_t i = 0; i < w * h * channels; i += channels) {
            float r = data[i] / 255.0f;
            float g = data[i+1] / 255.0f;
            float b = data[i+2] / 255.0f;
            pixels[i / channels] = Spectrum(r,g,b);
        }

        stbi_image_free(data);
    }

    for(size_t i = 0; i < pixels.size(); i++) {
        pixels[i].make_linear();
        if(!pixels[i].valid()) pixels[i] = {};
    }

    last_path = file;
    dirty = true;
    return {};
}

std::string HDR_Image::loaded_from() const {
    return last_path;
}

void HDR_Image::tonemap(float e) const {

    if(e <= 0.0f) {
        e = exposure;
    } else if(e != exposure) {
        exposure = e;
        dirty = true;
    }

    if(!dirty) return;

    std::vector<unsigned char> data;
    tonemap_to(data, e);
    render_tex.image((int)w, (int)h, data.data());

    dirty = false;
}

const GL::Tex2D& HDR_Image::get_texture(float e) const {
    tonemap(e);
    return render_tex;
}

void HDR_Image::tonemap_to(std::vector<unsigned char>& data, float e) const {
    
    if(e <= 0.0f) {
        e = exposure;
    }

    if(data.size() != w * h * 4)
        data.resize(w * h * 4);

    for(size_t j = 0; j < h; j++) {
        for(size_t i = 0; i < w; i++) {
            
            size_t pidx = (h - j - 1) * w + i;
            const Spectrum& sample = pixels[pidx];
  
            float r = 1.0f - std::exp(-sample.r * exposure);
            float g = 1.0f - std::exp(-sample.g * exposure);
            float b = 1.0f - std::exp(-sample.b * exposure);
            
            Spectrum out(r,g,b);
            out.make_srgb();
  
            size_t didx = 4 * (j * w + i);
            data[didx] = (unsigned char)std::round(out.r * 255.0f);
            data[didx+1] = (unsigned char)std::round(out.g * 255.0f);
            data[didx+2] = (unsigned char)std::round(out.b * 255.0f);
            data[didx+3] = 255;
        }
    }
}