haader/gui_gtk/main.cpp

#include <math.h>
#include <iostream>
using namespace std;

#include <gtk/gtk.h>
#include <glib.h>

#include "haader.h"
#include "image.h"

struct Gui {
    GtkWidget *window;
    GtkWidget *canvas;
    haader::HdrImageStack stack;
    haader::HdrImage hdr_image;
    haader::ResponseFunction response_function;
    haader::Image ldr_image;
    haader::Histogram hdr_histogram;
    haader::LdrHistogram ldr_histogram;
    cairo_surface_t *surface;
    double exposure_time;
    double compression;
};

static cairo_surface_t* image_to_cairo_surface(const haader::Image &image) {
    unsigned int width = image.get_width();
    unsigned int height = image.get_height();
    const unsigned char *image_data = image.get_const_image_data();

    cairo_surface_t *surf = cairo_image_surface_create(CAIRO_FORMAT_RGB24, width, height);
    int stride = cairo_image_surface_get_stride(surf);
    unsigned char *surf_data = cairo_image_surface_get_data(surf);

    unsigned int i = 0;
    unsigned int k = 0;
    for (unsigned int y = 0; y < height; y++) {
        for (unsigned int x = 0; x < width; x++) {
            surf_data[i + x * 4] = image_data[k + x * 3 + 2];
            surf_data[i + x * 4 + 1] = image_data[k + x * 3 + 1];
            surf_data[i + x * 4 + 2] = image_data[k + x * 3];
        }
        i += stride;
        k += width * 3;
    }

    return surf;
}

static void expose(Gui &gui) {
    gui.ldr_image = gui.hdr_image.expose(gui.exposure_time, gui.response_function, gui.compression);
    gui.ldr_histogram = gui.ldr_image.histogram();
    if (gui.surface) {
        cairo_surface_destroy(gui.surface);
        gui.surface = NULL;
    }
    gui.surface = image_to_cairo_surface(gui.ldr_image);
}

static gboolean canvas_draw(GtkWidget *widget, cairo_t *cr, gpointer user_data)
{
    cairo_set_source_rgb(cr, 0.2, 0.2, 0.2);
    cairo_paint(cr);

    Gui *gui = (Gui*) user_data;
    if (!gui->surface) {
        return false;
    }

    if (gui->hdr_histogram.m_bins.size() != 256) {
        return false;
    }

    if (gui->ldr_histogram.m_bins.size() != 256) {
        return false;
    }

    cairo_set_source_surface(cr, gui->surface, 5, 5);
    cairo_paint(cr);

    // canvas rect
    double cx = gui->ldr_image.get_width() + 10.0;
    double cy = 5.0;
    double cw = 256;
    double ch = 256;

    cairo_set_source_rgb(cr, 0.0, 0.0, 0.0);
    cairo_rectangle(cr, cx, cy, cw, ch);
    cairo_fill(cr);

    {
        double hist_scale = (256.0 / (double)(gui->hdr_histogram.m_max_freq));
        for (unsigned int i = 0; i < 256; i++) {
            double y = gui->hdr_histogram.m_bins[i] * hist_scale;
            cairo_rectangle(cr, cx + i, cy + ch - y, 1, y);
        }
        cairo_set_source_rgba(cr, 1.0, 0.0, 0.2, 0.4);
        cairo_fill(cr);
    }

    {
        double hist_scale = (256.0 / (double)(gui->ldr_histogram.m_max_freq));
        for (unsigned int i = 0; i < 256; i++) {
            double y = gui->ldr_histogram.m_bins[i] * hist_scale;
            cairo_rectangle(cr, cx + i, cy + ch - y, 1, y);
        }
        cairo_set_source_rgba(cr, 1.0, 0.0, 0.2, 0.9);
        cairo_fill(cr);
    }


    double minl = gui->hdr_histogram.m_min_value;
    double maxl = gui->hdr_histogram.m_max_value;
    double log_exp = log(gui->exposure_time);
    double scale = (maxl - minl) / 256.0;

    for (int i = 0; i < 256; i++) {
        double lum = minl + i * scale;
        int ly = gui->response_function.lookup((lum + log_exp) * gui->compression);
        cairo_line_to(cr, cx + i, cy + ch - ly);
    }
    cairo_set_source_rgba(cr, 1.0, 1.0, 1.0, 0.8);
    cairo_set_line_width(cr, 1.0);
    cairo_stroke_preserve(cr);

    cairo_line_to(cr, cx + cw, cy + ch);
    cairo_line_to(cr, cx, cy + ch);
    cairo_close_path(cr);
    cairo_set_source_rgba(cr, 0.0, 0.5, 1.0, 0.2);
    cairo_fill(cr);

    return FALSE;
}

void scale_exposure_changed(GtkRange *range, gpointer user_data) {
    Gui *gui = (Gui*) user_data;

    gui->exposure_time = pow(2.0, gtk_range_get_value(range));

    expose(*gui);

    gtk_widget_queue_draw(gui->canvas);
}

void scale_compression_changed(GtkRange *range, gpointer user_data) {
    Gui *gui = (Gui*) user_data;

    gui->compression = pow(2.0, gtk_range_get_value(range));

    expose(*gui);

    gtk_widget_queue_draw(gui->canvas);
}

void file_select_clicked(GtkButton *button, gpointer user_data) {
    Gui *gui = (Gui*) user_data;

    GtkWidget *dialog = gtk_file_chooser_dialog_new(
            "Open File",
            GTK_WINDOW(gui->window),
            GTK_FILE_CHOOSER_ACTION_OPEN,
            "Cancel",
            GTK_RESPONSE_CANCEL,
            "Open",
            GTK_RESPONSE_ACCEPT,
            NULL);

    gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER(dialog), true);

    bool ok = true;
    if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
        GSList *list = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(dialog));
        vector<string> new_list;

        GSList *element = list;
        while (element != NULL) {
            ok = ok && gui->stack.add_from_file_path((const char*)(element->data));
            g_free(element->data);
            element = g_slist_next(element);
            if (!ok) {
                break;
            }
        }

        g_slist_free(list);
    }

    if (ok) {
        // create HDR-image
        haader::InverseResponseFunction irf;
        if (gui->stack.get_inverse_response_function(irf, 4096)) {
            gui->hdr_image = gui->stack.get_hdr_image(irf);
            gui->ldr_image = gui->hdr_image.get_log_image();
            gui->hdr_histogram = gui->hdr_image.histogram(256);
            gui->ldr_histogram = gui->ldr_image.histogram();
            if (gui->surface) {
                cairo_surface_destroy(gui->surface);
                gui->surface = NULL;
            }
            gui->surface = image_to_cairo_surface(gui->ldr_image);
            gui->response_function = irf.to_response_function(1024);
        }

        gtk_widget_queue_draw(gui->canvas);
    }

    gtk_widget_destroy (dialog);
}

int main(int argc, char *argv[])
{
    gtk_init(&argc, &argv);

    Gui gui;
    gui.surface = NULL;
    gui.exposure_time = 0.0;
    gui.compression = 1.0;

    gui.window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(gui.window), "haader");
    gtk_window_set_default_size(GTK_WINDOW(gui.window), 800, 600);

    GtkWidget *file_button = gtk_button_new_with_label("Select files");
    gui.canvas = gtk_drawing_area_new();
    GtkWidget *scale_exposure = gtk_scale_new_with_range(GTK_ORIENTATION_HORIZONTAL, -20.0, 4.0, 0.001);
    gtk_range_set_value(GTK_RANGE(scale_exposure), log(gui.exposure_time) / log(2));

    GtkWidget *scale_compression = gtk_scale_new_with_range(GTK_ORIENTATION_HORIZONTAL, -4, 4.0, 0.001);
    gtk_range_set_value(GTK_RANGE(scale_compression), log(gui.compression) / log(2));

    GtkWidget *vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);

    gtk_container_add(GTK_CONTAINER(gui.window), vbox);
    gtk_box_pack_start(GTK_BOX(vbox), file_button, false, false, 0);
    gtk_box_pack_start(GTK_BOX(vbox), gui.canvas, true, true, 0);

    GtkWidget *grid = gtk_grid_new();
    gtk_box_pack_start(GTK_BOX(vbox), grid, false, false, 0);

    {
        GtkWidget *label = gtk_label_new("Exposure");
        gtk_grid_attach(GTK_GRID(grid), label, 0, 0, 1, 1);
        gtk_widget_set_size_request(scale_exposure, 600, -1);
        gtk_grid_attach(GTK_GRID(grid), scale_exposure, 1, 0, 1, 1);
    }

    {
        GtkWidget *label = gtk_label_new("Compression");
        gtk_grid_attach(GTK_GRID(grid), label, 0, 1, 1, 1);
        gtk_widget_set_size_request(scale_compression, 600, -1);
        gtk_grid_attach(GTK_GRID(grid), scale_compression, 1, 1, 1, 1);
    }

    g_signal_connect(gui.window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
    g_signal_connect(gui.canvas, "draw", G_CALLBACK(canvas_draw), &gui);
    g_signal_connect(file_button, "clicked", G_CALLBACK(file_select_clicked), &gui);
    g_signal_connect(scale_exposure, "value-changed", G_CALLBACK(scale_exposure_changed), &gui);
    g_signal_connect(scale_compression, "value-changed", G_CALLBACK(scale_compression_changed), &gui);

    gtk_widget_show_all(gui.window);

    gtk_main ();

    return 0;
}