Generate histograms for HDR and LDR images

haader.cpp

 
 #include "haader.h"
 
+#define max_number(a, b) (a) > (b) ? (a) : (b)
+#define min_number(a, b) (a) < (b) ? (a) : (b)
+
 using namespace std;
 using namespace haader;
 
     return output;
 }
 
+Histogram HdrImage::histogram(unsigned int number_of_bins) const {
+    Histogram hist;
+
+    hist.m_bins.resize(number_of_bins, 0);
+
+    if (m_image_data.size() == 0) {
+        return hist;
+    }
+
+    hist.m_min_value = m_image_data[0];
+    hist.m_max_value = m_image_data[0];
+
+    for (unsigned int i = 0; i < m_image_data.size(); i++) {
+        double val = m_image_data[i];
+        hist.m_min_value = min_number(hist.m_min_value, val);
+        hist.m_max_value = max_number(hist.m_max_value, val);
+    }
+
+    double scale = (double)number_of_bins / (hist.m_max_value - hist.m_min_value);
+
+    for (unsigned int i = 0; i < m_image_data.size(); i++) {
+        double val = m_image_data[i];
+        int bin = (val - hist.m_min_value) * scale;
+        bin = bin < 0 ? 0 : (bin >= (int)number_of_bins ? (number_of_bins - 1) : bin);
+        hist.m_bins[bin]++;
+    }
+
+    hist.m_max_freq = 0;
+    for (unsigned int i = 0; i < number_of_bins; i++) {
+        hist.m_max_freq = max_number(hist.m_max_freq, hist.m_bins[i]);
+    }
+
+    return hist;
+}
+
 
 HdrImageStack::HdrImageStack() {
 }
                      << file_paths[i]
                      << "\")"
                      << endl;
+                m_images.clear();
                 return false;
             }
             if (m_images[i].get_exposure_time() == 0.0) {
                      << file_paths[i]
                      << "\")"
                      << endl;
+                m_images.clear();
                 return false;
             }
         } else {
+            m_images.clear();
             return false;
         }
     }
         }
     }
 
-    if (output.repair()) {
-        cout << "Inverse response function" << endl;
-        cout << endl;
-        for (unsigned int i = 0; i < 256; i++) {
-            cout << i << "," << output.m_lookup_table[i] << endl;
-        }
-        cout << endl;
-
-        return true;
-    } else {
-        return false;
-    }
+    return output.repair();
 }
 
 HdrImage HdrImageStack::get_hdr_image(const InverseResponseFunction &invRespFunc) {

haader.h

             // 1.0 / (m_max_value - m_min_value)
             double m_recip_range;
 
-            // Response function is implemented as a lookup table of with 256 values
+            // Response function is implemented with a lookup table
             std::vector<int> m_lookup_table;
     };
 
             std::vector<double> m_lookup_table;
     };
 
+    class Histogram {
+        public:
+            std::vector<unsigned int> m_bins;
+            double m_min_value;
+            double m_max_value;
+            unsigned int m_max_freq;
+    };
+
     // High Dynamic Range Image.
     // Stores the logarithm of the scene luminance for each pixel/channel in a high resolution.
     class HdrImage {
             //     under-/overexposure in parts of the image.
             Image expose(double exposure_time, const ResponseFunction &rf, double compression=1.0);
 
+            Histogram histogram(unsigned int number_of_bins) const;
+
         private:
             // Pixel values (logarithm of scene luminance). The channels are interleaved (RGBRGBRGB...).
             std::vector<double> m_image_data;
             // The images
             std::vector<Image> m_images;
     };
-
 }
 
 #endif // HAADER_ILUCF4Z0

image.cpp

 #include "image.h"
 #include "exif.h"
 
+#define max_number(a, b) (a) > (b) ? (a) : (b)
+#define min_number(a, b) (a) < (b) ? (a) : (b)
+
 using namespace std;
 using namespace haader;
 
         cerr << "Can not read \"" << file_path << "\" as an image." << endl;
         return false;
     }
-    
+
     stbi_image_free(data);
 }
 
     }
 }
 
+LdrHistogram Image::histogram() const {
+    LdrHistogram hist;
+
+    hist.m_bins.resize(256, 0);
+
+    if (m_image_data.size() == 0) {
+        return hist;
+    }
+
+    for (unsigned int i = 0; i < m_image_data.size(); i++) {
+        hist.m_bins[m_image_data[i]]++;
+    }
+
+    hist.m_max_freq = 0;
+    for (unsigned int i = 0; i < 256; i++) {
+        hist.m_max_freq = max_number(hist.m_max_freq, hist.m_bins[i]);
+    }
+
+    return hist;
+}
+
+
 unsigned int Image::get_width() const {
     return m_width;
 }

image.h

 
 namespace haader {
 
+    class LdrHistogram {
+        public:
+            std::vector<unsigned int> m_bins;
+            unsigned int m_max_freq;
+    };
+
     // A low dynamic range image/photograph with an associated exposure time.
     class Image {
         friend class HdrImageStack;
             bool read_from_file(const char *file_path);
             bool save_as_ppm_file(const char *file_path, bool ascii=false) const;
 
+            LdrHistogram histogram() const;
+
             unsigned int get_width() const;
             unsigned int get_height() const;
             unsigned int get_components() const;