react-native-executorch 0.4.7 → 0.5.1-rc.0

package/third-party/include/opencv2/core/types.hpp

@@ -0,0 +1,2368 @@
+/*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 <cfloat>
+#include <climits>
+#include <limits>
+#include <vector>
+
+#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 traits
+
+//////////////////////////////// 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 traits
+
+//////////////////////////////// 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 traits
+
+//////////////////////////////// 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 traits
+
+//////////////////////////////// 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
+  /*! @warning After OpenCV 4.11.0, when calling Rect.contains() with
+   * cv::Point2f / cv::Point2d point, point should not convert/round to int.
+   * ```
+   * Rect_<int> r(0,0,500,500); Point_<float> pt(250.0f, 499.9f);
+   * r.contains(pt) returns false.(OpenCV 4.10.0 or before)
+   * r.contains(pt) returns true. (OpenCV 4.11.0 or later)
+   * ```
+   */
+  template <typename _Tp2> inline bool contains(const Point_<_Tp2> &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 traits
+
+///////////////////////////// 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_W_SIMPLE RotatedRect {
+public:
+  //! default constructor
+  CV_WRAP 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.
+  */
+  CV_WRAP 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).
+   */
+  CV_WRAP RotatedRect(const Point2f &point1, const Point2f &point2,
+                      const Point2f &point3);
+
+  /** returns 4 vertices of the rotated rectangle
+  @param pts The points array for storing rectangle vertices. The order is
+  _bottomLeft_, _topLeft_, topRight, bottomRight.
+  @note _Bottom_, _Top_, _Left_ and _Right_ sides refer to the original
+  rectangle (angle is 0), so after 180 degree rotation _bottomLeft_ point will
+  be located at the top right corner of the rectangle.
+  */
+  void points(Point2f pts[]) const;
+
+  CV_WRAP void points(CV_OUT std::vector<Point2f> &pts) const;
+
+  //! returns the minimal up-right integer rectangle containing the rotated
+  //! rectangle
+  CV_WRAP Rect boundingRect() const;
+  //! returns the minimal (exact) floating point rectangle containing the
+  //! rotated rectangle, not intended for use with images
+  CV_WRAP Rect2f boundingRect2f() const;
+  //! returns the rectangle mass center
+  CV_PROP_RW Point2f center;
+  //! returns width and height of the rectangle
+  CV_PROP_RW Size2f size;
+  //! returns the rotation angle. When the angle is 0, 90, 180, 270 etc., the
+  //! rectangle becomes an up-right rectangle.
+  CV_PROP_RW 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 traits
+
+//////////////////////////////// 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 traits
+
+//////////////////////////////// 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 traits
+
+/////////////////////////////// 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 traits
+
+//! @} 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>
+template <typename _Tp2>
+inline bool Rect_<_Tp>::contains(const Point_<_Tp2> &pt) const {
+  return x <= pt.x && pt.x < x + width && y <= pt.y && pt.y < y + height;
+}
+// See https://github.com/opencv/opencv/issues/26016
+template <>
+template <>
+inline bool Rect_<int>::contains(const Point_<double> &pt) const {
+  // std::numeric_limits<int>::digits is 31.
+  // std::numeric_limits<double>::digits is 53.
+  // So conversion int->double does not lead to accuracy errors.
+  const Rect_<double> _rect(static_cast<double>(x), static_cast<double>(y),
+                            static_cast<double>(width),
+                            static_cast<double>(height));
+  return _rect.contains(pt);
+}
+template <>
+template <>
+inline bool Rect_<int>::contains(const Point_<float> &_pt) const {
+  // std::numeric_limits<float>::digits is 24.
+  // std::numeric_limits<double>::digits is 53.
+  // So conversion float->double does not lead to accuracy errors.
+  return contains(
+      Point_<double>(static_cast<double>(_pt.x), static_cast<double>(_pt.y)));
+}
+
+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 a First rectangle
+ * @param b 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
+
+} // namespace cv
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+#endif // OPENCV_CORE_TYPES_HPP