refactored exposure compensators (opencv_stitching)

modules/stitching/exposure_compensate.cpp

@@ -54,15 +54,23 @@ Ptr<ExposureCompensator> ExposureCompensator::createDefault(int type)
         return new NoExposureCompensator();
     if (type == OVERLAP)
         return new OverlapExposureCompensator();
-    if (type == SEGMENT)
-        return new SegmentExposureCompensator();
     CV_Error(CV_StsBadArg, "unsupported exposure compensation method");
     return NULL;
 }
 
 
+void ExposureCompensator::feed(const vector<Point> &corners, const vector<Mat> &images, 
+                               const vector<Mat> &masks)
+{
+    vector<pair<Mat,uchar> > level_masks;
+    for (size_t i = 0; i < masks.size(); ++i)
+        level_masks.push_back(make_pair(masks[i], 255));
+    feed(corners, images, level_masks);
+}
+
+
 void OverlapExposureCompensator::feed(const vector<Point> &corners, const vector<Mat> &images, 
-                                      const vector<Mat> &masks)
+                                      const vector<pair<Mat,uchar> > &masks)
 {
     CV_Assert(corners.size() == images.size() && images.size() == masks.size());
 
@@ -84,9 +92,9 @@ void OverlapExposureCompensator::feed(const vector<Point> &corners, const vector
                 subimg1 = images[i](Rect(roi.tl() - corners[i], roi.br() - corners[i]));
                 subimg2 = images[j](Rect(roi.tl() - corners[j], roi.br() - corners[j]));
 
-                submask1 = masks[i](Rect(roi.tl() - corners[i], roi.br() - corners[i]));
-                submask2 = masks[j](Rect(roi.tl() - corners[j], roi.br() - corners[j]));
-                intersect = submask1 & submask2;
+                submask1 = masks[i].first(Rect(roi.tl() - corners[i], roi.br() - corners[i]));
+                submask2 = masks[j].first(Rect(roi.tl() - corners[j], roi.br() - corners[j]));
+                intersect = (submask1 == masks[i].second) & (submask2 == masks[j].second);
 
                 N(i, j) = N(j, i) = countNonZero(intersect);
 
@@ -127,22 +135,11 @@ void OverlapExposureCompensator::feed(const vector<Point> &corners, const vector
         }
     }
 
-    solve(A, b, gains_);
+    solve(A, b, gains);
 }
 
 
 void OverlapExposureCompensator::apply(int index, Point /*corner*/, Mat &image, const Mat &/*mask*/)
 {
-    image *= gains_(index, 0);
+    image *= gains(index, 0);
 }
-
-
-void SegmentExposureCompensator::feed(const vector<Point> &/*corners*/, const vector<Mat> &/*images*/, 
-                                      const vector<Mat> &/*masks*/)
-{
-}
-
-
-void SegmentExposureCompensator::apply(int /*index*/, Point /*corner*/, Mat &/*image*/, const Mat &/*mask*/)
-{
-}

modules/stitching/exposure_compensate.hpp

@@ -51,8 +51,10 @@ public:
     enum { NO, OVERLAP, SEGMENT };
     static cv::Ptr<ExposureCompensator> createDefault(int type);
 
+    void feed(const std::vector<cv::Point> &corners, const std::vector<cv::Mat> &images, 
+              const std::vector<cv::Mat> &masks);
     virtual void feed(const std::vector<cv::Point> &corners, const std::vector<cv::Mat> &images, 
-                      const std::vector<cv::Mat> &masks) = 0;
+                      const std::vector<std::pair<cv::Mat,uchar> > &masks) = 0;
     virtual void apply(int index, cv::Point corner, cv::Mat &image, const cv::Mat &mask) = 0;
 };
 
@@ -61,7 +63,7 @@ class NoExposureCompensator : public ExposureCompensator
 {
 public:
     void feed(const std::vector<cv::Point> &/*corners*/, const std::vector<cv::Mat> &/*images*/, 
-              const std::vector<cv::Mat> &/*masks*/) {};
+              const std::vector<std::pair<cv::Mat,uchar> > &/*masks*/) {};
     void apply(int /*index*/, cv::Point /*corner*/, cv::Mat &/*image*/, const cv::Mat &/*mask*/) {};
 };
 
@@ -70,20 +72,10 @@ class OverlapExposureCompensator : public ExposureCompensator
 {
 public:
     void feed(const std::vector<cv::Point> &corners, const std::vector<cv::Mat> &images, 
-              const std::vector<cv::Mat> &masks);
+              const std::vector<std::pair<cv::Mat,uchar> > &masks);
     void apply(int index, cv::Point corner, cv::Mat &image, const cv::Mat &mask);
 
-private:
-    cv::Mat_<double> gains_;
-};
-
-
-class SegmentExposureCompensator : public ExposureCompensator
-{
-public:
-    void feed(const std::vector<cv::Point> &corners, const std::vector<cv::Mat> &images, 
-              const std::vector<cv::Mat> &masks);
-    void apply(int index, cv::Point corner, cv::Mat &image, const cv::Mat &mask);
+    cv::Mat_<double> gains;
 };
 
 #endif // __OPENCV_EXPOSURE_COMPENSATE_HPP__

modules/stitching/main.cpp

@@ -201,8 +201,6 @@ int parseCmdArgs(int argc, char** argv)
                 expos_comp_type = ExposureCompensator::NO;
             else if (string(argv[i + 1]) == "overlap")
                 expos_comp_type = ExposureCompensator::OVERLAP;
-            else if (string(argv[i + 1]) == "segment")
-                expos_comp_type = ExposureCompensator::SEGMENT;
             else
             {
                 cout << "Bad exposure compensation method\n";

modules/stitching/precomp.hpp

@@ -46,14 +46,16 @@
 #include "cvconfig.h"
 #endif
 
+#include <vector>
+#include <algorithm>
+#include <utility>
 #include "opencv2/core/core.hpp"
 #include "opencv2/core/internal.hpp"
 #include "opencv2/imgproc/imgproc.hpp"
-#include "gcgraph.hpp"
 #include "opencv2/highgui/highgui.hpp"
 #include "opencv2/features2d/features2d.hpp"
 #include "opencv2/calib3d/calib3d.hpp"
 #include "opencv2/gpu/gpu.hpp"
-#include <vector>
+#include "gcgraph.hpp"
 
 #endif