changes blenders interface in opencv_stitching

modules/stitching/blenders.cpp

@@ -21,246 +21,206 @@ Ptr<Blender> Blender::createDefault(int type)
 }
 
 
-Point Blender::operator ()(const vector<Mat> &src, const vector<Point> &corners, const vector<Mat> &masks,
-                           Mat& dst)
+void Blender::prepare(const vector<Point> &corners, const vector<Size> &sizes)
 {
-    Mat dst_mask;
-    return (*this)(src, corners, masks, dst, dst_mask);
+    prepare(resultRoi(corners, sizes));
 }
 
 
-Point Blender::operator ()(const vector<Mat> &src, const vector<Point> &corners, const vector<Mat> &masks,
-                           Mat &dst, Mat &dst_mask)
+void Blender::prepare(Rect dst_roi)
 {
-    Point dst_tl = blend(src, corners, masks, dst, dst_mask);
-    dst.setTo(Scalar::all(0), dst_mask == 0);
-    return dst_tl;
+    dst_.create(dst_roi.size(), CV_32FC3);
+    dst_.setTo(Scalar::all(0));
+    dst_mask_.create(dst_roi.size(), CV_8U);
+    dst_mask_.setTo(Scalar::all(0));
+    dst_roi_ = dst_roi;
 }
 
 
-Point Blender::blend(const vector<Mat> &src, const vector<Point> &corners, const vector<Mat> &masks,
-                     Mat &dst, Mat &dst_mask)
+void Blender::feed(const Mat &img, const Mat &mask, Point tl) 
 {
-    for (size_t i = 0; i < src.size(); ++i)
-    {
-        CV_Assert(src[i].type() == CV_32FC3);
-        CV_Assert(masks[i].type() == CV_8U);
-    }
-    const int image_type = src[0].type();
-
-    Rect dst_roi = resultRoi(src, corners);
-
-    dst.create(dst_roi.size(), image_type);
-    dst.setTo(Scalar::all(0));
+    CV_Assert(img.type() == CV_32FC3);
+    CV_Assert(mask.type() == CV_8U);
 
-    dst_mask.create(dst_roi.size(), CV_8U);
-    dst_mask.setTo(Scalar::all(0));
+    int dx = tl.x - dst_roi_.x;
+    int dy = tl.y - dst_roi_.y;
 
-    for (size_t i = 0; i < src.size(); ++i)
+    for (int y = 0; y < img.rows; ++y)
     {
-        int dx = corners[i].x - dst_roi.x;
-        int dy = corners[i].y - dst_roi.y;
+        const Point3f *src_row = img.ptr<Point3f>(y);
+        Point3f *dst_row = dst_.ptr<Point3f>(dy + y);
+
+        const uchar *mask_row = mask.ptr<uchar>(y);
+        uchar *dst_mask_row = dst_mask_.ptr<uchar>(dy + y);
 
-        for (int y = 0; y < src[i].rows; ++y)
+        for (int x = 0; x < img.cols; ++x)
         {
-            const Point3f *src_row = src[i].ptr<Point3f>(y);
-            Point3f *dst_row = dst.ptr<Point3f>(dy + y);
-
-            const uchar *mask_row = masks[i].ptr<uchar>(y);
-            uchar *dst_mask_row = dst_mask.ptr<uchar>(dy + y);
-
-            for (int x = 0; x < src[i].cols; ++x)
-            {
-                if (mask_row[x])
-                    dst_row[dx + x] = src_row[x];
-                dst_mask_row[dx + x] |= mask_row[x];
-            }
+            if (mask_row[x]) 
+                dst_row[dx + x] = src_row[x];
+            dst_mask_row[dx + x] |= mask_row[x];
         }
     }
-
-    return dst_roi.tl();
 }
 
 
-Point FeatherBlender::blend(const vector<Mat> &src, const vector<Point> &corners, const vector<Mat> &masks,
-                            Mat &dst, Mat &dst_mask)
+void Blender::blend(Mat &dst, Mat &dst_mask)
 {
-    vector<Mat> weights(masks.size());
-    for (size_t i = 0; i < weights.size(); ++i)
-        createWeightMap(masks[i], sharpness_, weights[i]);
+    dst_.setTo(Scalar::all(0), dst_mask_ == 0);
+    dst = dst_;
+    dst_mask = dst_mask_;
+    dst_.release();
+    dst_mask_.release();
+}
 
-    Mat dst_weight;
-    Point dst_tl = blendLinear(src, corners, weights, dst, dst_weight);
-    dst_mask = dst_weight > WEIGHT_EPS;
 
-    return dst_tl;
+void FeatherBlender::prepare(Rect dst_roi)
+{
+    Blender::prepare(dst_roi);
+    dst_weight_map_.create(dst_roi.size(), CV_32F);
+    dst_weight_map_.setTo(0);
 }
 
 
-Point MultiBandBlender::blend(const vector<Mat> &src, const vector<Point> &corners, const vector<Mat> &masks,
-                             Mat &dst, Mat &dst_mask)
+void FeatherBlender::feed(const Mat &img, const Mat &mask, Point tl)
 {
-    CV_Assert(src.size() == corners.size() && src.size() == masks.size());
-    const int num_images = src.size();
-    const int img_type = src[0].type();
-
-    Rect dst_roi = resultRoi(src, corners);
-    computeResultMask(masks, corners, dst_mask);
+    CV_Assert(img.type() == CV_32FC3);
+    CV_Assert(mask.type() == CV_8U);
 
-    vector<Mat> dst_pyr_laplace(num_bands_ + 1);
-    dst_pyr_laplace[0].create(dst_roi.size(), img_type);
-    dst_pyr_laplace[0].setTo(Scalar::all(0));
+    int dx = tl.x - dst_roi_.x;
+    int dy = tl.y - dst_roi_.y;
 
-    vector<Mat> dst_band_weights(num_bands_ + 1);
-    dst_band_weights[0].create(dst_roi.size(), CV_32F);
-    dst_band_weights[0].setTo(0);
+    createWeightMap(mask, sharpness_, weight_map_);
 
-    for (int i = 1; i <= num_bands_; ++i)
+    for (int y = 0; y < img.rows; ++y)
     {
-        dst_pyr_laplace[i].create((dst_pyr_laplace[i - 1].rows + 1) / 2, 
-                                  (dst_pyr_laplace[i - 1].cols + 1) / 2, img_type);
-        dst_pyr_laplace[i].setTo(Scalar::all(0));
+        const Point3f* src_row = img.ptr<Point3f>(y);
+        Point3f* dst_row = dst_.ptr<Point3f>(dy + y);
 
-        dst_band_weights[i].create((dst_band_weights[i - 1].rows + 1) / 2,
-                                   (dst_band_weights[i - 1].cols + 1) / 2, CV_32F);
-        dst_band_weights[i].setTo(0);
-    }
+        const float* weight_row = weight_map_.ptr<float>(y);
+        float* dst_weight_row = dst_weight_map_.ptr<float>(dy + y);
 
-    for (int img_idx = 0; img_idx < num_images; ++img_idx)
-    {
-        int top = corners[img_idx].y - dst_roi.y;
-        int bottom = dst_roi.br().y - corners[img_idx].y - src[img_idx].rows;
-        int left = corners[img_idx].x - dst_roi.x;
-        int right = dst_roi.br().x - corners[img_idx].x - src[img_idx].cols;
-
-        vector<Mat> src_pyr_gauss(num_bands_ + 1);
-        copyMakeBorder(src[img_idx], src_pyr_gauss[0], top, bottom, left, right, BORDER_REFLECT);
-        for (int i = 0; i < num_bands_; ++i)
-            pyrDown(src_pyr_gauss[i], src_pyr_gauss[i + 1]);
-
-        vector<Mat> src_pyr_laplace;
-        createLaplacePyr(src_pyr_gauss, src_pyr_laplace);
-
-        vector<Mat> weight_pyr_gauss(num_bands_ + 1);
-        Mat mask_f;
-        masks[img_idx].convertTo(mask_f, CV_32F, 1./255.);
-        copyMakeBorder(mask_f, weight_pyr_gauss[0], top, bottom, left, right, BORDER_CONSTANT);
-        for (int i = 0; i < num_bands_; ++i)
-            pyrDown(weight_pyr_gauss[i], weight_pyr_gauss[i + 1]);
-
-        for (int band_idx = 0; band_idx <= num_bands_; ++band_idx)
+        for (int x = 0; x < img.cols; ++x)               
         {
-            for (int y = 0; y < dst_pyr_laplace[band_idx].rows; ++y)
-            {
-                const Point3f* src_row = src_pyr_laplace[band_idx].ptr<Point3f>(y);
-                const float* weight_row = weight_pyr_gauss[band_idx].ptr<float>(y);
-                Point3f* dst_row = dst_pyr_laplace[band_idx].ptr<Point3f>(y);
-                for (int x = 0; x < dst_pyr_laplace[band_idx].cols; ++x)               
-                    dst_row[x] += src_row[x] * weight_row[x];
-            }
-            dst_band_weights[band_idx] += weight_pyr_gauss[band_idx];
+            dst_row[dx + x] += src_row[x] * weight_row[x];
+            dst_weight_row[dx + x] += weight_row[x];
         }
     }
+}
 
-    for (int band_idx = 0; band_idx <= num_bands_; ++band_idx)
-        normalize(dst_band_weights[band_idx], dst_pyr_laplace[band_idx]);
 
-    restoreImageFromLaplacePyr(dst_pyr_laplace);
-    dst = dst_pyr_laplace[0];
-    return dst_roi.tl();
+void FeatherBlender::blend(Mat &dst, Mat &dst_mask)
+{
+    normalize(dst_weight_map_, dst_);
+    dst_mask_ = dst_weight_map_ > WEIGHT_EPS;
+    Blender::blend(dst, dst_mask);
 }
 
 
-//////////////////////////////////////////////////////////////////////////////
-// Auxiliary functions
-
-Rect resultRoi(const vector<Mat> &src, const vector<Point> &corners)
+void MultiBandBlender::prepare(Rect dst_roi)
 {
-    Point tl(numeric_limits<int>::max(), numeric_limits<int>::max());
-    Point br(numeric_limits<int>::min(), numeric_limits<int>::min());
+    Blender::prepare(dst_roi);
+
+    dst_pyr_laplace_.resize(num_bands_ + 1);
+    dst_pyr_laplace_[0].create(dst_roi.size(), CV_32FC3);
+    dst_pyr_laplace_[0].setTo(Scalar::all(0));
 
-    CV_Assert(src.size() == corners.size());
-    for (size_t i = 0; i < src.size(); ++i)
+    dst_band_weights_.resize(num_bands_ + 1);
+    dst_band_weights_[0].create(dst_roi.size(), CV_32F);
+    dst_band_weights_[0].setTo(0);
+
+    for (int i = 1; i <= num_bands_; ++i)
     {
-        tl.x = min(tl.x, corners[i].x);
-        tl.y = min(tl.y, corners[i].y);
-        br.x = max(br.x, corners[i].x + src[i].cols);
-        br.y = max(br.y, corners[i].y + src[i].rows);
+        dst_pyr_laplace_[i].create((dst_pyr_laplace_[i - 1].rows + 1) / 2, 
+                                   (dst_pyr_laplace_[i - 1].cols + 1) / 2, CV_32FC3);
+        dst_band_weights_[i].create((dst_band_weights_[i - 1].rows + 1) / 2,
+                                    (dst_band_weights_[i - 1].cols + 1) / 2, CV_32F);
+        dst_pyr_laplace_[i].setTo(Scalar::all(0));
+        dst_band_weights_[i].setTo(0);
     }
-
-    return Rect(tl, br);
 }
 
 
-Point computeResultMask(const vector<Mat> &masks, const vector<Point> &corners, Mat &dst_mask)
+void MultiBandBlender::feed(const Mat &img, const Mat &mask, Point tl)
 {
-    Rect dst_roi = resultRoi(masks, corners);
-
-    dst_mask.create(dst_roi.size(), CV_8U);
-    dst_mask.setTo(Scalar::all(0));
+    CV_Assert(img.type() == CV_32FC3);
+    CV_Assert(mask.type() == CV_8U);
 
-    for (size_t i = 0; i < masks.size(); ++i)
+    int top = tl.y - dst_roi_.y;
+    int left = tl.x - dst_roi_.x;
+    int bottom = dst_roi_.br().y - tl.y - img.rows;
+    int right = dst_roi_.br().x - tl.x - img.cols;
+
+    // Create the source image Laplacian pyramid
+    vector<Mat> src_pyr_gauss(num_bands_ + 1);
+    copyMakeBorder(img, src_pyr_gauss[0], top, bottom, left, right, 
+                   BORDER_REFLECT);
+    for (int i = 0; i < num_bands_; ++i)
+        pyrDown(src_pyr_gauss[i], src_pyr_gauss[i + 1]);
+    vector<Mat> src_pyr_laplace;
+    createLaplacePyr(src_pyr_gauss, src_pyr_laplace);
+    src_pyr_gauss.clear();
+
+    // Create the weight map Gaussian pyramid
+    Mat weight_map;
+    mask.convertTo(weight_map, CV_32F, 1./255.);
+    vector<Mat> weight_pyr_gauss(num_bands_ + 1);
+    copyMakeBorder(weight_map, weight_pyr_gauss[0], top, bottom, left, right, 
+                   BORDER_CONSTANT);
+    for (int i = 0; i < num_bands_; ++i)
+        pyrDown(weight_pyr_gauss[i], weight_pyr_gauss[i + 1]);
+
+    // Add weighted layer of the source image to the final Laplacian pyramid layer
+    for (int i = 0; i <= num_bands_; ++i)
     {
-        int dx = corners[i].x - dst_roi.x;
-        int dy = corners[i].y - dst_roi.y;
-
-        for (int y = 0; y < masks[i].rows; ++y)
+        for (int y = 0; y < dst_pyr_laplace_[i].rows; ++y)
         {
-            const uchar *mask_row = masks[i].ptr<uchar>(y);
-            uchar *dst_mask_row = dst_mask.ptr<uchar>(dy + y);
+            const Point3f* src_row = src_pyr_laplace[i].ptr<Point3f>(y);
+            Point3f* dst_row = dst_pyr_laplace_[i].ptr<Point3f>(y);
 
-            for (int x = 0; x < masks[i].cols; ++x)
-                dst_mask_row[dx + x] |= mask_row[x];
-        }
-    }
+            const float* weight_row = weight_pyr_gauss[i].ptr<float>(y);
 
-    return dst_roi.tl();
+            for (int x = 0; x < dst_pyr_laplace_[i].cols; ++x)               
+                dst_row[x] += src_row[x] * weight_row[x];
+        }
+        dst_band_weights_[i] += weight_pyr_gauss[i];
+    }    
 }
 
 
-Point blendLinear(const vector<Mat> &src, const vector<Point> &corners, const vector<Mat> &weights,
-                  Mat &dst, Mat& dst_weight)
+void MultiBandBlender::blend(Mat &dst, Mat &dst_mask)
 {
-    for (size_t i = 0; i < src.size(); ++i)
-    {
-        CV_Assert(src[i].type() == CV_32FC3);
-        CV_Assert(weights[i].type() == CV_32F);
-    }
-    const int image_type = src[0].type();
+    for (int i = 0; i <= num_bands_; ++i)
+        normalize(dst_band_weights_[i], dst_pyr_laplace_[i]);
 
-    Rect dst_roi = resultRoi(src, corners);
+    restoreImageFromLaplacePyr(dst_pyr_laplace_);
 
-    dst.create(dst_roi.size(), image_type);
-    dst.setTo(Scalar::all(0));
+    dst_ = dst_pyr_laplace_[0];
+    dst_mask_ = dst_band_weights_[0] > WEIGHT_EPS;
+    dst_pyr_laplace_.clear();
+    dst_band_weights_.clear();
 
-    dst_weight.create(dst_roi.size(), CV_32F);
-    dst_weight.setTo(Scalar::all(0));
+    Blender::blend(dst, dst_mask);
+}
 
-    // Compute colors sums and weights
-    for (size_t i = 0; i < src.size(); ++i)
-    {
-        int dx = corners[i].x - dst_roi.x;
-        int dy = corners[i].y - dst_roi.y;
 
-        for (int y = 0; y < src[i].rows; ++y)
-        {
-            const Point3f *src_row = src[i].ptr<Point3f>(y);
-            Point3f *dst_row = dst.ptr<Point3f>(dy + y);
+//////////////////////////////////////////////////////////////////////////////
+// Auxiliary functions
 
-            const float *weight_row = weights[i].ptr<float>(y);
-            float *dst_weight_row = dst_weight.ptr<float>(dy + y);
+Rect resultRoi(const vector<Point> &corners, const vector<Size> &sizes)
+{
+    Point tl(numeric_limits<int>::max(), numeric_limits<int>::max());
+    Point br(numeric_limits<int>::min(), numeric_limits<int>::min());
 
-            for (int x = 0; x < src[i].cols; ++x)
-            {
-                dst_row[dx + x] += src_row[x] * weight_row[x];
-                dst_weight_row[dx + x] += weight_row[x];
-            }
-        }
+    CV_Assert(sizes.size() == corners.size());
+    for (size_t i = 0; i < corners.size(); ++i)
+    {
+        tl.x = min(tl.x, corners[i].x);
+        tl.y = min(tl.y, corners[i].y);
+        br.x = max(br.x, corners[i].x + sizes[i].width);
+        br.y = max(br.y, corners[i].y + sizes[i].height);
     }
 
-    normalize(dst_weight, dst);
-
-    return dst_roi.tl();
+    return Rect(tl, br);
 }
 
 

modules/stitching/blenders.hpp

@@ -9,58 +9,59 @@ class Blender
 {
 public:
     enum { NO, FEATHER, MULTI_BAND };
-
     static cv::Ptr<Blender> createDefault(int type);
 
-    cv::Point operator ()(const std::vector<cv::Mat> &src, const std::vector<cv::Point> &corners, const std::vector<cv::Mat> &masks,
-                          cv::Mat& dst);
-    cv::Point operator ()(const std::vector<cv::Mat> &src, const std::vector<cv::Point> &corners, const std::vector<cv::Mat> &masks,
-                          cv::Mat& dst, cv::Mat& dst_mask);
+    void prepare(const std::vector<cv::Point> &corners, const std::vector<cv::Size> &sizes);
+    virtual void prepare(cv::Rect dst_roi);
+    virtual void feed(const cv::Mat &img, const cv::Mat &mask, cv::Point tl);
+    virtual void blend(cv::Mat &dst, cv::Mat &dst_mask);
 
 protected:
-    virtual cv::Point blend(const std::vector<cv::Mat> &src, const std::vector<cv::Point> &corners, const std::vector<cv::Mat> &masks,
-                            cv::Mat& dst, cv::Mat& dst_mask);
+    cv::Mat dst_, dst_mask_;
+    cv::Rect dst_roi_;
 };
 
 
 class FeatherBlender : public Blender
 {
 public:
-    FeatherBlender(float sharpness = 0.02f) : sharpness_(sharpness) {}
+    FeatherBlender(float sharpness = 0.02f) { setSharpness(sharpness); }
+    float sharpness() const { return sharpness_; }
+    void setSharpness(float val) { sharpness_ = val; }
 
-private:
-    cv::Point blend(const std::vector<cv::Mat> &src, const std::vector<cv::Point> &corners, const std::vector<cv::Mat> &masks,
-                    cv::Mat &dst, cv::Mat &dst_mask);
+    void prepare(cv::Rect dst_roi);
+    void feed(const cv::Mat &img, const cv::Mat &mask, cv::Point tl);
+    void blend(cv::Mat &dst, cv::Mat &dst_mask);
 
+private:
     float sharpness_;
+    cv::Mat weight_map_;
+    cv::Mat dst_weight_map_;
 };
 
 
 class MultiBandBlender : public Blender
 {
 public:
-    MultiBandBlender(int num_bands = 7) : num_bands_(num_bands) {}
-
+    MultiBandBlender(int num_bands = 7) { setNumBands(num_bands); }
     int numBands() const { return num_bands_; }
     void setNumBands(int val) { num_bands_ = val; }
 
-private:
-    cv::Point blend(const std::vector<cv::Mat> &src, const std::vector<cv::Point> &corners, const std::vector<cv::Mat> &masks,
-                    cv::Mat& dst, cv::Mat& dst_mask);
+    void prepare(cv::Rect dst_roi);
+    void feed(const cv::Mat &img, const cv::Mat &mask, cv::Point tl);
+    void blend(cv::Mat &dst, cv::Mat &dst_mask);
 
+private:
     int num_bands_;
+    std::vector<cv::Mat> dst_pyr_laplace_;
+    std::vector<cv::Mat> dst_band_weights_;
 };
 
 
 //////////////////////////////////////////////////////////////////////////////
 // Auxiliary functions
 
-cv::Rect resultRoi(const std::vector<cv::Mat> &src, const std::vector<cv::Point> &corners);
-
-cv::Point computeResultMask(const std::vector<cv::Mat> &masks, const std::vector<cv::Point> &corners, cv::Mat &mask);
-
-cv::Point blendLinear(const std::vector<cv::Mat> &src, const std::vector<cv::Point> &corners, const std::vector<cv::Mat> &weights,
-                      cv::Mat& dst, cv::Mat& dst_weight);
+cv::Rect resultRoi(const std::vector<cv::Point> &corners, const std::vector<cv::Size> &sizes);
 
 void normalize(const cv::Mat& weight, cv::Mat& src);
 

modules/stitching/main.cpp

@@ -71,7 +71,6 @@ int main(int argc, char* argv[])
     }
 
     int64 t = getTickCount();
-    LOGLN("Parsing params and reading images...");
     for (int i = 1; i < argc; ++i)
     {
         if (string(argv[i]) == "--trygpu")
@@ -189,7 +188,6 @@ int main(int argc, char* argv[])
         else
             img_names.push_back(argv[i]);
     }
-    LOGLN("Parsing params and reading images, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
 
     int num_images = static_cast<int>(img_names.size());
     if (num_images < 2)
@@ -198,8 +196,8 @@ int main(int argc, char* argv[])
         return -1;
     }
 
+    LOGLN("Reading images and finding features...");
     t = getTickCount();
-    LOGLN("Finding features...");
     vector<ImageFeatures> features(num_images);
     SurfFeaturesFinder finder(trygpu);
     Mat full_img, img;
@@ -224,10 +222,10 @@ int main(int argc, char* argv[])
         }
         finder(img, features[i]);
     }
-    LOGLN("Finding features, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
+    LOGLN("Reading images and finding features, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
 
-    t = getTickCount();
     LOGLN("Pairwise matching... ");
+    t = getTickCount();
     vector<MatchesInfo> pairwise_matches;
     BestOf2NearestMatcher matcher(trygpu);
     if (user_match_conf)
@@ -248,8 +246,8 @@ int main(int argc, char* argv[])
         return -1;
     }
 
-    t = getTickCount();
     LOGLN("Estimating rotations...");
+    t = getTickCount();
     HomographyBasedEstimator estimator;
     vector<CameraParams> cameras;
     estimator(features, pairwise_matches, cameras);
@@ -263,16 +261,16 @@ int main(int argc, char* argv[])
         LOGLN("Initial focal length " << i << ": " << cameras[i].focal);
     }
 
-    t = getTickCount();
     LOGLN("Bundle adjustment... ");
+    t = getTickCount();
     BundleAdjuster adjuster(ba_space, conf_thresh);
     adjuster(features, pairwise_matches, cameras);
     LOGLN("Bundle adjustment, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
 
     if (wave_correct)
     {
-        t = getTickCount();
         LOGLN("Wave correcting...");
+        t = getTickCount();
         vector<Mat> rmats;
         for (size_t i = 0; i < cameras.size(); ++i)
             rmats.push_back(cameras[i].R);
@@ -292,9 +290,10 @@ int main(int argc, char* argv[])
     nth_element(focals.begin(), focals.end(), focals.begin() + focals.size() / 2);
     float camera_focal = static_cast<float>(focals[focals.size() / 2]);
 
-    t = getTickCount();
     vector<Mat> images(num_images);
+
     LOGLN("Compose scaling...");
+    t = getTickCount();
     for (int i = 0; i < num_images; ++i)
     {
         Mat full_img = imread(img_names[i]);
@@ -319,38 +318,54 @@ int main(int argc, char* argv[])
     }
 
     vector<Point> corners(num_images);
+    vector<Size> sizes(num_images);
     vector<Mat> masks_warped(num_images);
     vector<Mat> images_warped(num_images);
 
-    t = getTickCount();
     LOGLN("Warping images... ");
+    t = getTickCount();
+
     Ptr<Warper> warper = Warper::createByCameraFocal(camera_focal, warp_type);
     for (int i = 0; i < num_images; ++i)
     {
-        corners[i] = (*warper)(images[i], static_cast<float>(cameras[i].focal), cameras[i].R, images_warped[i]);
-        (*warper)(masks[i], static_cast<float>(cameras[i].focal), cameras[i].R, masks_warped[i], INTER_NEAREST, BORDER_CONSTANT);
+        corners[i] = (*warper)(images[i], static_cast<float>(cameras[i].focal), cameras[i].R, 
+                               images_warped[i]);
+        sizes[i] = images_warped[i].size();
+        (*warper)(masks[i], static_cast<float>(cameras[i].focal), cameras[i].R, masks_warped[i], 
+                  INTER_NEAREST, BORDER_CONSTANT);
     }
+
     vector<Mat> images_f(num_images);
     for (int i = 0; i < num_images; ++i)
         images_warped[i].convertTo(images_f[i], CV_32F);
+
     LOGLN("Warping images, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
 
-    t = getTickCount();
     LOGLN("Finding seams...");
+    t = getTickCount();
     Ptr<SeamFinder> seam_finder = SeamFinder::createDefault(seam_find_type);
     (*seam_finder)(images_f, corners, masks_warped);
     LOGLN("Finding seams, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
 
-    t = getTickCount();
     LOGLN("Blending images...");
+    t = getTickCount();
+
     Ptr<Blender> blender = Blender::createDefault(blend_type);
+
     if (blend_type == Blender::MULTI_BAND)
+    {
         // Ensure last pyramid layer area is about 1 pix 
-        dynamic_cast<MultiBandBlender*>((Blender*)(blender))
-            ->setNumBands(static_cast<int>(ceil(log(static_cast<double>(images_f[0].size().area())) 
-                                                / log(4.0))));
+        MultiBandBlender* mb = dynamic_cast<MultiBandBlender*>((Blender*)(blender));
+        mb->setNumBands(static_cast<int>(ceil(log(static_cast<double>(images_f[0].size().area())) / log(4.0))));
+        LOGLN("Multi-band blending num. bands: " << mb->numBands());
+    }
+
+    blender->prepare(corners, sizes);
+    for (int i = 0; i < num_images; ++i)
+        blender->feed(images_f[i], masks_warped[i], corners[i]);
     Mat result, result_mask;
-    (*blender)(images_f, corners, masks_warped, result, result_mask);
+    blender->blend(result, result_mask);
+
     LOGLN("Blending images, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
 
     imwrite(result_name, result);