reg: classes are partially wrappen in python

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

@@ -121,13 +121,13 @@ namespace reg {
 
 The class is only used to define the common interface for any possible map.
  */
-class CV_EXPORTS Map
+class CV_EXPORTS_W Map
 {
 public:
     /*!
      * Virtual destructor
      */
-    virtual ~Map(void);
+    virtual ~Map();
 
     /*!
      * Warps image to a new coordinate frame. The calculation is img2(x)=img1(T^{-1}(x)), as we
@@ -136,7 +136,7 @@ public:
      * \param[in] img1 Original image
      * \param[out] img2 Warped image
      */
-    virtual void warp(InputArray img1, OutputArray img2) const;
+    CV_WRAP 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,13 +145,13 @@ public:
      * \param[in] img1 Original image
      * \param[out] img2 Warped image
      */
-    virtual void inverseWarp(InputArray img1, OutputArray img2) const = 0;
+    CV_WRAP virtual void inverseWarp(InputArray img1, OutputArray img2) const = 0;
 
     /*!
      * Calculates the inverse map
      * \return Inverse map
      */
-    virtual cv::Ptr<Map> inverseMap(void) const = 0;
+    CV_WRAP virtual cv::Ptr<Map> inverseMap() const = 0;
 
     /*!
      * Changes the map composing the current transformation with the one provided in the call.
@@ -165,7 +165,7 @@ public:
      * by that factor.
      * \param[in] factor Expansion if bigger than one, compression if smaller than one
      */
-    virtual void scale(double factor) = 0;
+    CV_WRAP virtual void scale(double factor) = 0;
 };
 
 //! @}

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

@@ -49,13 +49,13 @@ namespace reg {
 /*!
  * Defines an affine transformation
  */
-class CV_EXPORTS MapAffine : public Map
+class CV_EXPORTS_W MapAffine : public Map
 {
 public:
     /*!
      * Default constructor builds an identity map
      */
-    MapAffine(void);
+    CV_WRAP MapAffine();
 
     /*!
      * Constructor providing explicit values
@@ -67,15 +67,15 @@ public:
     /*!
      * Destructor
      */
-    ~MapAffine(void);
+    ~MapAffine();
 
-    void inverseWarp(InputArray img1, OutputArray img2) const;
+    CV_WRAP void inverseWarp(InputArray img1, OutputArray img2) const;
 
-    cv::Ptr<Map> inverseMap(void) const;
+    CV_WRAP cv::Ptr<Map> inverseMap() const;
 
     void compose(const Map& map);
 
-    void scale(double factor);
+    CV_WRAP void scale(double factor);
 
     /*!
      * Return linear part of the affine transformation

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

@@ -51,7 +51,7 @@ namespace reg {
 
 The class is only used to define the common interface for any possible mapping algorithm.
  */
-class CV_EXPORTS Mapper
+class CV_EXPORTS_W Mapper
 {
 public:
     virtual ~Mapper(void) {}
@@ -69,7 +69,7 @@ public:
      * Returns a map compatible with the Mapper class
      * \return Pointer to identity Map
      */
-    virtual cv::Ptr<Map> getMap(void) const = 0;
+    CV_WRAP virtual cv::Ptr<Map> getMap() const = 0;
 
 protected:
     /*

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

@@ -49,15 +49,15 @@ namespace reg {
 /*!
  * Mapper for affine motion
  */
-class CV_EXPORTS MapperGradAffine: public Mapper
+class CV_EXPORTS_W MapperGradAffine: public Mapper
 {
 public:
-    MapperGradAffine(void);
+    CV_WRAP MapperGradAffine();
     ~MapperGradAffine(void);
 
     virtual void calculate(InputArray img1, InputArray img2, cv::Ptr<Map>& res) const;
 
-    cv::Ptr<Map> getMap(void) const;
+    CV_WRAP cv::Ptr<Map> getMap() const;
 };
 
 //! @}

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

@@ -49,15 +49,15 @@ namespace reg {
 /*!
  * Mapper for euclidean motion: rotation plus shift
  */
-class CV_EXPORTS MapperGradEuclid: public Mapper
+class CV_EXPORTS_W MapperGradEuclid: public Mapper
 {
 public:
-    MapperGradEuclid(void);
-    ~MapperGradEuclid(void);
+    CV_WRAP MapperGradEuclid();
+    ~MapperGradEuclid();
 
     virtual void calculate(InputArray img1, InputArray img2, cv::Ptr<Map>& res) const;
 
-    cv::Ptr<Map> getMap(void) const;
+    CV_WRAP cv::Ptr<Map> getMap() const;
 };
 
 //! @}

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

@@ -49,15 +49,15 @@ namespace reg {
 /*!
  * Gradient mapper for a projective transformation
  */
-class CV_EXPORTS MapperGradProj: public Mapper
+class CV_EXPORTS_W MapperGradProj: public Mapper
 {
 public:
-    MapperGradProj(void);
-    ~MapperGradProj(void);
+    CV_WRAP MapperGradProj();
+    ~MapperGradProj();
 
     virtual void calculate(InputArray img1, InputArray img2, cv::Ptr<Map>& res) const;
 
-    cv::Ptr<Map> getMap(void) const;
+    CV_WRAP cv::Ptr<Map> getMap() const;
 };
 
 //! @}

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

@@ -49,15 +49,15 @@ namespace reg {
 /*!
  * Gradient mapper for a translation
  */
-class CV_EXPORTS MapperGradShift: public Mapper
+class CV_EXPORTS_W MapperGradShift: public Mapper
 {
 public:
-    MapperGradShift(void);
-    virtual ~MapperGradShift(void);
+    CV_WRAP MapperGradShift();
+    virtual ~MapperGradShift();
 
     virtual void calculate(InputArray img1, InputArray img2, cv::Ptr<Map>& res) const;
 
-    cv::Ptr<Map> getMap(void) const;
+    CV_WRAP cv::Ptr<Map> getMap() const;
 };
 
 //! @}

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

@@ -49,15 +49,15 @@ namespace reg {
 /*!
  * Calculates a similarity transformation between to images (scale, rotation, and shift)
  */
-class CV_EXPORTS MapperGradSimilar: public Mapper
+class CV_EXPORTS_W MapperGradSimilar: public Mapper
 {
 public:
-    MapperGradSimilar(void);
-    ~MapperGradSimilar(void);
+    CV_WRAP MapperGradSimilar();
+    ~MapperGradSimilar();
 
     virtual void calculate(InputArray img1, InputArray img2, cv::Ptr<Map>& res) const;
 
-    cv::Ptr<Map> getMap(void) const;
+    CV_WRAP cv::Ptr<Map> getMap() const;
 };
 
 //! @}

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

@@ -50,7 +50,7 @@ namespace reg {
 /*!
  * Calculates a map using a gaussian pyramid
  */
-class CV_EXPORTS MapperPyramid: public Mapper
+class CV_EXPORTS_W MapperPyramid: public Mapper
 {
 public:
     /*
@@ -61,10 +61,10 @@ public:
 
     void calculate(InputArray img1, InputArray img2, cv::Ptr<Map>& res) const;
 
-    cv::Ptr<Map> getMap(void) const;
+    CV_WRAP cv::Ptr<Map> getMap() const;
 
-    unsigned numLev_;           /*!< Number of levels of the pyramid */
-    unsigned numIterPerScale_;  /*!< Number of iterations at a given scale of the pyramid */
+    CV_WRAP unsigned numLev_;           /*!< Number of levels of the pyramid */
+    CV_WRAP unsigned numIterPerScale_;  /*!< Number of iterations at a given scale of the pyramid */
 
 private:
     MapperPyramid& operator=(const MapperPyramid&);

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

@@ -50,13 +50,13 @@ namespace reg {
 /*!
  * Defines an transformation that consists on a projective transformation
  */
-class CV_EXPORTS MapProjec : public Map
+class CV_EXPORTS_W MapProjec : public Map
 {
 public:
     /*!
      * Default constructor builds an identity map
      */
-    MapProjec(void);
+    CV_WRAP MapProjec();
 
     /*!
      * Constructor providing explicit values
@@ -67,15 +67,15 @@ public:
     /*!
      * Destructor
      */
-    ~MapProjec(void);
+    ~MapProjec();
 
-    void inverseWarp(InputArray img1, OutputArray img2) const;
+    CV_WRAP void inverseWarp(InputArray img1, OutputArray img2) const;
 
-    cv::Ptr<Map> inverseMap(void) const;
+    CV_WRAP cv::Ptr<Map> inverseMap() const;
 
     void compose(const Map& map);
 
-    void scale(double factor);
+    CV_WRAP void scale(double factor);
 
     /*!
      * Returns projection matrix

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

@@ -50,13 +50,13 @@ namespace reg {
 /*!
  * Defines an transformation that consists on a simple displacement
  */
-class CV_EXPORTS MapShift : public Map
+class CV_EXPORTS_W MapShift : public Map
 {
 public:
     /*!
      * Default constructor builds an identity map
      */
-    MapShift(void);
+    CV_WRAP MapShift();
 
     /*!
      * Constructor providing explicit values
@@ -67,15 +67,15 @@ public:
     /*!
      * Destructor
      */
-    ~MapShift(void);
+    ~MapShift();
 
-    void inverseWarp(InputArray img1, OutputArray img2) const;
+    CV_WRAP void inverseWarp(InputArray img1, OutputArray img2) const;
 
-    cv::Ptr<Map> inverseMap(void) const;
+    CV_WRAP cv::Ptr<Map> inverseMap() const;
 
     void compose(const Map& map);
 
-    void scale(double factor);
+    CV_WRAP void scale(double factor);
 
     /*!
      * Return displacement

modules/reg/src/map.cpp

@@ -44,7 +44,7 @@ namespace reg {
 
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-Map::~Map(void)
+Map::~Map()
 {
 }
 

modules/reg/src/mapaffine.cpp

@@ -45,7 +45,7 @@ namespace reg {
 
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-MapAffine::MapAffine(void)
+MapAffine::MapAffine()
     : linTr_(Matx<double, 2, 2>::eye()), shift_()
 {
 }
@@ -57,7 +57,7 @@ MapAffine::MapAffine(const Matx<double, 2, 2>& linTr, const Vec<double, 2>& shif
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-MapAffine::~MapAffine(void)
+MapAffine::~MapAffine()
 {
 }
 

modules/reg/src/mappergradaffine.cpp

@@ -44,13 +44,13 @@ namespace reg {
 
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-MapperGradAffine::MapperGradAffine(void)
+MapperGradAffine::MapperGradAffine()
 {
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-MapperGradAffine::~MapperGradAffine(void)
+MapperGradAffine::~MapperGradAffine()
 {
 }
 
@@ -154,7 +154,7 @@ void MapperGradAffine::calculate(InputArray _img1, InputArray image2, cv::Ptr<Ma
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-cv::Ptr<Map> MapperGradAffine::getMap(void) const
+cv::Ptr<Map> MapperGradAffine::getMap() const
 {
     return cv::Ptr<Map>(new MapAffine());
 }

modules/reg/src/mappergradeuclid.cpp

@@ -44,13 +44,13 @@ namespace reg {
 
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-MapperGradEuclid::MapperGradEuclid(void)
+MapperGradEuclid::MapperGradEuclid()
 {
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-MapperGradEuclid::~MapperGradEuclid(void)
+MapperGradEuclid::~MapperGradEuclid()
 {
 }
 
@@ -121,7 +121,7 @@ void MapperGradEuclid::calculate(
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-cv::Ptr<Map> MapperGradEuclid::getMap(void) const
+cv::Ptr<Map> MapperGradEuclid::getMap() const
 {
     return cv::Ptr<Map>(new MapAffine());
 }

modules/reg/src/mappergradproj.cpp

@@ -44,13 +44,13 @@ namespace reg {
 
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-MapperGradProj::MapperGradProj(void)
+MapperGradProj::MapperGradProj()
 {
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-MapperGradProj::~MapperGradProj(void)
+MapperGradProj::~MapperGradProj()
 {
 }
 
@@ -205,7 +205,7 @@ void MapperGradProj::calculate(
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-cv::Ptr<Map> MapperGradProj::getMap(void) const
+cv::Ptr<Map> MapperGradProj::getMap() const
 {
     return cv::Ptr<Map>(new MapProjec());
 }

modules/reg/src/mappergradshift.cpp

@@ -44,13 +44,13 @@ namespace reg {
 
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-MapperGradShift::MapperGradShift(void)
+MapperGradShift::MapperGradShift()
 {
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-MapperGradShift::~MapperGradShift(void)
+MapperGradShift::~MapperGradShift()
 {
 }
 
@@ -102,7 +102,7 @@ void MapperGradShift::calculate(
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-cv::Ptr<Map> MapperGradShift::getMap(void) const
+cv::Ptr<Map> MapperGradShift::getMap() const
 {
     return cv::Ptr<Map>(new MapShift());
 }

modules/reg/src/mappergradsimilar.cpp

@@ -44,13 +44,13 @@ namespace reg {
 
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-MapperGradSimilar::MapperGradSimilar(void)
+MapperGradSimilar::MapperGradSimilar()
 {
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-MapperGradSimilar::~MapperGradSimilar(void)
+MapperGradSimilar::~MapperGradSimilar()
 {
 }
 
@@ -136,7 +136,7 @@ void MapperGradSimilar::calculate(
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-cv::Ptr<Map> MapperGradSimilar::getMap(void) const
+cv::Ptr<Map> MapperGradSimilar::getMap() const
 {
     return cv::Ptr<Map>(new MapAffine());
 }

modules/reg/src/mapperpyramid.cpp

@@ -95,7 +95,7 @@ void MapperPyramid::calculate(InputArray _img1, InputArray image2, Ptr<Map>& res
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-cv::Ptr<Map> MapperPyramid::getMap(void) const
+cv::Ptr<Map> MapperPyramid::getMap() const
 {
     return cv::Ptr<Map>();
 }

modules/reg/src/mapprojec.cpp

@@ -45,7 +45,7 @@ namespace reg {
 
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-MapProjec::MapProjec(void)
+MapProjec::MapProjec()
     : projTr_(Matx<double, 3, 3>::eye())
 {
 }
@@ -57,7 +57,7 @@ MapProjec::MapProjec(const Matx<double, 3, 3>& projTr)
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-MapProjec::~MapProjec(void)
+MapProjec::~MapProjec()
 {
 }
 

modules/reg/src/mapshift.cpp

@@ -46,7 +46,7 @@ namespace reg {
 
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-MapShift::MapShift(void) : shift_()
+MapShift::MapShift() : shift_()
 {
 }
 
@@ -56,7 +56,7 @@ MapShift::MapShift(const Vec<double, 2>& shift) : shift_(shift)
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-MapShift::~MapShift(void)
+MapShift::~MapShift()
 {
 }