align : image pyramid

include/hdrplus/align.h

@@ -25,6 +25,7 @@ class align
         void process( const hdrplus::burst& burst_images, \
                       std::vector<std::vector<std::vector<std::pair<int, int>>>>& aligements );
 
+    private:
         const std::vector<int> inv_scale_factors = { 1, 2, 2, 4 };
 };
 

include/hdrplus/utility.h

@@ -119,6 +119,4 @@ cv::Mat downsample_nearest_neighbour( cv::Mat src_image )
     return dst_image;
 }
 
-cv::Mat gaussian_blur( cv::Mat src_image, double sigma );
-
 } // namespace hdrplus

src/align.cpp

@@ -1,4 +1,6 @@
 #include <vector>
+#include <string>
+#include <stdexcept> // std::runtime_error
 #include <opencv2/opencv.hpp> // all opencv header
 #include "hdrplus/align.h"
 #include "hdrplus/burst.h"
@@ -7,46 +9,63 @@
 namespace hdrplus
 {
 
+// static function only visible within file
+static void build_image_pyramid( \
+    std::vector<cv::Mat>& images_pyramid, \
+    const cv::Mat& src_image, \
+    const std::vector<int>& inv_scale_factors )
+{
+    images_pyramid.resize( inv_scale_factors.size() );
+    
+    for ( int i = 0; i < inv_scale_factors.size(); ++i )
+    {
+        cv::Mat blur_image;
+        cv::Mat downsample_image;
+
+        switch ( inv_scale_factors[ i ] )
+        {
+        case 1:
+            images_pyramid[ images_pyramid.size() - i - 1 ] = src_image;
+            // cv::Mat use reference count, will not create deep copy
+            downsample_image = src_image;
+            break;
+        case 2:
+            // Gaussian blur
+            cv::GaussianBlur( downsample_image, blur_image, cv::Size(0, 0), 1.0 );
+
+            // Downsample
+            downsample_image = downsample_nearest_neighbour<uint16_t, 2>( blur_image );
+
+            // Add
+            images_pyramid[ images_pyramid.size() - i - 1 ] = downsample_image;
+
+            break;
+        case 4:
+            cv::GaussianBlur( downsample_image, blur_image, cv::Size(0, 0), 2.0 );
+            downsample_image = downsample_nearest_neighbour<uint16_t, 4>( blur_image );
+            images_pyramid[ images_pyramid.size() - i - 1 ] = downsample_image;
+            break;
+        default:
+            throw std::runtime_error("inv scale factor " + std::to_string( inv_scale_factors[ i ]) + "invalid" );
+        }
+    }
+}
+
 void align::process( const hdrplus::burst& burst_images, \
                      std::vector<std::vector<std::vector<std::pair<int, int>>>>& aligements )
 {
-    /*
     // Build image pyramid
     std::vector<std::vector<cv::Mat>> grayscale_images_pyramid;
     grayscale_images_pyramid.resize( burst_images.grayscale_images_pad.size() );
     for ( int img_idx = 0; img_idx < burst_images.grayscale_images_pad.size(); ++img_idx )
     {
-        grayscale_images_pyramid[ img_idx ].resize( inv_scale_factors.size() );
+        build_image_pyramid( grayscale_images_pyramid[ img_idx ], \
-
+                             burst_images.grayscale_images_pad[ img_idx ], \
-        // pyramid image are laied out from coarse to fine
+                             inv_scale_factors );
-        // level 0 is the original grayscale image 
-        grayscale_images_pyramid[ img_idx ][ inv_scale_factors.size() - 1 ] = burst_images.grayscale_images_pad[ img_idx];
-
-        // downsample and gaussian blur
-        for ( int i = 1; i < inv_scale_factors.size(); ++i )
-        {
-            int inv_scale_factor_i = inv_scale_factors[ i ];
-            cv::Mat blurred_image = \
-                hdrplus::gaussian_blur( grayscale_images_pyramid[ img_idx ][ i - 1 ], inv_scale_factor_i * 0.5 );
-            
-            // Get around with template
-            cv::Mat downsampled_blurred_image;
-            if ( inv_scale_factor_i == 2 )
-            {
-                hdrplus::downsample_nearest_neighbour<uint16_t, 2>( blurred_image );
-            }
-            else if ( inv_scale_factor_i == 4 )
-            {
-                hdrplus::downsample_nearest_neighbour<uint16_t, 4>( blurred_image );
     }
 
-            grayscale_images_pyramid[ img_idx ][ inv_scale_factors.size() - i - 1 ] = downsampled_blurred_image;
-        }
-    }
 
-    cv::GaussianBlur( src_image, dst_image, cv::Size(0, 0), sigma );
 
-    */
 }
 
 } // namespace hdrplus