reg: enable wrapping of Map::compose()

sovrasov · sovrasov · commit 97dab3b568e8 · 2017-02-06T17:22:06.000+03:00
diff --git a/modules/reg/include/opencv2/reg/map.hpp b/modules/reg/include/opencv2/reg/map.hpp
@@ -158,7 +158,7 @@ class CV_EXPORTS_W Map
      * The order is first the current transformation, then the input argument.
      * \param[in] map Transformation to compose with.
      */
-    virtual void compose(const Map& map) = 0;
+    CV_WRAP virtual void compose(cv::Ptr<Map> map) = 0;
 
     /*!
      * Scales the map by a given factor as if the coordinates system is expanded/compressed
diff --git a/modules/reg/include/opencv2/reg/mapaffine.hpp b/modules/reg/include/opencv2/reg/mapaffine.hpp
@@ -73,7 +73,7 @@ class CV_EXPORTS_W MapAffine : public Map
 
     CV_WRAP cv::Ptr<Map> inverseMap() const;
 
-    void compose(const Map& map);
+    CV_WRAP void compose(cv::Ptr<Map> map);
 
     CV_WRAP void scale(double factor);
 
diff --git a/modules/reg/include/opencv2/reg/mapprojec.hpp b/modules/reg/include/opencv2/reg/mapprojec.hpp
@@ -73,7 +73,7 @@ class CV_EXPORTS_W MapProjec : public Map
 
     CV_WRAP cv::Ptr<Map> inverseMap() const;
 
-    void compose(const Map& map);
+    CV_WRAP void compose(cv::Ptr<Map> map);
 
     CV_WRAP void scale(double factor);
 
diff --git a/modules/reg/include/opencv2/reg/mapshift.hpp b/modules/reg/include/opencv2/reg/mapshift.hpp
@@ -73,7 +73,7 @@ class CV_EXPORTS_W MapShift : public Map
 
     CV_WRAP cv::Ptr<Map> inverseMap() const;
 
-    void compose(const Map& map);
+    CV_WRAP void compose(cv::Ptr<Map> map);
 
     CV_WRAP void scale(double factor);
 
diff --git a/modules/reg/src/mapaffine.cpp b/modules/reg/src/mapaffine.cpp
@@ -94,10 +94,10 @@ Ptr<Map> MapAffine::inverseMap(void) const
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-void MapAffine::compose(const Map& map)
+void MapAffine::compose(cv::Ptr<Map> map)
 {
     // Composition of affine transformations T and T' is (T o T') = A'Ax + A'b + b'
-    const MapAffine& mapAff = static_cast<const MapAffine&>(map);
+    const MapAffine& mapAff = static_cast<const MapAffine&>(*map);
     Matx<double, 2, 2> compMat = mapAff.getLinTr()*linTr_;
     Vec<double, 2> compShift = mapAff.getLinTr()*shift_ + mapAff.getShift();
     linTr_ = compMat;
diff --git a/modules/reg/src/mappergradaffine.cpp b/modules/reg/src/mappergradaffine.cpp
@@ -148,7 +148,7 @@ void MapperGradAffine::calculate(InputArray _img1, InputArray image2, cv::Ptr<Ma
     if(res.empty()) {
         res = Ptr<Map>(new MapAffine(linTr, shift));
     } else {
-        MapAffine newTr(linTr, shift);
+        Ptr<MapAffine> newTr(new MapAffine(linTr, shift));
         res->compose(newTr);
    }
 }
diff --git a/modules/reg/src/mappergradeuclid.cpp b/modules/reg/src/mappergradeuclid.cpp
@@ -115,7 +115,7 @@ void MapperGradEuclid::calculate(
     if(res.empty()) {
         res = Ptr<Map>(new MapAffine(linTr, shift));
     } else {
-        MapAffine newTr(linTr, shift);
+        Ptr<MapAffine> newTr(new MapAffine(linTr, shift));
         res->compose(newTr);
    }
 }
diff --git a/modules/reg/src/mappergradproj.cpp b/modules/reg/src/mappergradproj.cpp
@@ -199,7 +199,7 @@ void MapperGradProj::calculate(
     if(res.empty()) {
         res = Ptr<Map>(new MapProjec(H));
     } else {
-        MapProjec newTr(H);
+        Ptr<MapProjec> newTr(new MapProjec(H));
         res->compose(newTr);
    }
 }
diff --git a/modules/reg/src/mappergradshift.cpp b/modules/reg/src/mappergradshift.cpp
@@ -96,7 +96,7 @@ void MapperGradShift::calculate(
     if(res.empty()) {
         res = Ptr<Map>(new MapShift(shift));
     } else {
-        MapShift newTr(shift);
+        Ptr<MapShift> newTr(new MapShift(shift));
         res->compose(newTr);
    }
 }
diff --git a/modules/reg/src/mappergradsimilar.cpp b/modules/reg/src/mappergradsimilar.cpp
@@ -130,7 +130,7 @@ void MapperGradSimilar::calculate(
     if(res.empty()) {
         res = Ptr<Map>(new MapAffine(linTr, shift));
     } else {
-        MapAffine newTr(linTr, shift);
+        Ptr<MapAffine> newTr(new MapAffine(linTr, shift));
         res->compose(newTr);
    }
 }
diff --git a/modules/reg/src/mapperpyramid.cpp b/modules/reg/src/mapperpyramid.cpp
@@ -91,7 +91,7 @@ void MapperPyramid::calculate(InputArray _img1, InputArray image2, Ptr<Map>& res
         }
     }
 
-    res->compose(*ident.get());
+    res->compose(ident);
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/modules/reg/src/mapprojec.cpp b/modules/reg/src/mapprojec.cpp
@@ -96,10 +96,10 @@ Ptr<Map> MapProjec::inverseMap(void) const
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-void MapProjec::compose(const Map& map)
+void MapProjec::compose(Ptr<Map> map)
 {
     // Composition of homographies H and H' is (H o H') = H'*H
-    const MapProjec& mapProj = static_cast<const MapProjec&>(map);
+    const MapProjec& mapProj = static_cast<const MapProjec&>(*map);
     Matx<double, 3, 3> compProjTr = mapProj.getProjTr()*projTr_;
     projTr_ = compProjTr;
 }
diff --git a/modules/reg/src/mapshift.cpp b/modules/reg/src/mapshift.cpp
@@ -92,10 +92,10 @@ Ptr<Map> MapShift::inverseMap(void) const
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-void MapShift::compose(const Map& map)
+void MapShift::compose(cv::Ptr<Map> map)
 {
     // Composition of transformations T and T' is (T o T') = b + b'
-    const MapShift& mapShift = static_cast<const MapShift&>(map);
+    const MapShift& mapShift = static_cast<const MapShift&>(*map);
     shift_ += mapShift.getShift();
 }
 
diff --git a/modules/reg/test/test_reg.cpp b/modules/reg/test/test_reg.cpp
@@ -100,7 +100,7 @@ void RegTest::testShift()
 #endif
     // Check accuracy
     Ptr<Map> mapInv(mapShift->inverseMap());
-    mapTest.compose(*mapInv.get());
+    mapTest.compose(mapInv);
     double shNorm = norm(mapTest.getShift());
     EXPECT_LE(shNorm, 0.1);
 }
@@ -135,7 +135,7 @@ void RegTest::testEuclidean()
 #endif
     // Check accuracy
     Ptr<Map> mapInv(mapAff->inverseMap());
-    mapTest.compose(*mapInv.get());
+    mapTest.compose(mapInv);
     double shNorm = norm(mapTest.getShift());
     EXPECT_LE(shNorm, 0.1);
     double linTrNorm = norm(mapTest.getLinTr());
@@ -175,7 +175,7 @@ void RegTest::testSimilarity()
 
     // Check accuracy
     Ptr<Map> mapInv(mapAff->inverseMap());
-    mapTest.compose(*mapInv.get());
+    mapTest.compose(mapInv);
     double shNorm = norm(mapTest.getShift());
     EXPECT_LE(shNorm, 0.1);
     double linTrNorm = norm(mapTest.getLinTr());
@@ -211,7 +211,7 @@ void RegTest::testAffine()
 
     // Check accuracy
     Ptr<Map> mapInv(mapAff->inverseMap());
-    mapTest.compose(*mapInv.get());
+    mapTest.compose(mapInv);
     double shNorm = norm(mapTest.getShift());
     EXPECT_LE(shNorm, 0.1);
     double linTrNorm = norm(mapTest.getLinTr());
@@ -246,7 +246,7 @@ void RegTest::testProjective()
 
     // Check accuracy
     Ptr<Map> mapInv(mapProj->inverseMap());
-    mapTest.compose(*mapInv.get());
+    mapTest.compose(mapInv);
     double projNorm = norm(mapTest.getProjTr());
     EXPECT_LE(projNorm, sqrt(3.) + 0.01);
     EXPECT_GE(projNorm, sqrt(3.) - 0.01);

Original file line number	Diff line number	Diff line change
`@@ -94,10 +94,10 @@ Ptr<Map> MapAffine::inverseMap(void) const`
`94`	`94`	`}`
`95`	`95`
`96`	`96`	`////////////////////////////////////////////////////////////////////////////////////////////////////`
`97`		`-void MapAffine::compose(const Map& map)`
	`97`	`+void MapAffine::compose(cv::Ptr<Map> map)`
`98`	`98`	`{`
`99`	`99`	`// Composition of affine transformations T and T' is (T o T') = A'Ax + A'b + b'`
`100`		`- const MapAffine& mapAff = static_cast<const MapAffine&>(map);`
	`100`	`+ const MapAffine& mapAff = static_cast<const MapAffine&>(*map);`
`101`	`101`	`Matx<double, 2, 2> compMat = mapAff.getLinTr()*linTr_;`
`102`	`102`	`Vec<double, 2> compShift = mapAff.getLinTr()*shift_ + mapAff.getShift();`
`103`	`103`	`linTr_ = compMat;`
Original file line number	Diff line number	Diff line change
`@@ -148,7 +148,7 @@ void MapperGradAffine::calculate(InputArray _img1, InputArray image2, cv::Ptr<Ma`
`148`	`148`	`if(res.empty()) {`
`149`	`149`	`res = Ptr<Map>(new MapAffine(linTr, shift));`
`150`	`150`	`} else {`
`151`		`- MapAffine newTr(linTr, shift);`
	`151`	`+ Ptr<MapAffine> newTr(new MapAffine(linTr, shift));`
`152`	`152`	`res->compose(newTr);`
`153`	`153`	`}`
`154`	`154`	`}`
Original file line number	Diff line number	Diff line change
`@@ -115,7 +115,7 @@ void MapperGradEuclid::calculate(`
`115`	`115`	`if(res.empty()) {`
`116`	`116`	`res = Ptr<Map>(new MapAffine(linTr, shift));`
`117`	`117`	`} else {`
`118`		`- MapAffine newTr(linTr, shift);`
	`118`	`+ Ptr<MapAffine> newTr(new MapAffine(linTr, shift));`
`119`	`119`	`res->compose(newTr);`
`120`	`120`	`}`
`121`	`121`	`}`
Original file line number	Diff line number	Diff line change
`@@ -199,7 +199,7 @@ void MapperGradProj::calculate(`
`199`	`199`	`if(res.empty()) {`
`200`	`200`	`res = Ptr<Map>(new MapProjec(H));`
`201`	`201`	`} else {`
`202`		`- MapProjec newTr(H);`
	`202`	`+ Ptr<MapProjec> newTr(new MapProjec(H));`
`203`	`203`	`res->compose(newTr);`
`204`	`204`	`}`
`205`	`205`	`}`
Original file line number	Diff line number	Diff line change
`@@ -96,7 +96,7 @@ void MapperGradShift::calculate(`
`96`	`96`	`if(res.empty()) {`
`97`	`97`	`res = Ptr<Map>(new MapShift(shift));`
`98`	`98`	`} else {`
`99`		`- MapShift newTr(shift);`
	`99`	`+ Ptr<MapShift> newTr(new MapShift(shift));`
`100`	`100`	`res->compose(newTr);`
`101`	`101`	`}`
`102`	`102`	`}`
Original file line number	Diff line number	Diff line change
`@@ -130,7 +130,7 @@ void MapperGradSimilar::calculate(`
`130`	`130`	`if(res.empty()) {`
`131`	`131`	`res = Ptr<Map>(new MapAffine(linTr, shift));`
`132`	`132`	`} else {`
`133`		`- MapAffine newTr(linTr, shift);`
	`133`	`+ Ptr<MapAffine> newTr(new MapAffine(linTr, shift));`
`134`	`134`	`res->compose(newTr);`
`135`	`135`	`}`
`136`	`136`	`}`