diff --git a/modules/reg/include/opencv2/reg/map.hpp b/modules/reg/include/opencv2/reg/map.hpp
index e07644c56..a885a2844 100644
--- a/modules/reg/include/opencv2/reg/map.hpp
+++ b/modules/reg/include/opencv2/reg/map.hpp
@@ -158,7 +158,7 @@ public:
      * 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
index 3fac2588f..fea7396a3 100644
--- a/modules/reg/include/opencv2/reg/mapaffine.hpp
+++ b/modules/reg/include/opencv2/reg/mapaffine.hpp
@@ -73,7 +73,7 @@ public:
 
     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
index d6239324d..57d4894fe 100644
--- a/modules/reg/include/opencv2/reg/mapprojec.hpp
+++ b/modules/reg/include/opencv2/reg/mapprojec.hpp
@@ -73,7 +73,7 @@ public:
 
     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
index 322ff39aa..f991b21c5 100644
--- a/modules/reg/include/opencv2/reg/mapshift.hpp
+++ b/modules/reg/include/opencv2/reg/mapshift.hpp
@@ -73,7 +73,7 @@ public:
 
     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
index 266116fe5..b9d38d7b6 100644
--- 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
index b0b22cf07..37c761782 100644
--- 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
index 59f6a2877..10937cfc0 100644
--- 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
index e36e2f183..ccf7c45eb 100644
--- 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
index 21eef2c7d..8d7bfbd0e 100644
--- 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
index 34d106367..86386bcec 100644
--- 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
index 7c906da6d..586922676 100644
--- 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
index a07ebd539..9b653b443 100644
--- 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
index 3bb353514..2533c68da 100644
--- 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
index 019bc6196..d0f9d25b1 100644
--- 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);