Add option to create HdrImageStack from CSV file

include/haader.h

             // 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);
+            // Add an image from the given file path.
+            // Tries to retrieve the exposure time from the file if
+            // exposure_time is omitted or the given value is <= 0.0
+            bool add_from_file_path(const char* file_path, double exposure_time=0.0);
+
+            // Read images from a CSV file in this format:
+            // <path_image_1>,<exposure_time_1>
+            // <path_image_2>,<exposure_time_2>
+            // <path_image_3>,<exposure_time_3>
+            // ...
+            bool read_from_csv_file(const char* csv_path);
 
             bool get_average_image(Image &output);
             bool get_average_image_slow(Image &output);

include/image.h

 
             void to_string(std::string &s) const;
 
-            bool read_from_file(const char *file_path);
+            bool read_from_file(const char *file_path, double exposure_time=0.0);
             bool save_as_ppm_file(const char *file_path, bool ascii=false) const;
 
             LdrHistogram histogram() const;

src/haader.cpp

 #include <math.h>
 
 #include "haader.h"
+#include "csv_reader.h"
 
 #define max_number(a, b) (a) > (b) ? (a) : (b)
 #define min_number(a, b) (a) < (b) ? (a) : (b)
     return true;
 }
 
-bool HdrImageStack::add_from_file_path(const char* file_path) {
+bool HdrImageStack::add_from_file_path(const char* file_path, double exposure_time) {
     unsigned int i = m_images.size();
     m_images.push_back(Image());
 
-    if (m_images[i].read_from_file(file_path)) {
+    if (m_images[i].read_from_file(file_path, exposure_time)) {
         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 (\""
     return true;
 }
 
+struct CSVUserData {
+    bool ok;
+    HdrImageStack *stack;
+};
+
+static bool csv_row_callback(const CSVRow &row, void *userData) {
+    CSVUserData *cud = (CSVUserData*)userData;
+
+    string path;
+    double exposure_time = 0.0;
+
+    bool ok = row.getFieldAsString(0, &path);
+    ok = ok && row.getFieldAsDouble(1, &exposure_time);
+
+    if (ok) {
+        ok = ok && cud->stack->add_from_file_path(path.c_str(), exposure_time);
+    } else {
+        cout << "Failed to parse line " << row.getLineNumber() << endl;
+    }
+
+    if (!ok) {
+        cud->ok = false;
+        return false;
+    } else {
+        return true;
+    }
+}
+
+bool HdrImageStack::read_from_csv_file(const char* csv_path) {
+    string path(csv_path);
+
+    CSVUserData cud;
+    cud.ok = true;
+    cud.stack = this;
+
+    bool csv_ok = CSVReader::readFromFile(path, &csv_row_callback, &cud);
+
+    if (csv_ok && cud.ok) {
+        cout << "Successful read from " << csv_path << endl;
+        return true;
+    } else {
+        cout << "Failed to read from CSV " << csv_path << endl;
+        m_images.clear();
+        return false;
+    }
+}
+
 bool HdrImageStack::get_average_image_slow(Image &output) {
     if (m_images.size() == 0) {
         return false;

src/image.cpp

     s = ss.str();
 }
 
-bool Image::read_from_file(const char *file_path) {
+bool Image::read_from_file(const char *file_path, double exposure_time) {
     int x = 0;
     int y = 0;
     int components = 0;
         size_t size = (size_t)x * (size_t)y * (size_t)components;
         m_image_data.assign(data, data + size);
 
-        // try to read EXIF data
-        {
+        if (exposure_time <= 0.0) {
+            // try to read EXIF data
+
             ExifTags tags;
             ifstream stream;
             stream.open(file_path);
                     cout << "Exposure time: " << m_exposure_time << " sec" << endl;
                 }
             }
+        } else {
+            m_exposure_time = exposure_time;
         }
 
         return true;