node-native-win-utils 1.3.4 → 2.1.0

package/include/opencv2/core/types.hpp

@@ -1,2457 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                          License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
-// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is" and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef OPENCV_CORE_TYPES_HPP
-#define OPENCV_CORE_TYPES_HPP
-
-#ifndef __cplusplus
-#  error types.hpp header must be compiled as C++
-#endif
-
-#include <climits>
-#include <cfloat>
-#include <vector>
-#include <limits>
-
-#include "opencv2/core/cvdef.h"
-#include "opencv2/core/cvstd.hpp"
-#include "opencv2/core/matx.hpp"
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable: 4459)  // declaration of '...' hides global declaration
-#endif
-
-namespace cv
-{
-
-//! @addtogroup core_basic
-//! @{
-
-//////////////////////////////// Complex //////////////////////////////
-
-/** @brief  A complex number class.
-
-  The template class is similar and compatible with std::complex, however it provides slightly
-  more convenient access to the real and imaginary parts using through the simple field access, as opposite
-  to std::complex::real() and std::complex::imag().
-*/
-template<typename _Tp> class Complex
-{
-public:
-
-    //! default constructor
-    Complex();
-    Complex( _Tp _re, _Tp _im = 0 );
-
-    //! conversion to another data type
-    template<typename T2> operator Complex<T2>() const;
-    //! conjugation
-    Complex conj() const;
-
-    _Tp re, im; //< the real and the imaginary parts
-};
-
-typedef Complex<float> Complexf;
-typedef Complex<double> Complexd;
-
-template<typename _Tp> class DataType< Complex<_Tp> >
-{
-public:
-    typedef Complex<_Tp> value_type;
-    typedef value_type   work_type;
-    typedef _Tp          channel_type;
-
-    enum { generic_type = 0,
-           channels     = 2,
-           fmt          = DataType<channel_type>::fmt + ((channels - 1) << 8)
-#ifdef OPENCV_TRAITS_ENABLE_DEPRECATED
-           ,depth        = DataType<channel_type>::depth
-           ,type         = CV_MAKETYPE(depth, channels)
-#endif
-    };
-
-    typedef Vec<channel_type, channels> vec_type;
-};
-
-namespace traits {
-template<typename _Tp>
-struct Depth< Complex<_Tp> > { enum { value = Depth<_Tp>::value }; };
-template<typename _Tp>
-struct Type< Complex<_Tp> > { enum { value = CV_MAKETYPE(Depth<_Tp>::value, 2) }; };
-} // namespace
-
-
-//////////////////////////////// Point_ ////////////////////////////////
-
-/** @brief Template class for 2D points specified by its coordinates `x` and `y`.
-
-An instance of the class is interchangeable with C structures, CvPoint and CvPoint2D32f . There is
-also a cast operator to convert point coordinates to the specified type. The conversion from
-floating-point coordinates to integer coordinates is done by rounding. Commonly, the conversion
-uses this operation for each of the coordinates. Besides the class members listed in the
-declaration above, the following operations on points are implemented:
-@code
-    pt1 = pt2 + pt3;
-    pt1 = pt2 - pt3;
-    pt1 = pt2 * a;
-    pt1 = a * pt2;
-    pt1 = pt2 / a;
-    pt1 += pt2;
-    pt1 -= pt2;
-    pt1 *= a;
-    pt1 /= a;
-    double value = norm(pt); // L2 norm
-    pt1 == pt2;
-    pt1 != pt2;
-@endcode
-For your convenience, the following type aliases are defined:
-@code
-    typedef Point_<int> Point2i;
-    typedef Point2i Point;
-    typedef Point_<float> Point2f;
-    typedef Point_<double> Point2d;
-@endcode
-Example:
-@code
-    Point2f a(0.3f, 0.f), b(0.f, 0.4f);
-    Point pt = (a + b)*10.f;
-    cout << pt.x << ", " << pt.y << endl;
-@endcode
-*/
-template<typename _Tp> class Point_
-{
-public:
-    typedef _Tp value_type;
-
-    //! default constructor
-    Point_();
-    Point_(_Tp _x, _Tp _y);
-#if (defined(__GNUC__) && __GNUC__ < 5) && !defined(__clang__)  // GCC 4.x bug. Details: https://github.com/opencv/opencv/pull/20837
-    Point_(const Point_& pt);
-    Point_(Point_&& pt) CV_NOEXCEPT = default;
-#elif OPENCV_ABI_COMPATIBILITY < 500
-    Point_(const Point_& pt) = default;
-    Point_(Point_&& pt) CV_NOEXCEPT = default;
-#endif
-    Point_(const Size_<_Tp>& sz);
-    Point_(const Vec<_Tp, 2>& v);
-
-#if (defined(__GNUC__) && __GNUC__ < 5) && !defined(__clang__)  // GCC 4.x bug. Details: https://github.com/opencv/opencv/pull/20837
-    Point_& operator = (const Point_& pt);
-    Point_& operator = (Point_&& pt) CV_NOEXCEPT = default;
-#elif OPENCV_ABI_COMPATIBILITY < 500
-    Point_& operator = (const Point_& pt) = default;
-    Point_& operator = (Point_&& pt) CV_NOEXCEPT = default;
-#endif
-    //! conversion to another data type
-    template<typename _Tp2> operator Point_<_Tp2>() const;
-
-    //! conversion to the old-style C structures
-    operator Vec<_Tp, 2>() const;
-
-    //! dot product
-    _Tp dot(const Point_& pt) const;
-    //! dot product computed in double-precision arithmetics
-    double ddot(const Point_& pt) const;
-    //! cross-product
-    double cross(const Point_& pt) const;
-    //! checks whether the point is inside the specified rectangle
-    bool inside(const Rect_<_Tp>& r) const;
-    _Tp x; //!< x coordinate of the point
-    _Tp y; //!< y coordinate of the point
-};
-
-typedef Point_<int> Point2i;
-typedef Point_<int64> Point2l;
-typedef Point_<float> Point2f;
-typedef Point_<double> Point2d;
-typedef Point2i Point;
-
-template<typename _Tp> class DataType< Point_<_Tp> >
-{
-public:
-    typedef Point_<_Tp>                               value_type;
-    typedef Point_<typename DataType<_Tp>::work_type> work_type;
-    typedef _Tp                                       channel_type;
-
-    enum { generic_type = 0,
-           channels     = 2,
-           fmt          = traits::SafeFmt<channel_type>::fmt + ((channels - 1) << 8)
-#ifdef OPENCV_TRAITS_ENABLE_DEPRECATED
-           ,depth        = DataType<channel_type>::depth
-           ,type         = CV_MAKETYPE(depth, channels)
-#endif
-         };
-
-    typedef Vec<channel_type, channels> vec_type;
-};
-
-namespace traits {
-template<typename _Tp>
-struct Depth< Point_<_Tp> > { enum { value = Depth<_Tp>::value }; };
-template<typename _Tp>
-struct Type< Point_<_Tp> > { enum { value = CV_MAKETYPE(Depth<_Tp>::value, 2) }; };
-} // namespace
-
-
-//////////////////////////////// Point3_ ////////////////////////////////
-
-/** @brief Template class for 3D points specified by its coordinates `x`, `y` and `z`.
-
-An instance of the class is interchangeable with the C structure CvPoint2D32f . Similarly to
-Point_ , the coordinates of 3D points can be converted to another type. The vector arithmetic and
-comparison operations are also supported.
-
-The following Point3_\<\> aliases are available:
-@code
-    typedef Point3_<int> Point3i;
-    typedef Point3_<float> Point3f;
-    typedef Point3_<double> Point3d;
-@endcode
-@see cv::Point3i, cv::Point3f and cv::Point3d
-*/
-template<typename _Tp> class Point3_
-{
-public:
-    typedef _Tp value_type;
-
-    //! default constructor
-    Point3_();
-    Point3_(_Tp _x, _Tp _y, _Tp _z);
-#if OPENCV_ABI_COMPATIBILITY < 500
-    Point3_(const Point3_& pt) = default;
-    Point3_(Point3_&& pt) CV_NOEXCEPT = default;
-#endif
-    explicit Point3_(const Point_<_Tp>& pt);
-    Point3_(const Vec<_Tp, 3>& v);
-
-#if OPENCV_ABI_COMPATIBILITY < 500
-    Point3_& operator = (const Point3_& pt) = default;
-    Point3_& operator = (Point3_&& pt) CV_NOEXCEPT = default;
-#endif
-    //! conversion to another data type
-    template<typename _Tp2> operator Point3_<_Tp2>() const;
-    //! conversion to cv::Vec<>
-    operator Vec<_Tp, 3>() const;
-
-    //! dot product
-    _Tp dot(const Point3_& pt) const;
-    //! dot product computed in double-precision arithmetics
-    double ddot(const Point3_& pt) const;
-    //! cross product of the 2 3D points
-    Point3_ cross(const Point3_& pt) const;
-    _Tp x; //!< x coordinate of the 3D point
-    _Tp y; //!< y coordinate of the 3D point
-    _Tp z; //!< z coordinate of the 3D point
-};
-
-typedef Point3_<int> Point3i;
-typedef Point3_<float> Point3f;
-typedef Point3_<double> Point3d;
-
-template<typename _Tp> class DataType< Point3_<_Tp> >
-{
-public:
-    typedef Point3_<_Tp>                               value_type;
-    typedef Point3_<typename DataType<_Tp>::work_type> work_type;
-    typedef _Tp                                        channel_type;
-
-    enum { generic_type = 0,
-           channels     = 3,
-           fmt          = traits::SafeFmt<channel_type>::fmt + ((channels - 1) << 8)
-#ifdef OPENCV_TRAITS_ENABLE_DEPRECATED
-           ,depth        = DataType<channel_type>::depth
-           ,type         = CV_MAKETYPE(depth, channels)
-#endif
-         };
-
-    typedef Vec<channel_type, channels> vec_type;
-};
-
-namespace traits {
-template<typename _Tp>
-struct Depth< Point3_<_Tp> > { enum { value = Depth<_Tp>::value }; };
-template<typename _Tp>
-struct Type< Point3_<_Tp> > { enum { value = CV_MAKETYPE(Depth<_Tp>::value, 3) }; };
-} // namespace
-
-//////////////////////////////// Size_ ////////////////////////////////
-
-/** @brief Template class for specifying the size of an image or rectangle.
-
-The class includes two members called width and height. The structure can be converted to and from
-the old OpenCV structures CvSize and CvSize2D32f . The same set of arithmetic and comparison
-operations as for Point_ is available.
-
-OpenCV defines the following Size_\<\> aliases:
-@code
-    typedef Size_<int> Size2i;
-    typedef Size2i Size;
-    typedef Size_<float> Size2f;
-@endcode
-*/
-template<typename _Tp> class Size_
-{
-public:
-    typedef _Tp value_type;
-
-    //! default constructor
-    Size_();
-    Size_(_Tp _width, _Tp _height);
-#if OPENCV_ABI_COMPATIBILITY < 500
-    Size_(const Size_& sz) = default;
-    Size_(Size_&& sz) CV_NOEXCEPT = default;
-#endif
-    Size_(const Point_<_Tp>& pt);
-
-#if OPENCV_ABI_COMPATIBILITY < 500
-    Size_& operator = (const Size_& sz) = default;
-    Size_& operator = (Size_&& sz) CV_NOEXCEPT = default;
-#endif
-    //! the area (width*height)
-    _Tp area() const;
-    //! aspect ratio (width/height)
-    double aspectRatio() const;
-    //! true if empty
-    bool empty() const;
-
-    //! conversion of another data type.
-    template<typename _Tp2> operator Size_<_Tp2>() const;
-
-    _Tp width; //!< the width
-    _Tp height; //!< the height
-};
-
-typedef Size_<int> Size2i;
-typedef Size_<int64> Size2l;
-typedef Size_<float> Size2f;
-typedef Size_<double> Size2d;
-typedef Size2i Size;
-
-template<typename _Tp> class DataType< Size_<_Tp> >
-{
-public:
-    typedef Size_<_Tp>                               value_type;
-    typedef Size_<typename DataType<_Tp>::work_type> work_type;
-    typedef _Tp                                      channel_type;
-
-    enum { generic_type = 0,
-           channels     = 2,
-           fmt          = DataType<channel_type>::fmt + ((channels - 1) << 8)
-#ifdef OPENCV_TRAITS_ENABLE_DEPRECATED
-           ,depth        = DataType<channel_type>::depth
-           ,type         = CV_MAKETYPE(depth, channels)
-#endif
-         };
-
-    typedef Vec<channel_type, channels> vec_type;
-};
-
-namespace traits {
-template<typename _Tp>
-struct Depth< Size_<_Tp> > { enum { value = Depth<_Tp>::value }; };
-template<typename _Tp>
-struct Type< Size_<_Tp> > { enum { value = CV_MAKETYPE(Depth<_Tp>::value, 2) }; };
-} // namespace
-
-//////////////////////////////// Rect_ ////////////////////////////////
-
-/** @brief Template class for 2D rectangles
-
-described by the following parameters:
--   Coordinates of the top-left corner. This is a default interpretation of Rect_::x and Rect_::y
-    in OpenCV. Though, in your algorithms you may count x and y from the bottom-left corner.
--   Rectangle width and height.
-
-OpenCV typically assumes that the top and left boundary of the rectangle are inclusive, while the
-right and bottom boundaries are not. For example, the method Rect_::contains returns true if
-
-\f[x  \leq pt.x < x+width,
-      y  \leq pt.y < y+height\f]
-
-Virtually every loop over an image ROI in OpenCV (where ROI is specified by Rect_\<int\> ) is
-implemented as:
-@code
-    for(int y = roi.y; y < roi.y + roi.height; y++)
-        for(int x = roi.x; x < roi.x + roi.width; x++)
-        {
-            // ...
-        }
-@endcode
-In addition to the class members, the following operations on rectangles are implemented:
--   \f$\texttt{rect} = \texttt{rect} \pm \texttt{point}\f$ (shifting a rectangle by a certain offset)
--   \f$\texttt{rect} = \texttt{rect} \pm \texttt{size}\f$ (expanding or shrinking a rectangle by a
-    certain amount)
--   rect += point, rect -= point, rect += size, rect -= size (augmenting operations)
--   rect = rect1 & rect2 (rectangle intersection)
--   rect = rect1 | rect2 (minimum area rectangle containing rect1 and rect2 )
--   rect &= rect1, rect |= rect1 (and the corresponding augmenting operations)
--   rect == rect1, rect != rect1 (rectangle comparison)
-
-This is an example how the partial ordering on rectangles can be established (rect1 \f$\subseteq\f$
-rect2):
-@code
-    template<typename _Tp> inline bool
-    operator <= (const Rect_<_Tp>& r1, const Rect_<_Tp>& r2)
-    {
-        return (r1 & r2) == r1;
-    }
-@endcode
-For your convenience, the Rect_\<\> alias is available: cv::Rect
-*/
-template<typename _Tp> class Rect_
-{
-public:
-    typedef _Tp value_type;
-
-    //! default constructor
-    Rect_();
-    Rect_(_Tp _x, _Tp _y, _Tp _width, _Tp _height);
-#if OPENCV_ABI_COMPATIBILITY < 500
-    Rect_(const Rect_& r) = default;
-    Rect_(Rect_&& r) CV_NOEXCEPT = default;
-#endif
-    Rect_(const Point_<_Tp>& org, const Size_<_Tp>& sz);
-    Rect_(const Point_<_Tp>& pt1, const Point_<_Tp>& pt2);
-
-#if OPENCV_ABI_COMPATIBILITY < 500
-    Rect_& operator = (const Rect_& r) = default;
-    Rect_& operator = (Rect_&& r) CV_NOEXCEPT = default;
-#endif
-    //! the top-left corner
-    Point_<_Tp> tl() const;
-    //! the bottom-right corner
-    Point_<_Tp> br() const;
-
-    //! size (width, height) of the rectangle
-    Size_<_Tp> size() const;
-    //! area (width*height) of the rectangle
-    _Tp area() const;
-    //! true if empty
-    bool empty() const;
-
-    //! conversion to another data type
-    template<typename _Tp2> operator Rect_<_Tp2>() const;
-
-    //! checks whether the rectangle contains the point
-    bool contains(const Point_<_Tp>& pt) const;
-
-    _Tp x; //!< x coordinate of the top-left corner
-    _Tp y; //!< y coordinate of the top-left corner
-    _Tp width; //!< width of the rectangle
-    _Tp height; //!< height of the rectangle
-};
-
-typedef Rect_<int> Rect2i;
-typedef Rect_<float> Rect2f;
-typedef Rect_<double> Rect2d;
-typedef Rect2i Rect;
-
-template<typename _Tp> class DataType< Rect_<_Tp> >
-{
-public:
-    typedef Rect_<_Tp>                               value_type;
-    typedef Rect_<typename DataType<_Tp>::work_type> work_type;
-    typedef _Tp                                      channel_type;
-
-    enum { generic_type = 0,
-           channels     = 4,
-           fmt          = traits::SafeFmt<channel_type>::fmt + ((channels - 1) << 8)
-#ifdef OPENCV_TRAITS_ENABLE_DEPRECATED
-           ,depth        = DataType<channel_type>::depth
-           ,type         = CV_MAKETYPE(depth, channels)
-#endif
-         };
-
-    typedef Vec<channel_type, channels> vec_type;
-};
-
-namespace traits {
-template<typename _Tp>
-struct Depth< Rect_<_Tp> > { enum { value = Depth<_Tp>::value }; };
-template<typename _Tp>
-struct Type< Rect_<_Tp> > { enum { value = CV_MAKETYPE(Depth<_Tp>::value, 4) }; };
-} // namespace
-
-///////////////////////////// RotatedRect /////////////////////////////
-
-/** @brief The class represents rotated (i.e. not up-right) rectangles on a plane.
-
-Each rectangle is specified by the center point (mass center), length of each side (represented by
-#Size2f structure) and the rotation angle in degrees.
-
-The sample below demonstrates how to use RotatedRect:
-@snippet snippets/core_various.cpp RotatedRect_demo
-![image](pics/rotatedrect.png)
-
-@sa CamShift, fitEllipse, minAreaRect, CvBox2D
-*/
-class CV_EXPORTS RotatedRect
-{
-public:
-    //! default constructor
-    RotatedRect();
-    /** full constructor
-    @param center The rectangle mass center.
-    @param size Width and height of the rectangle.
-    @param angle The rotation angle in a clockwise direction. When the angle is 0, 90, 180, 270 etc.,
-    the rectangle becomes an up-right rectangle.
-    */
-    RotatedRect(const Point2f& center, const Size2f& size, float angle);
-    /**
-    Any 3 end points of the RotatedRect. They must be given in order (either clockwise or
-    anticlockwise).
-     */
-    RotatedRect(const Point2f& point1, const Point2f& point2, const Point2f& point3);
-
-    /** returns 4 vertices of the rectangle
-    @param pts The points array for storing rectangle vertices. The order is bottomLeft, topLeft, topRight, bottomRight.
-    */
-    void points(Point2f pts[]) const;
-    //! returns the minimal up-right integer rectangle containing the rotated rectangle
-    Rect boundingRect() const;
-    //! returns the minimal (exact) floating point rectangle containing the rotated rectangle, not intended for use with images
-    Rect_<float> boundingRect2f() const;
-    //! returns the rectangle mass center
-    Point2f center;
-    //! returns width and height of the rectangle
-    Size2f size;
-    //! returns the rotation angle. When the angle is 0, 90, 180, 270 etc., the rectangle becomes an up-right rectangle.
-    float angle;
-};
-
-template<> class DataType< RotatedRect >
-{
-public:
-    typedef RotatedRect  value_type;
-    typedef value_type   work_type;
-    typedef float        channel_type;
-
-    enum { generic_type = 0,
-           channels     = (int)sizeof(value_type)/sizeof(channel_type), // 5
-           fmt          = traits::SafeFmt<channel_type>::fmt + ((channels - 1) << 8)
-#ifdef OPENCV_TRAITS_ENABLE_DEPRECATED
-           ,depth        = DataType<channel_type>::depth
-           ,type         = CV_MAKETYPE(depth, channels)
-#endif
-         };
-
-    typedef Vec<channel_type, channels> vec_type;
-};
-
-namespace traits {
-template<>
-struct Depth< RotatedRect > { enum { value = Depth<float>::value }; };
-template<>
-struct Type< RotatedRect > { enum { value = CV_MAKETYPE(Depth<float>::value, (int)sizeof(RotatedRect)/sizeof(float)) }; };
-} // namespace
-
-
-//////////////////////////////// Range /////////////////////////////////
-
-/** @brief Template class specifying a continuous subsequence (slice) of a sequence.
-
-The class is used to specify a row or a column span in a matrix ( Mat ) and for many other purposes.
-Range(a,b) is basically the same as a:b in Matlab or a..b in Python. As in Python, start is an
-inclusive left boundary of the range and end is an exclusive right boundary of the range. Such a
-half-opened interval is usually denoted as \f$[start,end)\f$ .
-
-The static method Range::all() returns a special variable that means "the whole sequence" or "the
-whole range", just like " : " in Matlab or " ... " in Python. All the methods and functions in
-OpenCV that take Range support this special Range::all() value. But, of course, in case of your own
-custom processing, you will probably have to check and handle it explicitly:
-@code
-    void my_function(..., const Range& r, ....)
-    {
-        if(r == Range::all()) {
-            // process all the data
-        }
-        else {
-            // process [r.start, r.end)
-        }
-    }
-@endcode
-*/
-class CV_EXPORTS Range
-{
-public:
-    Range();
-    Range(int _start, int _end);
-    int size() const;
-    bool empty() const;
-    static Range all();
-
-    int start, end;
-};
-
-template<> class DataType<Range>
-{
-public:
-    typedef Range      value_type;
-    typedef value_type work_type;
-    typedef int        channel_type;
-
-    enum { generic_type = 0,
-           channels     = 2,
-           fmt          = traits::SafeFmt<channel_type>::fmt + ((channels - 1) << 8)
-#ifdef OPENCV_TRAITS_ENABLE_DEPRECATED
-           ,depth        = DataType<channel_type>::depth
-           ,type         = CV_MAKETYPE(depth, channels)
-#endif
-         };
-
-    typedef Vec<channel_type, channels> vec_type;
-};
-
-namespace traits {
-template<>
-struct Depth< Range > { enum { value = Depth<int>::value }; };
-template<>
-struct Type< Range > { enum { value = CV_MAKETYPE(Depth<int>::value, 2) }; };
-} // namespace
-
-
-//////////////////////////////// Scalar_ ///////////////////////////////
-
-/** @brief Template class for a 4-element vector derived from Vec.
-
-Being derived from Vec\<_Tp, 4\> , Scalar\_ and Scalar can be used just as typical 4-element
-vectors. In addition, they can be converted to/from CvScalar . The type Scalar is widely used in
-OpenCV to pass pixel values.
-*/
-template<typename _Tp> class Scalar_ : public Vec<_Tp, 4>
-{
-public:
-    //! default constructor
-    Scalar_();
-    Scalar_(_Tp v0, _Tp v1, _Tp v2=0, _Tp v3=0);
-    Scalar_(_Tp v0);
-
-    Scalar_(const Scalar_& s);
-    Scalar_(Scalar_&& s) CV_NOEXCEPT;
-
-    Scalar_& operator=(const Scalar_& s);
-    Scalar_& operator=(Scalar_&& s) CV_NOEXCEPT;
-
-    template<typename _Tp2, int cn>
-    Scalar_(const Vec<_Tp2, cn>& v);
-
-    //! returns a scalar with all elements set to v0
-    static Scalar_<_Tp> all(_Tp v0);
-
-    //! conversion to another data type
-    template<typename T2> operator Scalar_<T2>() const;
-
-    //! per-element product
-    Scalar_<_Tp> mul(const Scalar_<_Tp>& a, double scale=1 ) const;
-
-    //! returns (v0, -v1, -v2, -v3)
-    Scalar_<_Tp> conj() const;
-
-    //! returns true iff v1 == v2 == v3 == 0
-    bool isReal() const;
-};
-
-typedef Scalar_<double> Scalar;
-
-template<typename _Tp> class DataType< Scalar_<_Tp> >
-{
-public:
-    typedef Scalar_<_Tp>                               value_type;
-    typedef Scalar_<typename DataType<_Tp>::work_type> work_type;
-    typedef _Tp                                        channel_type;
-
-    enum { generic_type = 0,
-           channels     = 4,
-           fmt          = traits::SafeFmt<channel_type>::fmt + ((channels - 1) << 8)
-#ifdef OPENCV_TRAITS_ENABLE_DEPRECATED
-           ,depth        = DataType<channel_type>::depth
-           ,type         = CV_MAKETYPE(depth, channels)
-#endif
-         };
-
-    typedef Vec<channel_type, channels> vec_type;
-};
-
-namespace traits {
-template<typename _Tp>
-struct Depth< Scalar_<_Tp> > { enum { value = Depth<_Tp>::value }; };
-template<typename _Tp>
-struct Type< Scalar_<_Tp> > { enum { value = CV_MAKETYPE(Depth<_Tp>::value, 4) }; };
-} // namespace
-
-
-/////////////////////////////// KeyPoint ////////////////////////////////
-
-/** @brief Data structure for salient point detectors.
-
-The class instance stores a keypoint, i.e. a point feature found by one of many available keypoint
-detectors, such as Harris corner detector, #FAST, %StarDetector, %SURF, %SIFT etc.
-
-The keypoint is characterized by the 2D position, scale (proportional to the diameter of the
-neighborhood that needs to be taken into account), orientation and some other parameters. The
-keypoint neighborhood is then analyzed by another algorithm that builds a descriptor (usually
-represented as a feature vector). The keypoints representing the same object in different images
-can then be matched using %KDTree or another method.
-*/
-class CV_EXPORTS_W_SIMPLE KeyPoint
-{
-public:
-    //! the default constructor
-    CV_WRAP KeyPoint();
-    /**
-    @param pt x & y coordinates of the keypoint
-    @param size keypoint diameter
-    @param angle keypoint orientation
-    @param response keypoint detector response on the keypoint (that is, strength of the keypoint)
-    @param octave pyramid octave in which the keypoint has been detected
-    @param class_id object id
-     */
-    KeyPoint(Point2f pt, float size, float angle=-1, float response=0, int octave=0, int class_id=-1);
-    /**
-    @param x x-coordinate of the keypoint
-    @param y y-coordinate of the keypoint
-    @param size keypoint diameter
-    @param angle keypoint orientation
-    @param response keypoint detector response on the keypoint (that is, strength of the keypoint)
-    @param octave pyramid octave in which the keypoint has been detected
-    @param class_id object id
-     */
-    CV_WRAP KeyPoint(float x, float y, float size, float angle=-1, float response=0, int octave=0, int class_id=-1);
-
-    size_t hash() const;
-
-    /**
-    This method converts vector of keypoints to vector of points or the reverse, where each keypoint is
-    assigned the same size and the same orientation.
-
-    @param keypoints Keypoints obtained from any feature detection algorithm like SIFT/SURF/ORB
-    @param points2f Array of (x,y) coordinates of each keypoint
-    @param keypointIndexes Array of indexes of keypoints to be converted to points. (Acts like a mask to
-    convert only specified keypoints)
-    */
-    CV_WRAP static void convert(const std::vector<KeyPoint>& keypoints,
-                                CV_OUT std::vector<Point2f>& points2f,
-                                const std::vector<int>& keypointIndexes=std::vector<int>());
-    /** @overload
-    @param points2f Array of (x,y) coordinates of each keypoint
-    @param keypoints Keypoints obtained from any feature detection algorithm like SIFT/SURF/ORB
-    @param size keypoint diameter
-    @param response keypoint detector response on the keypoint (that is, strength of the keypoint)
-    @param octave pyramid octave in which the keypoint has been detected
-    @param class_id object id
-    */
-    CV_WRAP static void convert(const std::vector<Point2f>& points2f,
-                                CV_OUT std::vector<KeyPoint>& keypoints,
-                                float size=1, float response=1, int octave=0, int class_id=-1);
-
-    /**
-    This method computes overlap for pair of keypoints. Overlap is the ratio between area of keypoint
-    regions' intersection and area of keypoint regions' union (considering keypoint region as circle).
-    If they don't overlap, we get zero. If they coincide at same location with same size, we get 1.
-    @param kp1 First keypoint
-    @param kp2 Second keypoint
-    */
-    CV_WRAP static float overlap(const KeyPoint& kp1, const KeyPoint& kp2);
-
-    CV_PROP_RW Point2f pt; //!< coordinates of the keypoints
-    CV_PROP_RW float size; //!< diameter of the meaningful keypoint neighborhood
-    CV_PROP_RW float angle; //!< computed orientation of the keypoint (-1 if not applicable);
-                            //!< it's in [0,360) degrees and measured relative to
-                            //!< image coordinate system, ie in clockwise.
-    CV_PROP_RW float response; //!< the response by which the most strong keypoints have been selected. Can be used for the further sorting or subsampling
-    CV_PROP_RW int octave; //!< octave (pyramid layer) from which the keypoint has been extracted
-    CV_PROP_RW int class_id; //!< object class (if the keypoints need to be clustered by an object they belong to)
-};
-
-#ifdef OPENCV_TRAITS_ENABLE_DEPRECATED
-template<> class DataType<KeyPoint>
-{
-public:
-    typedef KeyPoint      value_type;
-    typedef float         work_type;
-    typedef float         channel_type;
-
-    enum { generic_type = 0,
-           depth        = DataType<channel_type>::depth,
-           channels     = (int)(sizeof(value_type)/sizeof(channel_type)), // 7
-           fmt          = DataType<channel_type>::fmt + ((channels - 1) << 8),
-           type         = CV_MAKETYPE(depth, channels)
-         };
-
-    typedef Vec<channel_type, channels> vec_type;
-};
-#endif
-
-
-//////////////////////////////// DMatch /////////////////////////////////
-
-/** @brief Class for matching keypoint descriptors
-
-query descriptor index, train descriptor index, train image index, and distance between
-descriptors.
-*/
-class CV_EXPORTS_W_SIMPLE DMatch
-{
-public:
-    CV_WRAP DMatch();
-    CV_WRAP DMatch(int _queryIdx, int _trainIdx, float _distance);
-    CV_WRAP DMatch(int _queryIdx, int _trainIdx, int _imgIdx, float _distance);
-
-    CV_PROP_RW int queryIdx; //!< query descriptor index
-    CV_PROP_RW int trainIdx; //!< train descriptor index
-    CV_PROP_RW int imgIdx;   //!< train image index
-
-    CV_PROP_RW float distance;
-
-    // less is better
-    bool operator<(const DMatch &m) const;
-};
-
-#ifdef OPENCV_TRAITS_ENABLE_DEPRECATED
-template<> class DataType<DMatch>
-{
-public:
-    typedef DMatch      value_type;
-    typedef int         work_type;
-    typedef int         channel_type;
-
-    enum { generic_type = 0,
-           depth        = DataType<channel_type>::depth,
-           channels     = (int)(sizeof(value_type)/sizeof(channel_type)), // 4
-           fmt          = DataType<channel_type>::fmt + ((channels - 1) << 8),
-           type         = CV_MAKETYPE(depth, channels)
-         };
-
-    typedef Vec<channel_type, channels> vec_type;
-};
-#endif
-
-
-///////////////////////////// TermCriteria //////////////////////////////
-
-/** @brief The class defining termination criteria for iterative algorithms.
-
-You can initialize it by default constructor and then override any parameters, or the structure may
-be fully initialized using the advanced variant of the constructor.
-*/
-class CV_EXPORTS TermCriteria
-{
-public:
-    /**
-      Criteria type, can be one of: COUNT, EPS or COUNT + EPS
-    */
-    enum Type
-    {
-        COUNT=1, //!< the maximum number of iterations or elements to compute
-        MAX_ITER=COUNT, //!< ditto
-        EPS=2 //!< the desired accuracy or change in parameters at which the iterative algorithm stops
-    };
-
-    //! default constructor
-    TermCriteria();
-    /**
-    @param type The type of termination criteria, one of TermCriteria::Type
-    @param maxCount The maximum number of iterations or elements to compute.
-    @param epsilon The desired accuracy or change in parameters at which the iterative algorithm stops.
-    */
-    TermCriteria(int type, int maxCount, double epsilon);
-
-    inline bool isValid() const
-    {
-        const bool isCount = (type & COUNT) && maxCount > 0;
-        const bool isEps = (type & EPS) && !cvIsNaN(epsilon);
-        return isCount || isEps;
-    }
-
-    int type; //!< the type of termination criteria: COUNT, EPS or COUNT + EPS
-    int maxCount; //!< the maximum number of iterations/elements
-    double epsilon; //!< the desired accuracy
-};
-
-
-//! @} core_basic
-
-///////////////////////// raster image moments //////////////////////////
-
-//! @addtogroup imgproc_shape
-//! @{
-
-/** @brief struct returned by cv::moments
-
-The spatial moments \f$\texttt{Moments::m}_{ji}\f$ are computed as:
-
-\f[\texttt{m} _{ji}= \sum _{x,y}  \left ( \texttt{array} (x,y)  \cdot x^j  \cdot y^i \right )\f]
-
-The central moments \f$\texttt{Moments::mu}_{ji}\f$ are computed as:
-
-\f[\texttt{mu} _{ji}= \sum _{x,y}  \left ( \texttt{array} (x,y)  \cdot (x -  \bar{x} )^j  \cdot (y -  \bar{y} )^i \right )\f]
-
-where \f$(\bar{x}, \bar{y})\f$ is the mass center:
-
-\f[\bar{x} = \frac{\texttt{m}_{10}}{\texttt{m}_{00}} , \; \bar{y} = \frac{\texttt{m}_{01}}{\texttt{m}_{00}}\f]
-
-The normalized central moments \f$\texttt{Moments::nu}_{ij}\f$ are computed as:
-
-\f[\texttt{nu} _{ji}= \frac{\texttt{mu}_{ji}}{\texttt{m}_{00}^{(i+j)/2+1}} .\f]
-
-@note
-\f$\texttt{mu}_{00}=\texttt{m}_{00}\f$, \f$\texttt{nu}_{00}=1\f$
-\f$\texttt{nu}_{10}=\texttt{mu}_{10}=\texttt{mu}_{01}=\texttt{mu}_{10}=0\f$ , hence the values are not
-stored.
-
-The moments of a contour are defined in the same way but computed using the Green's formula (see
-<http://en.wikipedia.org/wiki/Green_theorem>). So, due to a limited raster resolution, the moments
-computed for a contour are slightly different from the moments computed for the same rasterized
-contour.
-
-@note
-Since the contour moments are computed using Green formula, you may get seemingly odd results for
-contours with self-intersections, e.g. a zero area (m00) for butterfly-shaped contours.
- */
-class CV_EXPORTS_W_MAP Moments
-{
-public:
-    //! the default constructor
-    Moments();
-    //! the full constructor
-    Moments(double m00, double m10, double m01, double m20, double m11,
-            double m02, double m30, double m21, double m12, double m03 );
-    ////! the conversion from CvMoments
-    //Moments( const CvMoments& moments );
-    ////! the conversion to CvMoments
-    //operator CvMoments() const;
-
-    //! @name spatial moments
-    //! @{
-    CV_PROP_RW double  m00, m10, m01, m20, m11, m02, m30, m21, m12, m03;
-    //! @}
-
-    //! @name central moments
-    //! @{
-    CV_PROP_RW double  mu20, mu11, mu02, mu30, mu21, mu12, mu03;
-    //! @}
-
-    //! @name central normalized moments
-    //! @{
-    CV_PROP_RW double  nu20, nu11, nu02, nu30, nu21, nu12, nu03;
-    //! @}
-};
-
-template<> class DataType<Moments>
-{
-public:
-    typedef Moments     value_type;
-    typedef double      work_type;
-    typedef double      channel_type;
-
-    enum { generic_type = 0,
-           channels     = (int)(sizeof(value_type)/sizeof(channel_type)), // 24
-           fmt          = DataType<channel_type>::fmt + ((channels - 1) << 8)
-#ifdef OPENCV_TRAITS_ENABLE_DEPRECATED
-           ,depth        = DataType<channel_type>::depth
-           ,type         = CV_MAKETYPE(depth, channels)
-#endif
-         };
-
-    typedef Vec<channel_type, channels> vec_type;
-};
-
-namespace traits {
-template<>
-struct Depth< Moments > { enum { value = Depth<double>::value }; };
-template<>
-struct Type< Moments > { enum { value = CV_MAKETYPE(Depth<double>::value, (int)(sizeof(Moments)/sizeof(double))) }; };
-} // namespace
-
-//! @} imgproc_shape
-
-//! @cond IGNORED
-
-/////////////////////////////////////////////////////////////////////////
-///////////////////////////// Implementation ////////////////////////////
-/////////////////////////////////////////////////////////////////////////
-
-//////////////////////////////// Complex ////////////////////////////////
-
-template<typename _Tp> inline
-Complex<_Tp>::Complex()
-    : re(0), im(0) {}
-
-template<typename _Tp> inline
-Complex<_Tp>::Complex( _Tp _re, _Tp _im )
-    : re(_re), im(_im) {}
-
-template<typename _Tp> template<typename T2> inline
-Complex<_Tp>::operator Complex<T2>() const
-{
-    return Complex<T2>(saturate_cast<T2>(re), saturate_cast<T2>(im));
-}
-
-template<typename _Tp> inline
-Complex<_Tp> Complex<_Tp>::conj() const
-{
-    return Complex<_Tp>(re, -im);
-}
-
-
-template<typename _Tp> static inline
-bool operator == (const Complex<_Tp>& a, const Complex<_Tp>& b)
-{
-    return a.re == b.re && a.im == b.im;
-}
-
-template<typename _Tp> static inline
-bool operator != (const Complex<_Tp>& a, const Complex<_Tp>& b)
-{
-    return a.re != b.re || a.im != b.im;
-}
-
-template<typename _Tp> static inline
-Complex<_Tp> operator + (const Complex<_Tp>& a, const Complex<_Tp>& b)
-{
-    return Complex<_Tp>( a.re + b.re, a.im + b.im );
-}
-
-template<typename _Tp> static inline
-Complex<_Tp>& operator += (Complex<_Tp>& a, const Complex<_Tp>& b)
-{
-    a.re += b.re; a.im += b.im;
-    return a;
-}
-
-template<typename _Tp> static inline
-Complex<_Tp> operator - (const Complex<_Tp>& a, const Complex<_Tp>& b)
-{
-    return Complex<_Tp>( a.re - b.re, a.im - b.im );
-}
-
-template<typename _Tp> static inline
-Complex<_Tp>& operator -= (Complex<_Tp>& a, const Complex<_Tp>& b)
-{
-    a.re -= b.re; a.im -= b.im;
-    return a;
-}
-
-template<typename _Tp> static inline
-Complex<_Tp> operator - (const Complex<_Tp>& a)
-{
-    return Complex<_Tp>(-a.re, -a.im);
-}
-
-template<typename _Tp> static inline
-Complex<_Tp> operator * (const Complex<_Tp>& a, const Complex<_Tp>& b)
-{
-    return Complex<_Tp>( a.re*b.re - a.im*b.im, a.re*b.im + a.im*b.re );
-}
-
-template<typename _Tp> static inline
-Complex<_Tp> operator * (const Complex<_Tp>& a, _Tp b)
-{
-    return Complex<_Tp>( a.re*b, a.im*b );
-}
-
-template<typename _Tp> static inline
-Complex<_Tp> operator * (_Tp b, const Complex<_Tp>& a)
-{
-    return Complex<_Tp>( a.re*b, a.im*b );
-}
-
-template<typename _Tp> static inline
-Complex<_Tp> operator + (const Complex<_Tp>& a, _Tp b)
-{
-    return Complex<_Tp>( a.re + b, a.im );
-}
-
-template<typename _Tp> static inline
-Complex<_Tp> operator - (const Complex<_Tp>& a, _Tp b)
-{ return Complex<_Tp>( a.re - b, a.im ); }
-
-template<typename _Tp> static inline
-Complex<_Tp> operator + (_Tp b, const Complex<_Tp>& a)
-{
-    return Complex<_Tp>( a.re + b, a.im );
-}
-
-template<typename _Tp> static inline
-Complex<_Tp> operator - (_Tp b, const Complex<_Tp>& a)
-{
-    return Complex<_Tp>( b - a.re, -a.im );
-}
-
-template<typename _Tp> static inline
-Complex<_Tp>& operator += (Complex<_Tp>& a, _Tp b)
-{
-    a.re += b; return a;
-}
-
-template<typename _Tp> static inline
-Complex<_Tp>& operator -= (Complex<_Tp>& a, _Tp b)
-{
-    a.re -= b; return a;
-}
-
-template<typename _Tp> static inline
-Complex<_Tp>& operator *= (Complex<_Tp>& a, _Tp b)
-{
-    a.re *= b; a.im *= b; return a;
-}
-
-template<typename _Tp> static inline
-double abs(const Complex<_Tp>& a)
-{
-    return std::sqrt( (double)a.re*a.re + (double)a.im*a.im);
-}
-
-template<typename _Tp> static inline
-Complex<_Tp> operator / (const Complex<_Tp>& a, const Complex<_Tp>& b)
-{
-    double t = 1./((double)b.re*b.re + (double)b.im*b.im);
-    return Complex<_Tp>( (_Tp)((a.re*b.re + a.im*b.im)*t),
-                        (_Tp)((-a.re*b.im + a.im*b.re)*t) );
-}
-
-template<typename _Tp> static inline
-Complex<_Tp>& operator /= (Complex<_Tp>& a, const Complex<_Tp>& b)
-{
-    a = a / b;
-    return a;
-}
-
-template<typename _Tp> static inline
-Complex<_Tp> operator / (const Complex<_Tp>& a, _Tp b)
-{
-    _Tp t = (_Tp)1/b;
-    return Complex<_Tp>( a.re*t, a.im*t );
-}
-
-template<typename _Tp> static inline
-Complex<_Tp> operator / (_Tp b, const Complex<_Tp>& a)
-{
-    return Complex<_Tp>(b)/a;
-}
-
-template<typename _Tp> static inline
-Complex<_Tp> operator /= (const Complex<_Tp>& a, _Tp b)
-{
-    _Tp t = (_Tp)1/b;
-    a.re *= t; a.im *= t; return a;
-}
-
-
-
-//////////////////////////////// 2D Point ///////////////////////////////
-
-template<typename _Tp> inline
-Point_<_Tp>::Point_()
-    : x(0), y(0) {}
-
-template<typename _Tp> inline
-Point_<_Tp>::Point_(_Tp _x, _Tp _y)
-    : x(_x), y(_y) {}
-
-#if (defined(__GNUC__) && __GNUC__ < 5) && !defined(__clang__)  // GCC 4.x bug. Details: https://github.com/opencv/opencv/pull/20837
-template<typename _Tp> inline
-Point_<_Tp>::Point_(const Point_& pt)
-    : x(pt.x), y(pt.y) {}
-#endif
-
-template<typename _Tp> inline
-Point_<_Tp>::Point_(const Size_<_Tp>& sz)
-    : x(sz.width), y(sz.height) {}
-
-template<typename _Tp> inline
-Point_<_Tp>::Point_(const Vec<_Tp,2>& v)
-    : x(v[0]), y(v[1]) {}
-
-#if (defined(__GNUC__) && __GNUC__ < 5) && !defined(__clang__)  // GCC 4.x bug. Details: https://github.com/opencv/opencv/pull/20837
-template<typename _Tp> inline
-Point_<_Tp>& Point_<_Tp>::operator = (const Point_& pt)
-{
-    x = pt.x; y = pt.y;
-    return *this;
-}
-#endif
-
-template<typename _Tp> template<typename _Tp2> inline
-Point_<_Tp>::operator Point_<_Tp2>() const
-{
-    return Point_<_Tp2>(saturate_cast<_Tp2>(x), saturate_cast<_Tp2>(y));
-}
-
-template<typename _Tp> inline
-Point_<_Tp>::operator Vec<_Tp, 2>() const
-{
-    return Vec<_Tp, 2>(x, y);
-}
-
-template<typename _Tp> inline
-_Tp Point_<_Tp>::dot(const Point_& pt) const
-{
-    return saturate_cast<_Tp>(x*pt.x + y*pt.y);
-}
-
-template<typename _Tp> inline
-double Point_<_Tp>::ddot(const Point_& pt) const
-{
-    return (double)x*(double)(pt.x) + (double)y*(double)(pt.y);
-}
-
-template<typename _Tp> inline
-double Point_<_Tp>::cross(const Point_& pt) const
-{
-    return (double)x*pt.y - (double)y*pt.x;
-}
-
-template<typename _Tp> inline bool
-Point_<_Tp>::inside( const Rect_<_Tp>& r ) const
-{
-    return r.contains(*this);
-}
-
-
-template<typename _Tp> static inline
-Point_<_Tp>& operator += (Point_<_Tp>& a, const Point_<_Tp>& b)
-{
-    a.x += b.x;
-    a.y += b.y;
-    return a;
-}
-
-template<typename _Tp> static inline
-Point_<_Tp>& operator -= (Point_<_Tp>& a, const Point_<_Tp>& b)
-{
-    a.x -= b.x;
-    a.y -= b.y;
-    return a;
-}
-
-template<typename _Tp> static inline
-Point_<_Tp>& operator *= (Point_<_Tp>& a, int b)
-{
-    a.x = saturate_cast<_Tp>(a.x * b);
-    a.y = saturate_cast<_Tp>(a.y * b);
-    return a;
-}
-
-template<typename _Tp> static inline
-Point_<_Tp>& operator *= (Point_<_Tp>& a, float b)
-{
-    a.x = saturate_cast<_Tp>(a.x * b);
-    a.y = saturate_cast<_Tp>(a.y * b);
-    return a;
-}
-
-template<typename _Tp> static inline
-Point_<_Tp>& operator *= (Point_<_Tp>& a, double b)
-{
-    a.x = saturate_cast<_Tp>(a.x * b);
-    a.y = saturate_cast<_Tp>(a.y * b);
-    return a;
-}
-
-template<typename _Tp> static inline
-Point_<_Tp>& operator /= (Point_<_Tp>& a, int b)
-{
-    a.x = saturate_cast<_Tp>(a.x / b);
-    a.y = saturate_cast<_Tp>(a.y / b);
-    return a;
-}
-
-template<typename _Tp> static inline
-Point_<_Tp>& operator /= (Point_<_Tp>& a, float b)
-{
-    a.x = saturate_cast<_Tp>(a.x / b);
-    a.y = saturate_cast<_Tp>(a.y / b);
-    return a;
-}
-
-template<typename _Tp> static inline
-Point_<_Tp>& operator /= (Point_<_Tp>& a, double b)
-{
-    a.x = saturate_cast<_Tp>(a.x / b);
-    a.y = saturate_cast<_Tp>(a.y / b);
-    return a;
-}
-
-template<typename _Tp> static inline
-double norm(const Point_<_Tp>& pt)
-{
-    return std::sqrt((double)pt.x*pt.x + (double)pt.y*pt.y);
-}
-
-template<typename _Tp> static inline
-bool operator == (const Point_<_Tp>& a, const Point_<_Tp>& b)
-{
-    return a.x == b.x && a.y == b.y;
-}
-
-template<typename _Tp> static inline
-bool operator != (const Point_<_Tp>& a, const Point_<_Tp>& b)
-{
-    return a.x != b.x || a.y != b.y;
-}
-
-template<typename _Tp> static inline
-Point_<_Tp> operator + (const Point_<_Tp>& a, const Point_<_Tp>& b)
-{
-    return Point_<_Tp>( saturate_cast<_Tp>(a.x + b.x), saturate_cast<_Tp>(a.y + b.y) );
-}
-
-template<typename _Tp> static inline
-Point_<_Tp> operator - (const Point_<_Tp>& a, const Point_<_Tp>& b)
-{
-    return Point_<_Tp>( saturate_cast<_Tp>(a.x - b.x), saturate_cast<_Tp>(a.y - b.y) );
-}
-
-template<typename _Tp> static inline
-Point_<_Tp> operator - (const Point_<_Tp>& a)
-{
-    return Point_<_Tp>( saturate_cast<_Tp>(-a.x), saturate_cast<_Tp>(-a.y) );
-}
-
-template<typename _Tp> static inline
-Point_<_Tp> operator * (const Point_<_Tp>& a, int b)
-{
-    return Point_<_Tp>( saturate_cast<_Tp>(a.x*b), saturate_cast<_Tp>(a.y*b) );
-}
-
-template<typename _Tp> static inline
-Point_<_Tp> operator * (int a, const Point_<_Tp>& b)
-{
-    return Point_<_Tp>( saturate_cast<_Tp>(b.x*a), saturate_cast<_Tp>(b.y*a) );
-}
-
-template<typename _Tp> static inline
-Point_<_Tp> operator * (const Point_<_Tp>& a, float b)
-{
-    return Point_<_Tp>( saturate_cast<_Tp>(a.x*b), saturate_cast<_Tp>(a.y*b) );
-}
-
-template<typename _Tp> static inline
-Point_<_Tp> operator * (float a, const Point_<_Tp>& b)
-{
-    return Point_<_Tp>( saturate_cast<_Tp>(b.x*a), saturate_cast<_Tp>(b.y*a) );
-}
-
-template<typename _Tp> static inline
-Point_<_Tp> operator * (const Point_<_Tp>& a, double b)
-{
-    return Point_<_Tp>( saturate_cast<_Tp>(a.x*b), saturate_cast<_Tp>(a.y*b) );
-}
-
-template<typename _Tp> static inline
-Point_<_Tp> operator * (double a, const Point_<_Tp>& b)
-{
-    return Point_<_Tp>( saturate_cast<_Tp>(b.x*a), saturate_cast<_Tp>(b.y*a) );
-}
-
-template<typename _Tp> static inline
-Point_<_Tp> operator * (const Matx<_Tp, 2, 2>& a, const Point_<_Tp>& b)
-{
-    Matx<_Tp, 2, 1> tmp = a * Vec<_Tp,2>(b.x, b.y);
-    return Point_<_Tp>(tmp.val[0], tmp.val[1]);
-}
-
-template<typename _Tp> static inline
-Point3_<_Tp> operator * (const Matx<_Tp, 3, 3>& a, const Point_<_Tp>& b)
-{
-    Matx<_Tp, 3, 1> tmp = a * Vec<_Tp,3>(b.x, b.y, 1);
-    return Point3_<_Tp>(tmp.val[0], tmp.val[1], tmp.val[2]);
-}
-
-template<typename _Tp> static inline
-Point_<_Tp> operator / (const Point_<_Tp>& a, int b)
-{
-    Point_<_Tp> tmp(a);
-    tmp /= b;
-    return tmp;
-}
-
-template<typename _Tp> static inline
-Point_<_Tp> operator / (const Point_<_Tp>& a, float b)
-{
-    Point_<_Tp> tmp(a);
-    tmp /= b;
-    return tmp;
-}
-
-template<typename _Tp> static inline
-Point_<_Tp> operator / (const Point_<_Tp>& a, double b)
-{
-    Point_<_Tp> tmp(a);
-    tmp /= b;
-    return tmp;
-}
-
-
-template<typename _AccTp> static inline _AccTp normL2Sqr(const Point_<int>& pt);
-template<typename _AccTp> static inline _AccTp normL2Sqr(const Point_<int64>& pt);
-template<typename _AccTp> static inline _AccTp normL2Sqr(const Point_<float>& pt);
-template<typename _AccTp> static inline _AccTp normL2Sqr(const Point_<double>& pt);
-
-template<> inline int normL2Sqr<int>(const Point_<int>& pt) { return pt.dot(pt); }
-template<> inline int64 normL2Sqr<int64>(const Point_<int64>& pt) { return pt.dot(pt); }
-template<> inline float normL2Sqr<float>(const Point_<float>& pt) { return pt.dot(pt); }
-template<> inline double normL2Sqr<double>(const Point_<int>& pt) { return pt.dot(pt); }
-
-template<> inline double normL2Sqr<double>(const Point_<float>& pt) { return pt.ddot(pt); }
-template<> inline double normL2Sqr<double>(const Point_<double>& pt) { return pt.ddot(pt); }
-
-
-
-//////////////////////////////// 3D Point ///////////////////////////////
-
-template<typename _Tp> inline
-Point3_<_Tp>::Point3_()
-    : x(0), y(0), z(0) {}
-
-template<typename _Tp> inline
-Point3_<_Tp>::Point3_(_Tp _x, _Tp _y, _Tp _z)
-    : x(_x), y(_y), z(_z) {}
-
-template<typename _Tp> inline
-Point3_<_Tp>::Point3_(const Point_<_Tp>& pt)
-    : x(pt.x), y(pt.y), z(_Tp()) {}
-
-template<typename _Tp> inline
-Point3_<_Tp>::Point3_(const Vec<_Tp, 3>& v)
-    : x(v[0]), y(v[1]), z(v[2]) {}
-
-template<typename _Tp> template<typename _Tp2> inline
-Point3_<_Tp>::operator Point3_<_Tp2>() const
-{
-    return Point3_<_Tp2>(saturate_cast<_Tp2>(x), saturate_cast<_Tp2>(y), saturate_cast<_Tp2>(z));
-}
-
-template<typename _Tp> inline
-Point3_<_Tp>::operator Vec<_Tp, 3>() const
-{
-    return Vec<_Tp, 3>(x, y, z);
-}
-
-template<typename _Tp> inline
-_Tp Point3_<_Tp>::dot(const Point3_& pt) const
-{
-    return saturate_cast<_Tp>(x*pt.x + y*pt.y + z*pt.z);
-}
-
-template<typename _Tp> inline
-double Point3_<_Tp>::ddot(const Point3_& pt) const
-{
-    return (double)x*pt.x + (double)y*pt.y + (double)z*pt.z;
-}
-
-template<typename _Tp> inline
-Point3_<_Tp> Point3_<_Tp>::cross(const Point3_<_Tp>& pt) const
-{
-    return Point3_<_Tp>(y*pt.z - z*pt.y, z*pt.x - x*pt.z, x*pt.y - y*pt.x);
-}
-
-
-template<typename _Tp> static inline
-Point3_<_Tp>& operator += (Point3_<_Tp>& a, const Point3_<_Tp>& b)
-{
-    a.x += b.x;
-    a.y += b.y;
-    a.z += b.z;
-    return a;
-}
-
-template<typename _Tp> static inline
-Point3_<_Tp>& operator -= (Point3_<_Tp>& a, const Point3_<_Tp>& b)
-{
-    a.x -= b.x;
-    a.y -= b.y;
-    a.z -= b.z;
-    return a;
-}
-
-template<typename _Tp> static inline
-Point3_<_Tp>& operator *= (Point3_<_Tp>& a, int b)
-{
-    a.x = saturate_cast<_Tp>(a.x * b);
-    a.y = saturate_cast<_Tp>(a.y * b);
-    a.z = saturate_cast<_Tp>(a.z * b);
-    return a;
-}
-
-template<typename _Tp> static inline
-Point3_<_Tp>& operator *= (Point3_<_Tp>& a, float b)
-{
-    a.x = saturate_cast<_Tp>(a.x * b);
-    a.y = saturate_cast<_Tp>(a.y * b);
-    a.z = saturate_cast<_Tp>(a.z * b);
-    return a;
-}
-
-template<typename _Tp> static inline
-Point3_<_Tp>& operator *= (Point3_<_Tp>& a, double b)
-{
-    a.x = saturate_cast<_Tp>(a.x * b);
-    a.y = saturate_cast<_Tp>(a.y * b);
-    a.z = saturate_cast<_Tp>(a.z * b);
-    return a;
-}
-
-template<typename _Tp> static inline
-Point3_<_Tp>& operator /= (Point3_<_Tp>& a, int b)
-{
-    a.x = saturate_cast<_Tp>(a.x / b);
-    a.y = saturate_cast<_Tp>(a.y / b);
-    a.z = saturate_cast<_Tp>(a.z / b);
-    return a;
-}
-
-template<typename _Tp> static inline
-Point3_<_Tp>& operator /= (Point3_<_Tp>& a, float b)
-{
-    a.x = saturate_cast<_Tp>(a.x / b);
-    a.y = saturate_cast<_Tp>(a.y / b);
-    a.z = saturate_cast<_Tp>(a.z / b);
-    return a;
-}
-
-template<typename _Tp> static inline
-Point3_<_Tp>& operator /= (Point3_<_Tp>& a, double b)
-{
-    a.x = saturate_cast<_Tp>(a.x / b);
-    a.y = saturate_cast<_Tp>(a.y / b);
-    a.z = saturate_cast<_Tp>(a.z / b);
-    return a;
-}
-
-template<typename _Tp> static inline
-double norm(const Point3_<_Tp>& pt)
-{
-    return std::sqrt((double)pt.x*pt.x + (double)pt.y*pt.y + (double)pt.z*pt.z);
-}
-
-template<typename _Tp> static inline
-bool operator == (const Point3_<_Tp>& a, const Point3_<_Tp>& b)
-{
-    return a.x == b.x && a.y == b.y && a.z == b.z;
-}
-
-template<typename _Tp> static inline
-bool operator != (const Point3_<_Tp>& a, const Point3_<_Tp>& b)
-{
-    return a.x != b.x || a.y != b.y || a.z != b.z;
-}
-
-template<typename _Tp> static inline
-Point3_<_Tp> operator + (const Point3_<_Tp>& a, const Point3_<_Tp>& b)
-{
-    return Point3_<_Tp>( saturate_cast<_Tp>(a.x + b.x), saturate_cast<_Tp>(a.y + b.y), saturate_cast<_Tp>(a.z + b.z));
-}
-
-template<typename _Tp> static inline
-Point3_<_Tp> operator - (const Point3_<_Tp>& a, const Point3_<_Tp>& b)
-{
-    return Point3_<_Tp>( saturate_cast<_Tp>(a.x - b.x), saturate_cast<_Tp>(a.y - b.y), saturate_cast<_Tp>(a.z - b.z));
-}
-
-template<typename _Tp> static inline
-Point3_<_Tp> operator - (const Point3_<_Tp>& a)
-{
-    return Point3_<_Tp>( saturate_cast<_Tp>(-a.x), saturate_cast<_Tp>(-a.y), saturate_cast<_Tp>(-a.z) );
-}
-
-template<typename _Tp> static inline
-Point3_<_Tp> operator * (const Point3_<_Tp>& a, int b)
-{
-    return Point3_<_Tp>( saturate_cast<_Tp>(a.x*b), saturate_cast<_Tp>(a.y*b), saturate_cast<_Tp>(a.z*b) );
-}
-
-template<typename _Tp> static inline
-Point3_<_Tp> operator * (int a, const Point3_<_Tp>& b)
-{
-    return Point3_<_Tp>( saturate_cast<_Tp>(b.x * a), saturate_cast<_Tp>(b.y * a), saturate_cast<_Tp>(b.z * a) );
-}
-
-template<typename _Tp> static inline
-Point3_<_Tp> operator * (const Point3_<_Tp>& a, float b)
-{
-    return Point3_<_Tp>( saturate_cast<_Tp>(a.x * b), saturate_cast<_Tp>(a.y * b), saturate_cast<_Tp>(a.z * b) );
-}
-
-template<typename _Tp> static inline
-Point3_<_Tp> operator * (float a, const Point3_<_Tp>& b)
-{
-    return Point3_<_Tp>( saturate_cast<_Tp>(b.x * a), saturate_cast<_Tp>(b.y * a), saturate_cast<_Tp>(b.z * a) );
-}
-
-template<typename _Tp> static inline
-Point3_<_Tp> operator * (const Point3_<_Tp>& a, double b)
-{
-    return Point3_<_Tp>( saturate_cast<_Tp>(a.x * b), saturate_cast<_Tp>(a.y * b), saturate_cast<_Tp>(a.z * b) );
-}
-
-template<typename _Tp> static inline
-Point3_<_Tp> operator * (double a, const Point3_<_Tp>& b)
-{
-    return Point3_<_Tp>( saturate_cast<_Tp>(b.x * a), saturate_cast<_Tp>(b.y * a), saturate_cast<_Tp>(b.z * a) );
-}
-
-template<typename _Tp> static inline
-Point3_<_Tp> operator * (const Matx<_Tp, 3, 3>& a, const Point3_<_Tp>& b)
-{
-    Matx<_Tp, 3, 1> tmp = a * Vec<_Tp,3>(b.x, b.y, b.z);
-    return Point3_<_Tp>(tmp.val[0], tmp.val[1], tmp.val[2]);
-}
-
-template<typename _Tp> static inline
-Matx<_Tp, 4, 1> operator * (const Matx<_Tp, 4, 4>& a, const Point3_<_Tp>& b)
-{
-    return a * Matx<_Tp, 4, 1>(b.x, b.y, b.z, 1);
-}
-
-template<typename _Tp> static inline
-Point3_<_Tp> operator / (const Point3_<_Tp>& a, int b)
-{
-    Point3_<_Tp> tmp(a);
-    tmp /= b;
-    return tmp;
-}
-
-template<typename _Tp> static inline
-Point3_<_Tp> operator / (const Point3_<_Tp>& a, float b)
-{
-    Point3_<_Tp> tmp(a);
-    tmp /= b;
-    return tmp;
-}
-
-template<typename _Tp> static inline
-Point3_<_Tp> operator / (const Point3_<_Tp>& a, double b)
-{
-    Point3_<_Tp> tmp(a);
-    tmp /= b;
-    return tmp;
-}
-
-
-
-////////////////////////////////// Size /////////////////////////////////
-
-template<typename _Tp> inline
-Size_<_Tp>::Size_()
-    : width(0), height(0) {}
-
-template<typename _Tp> inline
-Size_<_Tp>::Size_(_Tp _width, _Tp _height)
-    : width(_width), height(_height) {}
-
-template<typename _Tp> inline
-Size_<_Tp>::Size_(const Point_<_Tp>& pt)
-    : width(pt.x), height(pt.y) {}
-
-template<typename _Tp> template<typename _Tp2> inline
-Size_<_Tp>::operator Size_<_Tp2>() const
-{
-    return Size_<_Tp2>(saturate_cast<_Tp2>(width), saturate_cast<_Tp2>(height));
-}
-
-template<typename _Tp> inline
-_Tp Size_<_Tp>::area() const
-{
-    const _Tp result = width * height;
-    CV_DbgAssert(!std::numeric_limits<_Tp>::is_integer
-        || width == 0 || result / width == height); // make sure the result fits in the return value
-    return result;
-}
-
-template<typename _Tp> inline
-double Size_<_Tp>::aspectRatio() const
-{
-    return width / static_cast<double>(height);
-}
-
-template<typename _Tp> inline
-bool Size_<_Tp>::empty() const
-{
-    return width <= 0 || height <= 0;
-}
-
-
-template<typename _Tp> static inline
-Size_<_Tp>& operator *= (Size_<_Tp>& a, _Tp b)
-{
-    a.width *= b;
-    a.height *= b;
-    return a;
-}
-
-template<typename _Tp> static inline
-Size_<_Tp> operator * (const Size_<_Tp>& a, _Tp b)
-{
-    Size_<_Tp> tmp(a);
-    tmp *= b;
-    return tmp;
-}
-
-template<typename _Tp> static inline
-Size_<_Tp>& operator /= (Size_<_Tp>& a, _Tp b)
-{
-    a.width /= b;
-    a.height /= b;
-    return a;
-}
-
-template<typename _Tp> static inline
-Size_<_Tp> operator / (const Size_<_Tp>& a, _Tp b)
-{
-    Size_<_Tp> tmp(a);
-    tmp /= b;
-    return tmp;
-}
-
-template<typename _Tp> static inline
-Size_<_Tp>& operator += (Size_<_Tp>& a, const Size_<_Tp>& b)
-{
-    a.width += b.width;
-    a.height += b.height;
-    return a;
-}
-
-template<typename _Tp> static inline
-Size_<_Tp> operator + (const Size_<_Tp>& a, const Size_<_Tp>& b)
-{
-    Size_<_Tp> tmp(a);
-    tmp += b;
-    return tmp;
-}
-
-template<typename _Tp> static inline
-Size_<_Tp>& operator -= (Size_<_Tp>& a, const Size_<_Tp>& b)
-{
-    a.width -= b.width;
-    a.height -= b.height;
-    return a;
-}
-
-template<typename _Tp> static inline
-Size_<_Tp> operator - (const Size_<_Tp>& a, const Size_<_Tp>& b)
-{
-    Size_<_Tp> tmp(a);
-    tmp -= b;
-    return tmp;
-}
-
-template<typename _Tp> static inline
-bool operator == (const Size_<_Tp>& a, const Size_<_Tp>& b)
-{
-    return a.width == b.width && a.height == b.height;
-}
-
-template<typename _Tp> static inline
-bool operator != (const Size_<_Tp>& a, const Size_<_Tp>& b)
-{
-    return !(a == b);
-}
-
-
-
-////////////////////////////////// Rect /////////////////////////////////
-
-template<typename _Tp> inline
-Rect_<_Tp>::Rect_()
-    : x(0), y(0), width(0), height(0) {}
-
-template<typename _Tp> inline
-Rect_<_Tp>::Rect_(_Tp _x, _Tp _y, _Tp _width, _Tp _height)
-    : x(_x), y(_y), width(_width), height(_height) {}
-
-template<typename _Tp> inline
-Rect_<_Tp>::Rect_(const Point_<_Tp>& org, const Size_<_Tp>& sz)
-    : x(org.x), y(org.y), width(sz.width), height(sz.height) {}
-
-template<typename _Tp> inline
-Rect_<_Tp>::Rect_(const Point_<_Tp>& pt1, const Point_<_Tp>& pt2)
-{
-    x = std::min(pt1.x, pt2.x);
-    y = std::min(pt1.y, pt2.y);
-    width = std::max(pt1.x, pt2.x) - x;
-    height = std::max(pt1.y, pt2.y) - y;
-}
-
-template<typename _Tp> inline
-Point_<_Tp> Rect_<_Tp>::tl() const
-{
-    return Point_<_Tp>(x,y);
-}
-
-template<typename _Tp> inline
-Point_<_Tp> Rect_<_Tp>::br() const
-{
-    return Point_<_Tp>(x + width, y + height);
-}
-
-template<typename _Tp> inline
-Size_<_Tp> Rect_<_Tp>::size() const
-{
-    return Size_<_Tp>(width, height);
-}
-
-template<typename _Tp> inline
-_Tp Rect_<_Tp>::area() const
-{
-    const _Tp result = width * height;
-    CV_DbgAssert(!std::numeric_limits<_Tp>::is_integer
-        || width == 0 || result / width == height); // make sure the result fits in the return value
-    return result;
-}
-
-template<typename _Tp> inline
-bool Rect_<_Tp>::empty() const
-{
-    return width <= 0 || height <= 0;
-}
-
-template<typename _Tp> template<typename _Tp2> inline
-Rect_<_Tp>::operator Rect_<_Tp2>() const
-{
-    return Rect_<_Tp2>(saturate_cast<_Tp2>(x), saturate_cast<_Tp2>(y), saturate_cast<_Tp2>(width), saturate_cast<_Tp2>(height));
-}
-
-template<typename _Tp> inline
-bool Rect_<_Tp>::contains(const Point_<_Tp>& pt) const
-{
-    return x <= pt.x && pt.x < x + width && y <= pt.y && pt.y < y + height;
-}
-
-
-template<typename _Tp> static inline
-Rect_<_Tp>& operator += ( Rect_<_Tp>& a, const Point_<_Tp>& b )
-{
-    a.x += b.x;
-    a.y += b.y;
-    return a;
-}
-
-template<typename _Tp> static inline
-Rect_<_Tp>& operator -= ( Rect_<_Tp>& a, const Point_<_Tp>& b )
-{
-    a.x -= b.x;
-    a.y -= b.y;
-    return a;
-}
-
-template<typename _Tp> static inline
-Rect_<_Tp>& operator += ( Rect_<_Tp>& a, const Size_<_Tp>& b )
-{
-    a.width += b.width;
-    a.height += b.height;
-    return a;
-}
-
-template<typename _Tp> static inline
-Rect_<_Tp>& operator -= ( Rect_<_Tp>& a, const Size_<_Tp>& b )
-{
-    const _Tp width = a.width - b.width;
-    const _Tp height = a.height - b.height;
-    CV_DbgAssert(width >= 0 && height >= 0);
-    a.width = width;
-    a.height = height;
-    return a;
-}
-
-template<typename _Tp> static inline
-Rect_<_Tp>& operator &= ( Rect_<_Tp>& a, const Rect_<_Tp>& b )
-{
-    if (a.empty() || b.empty()) {
-        a = Rect();
-        return a;
-    }
-    const Rect_<_Tp>& Rx_min = (a.x < b.x) ? a : b;
-    const Rect_<_Tp>& Rx_max = (a.x < b.x) ? b : a;
-    const Rect_<_Tp>& Ry_min = (a.y < b.y) ? a : b;
-    const Rect_<_Tp>& Ry_max = (a.y < b.y) ? b : a;
-    // Looking at the formula below, we will compute Rx_min.width - (Rx_max.x - Rx_min.x)
-    // but we want to avoid overflows. Rx_min.width >= 0 and (Rx_max.x - Rx_min.x) >= 0
-    // by definition so the difference does not overflow. The only thing that can overflow
-    // is (Rx_max.x - Rx_min.x). And it can only overflow if Rx_min.x < 0.
-    // Let us first deal with the following case.
-    if ((Rx_min.x < 0 && Rx_min.x + Rx_min.width < Rx_max.x) ||
-        (Ry_min.y < 0 && Ry_min.y + Ry_min.height < Ry_max.y)) {
-        a = Rect();
-        return a;
-    }
-    // We now know that either Rx_min.x >= 0, or
-    // Rx_min.x < 0 && Rx_min.x + Rx_min.width >= Rx_max.x and therefore
-    // Rx_min.width >= (Rx_max.x - Rx_min.x) which means (Rx_max.x - Rx_min.x)
-    // is inferior to a valid int and therefore does not overflow.
-    a.width = std::min(Rx_min.width - (Rx_max.x - Rx_min.x), Rx_max.width);
-    a.height = std::min(Ry_min.height - (Ry_max.y - Ry_min.y), Ry_max.height);
-    a.x = Rx_max.x;
-    a.y = Ry_max.y;
-    if (a.empty())
-        a = Rect();
-    return a;
-}
-
-template<typename _Tp> static inline
-Rect_<_Tp>& operator |= ( Rect_<_Tp>& a, const Rect_<_Tp>& b )
-{
-    if (a.empty()) {
-        a = b;
-    }
-    else if (!b.empty()) {
-        _Tp x1 = std::min(a.x, b.x);
-        _Tp y1 = std::min(a.y, b.y);
-        a.width = std::max(a.x + a.width, b.x + b.width) - x1;
-        a.height = std::max(a.y + a.height, b.y + b.height) - y1;
-        a.x = x1;
-        a.y = y1;
-    }
-    return a;
-}
-
-template<typename _Tp> static inline
-bool operator == (const Rect_<_Tp>& a, const Rect_<_Tp>& b)
-{
-    return a.x == b.x && a.y == b.y && a.width == b.width && a.height == b.height;
-}
-
-template<typename _Tp> static inline
-bool operator != (const Rect_<_Tp>& a, const Rect_<_Tp>& b)
-{
-    return a.x != b.x || a.y != b.y || a.width != b.width || a.height != b.height;
-}
-
-template<typename _Tp> static inline
-Rect_<_Tp> operator + (const Rect_<_Tp>& a, const Point_<_Tp>& b)
-{
-    return Rect_<_Tp>( a.x + b.x, a.y + b.y, a.width, a.height );
-}
-
-template<typename _Tp> static inline
-Rect_<_Tp> operator - (const Rect_<_Tp>& a, const Point_<_Tp>& b)
-{
-    return Rect_<_Tp>( a.x - b.x, a.y - b.y, a.width, a.height );
-}
-
-template<typename _Tp> static inline
-Rect_<_Tp> operator + (const Rect_<_Tp>& a, const Size_<_Tp>& b)
-{
-    return Rect_<_Tp>( a.x, a.y, a.width + b.width, a.height + b.height );
-}
-
-template<typename _Tp> static inline
-Rect_<_Tp> operator - (const Rect_<_Tp>& a, const Size_<_Tp>& b)
-{
-    const _Tp width = a.width - b.width;
-    const _Tp height = a.height - b.height;
-    CV_DbgAssert(width >= 0 && height >= 0);
-    return Rect_<_Tp>( a.x, a.y, width, height );
-}
-
-template<typename _Tp> static inline
-Rect_<_Tp> operator & (const Rect_<_Tp>& a, const Rect_<_Tp>& b)
-{
-    Rect_<_Tp> c = a;
-    return c &= b;
-}
-
-template<typename _Tp> static inline
-Rect_<_Tp> operator | (const Rect_<_Tp>& a, const Rect_<_Tp>& b)
-{
-    Rect_<_Tp> c = a;
-    return c |= b;
-}
-
-/**
- * @brief measure dissimilarity between two sample sets
- *
- * computes the complement of the Jaccard Index as described in <https://en.wikipedia.org/wiki/Jaccard_index>.
- * For rectangles this reduces to computing the intersection over the union.
- */
-template<typename _Tp> static inline
-double jaccardDistance(const Rect_<_Tp>& a, const Rect_<_Tp>& b) {
-    _Tp Aa = a.area();
-    _Tp Ab = b.area();
-
-    if ((Aa + Ab) <= std::numeric_limits<_Tp>::epsilon()) {
-        // jaccard_index = 1 -> distance = 0
-        return 0.0;
-    }
-
-    double Aab = (a & b).area();
-    // distance = 1 - jaccard_index
-    return 1.0 - Aab / (Aa + Ab - Aab);
-}
-
-/** @brief Finds out if there is any intersection between two rectangles
- *
- * mainly useful for language bindings
- * @param rect1 First rectangle
- * @param rect2 Second rectangle
- * @return the area of the intersection
- */
-CV_EXPORTS_W inline double rectangleIntersectionArea(const Rect2d& a, const Rect2d& b) { return (a & b).area(); }
-
-////////////////////////////// RotatedRect //////////////////////////////
-
-inline
-RotatedRect::RotatedRect()
-    : center(), size(), angle(0) {}
-
-inline
-RotatedRect::RotatedRect(const Point2f& _center, const Size2f& _size, float _angle)
-    : center(_center), size(_size), angle(_angle) {}
-
-///////////////////////////////// Range /////////////////////////////////
-
-inline
-Range::Range()
-    : start(0), end(0) {}
-
-inline
-Range::Range(int _start, int _end)
-    : start(_start), end(_end) {}
-
-inline
-int Range::size() const
-{
-    return end - start;
-}
-
-inline
-bool Range::empty() const
-{
-    return start == end;
-}
-
-inline
-Range Range::all()
-{
-    return Range(INT_MIN, INT_MAX);
-}
-
-
-static inline
-bool operator == (const Range& r1, const Range& r2)
-{
-    return r1.start == r2.start && r1.end == r2.end;
-}
-
-static inline
-bool operator != (const Range& r1, const Range& r2)
-{
-    return !(r1 == r2);
-}
-
-static inline
-bool operator !(const Range& r)
-{
-    return r.start == r.end;
-}
-
-static inline
-Range operator & (const Range& r1, const Range& r2)
-{
-    Range r(std::max(r1.start, r2.start), std::min(r1.end, r2.end));
-    r.end = std::max(r.end, r.start);
-    return r;
-}
-
-static inline
-Range& operator &= (Range& r1, const Range& r2)
-{
-    r1 = r1 & r2;
-    return r1;
-}
-
-static inline
-Range operator + (const Range& r1, int delta)
-{
-    return Range(r1.start + delta, r1.end + delta);
-}
-
-static inline
-Range operator + (int delta, const Range& r1)
-{
-    return Range(r1.start + delta, r1.end + delta);
-}
-
-static inline
-Range operator - (const Range& r1, int delta)
-{
-    return r1 + (-delta);
-}
-
-
-
-///////////////////////////////// Scalar ////////////////////////////////
-
-template<typename _Tp> inline
-Scalar_<_Tp>::Scalar_()
-{
-    this->val[0] = this->val[1] = this->val[2] = this->val[3] = 0;
-}
-
-template<typename _Tp> inline
-Scalar_<_Tp>::Scalar_(_Tp v0, _Tp v1, _Tp v2, _Tp v3)
-{
-    this->val[0] = v0;
-    this->val[1] = v1;
-    this->val[2] = v2;
-    this->val[3] = v3;
-}
-
-template<typename _Tp> inline
-Scalar_<_Tp>::Scalar_(const Scalar_<_Tp>& s) : Vec<_Tp, 4>(s) {
-}
-
-template<typename _Tp> inline
-Scalar_<_Tp>::Scalar_(Scalar_<_Tp>&& s) CV_NOEXCEPT {
-    this->val[0] = std::move(s.val[0]);
-    this->val[1] = std::move(s.val[1]);
-    this->val[2] = std::move(s.val[2]);
-    this->val[3] = std::move(s.val[3]);
-}
-
-template<typename _Tp> inline
-Scalar_<_Tp>& Scalar_<_Tp>::operator=(const Scalar_<_Tp>& s) {
-    this->val[0] = s.val[0];
-    this->val[1] = s.val[1];
-    this->val[2] = s.val[2];
-    this->val[3] = s.val[3];
-    return *this;
-}
-
-template<typename _Tp> inline
-Scalar_<_Tp>& Scalar_<_Tp>::operator=(Scalar_<_Tp>&& s) CV_NOEXCEPT {
-    this->val[0] = std::move(s.val[0]);
-    this->val[1] = std::move(s.val[1]);
-    this->val[2] = std::move(s.val[2]);
-    this->val[3] = std::move(s.val[3]);
-    return *this;
-}
-
-template<typename _Tp> template<typename _Tp2, int cn> inline
-Scalar_<_Tp>::Scalar_(const Vec<_Tp2, cn>& v)
-{
-    int i;
-    for( i = 0; i < (cn < 4 ? cn : 4); i++ )
-        this->val[i] = cv::saturate_cast<_Tp>(v.val[i]);
-    for( ; i < 4; i++ )
-        this->val[i] = 0;
-}
-
-template<typename _Tp> inline
-Scalar_<_Tp>::Scalar_(_Tp v0)
-{
-    this->val[0] = v0;
-    this->val[1] = this->val[2] = this->val[3] = 0;
-}
-
-template<typename _Tp> inline
-Scalar_<_Tp> Scalar_<_Tp>::all(_Tp v0)
-{
-    return Scalar_<_Tp>(v0, v0, v0, v0);
-}
-
-
-template<typename _Tp> inline
-Scalar_<_Tp> Scalar_<_Tp>::mul(const Scalar_<_Tp>& a, double scale ) const
-{
-    return Scalar_<_Tp>(saturate_cast<_Tp>(this->val[0] * a.val[0] * scale),
-                        saturate_cast<_Tp>(this->val[1] * a.val[1] * scale),
-                        saturate_cast<_Tp>(this->val[2] * a.val[2] * scale),
-                        saturate_cast<_Tp>(this->val[3] * a.val[3] * scale));
-}
-
-template<typename _Tp> inline
-Scalar_<_Tp> Scalar_<_Tp>::conj() const
-{
-    return Scalar_<_Tp>(saturate_cast<_Tp>( this->val[0]),
-                        saturate_cast<_Tp>(-this->val[1]),
-                        saturate_cast<_Tp>(-this->val[2]),
-                        saturate_cast<_Tp>(-this->val[3]));
-}
-
-template<typename _Tp> inline
-bool Scalar_<_Tp>::isReal() const
-{
-    return this->val[1] == 0 && this->val[2] == 0 && this->val[3] == 0;
-}
-
-
-template<typename _Tp> template<typename T2> inline
-Scalar_<_Tp>::operator Scalar_<T2>() const
-{
-    return Scalar_<T2>(saturate_cast<T2>(this->val[0]),
-                       saturate_cast<T2>(this->val[1]),
-                       saturate_cast<T2>(this->val[2]),
-                       saturate_cast<T2>(this->val[3]));
-}
-
-
-template<typename _Tp> static inline
-Scalar_<_Tp>& operator += (Scalar_<_Tp>& a, const Scalar_<_Tp>& b)
-{
-    a.val[0] += b.val[0];
-    a.val[1] += b.val[1];
-    a.val[2] += b.val[2];
-    a.val[3] += b.val[3];
-    return a;
-}
-
-template<typename _Tp> static inline
-Scalar_<_Tp>& operator -= (Scalar_<_Tp>& a, const Scalar_<_Tp>& b)
-{
-    a.val[0] -= b.val[0];
-    a.val[1] -= b.val[1];
-    a.val[2] -= b.val[2];
-    a.val[3] -= b.val[3];
-    return a;
-}
-
-template<typename _Tp> static inline
-Scalar_<_Tp>& operator *= ( Scalar_<_Tp>& a, _Tp v )
-{
-    a.val[0] *= v;
-    a.val[1] *= v;
-    a.val[2] *= v;
-    a.val[3] *= v;
-    return a;
-}
-
-template<typename _Tp> static inline
-bool operator == ( const Scalar_<_Tp>& a, const Scalar_<_Tp>& b )
-{
-    return a.val[0] == b.val[0] && a.val[1] == b.val[1] &&
-           a.val[2] == b.val[2] && a.val[3] == b.val[3];
-}
-
-template<typename _Tp> static inline
-bool operator != ( const Scalar_<_Tp>& a, const Scalar_<_Tp>& b )
-{
-    return a.val[0] != b.val[0] || a.val[1] != b.val[1] ||
-           a.val[2] != b.val[2] || a.val[3] != b.val[3];
-}
-
-template<typename _Tp> static inline
-Scalar_<_Tp> operator + (const Scalar_<_Tp>& a, const Scalar_<_Tp>& b)
-{
-    return Scalar_<_Tp>(a.val[0] + b.val[0],
-                        a.val[1] + b.val[1],
-                        a.val[2] + b.val[2],
-                        a.val[3] + b.val[3]);
-}
-
-template<typename _Tp> static inline
-Scalar_<_Tp> operator - (const Scalar_<_Tp>& a, const Scalar_<_Tp>& b)
-{
-    return Scalar_<_Tp>(saturate_cast<_Tp>(a.val[0] - b.val[0]),
-                        saturate_cast<_Tp>(a.val[1] - b.val[1]),
-                        saturate_cast<_Tp>(a.val[2] - b.val[2]),
-                        saturate_cast<_Tp>(a.val[3] - b.val[3]));
-}
-
-template<typename _Tp> static inline
-Scalar_<_Tp> operator * (const Scalar_<_Tp>& a, _Tp alpha)
-{
-    return Scalar_<_Tp>(a.val[0] * alpha,
-                        a.val[1] * alpha,
-                        a.val[2] * alpha,
-                        a.val[3] * alpha);
-}
-
-template<typename _Tp> static inline
-Scalar_<_Tp> operator * (_Tp alpha, const Scalar_<_Tp>& a)
-{
-    return a*alpha;
-}
-
-template<typename _Tp> static inline
-Scalar_<_Tp> operator - (const Scalar_<_Tp>& a)
-{
-    return Scalar_<_Tp>(saturate_cast<_Tp>(-a.val[0]),
-                        saturate_cast<_Tp>(-a.val[1]),
-                        saturate_cast<_Tp>(-a.val[2]),
-                        saturate_cast<_Tp>(-a.val[3]));
-}
-
-
-template<typename _Tp> static inline
-Scalar_<_Tp> operator * (const Scalar_<_Tp>& a, const Scalar_<_Tp>& b)
-{
-    return Scalar_<_Tp>(saturate_cast<_Tp>(a[0]*b[0] - a[1]*b[1] - a[2]*b[2] - a[3]*b[3]),
-                        saturate_cast<_Tp>(a[0]*b[1] + a[1]*b[0] + a[2]*b[3] - a[3]*b[2]),
-                        saturate_cast<_Tp>(a[0]*b[2] - a[1]*b[3] + a[2]*b[0] + a[3]*b[1]),
-                        saturate_cast<_Tp>(a[0]*b[3] + a[1]*b[2] - a[2]*b[1] + a[3]*b[0]));
-}
-
-template<typename _Tp> static inline
-Scalar_<_Tp>& operator *= (Scalar_<_Tp>& a, const Scalar_<_Tp>& b)
-{
-    a = a * b;
-    return a;
-}
-
-template<typename _Tp> static inline
-Scalar_<_Tp> operator / (const Scalar_<_Tp>& a, _Tp alpha)
-{
-    return Scalar_<_Tp>(a.val[0] / alpha,
-                        a.val[1] / alpha,
-                        a.val[2] / alpha,
-                        a.val[3] / alpha);
-}
-
-template<typename _Tp> static inline
-Scalar_<float> operator / (const Scalar_<float>& a, float alpha)
-{
-    float s = 1 / alpha;
-    return Scalar_<float>(a.val[0] * s, a.val[1] * s, a.val[2] * s, a.val[3] * s);
-}
-
-template<typename _Tp> static inline
-Scalar_<double> operator / (const Scalar_<double>& a, double alpha)
-{
-    double s = 1 / alpha;
-    return Scalar_<double>(a.val[0] * s, a.val[1] * s, a.val[2] * s, a.val[3] * s);
-}
-
-template<typename _Tp> static inline
-Scalar_<_Tp>& operator /= (Scalar_<_Tp>& a, _Tp alpha)
-{
-    a = a / alpha;
-    return a;
-}
-
-template<typename _Tp> static inline
-Scalar_<_Tp> operator / (_Tp a, const Scalar_<_Tp>& b)
-{
-    _Tp s = a / (b[0]*b[0] + b[1]*b[1] + b[2]*b[2] + b[3]*b[3]);
-    return b.conj() * s;
-}
-
-template<typename _Tp> static inline
-Scalar_<_Tp> operator / (const Scalar_<_Tp>& a, const Scalar_<_Tp>& b)
-{
-    return a * ((_Tp)1 / b);
-}
-
-template<typename _Tp> static inline
-Scalar_<_Tp>& operator /= (Scalar_<_Tp>& a, const Scalar_<_Tp>& b)
-{
-    a = a / b;
-    return a;
-}
-
-template<typename _Tp> static inline
-Scalar operator * (const Matx<_Tp, 4, 4>& a, const Scalar& b)
-{
-    Matx<double, 4, 1> c((Matx<double, 4, 4>)a, b, Matx_MatMulOp());
-    return reinterpret_cast<const Scalar&>(c);
-}
-
-template<> inline
-Scalar operator * (const Matx<double, 4, 4>& a, const Scalar& b)
-{
-    Matx<double, 4, 1> c(a, b, Matx_MatMulOp());
-    return reinterpret_cast<const Scalar&>(c);
-}
-
-
-
-//////////////////////////////// KeyPoint ///////////////////////////////
-
-inline
-KeyPoint::KeyPoint()
-    : pt(0,0), size(0), angle(-1), response(0), octave(0), class_id(-1) {}
-
-inline
-KeyPoint::KeyPoint(Point2f _pt, float _size, float _angle, float _response, int _octave, int _class_id)
-    : pt(_pt), size(_size), angle(_angle), response(_response), octave(_octave), class_id(_class_id) {}
-
-inline
-KeyPoint::KeyPoint(float x, float y, float _size, float _angle, float _response, int _octave, int _class_id)
-    : pt(x, y), size(_size), angle(_angle), response(_response), octave(_octave), class_id(_class_id) {}
-
-
-
-///////////////////////////////// DMatch ////////////////////////////////
-
-inline
-DMatch::DMatch()
-    : queryIdx(-1), trainIdx(-1), imgIdx(-1), distance(FLT_MAX) {}
-
-inline
-DMatch::DMatch(int _queryIdx, int _trainIdx, float _distance)
-    : queryIdx(_queryIdx), trainIdx(_trainIdx), imgIdx(-1), distance(_distance) {}
-
-inline
-DMatch::DMatch(int _queryIdx, int _trainIdx, int _imgIdx, float _distance)
-    : queryIdx(_queryIdx), trainIdx(_trainIdx), imgIdx(_imgIdx), distance(_distance) {}
-
-inline
-bool DMatch::operator < (const DMatch &m) const
-{
-    return distance < m.distance;
-}
-
-
-
-////////////////////////////// TermCriteria /////////////////////////////
-
-inline
-TermCriteria::TermCriteria()
-    : type(0), maxCount(0), epsilon(0) {}
-
-inline
-TermCriteria::TermCriteria(int _type, int _maxCount, double _epsilon)
-    : type(_type), maxCount(_maxCount), epsilon(_epsilon) {}
-
-//! @endcond
-
-} // cv
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-#endif //OPENCV_CORE_TYPES_HPP