Commit old changes from 2017-07-13

* Add GUI
* Write response functions to CSV
...

Makefile

@@ -2,9 +2,15 @@ CXXFLAGS= -std=c++98 -pedantic -Wall -O3
 LIBS=
 OBJS= haader.o image.o exif.o csv_reader.o
 
+GUI_CFLAGS= $$(pkg-config gtk+-3.0 --cflags)
+GUI_LIBS= $$(pkg-config gtk+-3.0 --libs)
+
 haader: main.cpp $(OBJS)
 	$(CXX) main.cpp -o haader $(OBJS) $(CXXFLAGS) $(LIBS)
 
+haader_gui: haader_gui.cpp $(OBJS)
+	$(CXX) haader_gui.cpp -o haader_gui $(OBJS) $(CXXFLAGS) $(GUI_CFLAGS) $(LIBS) $(GUI_LIBS)
+
 run: haader
 	./haader
 

haader.cpp

@@ -1,6 +1,7 @@
 #include <iostream>
 #include <fstream>
 #include <algorithm>
+#include <clocale>
 #include <stdlib.h>
 #include <time.h>
 #include <math.h>
@@ -24,6 +25,19 @@ int ResponseFunction::lookup(double value) const {
     }
 }
 
+void ResponseFunction::to_csv_stream(ostream &stream) const {
+    // Set locale. Numbers should have a decimal point (not a comma)
+    std::setlocale(LC_NUMERIC, "C");
+
+    unsigned int size = m_lookup_table.size();
+    double recip_size = 1.0 / (double)(size - 1);
+    for (unsigned int i = 0; i < size; i++) {
+        double x = m_min_value + i * recip_size * (m_max_value - m_min_value);
+        int y = m_lookup_table[i];
+        stream << x << ',' << y << endl;
+    }
+}
+
 double InverseResponseFunction::lookup(int index) const {
     return m_lookup_table[index];
 }
@@ -77,6 +91,13 @@ ResponseFunction InverseResponseFunction::to_response_function(int bins) {
     return rf;
 }
 
+void InverseResponseFunction::to_csv_stream(ostream &stream) const {
+    unsigned int size = m_lookup_table.size();
+    for (unsigned int i = 0; i < size; i++) {
+        stream << i << ',' << m_lookup_table[i] << endl;
+    }
+}
+
 bool InverseResponseFunction::repair() {
 
     // Fill missing values
@@ -281,6 +302,35 @@ bool HdrImageStack::read_from_files(char * const* file_paths, int number_of_path
     return true;
 }
 
+bool HdrImageStack::add_from_file_path(const char* file_path) {
+    unsigned int i = m_images.size();
+    m_images.push_back(Image());
+
+    if (m_images[i].read_from_file(file_path)) {
+        cout << "Read \"" << file_path << "\"" << endl;
+        if (!m_images[0].has_equal_dimensions(m_images[i])) {
+            cerr << "HdrImageStack::add_from_file_path: Dimensions do not match (\""
+                 << file_path
+                 << "\")"
+                 << endl;
+            return false;
+        }
+        if (m_images[i].get_exposure_time() == 0.0) {
+            cerr << "HdrImageStack::read_from_files: Could not get exposure time (\""
+                 << file_path
+                 << "\")"
+                 << endl;
+            return false;
+        }
+    } else {
+        return false;
+    }
+
+    sort_by_exposure();
+
+    return true;
+}
+
 bool HdrImageStack::get_average_image_slow(Image &output) {
     if (m_images.size() == 0) {
         return false;
@@ -348,6 +398,11 @@ bool HdrImageStack::get_average_image(Image &output) {
 }
 
 bool HdrImageStack::get_inverse_response_function(InverseResponseFunction &output, unsigned int num_samples) {
+    if (m_images.size() == 0) {
+        cerr << "HdrImageStack::get_inverse_response_function: There are no images." << endl;
+        return false;
+    }
+
     srand(time(0));
 
     unsigned int images_size = m_images.size();

haader.h

@@ -2,6 +2,7 @@
 #define HAADER_ILUCF4Z0
 
 #include <vector>
+#include <iostream>
 
 #include "image.h"
 
@@ -12,6 +13,9 @@ namespace haader {
             // Returns a pixel value (0-255) given the logarithm of a luminance value.
             int lookup(double value) const;
 
+            // Write the lookup table in CSV-format to the given stream
+            void to_csv_stream(std::ostream &stream) const;
+
         private:
             // minimum log of luminance value
             double m_min_value;
@@ -43,6 +47,9 @@ namespace haader {
             // bins: Size of the lookup table for the response function
             ResponseFunction to_response_function(int bins=1024);
 
+            // Write the lookup table in CSV-format to the given stream
+            void to_csv_stream(std::ostream &stream) const;
+
         private:
 
             // Returns true if a monotonically increasing lookup table without missing values
@@ -103,6 +110,9 @@ namespace haader {
             // Read images from the given array of file paths
             bool read_from_files(char * const* file_paths, int number_of_paths);
 
+            // Add an image from the given file path
+            bool add_from_file_path(const char* file_path);
+
             bool get_average_image(Image &output);
             bool get_average_image_slow(Image &output);
 

haader_gui.cpp

@@ -0,0 +1,176 @@
+#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;
+}

image.cpp

@@ -125,3 +125,11 @@ bool Image::has_equal_dimensions(const Image &other) const {
 double Image::get_exposure_time() const {
     return m_exposure_time;
 }
+
+const unsigned char* Image::get_const_image_data() const {
+    return m_image_data.data();
+}
+
+unsigned char* Image::get_image_data() {
+    return m_image_data.data();
+}

image.h

@@ -24,6 +24,8 @@ namespace haader {
             unsigned int get_components() const;
             bool has_equal_dimensions(const Image &other) const;
             double get_exposure_time() const;
+            const unsigned char* get_const_image_data() const;
+            unsigned char* get_image_data();
 
         private:
             std::vector<unsigned char> m_image_data;

main.cpp

@@ -5,6 +5,7 @@
 
 #include <iostream>
 #include <sstream>
+#include <fstream>
 #include <iomanip>
 
 using namespace std;
@@ -38,7 +39,13 @@ int main(int argc, char *argv[])
 
             // approximate inverse response function
             haader::InverseResponseFunction irf;
-            bool irf_ok = stack.get_inverse_response_function(irf, 2000);
+            bool irf_ok = stack.get_inverse_response_function(irf, 1000);
+
+            {
+                fstream s;
+                s.open("irf.csv", std::ios::out);
+                irf.to_csv_stream(s);
+            }
 
             if (irf_ok) {
                 haader::HdrImage hdr_img;
@@ -54,6 +61,22 @@ int main(int argc, char *argv[])
                 haader::ResponseFunction rf;
                 rf = irf.to_response_function(1024);
 
+                {
+                    fstream s;
+                    s.open("rf.csv", std::ios::out);
+                    rf.to_csv_stream(s);
+                }
+
+                {
+                    haader::Image x = hdr_img.expose(0.001, rf, 1.0);
+                    x.save_as_ppm_file("test_1000.ppm");
+                }
+
+                {
+                    haader::Image x = hdr_img.expose(1.0 / 1024.0, rf, 1.0);
+                    x.save_as_ppm_file("test_1024.ppm");
+                }
+
                 // create images by a simulated exposure of the HDR image with the response function
                 cout << "Expose..." << endl;
                 for (int i = 0; i < 20; i++) {
@@ -73,6 +96,7 @@ int main(int argc, char *argv[])
                     cout << "save as " << path << endl;
                 }
             }
+
             clock_t end = clock();
             double seconds = (end - start) / (double)CLOCKS_PER_SEC;
             cout << "\nsecs: " << seconds << endl;