haader/haader_gui.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;
    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);
    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) {
        cairo_set_source_surface(cr, gui->surface, 0, 0);
        cairo_paint(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);

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

        GSList *element = list;
        while (element != NULL) {
            //TODO handle errors
            gui->stack.add_from_file_path((const char*)(element->data));
            g_free(element->data);
            element = g_slist_next(element);
        }

        g_slist_free(list);
    }

    // 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();
        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);
    GtkWidget *scale_compression = gtk_scale_new_with_range(GTK_ORIENTATION_HORIZONTAL, -4, 4.0, 0.001);

    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);
    gtk_box_pack_start(GTK_BOX(vbox), scale_exposure, false, false, 0);
    gtk_box_pack_start(GTK_BOX(vbox), scale_compression, false, false, 0);

    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;
}