reg: enable wrapping for all significant methods

sovrasov · sovrasov · commit 51464723b83d · 2017-02-06T18:33:12.000+03:00
diff --git a/modules/reg/include/opencv2/reg/mapaffine.hpp b/modules/reg/include/opencv2/reg/mapaffine.hpp
@@ -85,6 +85,10 @@ class CV_EXPORTS_W MapAffine : public Map
         return linTr_;
     }
 
+    CV_WRAP void getLinTr(OutputArray linTr) const {
+        Mat(linTr_).copyTo(linTr);
+    }
+
     /*!
      * Return displacement part of the affine transformation
      * \return Displacement part of the affine transformation
@@ -93,6 +97,10 @@ class CV_EXPORTS_W MapAffine : public Map
         return shift_;
     }
 
+    CV_WRAP void getShift(OutputArray shift) const {
+        Mat(shift_).copyTo(shift);
+    }
+
 private:
     cv::Matx<double, 2, 2> linTr_;
     cv::Vec<double, 2> shift_;
diff --git a/modules/reg/include/opencv2/reg/mapper.hpp b/modules/reg/include/opencv2/reg/mapper.hpp
@@ -63,7 +63,7 @@ class CV_EXPORTS_W Mapper
      * \param[in,out] res Map from img1 to img2, stored in a smart pointer. If present as input,
      *       it is an initial rough estimation that the mapper will try to refine.
      */
-    virtual void calculate(InputArray img1, InputArray img2, cv::Ptr<Map>& res) const = 0;
+    CV_WRAP virtual cv::Ptr<Map> calculate(InputArray img1, InputArray img2, cv::Ptr<Map> init = cv::Ptr<Map>()) const = 0;
 
     /*
      * Returns a map compatible with the Mapper class
diff --git a/modules/reg/include/opencv2/reg/mappergradaffine.hpp b/modules/reg/include/opencv2/reg/mappergradaffine.hpp
@@ -55,7 +55,7 @@ class CV_EXPORTS_W MapperGradAffine: public Mapper
     CV_WRAP MapperGradAffine();
     ~MapperGradAffine(void);
 
-    virtual void calculate(InputArray img1, InputArray img2, cv::Ptr<Map>& res) const;
+    CV_WRAP virtual cv::Ptr<Map> calculate(InputArray img1, InputArray img2, cv::Ptr<Map> init = cv::Ptr<Map>()) const;
 
     CV_WRAP cv::Ptr<Map> getMap() const;
 };
diff --git a/modules/reg/include/opencv2/reg/mappergradeuclid.hpp b/modules/reg/include/opencv2/reg/mappergradeuclid.hpp
@@ -55,7 +55,7 @@ class CV_EXPORTS_W MapperGradEuclid: public Mapper
     CV_WRAP MapperGradEuclid();
     ~MapperGradEuclid();
 
-    virtual void calculate(InputArray img1, InputArray img2, cv::Ptr<Map>& res) const;
+    CV_WRAP virtual cv::Ptr<Map> calculate(InputArray img1, InputArray img2, cv::Ptr<Map> init = cv::Ptr<Map>()) const;
 
     CV_WRAP cv::Ptr<Map> getMap() const;
 };
diff --git a/modules/reg/include/opencv2/reg/mappergradproj.hpp b/modules/reg/include/opencv2/reg/mappergradproj.hpp
@@ -55,7 +55,7 @@ class CV_EXPORTS_W MapperGradProj: public Mapper
     CV_WRAP MapperGradProj();
     ~MapperGradProj();
 
-    virtual void calculate(InputArray img1, InputArray img2, cv::Ptr<Map>& res) const;
+    CV_WRAP virtual cv::Ptr<Map> calculate(InputArray img1, InputArray img2, cv::Ptr<Map> init = cv::Ptr<Map>()) const;
 
     CV_WRAP cv::Ptr<Map> getMap() const;
 };
diff --git a/modules/reg/include/opencv2/reg/mappergradshift.hpp b/modules/reg/include/opencv2/reg/mappergradshift.hpp
@@ -55,7 +55,7 @@ class CV_EXPORTS_W MapperGradShift: public Mapper
     CV_WRAP MapperGradShift();
     virtual ~MapperGradShift();
 
-    virtual void calculate(InputArray img1, InputArray img2, cv::Ptr<Map>& res) const;
+    CV_WRAP virtual cv::Ptr<Map> calculate(InputArray img1, InputArray img2, cv::Ptr<Map> init = cv::Ptr<Map>()) const;
 
     CV_WRAP cv::Ptr<Map> getMap() const;
 };
diff --git a/modules/reg/include/opencv2/reg/mappergradsimilar.hpp b/modules/reg/include/opencv2/reg/mappergradsimilar.hpp
@@ -55,7 +55,7 @@ class CV_EXPORTS_W MapperGradSimilar: public Mapper
     CV_WRAP MapperGradSimilar();
     ~MapperGradSimilar();
 
-    virtual void calculate(InputArray img1, InputArray img2, cv::Ptr<Map>& res) const;
+    CV_WRAP virtual cv::Ptr<Map> calculate(InputArray img1, InputArray img2, cv::Ptr<Map> init = cv::Ptr<Map>()) const;
 
     CV_WRAP cv::Ptr<Map> getMap() const;
 };
diff --git a/modules/reg/include/opencv2/reg/mapperpyramid.hpp b/modules/reg/include/opencv2/reg/mapperpyramid.hpp
@@ -57,9 +57,9 @@ class CV_EXPORTS_W MapperPyramid: public Mapper
      * Constructor
      * \param[in] baseMapper Base mapper used for the refinements
      */
-    MapperPyramid(const Mapper& baseMapper);
+    CV_WRAP MapperPyramid(Ptr<Mapper> baseMapper);
 
-    void calculate(InputArray img1, InputArray img2, cv::Ptr<Map>& res) const;
+    CV_WRAP virtual cv::Ptr<Map> calculate(InputArray img1, InputArray img2, cv::Ptr<Map> init = cv::Ptr<Map>()) const;
 
     CV_WRAP cv::Ptr<Map> getMap() const;
 
diff --git a/modules/reg/include/opencv2/reg/mapprojec.hpp b/modules/reg/include/opencv2/reg/mapprojec.hpp
@@ -85,10 +85,14 @@ class CV_EXPORTS_W MapProjec : public Map
         return projTr_;
     }
 
+    CV_WRAP void getProjTr(OutputArray projTr) const {
+        Mat(projTr_).copyTo(projTr);
+    }
+
     /*!
      * Normalizes object's homography
      */
-    void normalize(void) {
+    CV_WRAP void normalize() {
         double z = 1./projTr_(2, 2);
         for(size_t v_i = 0; v_i < sizeof(projTr_.val)/sizeof(projTr_.val[0]); ++v_i)
             projTr_.val[v_i] *= z;
diff --git a/modules/reg/include/opencv2/reg/mapshift.hpp b/modules/reg/include/opencv2/reg/mapshift.hpp
@@ -85,6 +85,10 @@ class CV_EXPORTS_W MapShift : public Map
         return shift_;
     }
 
+    CV_WRAP void getShift(OutputArray shift) const {
+        Mat(shift_).copyTo(shift);
+    }
+
 private:
     cv::Vec<double, 2> shift_;      /*< Displacement */
 };
diff --git a/modules/reg/src/mappergradaffine.cpp b/modules/reg/src/mappergradaffine.cpp
@@ -56,7 +56,7 @@ MapperGradAffine::~MapperGradAffine()
 
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-void MapperGradAffine::calculate(InputArray _img1, InputArray image2, cv::Ptr<Map>& res) const
+cv::Ptr<Map> MapperGradAffine::calculate(InputArray _img1, InputArray image2, cv::Ptr<Map> init) const
 {
     Mat img1 = _img1.getMat();
     Mat gradx, grady, imgDiff;
@@ -66,9 +66,9 @@ void MapperGradAffine::calculate(InputArray _img1, InputArray image2, cv::Ptr<Ma
     CV_DbgAssert(img1.channels() == image2.channels());
     CV_DbgAssert(img1.channels() == 1 || img1.channels() == 3);
 
-    if(!res.empty()) {
+    if(!init.empty()) {
         // We have initial values for the registration: we move img2 to that initial reference
-        res->inverseWarp(image2, img2);
+        init->inverseWarp(image2, img2);
     } else {
         img2 = image2.getMat();
     }
@@ -145,11 +145,14 @@ void MapperGradAffine::calculate(InputArray _img1, InputArray image2, cv::Ptr<Ma
 
     Matx<double, 2, 2> linTr(k(0) + 1., k(1), k(3), k(4) + 1.);
     Vec<double, 2> shift(k(2), k(5));
-    if(res.empty()) {
-        res = Ptr<Map>(new MapAffine(linTr, shift));
+    if(init.empty()) {
+        return Ptr<Map>(new MapAffine(linTr, shift));
     } else {
         Ptr<MapAffine> newTr(new MapAffine(linTr, shift));
-        res->compose(newTr);
+        MapAffine* initPtr = dynamic_cast<MapAffine*>(init.get());
+        Ptr<MapAffine> oldTr(new MapAffine(initPtr->getLinTr(), initPtr->getShift()));
+        oldTr->compose(newTr);
+        return oldTr;
    }
 }
 
diff --git a/modules/reg/src/mappergradeuclid.cpp b/modules/reg/src/mappergradeuclid.cpp
@@ -56,8 +56,8 @@ MapperGradEuclid::~MapperGradEuclid()
 
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-void MapperGradEuclid::calculate(
-    InputArray _img1, InputArray image2, cv::Ptr<Map>& res) const
+cv::Ptr<Map> MapperGradEuclid::calculate(
+    InputArray _img1, InputArray image2, cv::Ptr<Map> init) const
 {
     Mat img1 = _img1.getMat();
     Mat gradx, grady, imgDiff;
@@ -67,9 +67,9 @@ void MapperGradEuclid::calculate(
     CV_DbgAssert(img1.channels() == image2.channels());
     CV_DbgAssert(img1.channels() == 1 || img1.channels() == 3);
 
-    if(!res.empty()) {
+    if(!init.empty()) {
         // We have initial values for the registration: we move img2 to that initial reference
-        res->inverseWarp(image2, img2);
+        init->inverseWarp(image2, img2);
     } else {
         img2 = image2.getMat();
     }
@@ -112,11 +112,14 @@ void MapperGradEuclid::calculate(
     Matx<double, 2, 2> linTr(cosT, -sinT, sinT, cosT);
     Vec<double, 2> shift(k(0), k(1));
 
-    if(res.empty()) {
-        res = Ptr<Map>(new MapAffine(linTr, shift));
+    if(init.empty()) {
+        return Ptr<Map>(new MapAffine(linTr, shift));
     } else {
         Ptr<MapAffine> newTr(new MapAffine(linTr, shift));
-        res->compose(newTr);
+        MapAffine* initPtr = dynamic_cast<MapAffine*>(init.get());
+        Ptr<MapAffine> oldTr(new MapAffine(initPtr->getLinTr(), initPtr->getShift()));
+        oldTr->compose(newTr);
+        return oldTr;
    }
 }
 
diff --git a/modules/reg/src/mappergradproj.cpp b/modules/reg/src/mappergradproj.cpp
@@ -56,8 +56,8 @@ MapperGradProj::~MapperGradProj()
 
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-void MapperGradProj::calculate(
-    InputArray _img1, InputArray image2, cv::Ptr<Map>& res) const
+cv::Ptr<Map> MapperGradProj::calculate(
+    InputArray _img1, InputArray image2, cv::Ptr<Map> init) const
 {
     Mat img1 = _img1.getMat();
     Mat gradx, grady, imgDiff;
@@ -67,9 +67,9 @@ void MapperGradProj::calculate(
     CV_DbgAssert(img1.channels() == image2.channels());
     CV_DbgAssert(img1.channels() == 1 || img1.channels() == 3);
 
-    if(!res.empty()) {
+    if(!init.empty()) {
         // We have initial values for the registration: we move img2 to that initial reference
-        res->inverseWarp(image2, img2);
+        init->inverseWarp(image2, img2);
     } else {
         img2 = image2.getMat();
     }
@@ -196,11 +196,14 @@ void MapperGradProj::calculate(
     Vec<double, 8> k = A.inv(DECOMP_CHOLESKY)*b;
 
     Matx<double, 3, 3> H(k(0) + 1., k(1), k(2), k(3), k(4) + 1., k(5), k(6), k(7), 1.);
-    if(res.empty()) {
-        res = Ptr<Map>(new MapProjec(H));
+    if(init.empty()) {
+        return Ptr<Map>(new MapProjec(H));
     } else {
         Ptr<MapProjec> newTr(new MapProjec(H));
-        res->compose(newTr);
+        MapProjec* initPtr = dynamic_cast<MapProjec*>(init.get());
+        Ptr<MapProjec> oldTr(new MapProjec(initPtr->getProjTr()));
+        oldTr->compose(newTr);
+        return oldTr;
    }
 }
 
diff --git a/modules/reg/src/mappergradshift.cpp b/modules/reg/src/mappergradshift.cpp
@@ -56,18 +56,18 @@ MapperGradShift::~MapperGradShift()
 
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-void MapperGradShift::calculate(
-    InputArray _img1, InputArray image2, cv::Ptr<Map>& res) const
+cv::Ptr<Map> MapperGradShift::calculate(
+    InputArray _img1, InputArray image2, cv::Ptr<Map> init) const
 {
     Mat img1 = _img1.getMat();
     Mat gradx, grady, imgDiff;
     Mat img2;
 
     CV_DbgAssert(img1.size() == image2.size());
 
-    if(!res.empty()) {
+    if(!init.empty()) {
         // We have initial values for the registration: we move img2 to that initial reference
-        res->inverseWarp(image2, img2);
+        init->inverseWarp(image2, img2);
     } else {
         img2 = image2.getMat();
     }
@@ -93,11 +93,14 @@ void MapperGradShift::calculate(
     // Calculate shift. We use Cholesky decomposition, as A is symmetric.
     Vec<double, 2> shift = A.inv(DECOMP_CHOLESKY)*b;
 
-    if(res.empty()) {
-        res = Ptr<Map>(new MapShift(shift));
+    if(init.empty()) {
+        return Ptr<Map>(new MapShift(shift));
     } else {
         Ptr<MapShift> newTr(new MapShift(shift));
-        res->compose(newTr);
+        MapShift* initPtr = dynamic_cast<MapShift*>(init.get());
+        Ptr<MapShift> oldTr(new MapShift(initPtr->getShift()));
+        oldTr->compose(newTr);
+        return oldTr;
    }
 }
 
diff --git a/modules/reg/src/mappergradsimilar.cpp b/modules/reg/src/mappergradsimilar.cpp
@@ -56,8 +56,8 @@ MapperGradSimilar::~MapperGradSimilar()
 
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-void MapperGradSimilar::calculate(
-    InputArray _img1, InputArray image2, cv::Ptr<Map>& res) const
+cv::Ptr<Map> MapperGradSimilar::calculate(
+    InputArray _img1, InputArray image2, cv::Ptr<Map> init) const
 {
     Mat img1 = _img1.getMat();
     Mat gradx, grady, imgDiff;
@@ -67,9 +67,9 @@ void MapperGradSimilar::calculate(
     CV_DbgAssert(img1.channels() == image2.channels());
     CV_DbgAssert(img1.channels() == 1 || img1.channels() == 3);
 
-    if(!res.empty()) {
+    if(!init.empty()) {
         // We have initial values for the registration: we move img2 to that initial reference
-        res->inverseWarp(image2, img2);
+        init->inverseWarp(image2, img2);
     } else {
         img2 = image2.getMat();
     }
@@ -127,11 +127,14 @@ void MapperGradSimilar::calculate(
 
     Matx<double, 2, 2> linTr(k(0) + 1., k(1), -k(1), k(0) + 1.);
     Vec<double, 2> shift(k(2), k(3));
-    if(res.empty()) {
-        res = Ptr<Map>(new MapAffine(linTr, shift));
+    if(init.empty()) {
+        return Ptr<Map>(new MapAffine(linTr, shift));
     } else {
         Ptr<MapAffine> newTr(new MapAffine(linTr, shift));
-        res->compose(newTr);
+        MapAffine* initPtr = dynamic_cast<MapAffine*>(init.get());
+        Ptr<MapAffine> oldTr(new MapAffine(initPtr->getLinTr(), initPtr->getShift()));
+        oldTr->compose(newTr);
+        return oldTr;
    }
 }
 
diff --git a/modules/reg/src/mapperpyramid.cpp b/modules/reg/src/mapperpyramid.cpp
@@ -48,22 +48,22 @@ namespace reg {
 
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-MapperPyramid::MapperPyramid(const Mapper& baseMapper)
-    : numLev_(3), numIterPerScale_(3), baseMapper_(baseMapper)
+MapperPyramid::MapperPyramid(Ptr<Mapper> baseMapper)
+    : numLev_(3), numIterPerScale_(3), baseMapper_(*baseMapper)
 {
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-void MapperPyramid::calculate(InputArray _img1, InputArray image2, Ptr<Map>& res) const
+Ptr<Map> MapperPyramid::calculate(InputArray _img1, InputArray image2, Ptr<Map> init) const
 {
     Mat img1 = _img1.getMat();
     Mat img2;
 
-    if(!res.empty()) {
+    if(!init.empty()) {
         // We have initial values for the registration: we move img2 to that initial reference
-        res->inverseWarp(image2, img2);
+        init->inverseWarp(image2, img2);
     } else {
-        res = baseMapper_.getMap();
+        init = baseMapper_.getMap();
         img2 = image2.getMat();
     }
 
@@ -87,11 +87,12 @@ void MapperPyramid::calculate(InputArray _img1, InputArray image2, Ptr<Map>& res
             ident->scale(2.);
         }
         for(size_t it_i = 0; it_i < numIterPerScale_; ++it_i) {
-            baseMapper_.calculate(currRef, currImg, ident);
+            ident = baseMapper_.calculate(currRef, currImg, ident);
         }
     }
 
-    res->compose(ident);
+    init->compose(ident);
+    return init;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/modules/reg/test/test_reg.cpp b/modules/reg/test/test_reg.cpp
