reg: use IOArrays in public API

modules/reg/include/opencv2/reg/map.hpp

@@ -136,7 +136,7 @@ public:
      * \param[in] img1 Original image
      * \param[out] img2 Warped image
      */
-    virtual void warp(const cv::Mat& img1, cv::Mat& img2) const;
+    virtual void warp(InputArray img1, OutputArray img2) const;
 
     /*!
      * Warps image to a new coordinate frame. The calculation is img2(x)=img1(T(x)), so in fact
@@ -145,7 +145,7 @@ public:
      * \param[in] img1 Original image
      * \param[out] img2 Warped image
      */
-    virtual void inverseWarp(const cv::Mat& img1, cv::Mat& img2) const = 0;
+    virtual void inverseWarp(InputArray img1, OutputArray img2) const = 0;
 
     /*!
      * Calculates the inverse map

modules/reg/include/opencv2/reg/mapaffine.hpp

@@ -69,7 +69,7 @@ public:
      */
     ~MapAffine(void);
 
-    void inverseWarp(const cv::Mat& img1, cv::Mat& img2) const;
+    void inverseWarp(InputArray img1, OutputArray img2) const;
 
     cv::Ptr<Map> inverseMap(void) const;
 

modules/reg/include/opencv2/reg/mapper.hpp

@@ -63,7 +63,7 @@ public:
      * \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(const cv::Mat& img1, const cv::Mat& img2, cv::Ptr<Map>& res) const = 0;
+    virtual void calculate(InputArray img1, InputArray img2, cv::Ptr<Map>& res) const = 0;
 
     /*
      * Returns a map compatible with the Mapper class

modules/reg/include/opencv2/reg/mappergradaffine.hpp

@@ -55,7 +55,7 @@ public:
     MapperGradAffine(void);
     ~MapperGradAffine(void);
 
-    virtual void calculate(const cv::Mat& img1, const cv::Mat& img2, cv::Ptr<Map>& res) const;
+    virtual void calculate(InputArray img1, InputArray img2, cv::Ptr<Map>& res) const;
 
     cv::Ptr<Map> getMap(void) const;
 };

modules/reg/include/opencv2/reg/mappergradeuclid.hpp

@@ -55,7 +55,7 @@ public:
     MapperGradEuclid(void);
     ~MapperGradEuclid(void);
 
-    virtual void calculate(const cv::Mat& img1, const cv::Mat& img2, cv::Ptr<Map>& res) const;
+    virtual void calculate(InputArray img1, InputArray img2, cv::Ptr<Map>& res) const;
 
     cv::Ptr<Map> getMap(void) const;
 };

modules/reg/include/opencv2/reg/mappergradproj.hpp

@@ -55,7 +55,7 @@ public:
     MapperGradProj(void);
     ~MapperGradProj(void);
 
-    virtual void calculate(const cv::Mat& img1, const cv::Mat& img2, cv::Ptr<Map>& res) const;
+    virtual void calculate(InputArray img1, InputArray img2, cv::Ptr<Map>& res) const;
 
     cv::Ptr<Map> getMap(void) const;
 };

modules/reg/include/opencv2/reg/mappergradshift.hpp

@@ -55,7 +55,7 @@ public:
     MapperGradShift(void);
     virtual ~MapperGradShift(void);
 
-    virtual void calculate(const cv::Mat& img1, const cv::Mat& img2, cv::Ptr<Map>& res) const;
+    virtual void calculate(InputArray img1, InputArray img2, cv::Ptr<Map>& res) const;
 
     cv::Ptr<Map> getMap(void) const;
 };

modules/reg/include/opencv2/reg/mappergradsimilar.hpp

@@ -55,7 +55,7 @@ public:
     MapperGradSimilar(void);
     ~MapperGradSimilar(void);
 
-    virtual void calculate(const cv::Mat& img1, const cv::Mat& img2, cv::Ptr<Map>& res) const;
+    virtual void calculate(InputArray img1, InputArray img2, cv::Ptr<Map>& res) const;
 
     cv::Ptr<Map> getMap(void) const;
 };

modules/reg/include/opencv2/reg/mapperpyramid.hpp

@@ -59,7 +59,7 @@ public:
      */
     MapperPyramid(const Mapper& baseMapper);
 
-    void calculate(const cv::Mat& img1, const cv::Mat& img2, cv::Ptr<Map>& res) const;
+    void calculate(InputArray img1, InputArray img2, cv::Ptr<Map>& res) const;
 
     cv::Ptr<Map> getMap(void) const;
 

modules/reg/include/opencv2/reg/mapprojec.hpp

@@ -69,7 +69,7 @@ public:
      */
     ~MapProjec(void);
 
-    void inverseWarp(const cv::Mat& img1, cv::Mat& img2) const;
+    void inverseWarp(InputArray img1, OutputArray img2) const;
 
     cv::Ptr<Map> inverseMap(void) const;
 

modules/reg/include/opencv2/reg/mapshift.hpp

@@ -69,7 +69,7 @@ public:
      */
     ~MapShift(void);
 
-    void inverseWarp(const cv::Mat& img1, cv::Mat& img2) const;
+    void inverseWarp(InputArray img1, OutputArray img2) const;
 
     cv::Ptr<Map> inverseMap(void) const;
 

modules/reg/src/map.cpp

@@ -49,7 +49,7 @@ Map::~Map(void)
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-void Map::warp(const Mat& img1, Mat& img2) const
+void Map::warp(InputArray img1, OutputArray img2) const
 {
     Ptr<Map> invMap(inverseMap());
     invMap->inverseWarp(img1, img2);

modules/reg/src/mapaffine.cpp

@@ -62,8 +62,9 @@ MapAffine::~MapAffine(void)
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-void MapAffine::inverseWarp(const Mat& img1, Mat& img2) const
+void MapAffine::inverseWarp(InputArray _img1, OutputArray img2) const
 {
+    Mat img1 = _img1.getMat();
     // Rows and columns in destination
     Mat dest_r, dest_c;
     dest_r.create(img1.size(), CV_32FC1);

modules/reg/src/mappergradaffine.cpp

@@ -56,9 +56,9 @@ MapperGradAffine::~MapperGradAffine(void)
 
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-void MapperGradAffine::calculate(
+void MapperGradAffine::calculate(InputArray _img1, InputArray image2, cv::Ptr<Map>& res) const
-    const cv::Mat& img1, const cv::Mat& image2, cv::Ptr<Map>& res) const
 {
+    Mat img1 = _img1.getMat();
     Mat gradx, grady, imgDiff;
     Mat img2;
 
@@ -70,7 +70,7 @@ void MapperGradAffine::calculate(
         // We have initial values for the registration: we move img2 to that initial reference
         res->inverseWarp(image2, img2);
     } else {
-        img2 = image2;
+        img2 = image2.getMat();
     }
 
     // Get gradient in all channels

modules/reg/src/mappergradeuclid.cpp

@@ -57,8 +57,9 @@ MapperGradEuclid::~MapperGradEuclid(void)
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 void MapperGradEuclid::calculate(
-    const cv::Mat& img1, const cv::Mat& image2, cv::Ptr<Map>& res) const
+    InputArray _img1, InputArray image2, cv::Ptr<Map>& res) const
 {
+    Mat img1 = _img1.getMat();
     Mat gradx, grady, imgDiff;
     Mat img2;
 
@@ -70,7 +71,7 @@ void MapperGradEuclid::calculate(
         // We have initial values for the registration: we move img2 to that initial reference
         res->inverseWarp(image2, img2);
     } else {
-        img2 = image2;
+        img2 = image2.getMat();
     }
 
     // Matrices with reference frame coordinates

modules/reg/src/mappergradproj.cpp

@@ -57,8 +57,9 @@ MapperGradProj::~MapperGradProj(void)
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 void MapperGradProj::calculate(
-    const cv::Mat& img1, const cv::Mat& image2, cv::Ptr<Map>& res) const
+    InputArray _img1, InputArray image2, cv::Ptr<Map>& res) const
 {
+    Mat img1 = _img1.getMat();
     Mat gradx, grady, imgDiff;
     Mat img2;
 
@@ -70,7 +71,7 @@ void MapperGradProj::calculate(
         // We have initial values for the registration: we move img2 to that initial reference
         res->inverseWarp(image2, img2);
     } else {
-        img2 = image2;
+        img2 = image2.getMat();
     }
 
     // Get gradient in all channels

modules/reg/src/mappergradshift.cpp

@@ -57,8 +57,9 @@ MapperGradShift::~MapperGradShift(void)
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 void MapperGradShift::calculate(
-    const cv::Mat& img1, const cv::Mat& image2, cv::Ptr<Map>& res) const
+    InputArray _img1, InputArray image2, cv::Ptr<Map>& res) const
 {
+    Mat img1 = _img1.getMat();
     Mat gradx, grady, imgDiff;
     Mat img2;
 
@@ -68,7 +69,7 @@ void MapperGradShift::calculate(
         // We have initial values for the registration: we move img2 to that initial reference
         res->inverseWarp(image2, img2);
     } else {
-        img2 = image2;
+        img2 = image2.getMat();
     }
 
     // Get gradient in all channels

modules/reg/src/mappergradsimilar.cpp

@@ -57,8 +57,9 @@ MapperGradSimilar::~MapperGradSimilar(void)
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 void MapperGradSimilar::calculate(
-    const cv::Mat& img1, const cv::Mat& image2, cv::Ptr<Map>& res) const
+    InputArray _img1, InputArray image2, cv::Ptr<Map>& res) const
 {
+    Mat img1 = _img1.getMat();
     Mat gradx, grady, imgDiff;
     Mat img2;
 
@@ -70,7 +71,7 @@ void MapperGradSimilar::calculate(
         // We have initial values for the registration: we move img2 to that initial reference
         res->inverseWarp(image2, img2);
     } else {
-        img2 = image2;
+        img2 = image2.getMat();
     }
 
     // Get gradient in all channels

modules/reg/src/mapperpyramid.cpp

@@ -54,8 +54,9 @@ MapperPyramid::MapperPyramid(const Mapper& baseMapper)
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-void MapperPyramid::calculate(const Mat& img1, const Mat& image2, Ptr<Map>& res) const
+void MapperPyramid::calculate(InputArray _img1, InputArray image2, Ptr<Map>& res) const
 {
+    Mat img1 = _img1.getMat();
     Mat img2;
 
     if(!res.empty()) {
@@ -63,7 +64,7 @@ void MapperPyramid::calculate(const Mat& img1, const Mat& image2, Ptr<Map>& res)
         res->inverseWarp(image2, img2);
     } else {
         res = baseMapper_.getMap();
-        img2 = image2;
+        img2 = image2.getMat();
     }
 
     cv::Ptr<Map> ident = baseMapper_.getMap();

modules/reg/src/mapprojec.cpp

@@ -62,8 +62,9 @@ MapProjec::~MapProjec(void)
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-void MapProjec::inverseWarp(const Mat& img1, Mat& img2) const
+void MapProjec::inverseWarp(InputArray _img1, OutputArray img2) const
 {
+    Mat img1 = _img1.getMat();
     // Rows and columns in destination
     Mat dest_r, dest_c;
     dest_r.create(img1.size(), CV_32FC1);

modules/reg/src/mapshift.cpp

@@ -61,8 +61,9 @@ MapShift::~MapShift(void)
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-void MapShift::inverseWarp(const Mat& img1, Mat& img2) const
+void MapShift::inverseWarp(InputArray _img1, OutputArray img2) const
 {
+    Mat img1 = _img1.getMat();
     // Rows and columns in destination
     Mat dest_r, dest_c;
     dest_r.create(img1.size(), CV_32FC1);