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

package/third-party/include/opencv2/core/mat.inl.hpp

@@ -0,0 +1,2753 @@
+/*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.
+// Copyright (C) 2015, Itseez Inc., 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_MATRIX_OPERATIONS_HPP
+#define OPENCV_CORE_MATRIX_OPERATIONS_HPP
+
+#ifndef __cplusplus
+#error mat.inl.hpp header must be compiled as C++
+#endif
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4127 5054)
+#endif
+
+#if defined(CV_SKIP_DISABLE_CLANG_ENUM_WARNINGS)
+// nothing
+#elif defined(CV_FORCE_DISABLE_CLANG_ENUM_WARNINGS)
+#define CV_DISABLE_CLANG_ENUM_WARNINGS
+#elif defined(__clang__) && defined(__has_warning)
+#if __has_warning("-Wdeprecated-enum-enum-conversion") &&                      \
+    __has_warning("-Wdeprecated-anon-enum-enum-conversion")
+#define CV_DISABLE_CLANG_ENUM_WARNINGS
+#endif
+#endif
+#ifdef CV_DISABLE_CLANG_ENUM_WARNINGS
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-enum-enum-conversion"
+#pragma clang diagnostic ignored "-Wdeprecated-anon-enum-enum-conversion"
+#endif
+
+namespace cv {
+CV__DEBUG_NS_BEGIN
+
+//! @cond IGNORED
+
+////////////////////////// Custom (raw) type wrapper //////////////////////////
+
+template <typename _Tp> static inline int rawType() {
+  CV_StaticAssert(sizeof(_Tp) <= CV_CN_MAX, "sizeof(_Tp) is too large");
+  const int elemSize = sizeof(_Tp);
+  return (int)CV_MAKETYPE(CV_8U, elemSize);
+}
+
+//////////////////////// Input/Output Arrays ////////////////////////
+
+inline void _InputArray::init(int _flags, const void *_obj) {
+  flags = _flags;
+  obj = (void *)_obj;
+}
+
+inline void _InputArray::init(int _flags, const void *_obj, Size _sz) {
+  flags = _flags;
+  obj = (void *)_obj;
+  sz = _sz;
+}
+
+inline void *_InputArray::getObj() const { return obj; }
+inline int _InputArray::getFlags() const { return flags; }
+inline Size _InputArray::getSz() const { return sz; }
+
+inline _InputArray::_InputArray() { init(0 + NONE, 0); }
+inline _InputArray::_InputArray(int _flags, void *_obj) { init(_flags, _obj); }
+inline _InputArray::_InputArray(const Mat &m) { init(+MAT + ACCESS_READ, &m); }
+inline _InputArray::_InputArray(const std::vector<Mat> &vec) {
+  init(+STD_VECTOR_MAT + ACCESS_READ, &vec);
+}
+
+template <typename _Tp>
+inline _InputArray::_InputArray(const std::vector<_Tp> &vec) {
+  init(FIXED_TYPE + STD_VECTOR + traits::Type<_Tp>::value + ACCESS_READ, &vec);
+}
+
+template <typename _Tp, std::size_t _Nm>
+inline _InputArray::_InputArray(const std::array<_Tp, _Nm> &arr) {
+  init(FIXED_TYPE + FIXED_SIZE + MATX + traits::Type<_Tp>::value + ACCESS_READ,
+       arr.data(), Size(1, _Nm));
+}
+
+template <std::size_t _Nm>
+inline _InputArray::_InputArray(const std::array<Mat, _Nm> &arr) {
+  init(+STD_ARRAY_MAT + ACCESS_READ, arr.data(), Size(1, _Nm));
+}
+
+inline _InputArray::_InputArray(const std::vector<bool> &vec) {
+  init(FIXED_TYPE + STD_BOOL_VECTOR + traits::Type<bool>::value + ACCESS_READ,
+       &vec);
+}
+
+template <typename _Tp>
+inline _InputArray::_InputArray(const std::vector<std::vector<_Tp>> &vec) {
+  init(FIXED_TYPE + STD_VECTOR_VECTOR + traits::Type<_Tp>::value + ACCESS_READ,
+       &vec);
+}
+
+template <typename _Tp>
+inline _InputArray::_InputArray(const std::vector<Mat_<_Tp>> &vec) {
+  init(FIXED_TYPE + STD_VECTOR_MAT + traits::Type<_Tp>::value + ACCESS_READ,
+       &vec);
+}
+
+template <typename _Tp, int m, int n>
+inline _InputArray::_InputArray(const Matx<_Tp, m, n> &mtx) {
+  init(FIXED_TYPE + FIXED_SIZE + MATX + traits::Type<_Tp>::value + ACCESS_READ,
+       &mtx, Size(n, m));
+}
+
+template <typename _Tp> inline _InputArray::_InputArray(const _Tp *vec, int n) {
+  init(FIXED_TYPE + FIXED_SIZE + MATX + traits::Type<_Tp>::value + ACCESS_READ,
+       vec, Size(n, 1));
+}
+
+template <typename _Tp> inline _InputArray::_InputArray(const Mat_<_Tp> &m) {
+  init(FIXED_TYPE + MAT + traits::Type<_Tp>::value + ACCESS_READ, &m);
+}
+
+inline _InputArray::_InputArray(const double &val) {
+  init(FIXED_TYPE + FIXED_SIZE + MATX + CV_64F + ACCESS_READ, &val, Size(1, 1));
+}
+
+template <typename _Tp>
+inline _InputArray _InputArray::rawIn(const std::vector<_Tp> &vec) {
+  _InputArray v;
+  v.flags = _InputArray::FIXED_TYPE + _InputArray::STD_VECTOR + rawType<_Tp>() +
+            ACCESS_READ;
+  v.obj = (void *)&vec;
+  return v;
+}
+
+template <typename _Tp, std::size_t _Nm>
+inline _InputArray _InputArray::rawIn(const std::array<_Tp, _Nm> &arr) {
+  _InputArray v;
+  v.flags =
+      FIXED_TYPE + FIXED_SIZE + MATX + traits::Type<_Tp>::value + ACCESS_READ;
+  v.obj = (void *)arr.data();
+  v.sz = Size(1, _Nm);
+  return v;
+}
+
+inline _InputArray::~_InputArray() {}
+
+inline Mat _InputArray::getMat(int i) const {
+  if (kind() == MAT && i < 0)
+    return *(const Mat *)obj;
+  return getMat_(i);
+}
+
+inline bool _InputArray::isMat() const { return kind() == _InputArray::MAT; }
+inline bool _InputArray::isMatVector() const {
+  return kind() == _InputArray::STD_VECTOR_MAT;
+}
+inline bool _InputArray::isMatx() const { return kind() == _InputArray::MATX; }
+inline bool _InputArray::isVector() const {
+  return kind() == _InputArray::STD_VECTOR ||
+         kind() == _InputArray::STD_BOOL_VECTOR ||
+         (kind() == _InputArray::MATX && (sz.width <= 1 || sz.height <= 1));
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+
+inline _OutputArray::_OutputArray() { init(+NONE + ACCESS_WRITE, 0); }
+inline _OutputArray::_OutputArray(int _flags, void *_obj) {
+  init(_flags + ACCESS_WRITE, _obj);
+}
+inline _OutputArray::_OutputArray(Mat &m) { init(+MAT + ACCESS_WRITE, &m); }
+inline _OutputArray::_OutputArray(std::vector<Mat> &vec) {
+  init(+STD_VECTOR_MAT + ACCESS_WRITE, &vec);
+}
+
+template <typename _Tp>
+inline _OutputArray::_OutputArray(std::vector<_Tp> &vec) {
+  init(FIXED_TYPE + STD_VECTOR + traits::Type<_Tp>::value + ACCESS_WRITE, &vec);
+}
+
+template <typename _Tp, std::size_t _Nm>
+inline _OutputArray::_OutputArray(std::array<_Tp, _Nm> &arr) {
+  init(FIXED_TYPE + FIXED_SIZE + MATX + traits::Type<_Tp>::value + ACCESS_WRITE,
+       arr.data(), Size(1, _Nm));
+}
+
+template <std::size_t _Nm>
+inline _OutputArray::_OutputArray(std::array<Mat, _Nm> &arr) {
+  init(+STD_ARRAY_MAT + ACCESS_WRITE, arr.data(), Size(1, _Nm));
+}
+
+template <typename _Tp>
+inline _OutputArray::_OutputArray(std::vector<std::vector<_Tp>> &vec) {
+  init(FIXED_TYPE + STD_VECTOR_VECTOR + traits::Type<_Tp>::value + ACCESS_WRITE,
+       &vec);
+}
+
+template <typename _Tp>
+inline _OutputArray::_OutputArray(std::vector<Mat_<_Tp>> &vec) {
+  init(FIXED_TYPE + STD_VECTOR_MAT + traits::Type<_Tp>::value + ACCESS_WRITE,
+       &vec);
+}
+
+template <typename _Tp> inline _OutputArray::_OutputArray(Mat_<_Tp> &m) {
+  init(FIXED_TYPE + MAT + traits::Type<_Tp>::value + ACCESS_WRITE, &m);
+}
+
+template <typename _Tp, int m, int n>
+inline _OutputArray::_OutputArray(Matx<_Tp, m, n> &mtx) {
+  init(FIXED_TYPE + FIXED_SIZE + MATX + traits::Type<_Tp>::value + ACCESS_WRITE,
+       &mtx, Size(n, m));
+}
+
+template <typename _Tp> inline _OutputArray::_OutputArray(_Tp *vec, int n) {
+  init(FIXED_TYPE + FIXED_SIZE + MATX + traits::Type<_Tp>::value + ACCESS_WRITE,
+       vec, Size(n, 1));
+}
+
+template <typename _Tp>
+inline _OutputArray::_OutputArray(const std::vector<_Tp> &vec) {
+  init(FIXED_TYPE + FIXED_SIZE + STD_VECTOR + traits::Type<_Tp>::value +
+           ACCESS_WRITE,
+       &vec);
+}
+
+template <typename _Tp, std::size_t _Nm>
+inline _OutputArray::_OutputArray(const std::array<_Tp, _Nm> &arr) {
+  init(FIXED_TYPE + FIXED_SIZE + MATX + traits::Type<_Tp>::value + ACCESS_WRITE,
+       arr.data(), Size(1, _Nm));
+}
+
+template <std::size_t _Nm>
+inline _OutputArray::_OutputArray(const std::array<Mat, _Nm> &arr) {
+  init(FIXED_SIZE + STD_ARRAY_MAT + ACCESS_WRITE, arr.data(), Size(1, _Nm));
+}
+
+template <typename _Tp>
+inline _OutputArray::_OutputArray(const std::vector<std::vector<_Tp>> &vec) {
+  init(FIXED_TYPE + FIXED_SIZE + STD_VECTOR_VECTOR + traits::Type<_Tp>::value +
+           ACCESS_WRITE,
+       &vec);
+}
+
+template <typename _Tp>
+inline _OutputArray::_OutputArray(const std::vector<Mat_<_Tp>> &vec) {
+  init(FIXED_TYPE + FIXED_SIZE + STD_VECTOR_MAT + traits::Type<_Tp>::value +
+           ACCESS_WRITE,
+       &vec);
+}
+
+template <typename _Tp> inline _OutputArray::_OutputArray(const Mat_<_Tp> &m) {
+  init(FIXED_TYPE + FIXED_SIZE + MAT + traits::Type<_Tp>::value + ACCESS_WRITE,
+       &m);
+}
+
+template <typename _Tp, int m, int n>
+inline _OutputArray::_OutputArray(const Matx<_Tp, m, n> &mtx) {
+  init(FIXED_TYPE + FIXED_SIZE + MATX + traits::Type<_Tp>::value + ACCESS_WRITE,
+       &mtx, Size(n, m));
+}
+
+template <typename _Tp>
+inline _OutputArray::_OutputArray(const _Tp *vec, int n) {
+  init(FIXED_TYPE + FIXED_SIZE + MATX + traits::Type<_Tp>::value + ACCESS_WRITE,
+       vec, Size(n, 1));
+}
+
+inline _OutputArray::_OutputArray(const Mat &m) {
+  init(FIXED_TYPE + FIXED_SIZE + MAT + ACCESS_WRITE, &m);
+}
+
+inline _OutputArray::_OutputArray(const std::vector<Mat> &vec) {
+  init(FIXED_SIZE + STD_VECTOR_MAT + ACCESS_WRITE, &vec);
+}
+
+template <typename _Tp>
+inline _OutputArray _OutputArray::rawOut(std::vector<_Tp> &vec) {
+  _OutputArray v;
+  v.flags = _InputArray::FIXED_TYPE + _InputArray::STD_VECTOR + rawType<_Tp>() +
+            ACCESS_WRITE;
+  v.obj = (void *)&vec;
+  return v;
+}
+
+template <typename _Tp, std::size_t _Nm>
+inline _OutputArray _OutputArray::rawOut(std::array<_Tp, _Nm> &arr) {
+  _OutputArray v;
+  v.flags =
+      FIXED_TYPE + FIXED_SIZE + MATX + traits::Type<_Tp>::value + ACCESS_WRITE;
+  v.obj = (void *)arr.data();
+  v.sz = Size(1, _Nm);
+  return v;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+inline _InputOutputArray::_InputOutputArray() { init(0 + ACCESS_RW, 0); }
+inline _InputOutputArray::_InputOutputArray(int _flags, void *_obj) {
+  init(_flags + ACCESS_RW, _obj);
+}
+inline _InputOutputArray::_InputOutputArray(Mat &m) {
+  init(+MAT + ACCESS_RW, &m);
+}
+inline _InputOutputArray::_InputOutputArray(std::vector<Mat> &vec) {
+  init(+STD_VECTOR_MAT + ACCESS_RW, &vec);
+}
+
+template <typename _Tp>
+inline _InputOutputArray::_InputOutputArray(std::vector<_Tp> &vec) {
+  init(FIXED_TYPE + STD_VECTOR + traits::Type<_Tp>::value + ACCESS_RW, &vec);
+}
+
+template <typename _Tp, std::size_t _Nm>
+inline _InputOutputArray::_InputOutputArray(std::array<_Tp, _Nm> &arr) {
+  init(FIXED_TYPE + FIXED_SIZE + MATX + traits::Type<_Tp>::value + ACCESS_RW,
+       arr.data(), Size(1, _Nm));
+}
+
+template <std::size_t _Nm>
+inline _InputOutputArray::_InputOutputArray(std::array<Mat, _Nm> &arr) {
+  init(+STD_ARRAY_MAT + ACCESS_RW, arr.data(), Size(1, _Nm));
+}
+
+template <typename _Tp>
+inline _InputOutputArray::_InputOutputArray(
+    std::vector<std::vector<_Tp>> &vec) {
+  init(FIXED_TYPE + STD_VECTOR_VECTOR + traits::Type<_Tp>::value + ACCESS_RW,
+       &vec);
+}
+
+template <typename _Tp>
+inline _InputOutputArray::_InputOutputArray(std::vector<Mat_<_Tp>> &vec) {
+  init(FIXED_TYPE + STD_VECTOR_MAT + traits::Type<_Tp>::value + ACCESS_RW,
+       &vec);
+}
+
+template <typename _Tp>
+inline _InputOutputArray::_InputOutputArray(Mat_<_Tp> &m) {
+  init(FIXED_TYPE + MAT + traits::Type<_Tp>::value + ACCESS_RW, &m);
+}
+
+template <typename _Tp, int m, int n>
+inline _InputOutputArray::_InputOutputArray(Matx<_Tp, m, n> &mtx) {
+  init(FIXED_TYPE + FIXED_SIZE + MATX + traits::Type<_Tp>::value + ACCESS_RW,
+       &mtx, Size(n, m));
+}
+
+template <typename _Tp>
+inline _InputOutputArray::_InputOutputArray(_Tp *vec, int n) {
+  init(FIXED_TYPE + FIXED_SIZE + MATX + traits::Type<_Tp>::value + ACCESS_RW,
+       vec, Size(n, 1));
+}
+
+template <typename _Tp>
+inline _InputOutputArray::_InputOutputArray(const std::vector<_Tp> &vec) {
+  init(FIXED_TYPE + FIXED_SIZE + STD_VECTOR + traits::Type<_Tp>::value +
+           ACCESS_RW,
+       &vec);
+}
+
+template <typename _Tp, std::size_t _Nm>
+inline _InputOutputArray::_InputOutputArray(const std::array<_Tp, _Nm> &arr) {
+  init(FIXED_TYPE + FIXED_SIZE + MATX + traits::Type<_Tp>::value + ACCESS_RW,
+       arr.data(), Size(1, _Nm));
+}
+
+template <std::size_t _Nm>
+inline _InputOutputArray::_InputOutputArray(const std::array<Mat, _Nm> &arr) {
+  init(FIXED_SIZE + STD_ARRAY_MAT + ACCESS_RW, arr.data(), Size(1, _Nm));
+}
+
+template <typename _Tp>
+inline _InputOutputArray::_InputOutputArray(
+    const std::vector<std::vector<_Tp>> &vec) {
+  init(FIXED_TYPE + FIXED_SIZE + STD_VECTOR_VECTOR + traits::Type<_Tp>::value +
+           ACCESS_RW,
+       &vec);
+}
+
+template <typename _Tp>
+inline _InputOutputArray::_InputOutputArray(const std::vector<Mat_<_Tp>> &vec) {
+  init(FIXED_TYPE + FIXED_SIZE + STD_VECTOR_MAT + traits::Type<_Tp>::value +
+           ACCESS_RW,
+       &vec);
+}
+
+template <typename _Tp>
+inline _InputOutputArray::_InputOutputArray(const Mat_<_Tp> &m) {
+  init(FIXED_TYPE + FIXED_SIZE + MAT + traits::Type<_Tp>::value + ACCESS_RW,
+       &m);
+}
+
+template <typename _Tp, int m, int n>
+inline _InputOutputArray::_InputOutputArray(const Matx<_Tp, m, n> &mtx) {
+  init(FIXED_TYPE + FIXED_SIZE + MATX + traits::Type<_Tp>::value + ACCESS_RW,
+       &mtx, Size(n, m));
+}
+
+template <typename _Tp>
+inline _InputOutputArray::_InputOutputArray(const _Tp *vec, int n) {
+  init(FIXED_TYPE + FIXED_SIZE + MATX + traits::Type<_Tp>::value + ACCESS_RW,
+       vec, Size(n, 1));
+}
+
+inline _InputOutputArray::_InputOutputArray(const Mat &m) {
+  init(FIXED_TYPE + FIXED_SIZE + MAT + ACCESS_RW, &m);
+}
+
+inline _InputOutputArray::_InputOutputArray(const std::vector<Mat> &vec) {
+  init(FIXED_SIZE + STD_VECTOR_MAT + ACCESS_RW, &vec);
+}
+
+template <typename _Tp>
+inline _InputOutputArray _InputOutputArray::rawInOut(std::vector<_Tp> &vec) {
+  _InputOutputArray v;
+  v.flags = _InputArray::FIXED_TYPE + _InputArray::STD_VECTOR + rawType<_Tp>() +
+            ACCESS_RW;
+  v.obj = (void *)&vec;
+  return v;
+}
+
+template <typename _Tp, std::size_t _Nm>
+inline _InputOutputArray
+_InputOutputArray::rawInOut(std::array<_Tp, _Nm> &arr) {
+  _InputOutputArray v;
+  v.flags =
+      FIXED_TYPE + FIXED_SIZE + MATX + traits::Type<_Tp>::value + ACCESS_RW;
+  v.obj = (void *)arr.data();
+  v.sz = Size(1, _Nm);
+  return v;
+}
+
+template <typename _Tp> static inline _InputArray rawIn(_Tp &v) {
+  return _InputArray::rawIn(v);
+}
+template <typename _Tp> static inline _OutputArray rawOut(_Tp &v) {
+  return _OutputArray::rawOut(v);
+}
+template <typename _Tp> static inline _InputOutputArray rawInOut(_Tp &v) {
+  return _InputOutputArray::rawInOut(v);
+}
+
+CV__DEBUG_NS_END
+
+//////////////////////////////////////////// Mat
+/////////////////////////////////////////////
+
+template <typename _Tp>
+inline Mat::Mat(const std::vector<_Tp> &vec, bool copyData)
+    : flags(+MAGIC_VAL + traits::Type<_Tp>::value + CV_MAT_CONT_FLAG), dims(2),
+      rows((int)vec.size()), cols(1), data(0), datastart(0), dataend(0),
+      datalimit(0), allocator(0), u(0), size(&rows), step(0) {
+  if (vec.empty())
+    return;
+  if (!copyData) {
+    step[0] = step[1] = sizeof(_Tp);
+    datastart = data = (uchar *)&vec[0];
+    datalimit = dataend = datastart + rows * step[0];
+  } else
+    Mat((int)vec.size(), 1, traits::Type<_Tp>::value, (uchar *)&vec[0])
+        .copyTo(*this);
+}
+
+template <typename _Tp, typename>
+inline Mat::Mat(const std::initializer_list<_Tp> list) : Mat() {
+  CV_Assert(list.size() != 0);
+  Mat((int)list.size(), 1, traits::Type<_Tp>::value, (uchar *)list.begin())
+      .copyTo(*this);
+}
+
+template <typename _Tp>
+inline Mat::Mat(const std::initializer_list<int> sizes,
+                const std::initializer_list<_Tp> list)
+    : Mat() {
+  size_t size_total = 1;
+  for (auto s : sizes)
+    size_total *= s;
+  CV_Assert(list.size() != 0);
+  CV_Assert(size_total == list.size());
+  Mat((int)sizes.size(), (int *)sizes.begin(), traits::Type<_Tp>::value,
+      (uchar *)list.begin())
+      .copyTo(*this);
+}
+
+template <typename _Tp, std::size_t _Nm>
+inline Mat::Mat(const std::array<_Tp, _Nm> &arr, bool copyData)
+    : flags(+MAGIC_VAL + traits::Type<_Tp>::value + CV_MAT_CONT_FLAG), dims(2),
+      rows((int)arr.size()), cols(1), data(0), datastart(0), dataend(0),
+      datalimit(0), allocator(0), u(0), size(&rows), step(0) {
+  if (arr.empty())
+    return;
+  if (!copyData) {
+    step[0] = step[1] = sizeof(_Tp);
+    datastart = data = (uchar *)arr.data();
+    datalimit = dataend = datastart + rows * step[0];
+  } else
+    Mat((int)arr.size(), 1, traits::Type<_Tp>::value, (uchar *)arr.data())
+        .copyTo(*this);
+}
+
+template <typename _Tp, int n>
+inline Mat::Mat(const Vec<_Tp, n> &vec, bool copyData)
+    : flags(+MAGIC_VAL + traits::Type<_Tp>::value + CV_MAT_CONT_FLAG), dims(2),
+      rows(n), cols(1), data(0), datastart(0), dataend(0), datalimit(0),
+      allocator(0), u(0), size(&rows), step(0) {
+  if (!copyData) {
+    step[0] = step[1] = sizeof(_Tp);
+    datastart = data = (uchar *)vec.val;
+    datalimit = dataend = datastart + rows * step[0];
+  } else
+    Mat(n, 1, traits::Type<_Tp>::value, (void *)vec.val).copyTo(*this);
+}
+
+template <typename _Tp, int m, int n>
+inline Mat::Mat(const Matx<_Tp, m, n> &M, bool copyData)
+    : flags(+MAGIC_VAL + traits::Type<_Tp>::value + CV_MAT_CONT_FLAG), dims(2),
+      rows(m), cols(n), data(0), datastart(0), dataend(0), datalimit(0),
+      allocator(0), u(0), size(&rows), step(0) {
+  if (!copyData) {
+    step[0] = cols * sizeof(_Tp);
+    step[1] = sizeof(_Tp);
+    datastart = data = (uchar *)M.val;
+    datalimit = dataend = datastart + rows * step[0];
+  } else
+    Mat(m, n, traits::Type<_Tp>::value, (uchar *)M.val).copyTo(*this);
+}
+
+template <typename _Tp>
+inline Mat::Mat(const Point_<_Tp> &pt, bool copyData)
+    : flags(+MAGIC_VAL + traits::Type<_Tp>::value + CV_MAT_CONT_FLAG), dims(2),
+      rows(2), cols(1), data(0), datastart(0), dataend(0), datalimit(0),
+      allocator(0), u(0), size(&rows), step(0) {
+  if (!copyData) {
+    step[0] = step[1] = sizeof(_Tp);
+    datastart = data = (uchar *)&pt.x;
+    datalimit = dataend = datastart + rows * step[0];
+  } else {
+    create(2, 1, traits::Type<_Tp>::value);
+    ((_Tp *)data)[0] = pt.x;
+    ((_Tp *)data)[1] = pt.y;
+  }
+}
+
+template <typename _Tp>
+inline Mat::Mat(const Point3_<_Tp> &pt, bool copyData)
+    : flags(+MAGIC_VAL + traits::Type<_Tp>::value + CV_MAT_CONT_FLAG), dims(2),
+      rows(3), cols(1), data(0), datastart(0), dataend(0), datalimit(0),
+      allocator(0), u(0), size(&rows), step(0) {
+  if (!copyData) {
+    step[0] = step[1] = sizeof(_Tp);
+    datastart = data = (uchar *)&pt.x;
+    datalimit = dataend = datastart + rows * step[0];
+  } else {
+    create(3, 1, traits::Type<_Tp>::value);
+    ((_Tp *)data)[0] = pt.x;
+    ((_Tp *)data)[1] = pt.y;
+    ((_Tp *)data)[2] = pt.z;
+  }
+}
+
+template <typename _Tp>
+inline Mat::Mat(const MatCommaInitializer_<_Tp> &commaInitializer)
+    : flags(+MAGIC_VAL + traits::Type<_Tp>::value + CV_MAT_CONT_FLAG), dims(0),
+      rows(0), cols(0), data(0), datastart(0), dataend(0), allocator(0), u(0),
+      size(&rows) {
+  *this = commaInitializer.operator Mat_<_Tp>();
+}
+
+inline Mat Mat::row(int y) const {
+  return Mat(*this, Range(y, y + 1), Range::all());
+}
+
+inline Mat Mat::col(int x) const {
+  return Mat(*this, Range::all(), Range(x, x + 1));
+}
+
+inline Mat Mat::rowRange(int startrow, int endrow) const {
+  return Mat(*this, Range(startrow, endrow), Range::all());
+}
+
+inline Mat Mat::rowRange(const Range &r) const {
+  return Mat(*this, r, Range::all());
+}
+
+inline Mat Mat::colRange(int startcol, int endcol) const {
+  return Mat(*this, Range::all(), Range(startcol, endcol));
+}
+
+inline Mat Mat::colRange(const Range &r) const {
+  return Mat(*this, Range::all(), r);
+}
+
+inline Mat Mat::operator()(Range _rowRange, Range _colRange) const {
+  return Mat(*this, _rowRange, _colRange);
+}
+
+inline Mat Mat::operator()(const Rect &roi) const { return Mat(*this, roi); }
+
+inline Mat Mat::operator()(const Range *ranges) const {
+  return Mat(*this, ranges);
+}
+
+inline Mat Mat::operator()(const std::vector<Range> &ranges) const {
+  return Mat(*this, ranges);
+}
+
+inline bool Mat::isContinuous() const { return (flags & CONTINUOUS_FLAG) != 0; }
+
+inline bool Mat::isSubmatrix() const { return (flags & SUBMATRIX_FLAG) != 0; }
+
+inline size_t Mat::elemSize() const {
+  size_t res = dims > 0 ? step.p[dims - 1] : 0;
+  CV_DbgAssert(res != 0);
+  return res;
+}
+
+inline size_t Mat::elemSize1() const { return CV_ELEM_SIZE1(flags); }
+
+inline int Mat::type() const { return CV_MAT_TYPE(flags); }
+
+inline int Mat::depth() const { return CV_MAT_DEPTH(flags); }
+
+inline int Mat::channels() const { return CV_MAT_CN(flags); }
+
+inline uchar *Mat::ptr(int y) {
+  CV_DbgAssert(y == 0 ||
+               (data && dims >= 1 && (unsigned)y < (unsigned)size.p[0]));
+  return data + step.p[0] * y;
+}
+
+inline const uchar *Mat::ptr(int y) const {
+  CV_DbgAssert(y == 0 ||
+               (data && dims >= 1 && (unsigned)y < (unsigned)size.p[0]));
+  return data + step.p[0] * y;
+}
+
+template <typename _Tp> inline _Tp *Mat::ptr(int y) {
+  CV_DbgAssert(y == 0 ||
+               (data && dims >= 1 && (unsigned)y < (unsigned)size.p[0]));
+  return (_Tp *)(data + step.p[0] * y);
+}
+
+template <typename _Tp> inline const _Tp *Mat::ptr(int y) const {
+  CV_DbgAssert(y == 0 ||
+               (data && dims >= 1 && (unsigned)y < (unsigned)size.p[0]));
+  return (const _Tp *)(data + step.p[0] * y);
+}
+
+inline uchar *Mat::ptr(int i0, int i1) {
+  CV_DbgAssert(dims >= 2);
+  CV_DbgAssert(data);
+  CV_DbgAssert((unsigned)i0 < (unsigned)size.p[0]);
+  CV_DbgAssert((unsigned)i1 < (unsigned)size.p[1]);
+  return data + i0 * step.p[0] + i1 * step.p[1];
+}
+
+inline const uchar *Mat::ptr(int i0, int i1) const {
+  CV_DbgAssert(dims >= 2);
+  CV_DbgAssert(data);
+  CV_DbgAssert((unsigned)i0 < (unsigned)size.p[0]);
+  CV_DbgAssert((unsigned)i1 < (unsigned)size.p[1]);
+  return data + i0 * step.p[0] + i1 * step.p[1];
+}
+
+template <typename _Tp> inline _Tp *Mat::ptr(int i0, int i1) {
+  CV_DbgAssert(dims >= 2);
+  CV_DbgAssert(data);
+  CV_DbgAssert((unsigned)i0 < (unsigned)size.p[0]);
+  CV_DbgAssert((unsigned)i1 < (unsigned)size.p[1]);
+  return (_Tp *)(data + i0 * step.p[0] + i1 * step.p[1]);
+}
+
+template <typename _Tp> inline const _Tp *Mat::ptr(int i0, int i1) const {
+  CV_DbgAssert(dims >= 2);
+  CV_DbgAssert(data);
+  CV_DbgAssert((unsigned)i0 < (unsigned)size.p[0]);
+  CV_DbgAssert((unsigned)i1 < (unsigned)size.p[1]);
+  return (const _Tp *)(data + i0 * step.p[0] + i1 * step.p[1]);
+}
+
+inline uchar *Mat::ptr(int i0, int i1, int i2) {
+  CV_DbgAssert(dims >= 3);
+  CV_DbgAssert(data);
+  CV_DbgAssert((unsigned)i0 < (unsigned)size.p[0]);
+  CV_DbgAssert((unsigned)i1 < (unsigned)size.p[1]);
+  CV_DbgAssert((unsigned)i2 < (unsigned)size.p[2]);
+  return data + i0 * step.p[0] + i1 * step.p[1] + i2 * step.p[2];
+}
+
+inline const uchar *Mat::ptr(int i0, int i1, int i2) const {
+  CV_DbgAssert(dims >= 3);
+  CV_DbgAssert(data);
+  CV_DbgAssert((unsigned)i0 < (unsigned)size.p[0]);
+  CV_DbgAssert((unsigned)i1 < (unsigned)size.p[1]);
+  CV_DbgAssert((unsigned)i2 < (unsigned)size.p[2]);
+  return data + i0 * step.p[0] + i1 * step.p[1] + i2 * step.p[2];
+}
+
+template <typename _Tp> inline _Tp *Mat::ptr(int i0, int i1, int i2) {
+  CV_DbgAssert(dims >= 3);
+  CV_DbgAssert(data);
+  CV_DbgAssert((unsigned)i0 < (unsigned)size.p[0]);
+  CV_DbgAssert((unsigned)i1 < (unsigned)size.p[1]);
+  CV_DbgAssert((unsigned)i2 < (unsigned)size.p[2]);
+  return (_Tp *)(data + i0 * step.p[0] + i1 * step.p[1] + i2 * step.p[2]);
+}
+
+template <typename _Tp>
+inline const _Tp *Mat::ptr(int i0, int i1, int i2) const {
+  CV_DbgAssert(dims >= 3);
+  CV_DbgAssert(data);
+  CV_DbgAssert((unsigned)i0 < (unsigned)size.p[0]);
+  CV_DbgAssert((unsigned)i1 < (unsigned)size.p[1]);
+  CV_DbgAssert((unsigned)i2 < (unsigned)size.p[2]);
+  return (const _Tp *)(data + i0 * step.p[0] + i1 * step.p[1] + i2 * step.p[2]);
+}
+
+inline uchar *Mat::ptr(const int *idx) {
+  int i, d = dims;
+  uchar *p = data;
+  CV_DbgAssert(d >= 1 && p);
+  for (i = 0; i < d; i++) {
+    CV_DbgAssert((unsigned)idx[i] < (unsigned)size.p[i]);
+    p += idx[i] * step.p[i];
+  }
+  return p;
+}
+
+inline const uchar *Mat::ptr(const int *idx) const {
+  int i, d = dims;
+  uchar *p = data;
+  CV_DbgAssert(d >= 1 && p);
+  for (i = 0; i < d; i++) {
+    CV_DbgAssert((unsigned)idx[i] < (unsigned)size.p[i]);
+    p += idx[i] * step.p[i];
+  }
+  return p;
+}
+
+template <typename _Tp> inline _Tp *Mat::ptr(const int *idx) {
+  int i, d = dims;
+  uchar *p = data;
+  CV_DbgAssert(d >= 1 && p);
+  for (i = 0; i < d; i++) {
+    CV_DbgAssert((unsigned)idx[i] < (unsigned)size.p[i]);
+    p += idx[i] * step.p[i];
+  }
+  return (_Tp *)p;
+}
+
+template <typename _Tp> inline const _Tp *Mat::ptr(const int *idx) const {
+  int i, d = dims;
+  uchar *p = data;
+  CV_DbgAssert(d >= 1 && p);
+  for (i = 0; i < d; i++) {
+    CV_DbgAssert((unsigned)idx[i] < (unsigned)size.p[i]);
+    p += idx[i] * step.p[i];
+  }
+  return (const _Tp *)p;
+}
+
+template <int n> inline uchar *Mat::ptr(const Vec<int, n> &idx) {
+  return Mat::ptr(idx.val);
+}
+
+template <int n> inline const uchar *Mat::ptr(const Vec<int, n> &idx) const {
+  return Mat::ptr(idx.val);
+}
+
+template <typename _Tp, int n> inline _Tp *Mat::ptr(const Vec<int, n> &idx) {
+  CV_DbgAssert(elemSize() == sizeof(_Tp));
+  return Mat::ptr<_Tp>(idx.val);
+}
+
+template <typename _Tp, int n>
+inline const _Tp *Mat::ptr(const Vec<int, n> &idx) const {
+  CV_DbgAssert(elemSize() == sizeof(_Tp));
+  return Mat::ptr<_Tp>(idx.val);
+}
+
+template <typename _Tp> inline _Tp &Mat::at(int i0, int i1) {
+  CV_DbgAssert(dims <= 2);
+  CV_DbgAssert(data);
+  CV_DbgAssert((unsigned)i0 < (unsigned)size.p[0]);
+  CV_DbgAssert((unsigned)(i1 * DataType<_Tp>::channels) <
+               (unsigned)(size.p[1] * channels()));
+  CV_DbgAssert(CV_ELEM_SIZE1(traits::Depth<_Tp>::value) == elemSize1());
+  return ((_Tp *)(data + step.p[0] * i0))[i1];
+}
+
+template <typename _Tp> inline const _Tp &Mat::at(int i0, int i1) const {
+  CV_DbgAssert(dims <= 2);
+  CV_DbgAssert(data);
+  CV_DbgAssert((unsigned)i0 < (unsigned)size.p[0]);
+  CV_DbgAssert((unsigned)(i1 * DataType<_Tp>::channels) <
+               (unsigned)(size.p[1] * channels()));
+  CV_DbgAssert(CV_ELEM_SIZE1(traits::Depth<_Tp>::value) == elemSize1());
+  return ((const _Tp *)(data + step.p[0] * i0))[i1];
+}
+
+template <typename _Tp> inline _Tp &Mat::at(Point pt) {
+  CV_DbgAssert(dims <= 2);
+  CV_DbgAssert(data);
+  CV_DbgAssert((unsigned)pt.y < (unsigned)size.p[0]);
+  CV_DbgAssert((unsigned)(pt.x * DataType<_Tp>::channels) <
+               (unsigned)(size.p[1] * channels()));
+  CV_DbgAssert(CV_ELEM_SIZE1(traits::Depth<_Tp>::value) == elemSize1());
+  return ((_Tp *)(data + step.p[0] * pt.y))[pt.x];
+}
+
+template <typename _Tp> inline const _Tp &Mat::at(Point pt) const {
+  CV_DbgAssert(dims <= 2);
+  CV_DbgAssert(data);
+  CV_DbgAssert((unsigned)pt.y < (unsigned)size.p[0]);
+  CV_DbgAssert((unsigned)(pt.x * DataType<_Tp>::channels) <
+               (unsigned)(size.p[1] * channels()));
+  CV_DbgAssert(CV_ELEM_SIZE1(traits::Depth<_Tp>::value) == elemSize1());
+  return ((const _Tp *)(data + step.p[0] * pt.y))[pt.x];
+}
+
+template <typename _Tp> inline _Tp &Mat::at(int i0) {
+  CV_DbgAssert(dims <= 2);
+  CV_DbgAssert(data);
+  CV_DbgAssert((unsigned)i0 < (unsigned)(size.p[0] * size.p[1]));
+  CV_DbgAssert(elemSize() == sizeof(_Tp));
+  if (isContinuous() || size.p[0] == 1)
+    return ((_Tp *)data)[i0];
+  if (size.p[1] == 1)
+    return *(_Tp *)(data + step.p[0] * i0);
+  int i = i0 / cols, j = i0 - i * cols;
+  return ((_Tp *)(data + step.p[0] * i))[j];
+}
+
+template <typename _Tp> inline const _Tp &Mat::at(int i0) const {
+  CV_DbgAssert(dims <= 2);
+  CV_DbgAssert(data);
+  CV_DbgAssert((unsigned)i0 < (unsigned)(size.p[0] * size.p[1]));
+  CV_DbgAssert(elemSize() == sizeof(_Tp));
+  if (isContinuous() || size.p[0] == 1)
+    return ((const _Tp *)data)[i0];
+  if (size.p[1] == 1)
+    return *(const _Tp *)(data + step.p[0] * i0);
+  int i = i0 / cols, j = i0 - i * cols;
+  return ((const _Tp *)(data + step.p[0] * i))[j];
+}
+
+template <typename _Tp> inline _Tp &Mat::at(int i0, int i1, int i2) {
+  CV_DbgAssert(elemSize() == sizeof(_Tp));
+  return *(_Tp *)ptr(i0, i1, i2);
+}
+
+template <typename _Tp>
+inline const _Tp &Mat::at(int i0, int i1, int i2) const {
+  CV_DbgAssert(elemSize() == sizeof(_Tp));
+  return *(const _Tp *)ptr(i0, i1, i2);
+}
+
+template <typename _Tp> inline _Tp &Mat::at(const int *idx) {
+  CV_DbgAssert(elemSize() == sizeof(_Tp));
+  return *(_Tp *)ptr(idx);
+}
+
+template <typename _Tp> inline const _Tp &Mat::at(const int *idx) const {
+  CV_DbgAssert(elemSize() == sizeof(_Tp));
+  return *(const _Tp *)ptr(idx);
+}
+
+template <typename _Tp, int n> inline _Tp &Mat::at(const Vec<int, n> &idx) {
+  CV_DbgAssert(elemSize() == sizeof(_Tp));
+  return *(_Tp *)ptr(idx.val);
+}
+
+template <typename _Tp, int n>
+inline const _Tp &Mat::at(const Vec<int, n> &idx) const {
+  CV_DbgAssert(elemSize() == sizeof(_Tp));
+  return *(const _Tp *)ptr(idx.val);
+}
+
+template <typename _Tp> inline MatConstIterator_<_Tp> Mat::begin() const {
+  if (empty())
+    return MatConstIterator_<_Tp>();
+  CV_DbgAssert(elemSize() == sizeof(_Tp));
+  return MatConstIterator_<_Tp>((const Mat_<_Tp> *)this);
+}
+
+template <typename _Tp>
+inline std::reverse_iterator<MatConstIterator_<_Tp>> Mat::rbegin() const {
+  if (empty())
+    return std::reverse_iterator<MatConstIterator_<_Tp>>();
+  CV_DbgAssert(elemSize() == sizeof(_Tp));
+  MatConstIterator_<_Tp> it((const Mat_<_Tp> *)this);
+  it += total();
+  return std::reverse_iterator<MatConstIterator_<_Tp>>(it);
+}
+
+template <typename _Tp> inline MatConstIterator_<_Tp> Mat::end() const {
+  if (empty())
+    return MatConstIterator_<_Tp>();
+  CV_DbgAssert(elemSize() == sizeof(_Tp));
+  MatConstIterator_<_Tp> it((const Mat_<_Tp> *)this);
+  it += total();
+  return it;
+}
+
+template <typename _Tp>
+inline std::reverse_iterator<MatConstIterator_<_Tp>> Mat::rend() const {
+  if (empty())
+    return std::reverse_iterator<MatConstIterator_<_Tp>>();
+  CV_DbgAssert(elemSize() == sizeof(_Tp));
+  return std::reverse_iterator<MatConstIterator_<_Tp>>((const Mat_<_Tp> *)this);
+}
+
+template <typename _Tp> inline MatIterator_<_Tp> Mat::begin() {
+  if (empty())
+    return MatIterator_<_Tp>();
+  CV_DbgAssert(elemSize() == sizeof(_Tp));
+  return MatIterator_<_Tp>((Mat_<_Tp> *)this);
+}
+
+template <typename _Tp>
+inline std::reverse_iterator<MatIterator_<_Tp>> Mat::rbegin() {
+  if (empty())
+    return std::reverse_iterator<MatIterator_<_Tp>>();
+  CV_DbgAssert(elemSize() == sizeof(_Tp));
+  MatIterator_<_Tp> it((Mat_<_Tp> *)this);
+  it += total();
+  return std::reverse_iterator<MatIterator_<_Tp>>(it);
+}
+
+template <typename _Tp> inline MatIterator_<_Tp> Mat::end() {
+  if (empty())
+    return MatIterator_<_Tp>();
+  CV_DbgAssert(elemSize() == sizeof(_Tp));
+  MatIterator_<_Tp> it((Mat_<_Tp> *)this);
+  it += total();
+  return it;
+}
+
+template <typename _Tp>
+inline std::reverse_iterator<MatIterator_<_Tp>> Mat::rend() {
+  if (empty())
+    return std::reverse_iterator<MatIterator_<_Tp>>();
+  CV_DbgAssert(elemSize() == sizeof(_Tp));
+  return std::reverse_iterator<MatIterator_<_Tp>>(
+      MatIterator_<_Tp>((Mat_<_Tp> *)this));
+}
+
+template <typename _Tp, typename Functor>
+inline void Mat::forEach(const Functor &operation) {
+  this->forEach_impl<_Tp>(operation);
+}
+
+template <typename _Tp, typename Functor>
+inline void Mat::forEach(const Functor &operation) const {
+  // call as not const
+  (const_cast<Mat *>(this))->forEach<_Tp>(operation);
+}
+
+template <typename _Tp> inline Mat::operator std::vector<_Tp>() const {
+  std::vector<_Tp> v;
+  copyTo(v);
+  return v;
+}
+
+template <typename _Tp, std::size_t _Nm>
+inline Mat::operator std::array<_Tp, _Nm>() const {
+  std::array<_Tp, _Nm> v;
+  copyTo(v);
+  return v;
+}
+
+template <typename _Tp, int n> inline Mat::operator Vec<_Tp, n>() const {
+  CV_Assert(data && dims <= 2 && (rows == 1 || cols == 1) &&
+            rows + cols - 1 == n && channels() == 1);
+
+  if (isContinuous() && type() == traits::Type<_Tp>::value)
+    return Vec<_Tp, n>((_Tp *)data);
+  Vec<_Tp, n> v;
+  Mat tmp(rows, cols, traits::Type<_Tp>::value, v.val);
+  convertTo(tmp, tmp.type());
+  return v;
+}
+
+template <typename _Tp, int m, int n>
+inline Mat::operator Matx<_Tp, m, n>() const {
+  CV_Assert(data && dims <= 2 && rows == m && cols == n && channels() == 1);
+
+  if (isContinuous() && type() == traits::Type<_Tp>::value)
+    return Matx<_Tp, m, n>((_Tp *)data);
+  Matx<_Tp, m, n> mtx;
+  Mat tmp(rows, cols, traits::Type<_Tp>::value, mtx.val);
+  convertTo(tmp, tmp.type());
+  return mtx;
+}
+
+template <typename _Tp> inline void Mat::push_back(const _Tp &elem) {
+  if (!data) {
+    *this = Mat(1, 1, traits::Type<_Tp>::value, (void *)&elem).clone();
+    return;
+  }
+  CV_Assert(traits::Type<_Tp>::value == type() && cols == 1
+            /* && dims == 2 (cols == 1 implies dims == 2) */);
+  const uchar *tmp = dataend + step[0];
+  if (!isSubmatrix() && isContinuous() && tmp <= datalimit) {
+    *(_Tp *)(data + (size.p[0]++) * step.p[0]) = elem;
+    dataend = tmp;
+  } else
+    push_back_(&elem);
+}
+
+template <typename _Tp> inline void Mat::push_back(const Mat_<_Tp> &m) {
+  push_back((const Mat &)m);
+}
+
+template <> inline void Mat::push_back(const MatExpr &expr) {
+  push_back(static_cast<Mat>(expr));
+}
+
+template <typename _Tp> inline void Mat::push_back(const std::vector<_Tp> &v) {
+  push_back(Mat(v));
+}
+
+///////////////////////////// MatSize ////////////////////////////
+
+inline MatSize::MatSize(int *_p) CV_NOEXCEPT : p(_p) {}
+
+inline int MatSize::dims() const CV_NOEXCEPT { return (p - 1)[0]; }
+
+inline Size MatSize::operator()() const {
+  CV_DbgAssert(dims() <= 2);
+  return Size(p[1], p[0]);
+}
+
+inline const int &MatSize::operator[](int i) const {
+  CV_DbgAssert(i < dims());
+#ifdef __OPENCV_BUILD
+  CV_DbgAssert(i >= 0);
+#endif
+  return p[i];
+}
+
+inline int &MatSize::operator[](int i) {
+  CV_DbgAssert(i < dims());
+#ifdef __OPENCV_BUILD
+  CV_DbgAssert(i >= 0);
+#endif
+  return p[i];
+}
+
+inline MatSize::operator const int *() const CV_NOEXCEPT { return p; }
+
+inline bool MatSize::operator!=(const MatSize &sz) const CV_NOEXCEPT {
+  return !(*this == sz);
+}
+
+///////////////////////////// MatStep ////////////////////////////
+
+inline MatStep::MatStep() CV_NOEXCEPT {
+  p = buf;
+  p[0] = p[1] = 0;
+}
+
+inline MatStep::MatStep(size_t s) CV_NOEXCEPT {
+  p = buf;
+  p[0] = s;
+  p[1] = 0;
+}
+
+inline const size_t &MatStep::operator[](int i) const CV_NOEXCEPT {
+  return p[i];
+}
+
+inline size_t &MatStep::operator[](int i) CV_NOEXCEPT { return p[i]; }
+
+inline MatStep::operator size_t() const {
+  CV_DbgAssert(p == buf);
+  return buf[0];
+}
+
+inline MatStep &MatStep::operator=(size_t s) {
+  CV_DbgAssert(p == buf);
+  buf[0] = s;
+  return *this;
+}
+
+////////////////////////////// Mat_<_Tp> ////////////////////////////
+
+template <typename _Tp> inline Mat_<_Tp>::Mat_() CV_NOEXCEPT : Mat() {
+  flags = (flags & ~CV_MAT_TYPE_MASK) + traits::Type<_Tp>::value;
+}
+
+template <typename _Tp>
+inline Mat_<_Tp>::Mat_(int _rows, int _cols)
+    : Mat(_rows, _cols, traits::Type<_Tp>::value) {}
+
+template <typename _Tp>
+inline Mat_<_Tp>::Mat_(int _rows, int _cols, const _Tp &value)
+    : Mat(_rows, _cols, traits::Type<_Tp>::value) {
+  *this = value;
+}
+
+template <typename _Tp>
+inline Mat_<_Tp>::Mat_(Size _sz)
+    : Mat(_sz.height, _sz.width, traits::Type<_Tp>::value) {}
+
+template <typename _Tp>
+inline Mat_<_Tp>::Mat_(Size _sz, const _Tp &value)
+    : Mat(_sz.height, _sz.width, traits::Type<_Tp>::value) {
+  *this = value;
+}
+
+template <typename _Tp>
+inline Mat_<_Tp>::Mat_(int _dims, const int *_sz)
+    : Mat(_dims, _sz, traits::Type<_Tp>::value) {}
+
+template <typename _Tp>
+inline Mat_<_Tp>::Mat_(int _dims, const int *_sz, const _Tp &_s)
+    : Mat(_dims, _sz, traits::Type<_Tp>::value, Scalar(_s)) {}
+
+template <typename _Tp>
+inline Mat_<_Tp>::Mat_(int _dims, const int *_sz, _Tp *_data,
+                       const size_t *_steps)
+    : Mat(_dims, _sz, traits::Type<_Tp>::value, _data, _steps) {}
+
+template <typename _Tp>
+inline Mat_<_Tp>::Mat_(const Mat_<_Tp> &m, const Range *ranges)
+    : Mat(m, ranges) {}
+
+template <typename _Tp>
+inline Mat_<_Tp>::Mat_(const Mat_<_Tp> &m, const std::vector<Range> &ranges)
+    : Mat(m, ranges) {}
+
+template <typename _Tp> inline Mat_<_Tp>::Mat_(const Mat &m) : Mat() {
+  flags = (flags & ~CV_MAT_TYPE_MASK) + traits::Type<_Tp>::value;
+  *this = m;
+}
+
+template <typename _Tp> inline Mat_<_Tp>::Mat_(const Mat_ &m) : Mat(m) {}
+
+template <typename _Tp>
+inline Mat_<_Tp>::Mat_(int _rows, int _cols, _Tp *_data, size_t steps)
+    : Mat(_rows, _cols, traits::Type<_Tp>::value, _data, steps) {}
+
+template <typename _Tp>
+inline Mat_<_Tp>::Mat_(const Mat_ &m, const Range &_rowRange,
+                       const Range &_colRange)
+    : Mat(m, _rowRange, _colRange) {}
+
+template <typename _Tp>
+inline Mat_<_Tp>::Mat_(const Mat_ &m, const Rect &roi) : Mat(m, roi) {}
+
+template <typename _Tp>
+template <int n>
+inline Mat_<_Tp>::Mat_(const Vec<typename DataType<_Tp>::channel_type, n> &vec,
+                       bool copyData)
+    : Mat(n / DataType<_Tp>::channels, 1, traits::Type<_Tp>::value,
+          (void *)&vec) {
+  CV_Assert(n % DataType<_Tp>::channels == 0);
+  if (copyData)
+    *this = clone();
+}
+
+template <typename _Tp>
+template <int m, int n>
+inline Mat_<_Tp>::Mat_(
+    const Matx<typename DataType<_Tp>::channel_type, m, n> &M, bool copyData)
+    : Mat(m, n / DataType<_Tp>::channels, traits::Type<_Tp>::value,
+          (void *)&M) {
+  CV_Assert(n % DataType<_Tp>::channels == 0);
+  if (copyData)
+    *this = clone();
+}
+
+template <typename _Tp>
+inline Mat_<_Tp>::Mat_(const Point_<typename DataType<_Tp>::channel_type> &pt,
+                       bool copyData)
+    : Mat(2 / DataType<_Tp>::channels, 1, traits::Type<_Tp>::value,
+          (void *)&pt) {
+  CV_Assert(2 % DataType<_Tp>::channels == 0);
+  if (copyData)
+    *this = clone();
+}
+
+template <typename _Tp>
+inline Mat_<_Tp>::Mat_(const Point3_<typename DataType<_Tp>::channel_type> &pt,
+                       bool copyData)
+    : Mat(3 / DataType<_Tp>::channels, 1, traits::Type<_Tp>::value,
+          (void *)&pt) {
+  CV_Assert(3 % DataType<_Tp>::channels == 0);
+  if (copyData)
+    *this = clone();
+}
+
+template <typename _Tp>
+inline Mat_<_Tp>::Mat_(const MatCommaInitializer_<_Tp> &commaInitializer)
+    : Mat(commaInitializer) {}
+
+template <typename _Tp>
+inline Mat_<_Tp>::Mat_(const std::vector<_Tp> &vec, bool copyData)
+    : Mat(vec, copyData) {}
+
+template <typename _Tp>
+inline Mat_<_Tp>::Mat_(std::initializer_list<_Tp> list) : Mat(list) {}
+
+template <typename _Tp>
+inline Mat_<_Tp>::Mat_(const std::initializer_list<int> sizes,
+                       std::initializer_list<_Tp> list)
+    : Mat(sizes, list) {}
+
+template <typename _Tp>
+template <std::size_t _Nm>
+inline Mat_<_Tp>::Mat_(const std::array<_Tp, _Nm> &arr, bool copyData)
+    : Mat(arr, copyData) {}
+
+template <typename _Tp> inline Mat_<_Tp> &Mat_<_Tp>::operator=(const Mat &m) {
+  if (m.empty()) {
+    release();
+    return *this;
+  }
+  if (traits::Type<_Tp>::value == m.type()) {
+    Mat::operator=(m);
+    return *this;
+  }
+  if (traits::Depth<_Tp>::value == m.depth()) {
+    return (*this = m.reshape(DataType<_Tp>::channels, m.dims, 0));
+  }
+  CV_Assert(DataType<_Tp>::channels == m.channels() || m.empty());
+  m.convertTo(*this, type());
+  return *this;
+}
+
+template <typename _Tp> inline Mat_<_Tp> &Mat_<_Tp>::operator=(const Mat_ &m) {
+  Mat::operator=(m);
+  return *this;
+}
+
+template <typename _Tp> inline Mat_<_Tp> &Mat_<_Tp>::operator=(const _Tp &s) {
+  typedef typename DataType<_Tp>::vec_type VT;
+  Mat::operator=(Scalar((const VT &)s));
+  return *this;
+}
+
+template <typename _Tp> inline void Mat_<_Tp>::create(int _rows, int _cols) {
+  Mat::create(_rows, _cols, traits::Type<_Tp>::value);
+}
+
+template <typename _Tp> inline void Mat_<_Tp>::create(Size _sz) {
+  Mat::create(_sz, traits::Type<_Tp>::value);
+}
+
+template <typename _Tp>
+inline void Mat_<_Tp>::create(int _dims, const int *_sz) {
+  Mat::create(_dims, _sz, traits::Type<_Tp>::value);
+}
+
+template <typename _Tp> inline void Mat_<_Tp>::release() {
+  Mat::release();
+  flags = (flags & ~CV_MAT_TYPE_MASK) + traits::Type<_Tp>::value;
+}
+
+template <typename _Tp> inline Mat_<_Tp> Mat_<_Tp>::cross(const Mat_ &m) const {
+  return Mat_<_Tp>(Mat::cross(m));
+}
+
+template <typename _Tp>
+template <typename T2>
+inline Mat_<_Tp>::operator Mat_<T2>() const {
+  return Mat_<T2>(static_cast<const Mat &>(*this));
+}
+
+template <typename _Tp> inline Mat_<_Tp> Mat_<_Tp>::row(int y) const {
+  return Mat_(*this, Range(y, y + 1), Range::all());
+}
+
+template <typename _Tp> inline Mat_<_Tp> Mat_<_Tp>::col(int x) const {
+  return Mat_(*this, Range::all(), Range(x, x + 1));
+}
+
+template <typename _Tp> inline Mat_<_Tp> Mat_<_Tp>::diag(int d) const {
+  return Mat_(Mat::diag(d));
+}
+
+template <typename _Tp> inline Mat_<_Tp> Mat_<_Tp>::clone() const {
+  return Mat_(Mat::clone());
+}
+
+template <typename _Tp> inline size_t Mat_<_Tp>::elemSize() const {
+  CV_DbgAssert(Mat::elemSize() == sizeof(_Tp));
+  return sizeof(_Tp);
+}
+
+template <typename _Tp> inline size_t Mat_<_Tp>::elemSize1() const {
+  CV_DbgAssert(Mat::elemSize1() == sizeof(_Tp) / DataType<_Tp>::channels);
+  return sizeof(_Tp) / DataType<_Tp>::channels;
+}
+
+template <typename _Tp> inline int Mat_<_Tp>::type() const {
+  CV_DbgAssert(Mat::type() == traits::Type<_Tp>::value);
+  return traits::Type<_Tp>::value;
+}
+
+template <typename _Tp> inline int Mat_<_Tp>::depth() const {
+  CV_DbgAssert(Mat::depth() == traits::Depth<_Tp>::value);
+  return traits::Depth<_Tp>::value;
+}
+
+template <typename _Tp> inline int Mat_<_Tp>::channels() const {
+  CV_DbgAssert(Mat::channels() == DataType<_Tp>::channels);
+  return DataType<_Tp>::channels;
+}
+
+template <typename _Tp> inline size_t Mat_<_Tp>::stepT(int i) const {
+  return step.p[i] / elemSize();
+}
+
+template <typename _Tp> inline size_t Mat_<_Tp>::step1(int i) const {
+  return step.p[i] / elemSize1();
+}
+
+template <typename _Tp>
+inline Mat_<_Tp> &Mat_<_Tp>::adjustROI(int dtop, int dbottom, int dleft,
+                                       int dright) {
+  return (Mat_<_Tp> &)(Mat::adjustROI(dtop, dbottom, dleft, dright));
+}
+
+template <typename _Tp>
+inline Mat_<_Tp> Mat_<_Tp>::operator()(const Range &_rowRange,
+                                       const Range &_colRange) const {
+  return Mat_<_Tp>(*this, _rowRange, _colRange);
+}
+
+template <typename _Tp>
+inline Mat_<_Tp> Mat_<_Tp>::operator()(const Rect &roi) const {
+  return Mat_<_Tp>(*this, roi);
+}
+
+template <typename _Tp>
+inline Mat_<_Tp> Mat_<_Tp>::operator()(const Range *ranges) const {
+  return Mat_<_Tp>(*this, ranges);
+}
+
+template <typename _Tp>
+inline Mat_<_Tp> Mat_<_Tp>::operator()(const std::vector<Range> &ranges) const {
+  return Mat_<_Tp>(*this, ranges);
+}
+
+template <typename _Tp> inline _Tp *Mat_<_Tp>::operator[](int y) {
+  CV_DbgAssert(0 <= y && y < size.p[0]);
+  return (_Tp *)(data + y * step.p[0]);
+}
+
+template <typename _Tp> inline const _Tp *Mat_<_Tp>::operator[](int y) const {
+  CV_DbgAssert(0 <= y && y < size.p[0]);
+  return (const _Tp *)(data + y * step.p[0]);
+}
+
+template <typename _Tp> inline _Tp &Mat_<_Tp>::operator()(int i0, int i1) {
+  CV_DbgAssert(dims <= 2);
+  CV_DbgAssert(data);
+  CV_DbgAssert((unsigned)i0 < (unsigned)size.p[0]);
+  CV_DbgAssert((unsigned)i1 < (unsigned)size.p[1]);
+  CV_DbgAssert(type() == traits::Type<_Tp>::value);
+  return ((_Tp *)(data + step.p[0] * i0))[i1];
+}
+
+template <typename _Tp>
+inline const _Tp &Mat_<_Tp>::operator()(int i0, int i1) const {
+  CV_DbgAssert(dims <= 2);
+  CV_DbgAssert(data);
+  CV_DbgAssert((unsigned)i0 < (unsigned)size.p[0]);
+  CV_DbgAssert((unsigned)i1 < (unsigned)size.p[1]);
+  CV_DbgAssert(type() == traits::Type<_Tp>::value);
+  return ((const _Tp *)(data + step.p[0] * i0))[i1];
+}
+
+template <typename _Tp> inline _Tp &Mat_<_Tp>::operator()(Point pt) {
+  CV_DbgAssert(dims <= 2);
+  CV_DbgAssert(data);
+  CV_DbgAssert((unsigned)pt.y < (unsigned)size.p[0]);
+  CV_DbgAssert((unsigned)pt.x < (unsigned)size.p[1]);
+  CV_DbgAssert(type() == traits::Type<_Tp>::value);
+  return ((_Tp *)(data + step.p[0] * pt.y))[pt.x];
+}
+
+template <typename _Tp>
+inline const _Tp &Mat_<_Tp>::operator()(Point pt) const {
+  CV_DbgAssert(dims <= 2);
+  CV_DbgAssert(data);
+  CV_DbgAssert((unsigned)pt.y < (unsigned)size.p[0]);
+  CV_DbgAssert((unsigned)pt.x < (unsigned)size.p[1]);
+  CV_DbgAssert(type() == traits::Type<_Tp>::value);
+  return ((const _Tp *)(data + step.p[0] * pt.y))[pt.x];
+}
+
+template <typename _Tp> inline _Tp &Mat_<_Tp>::operator()(const int *idx) {
+  return Mat::at<_Tp>(idx);
+}
+
+template <typename _Tp>
+inline const _Tp &Mat_<_Tp>::operator()(const int *idx) const {
+  return Mat::at<_Tp>(idx);
+}
+
+template <typename _Tp>
+template <int n>
+inline _Tp &Mat_<_Tp>::operator()(const Vec<int, n> &idx) {
+  return Mat::at<_Tp>(idx);
+}
+
+template <typename _Tp>
+template <int n>
+inline const _Tp &Mat_<_Tp>::operator()(const Vec<int, n> &idx) const {
+  return Mat::at<_Tp>(idx);
+}
+
+template <typename _Tp> inline _Tp &Mat_<_Tp>::operator()(int i0) {
+  return this->at<_Tp>(i0);
+}
+
+template <typename _Tp> inline const _Tp &Mat_<_Tp>::operator()(int i0) const {
+  return this->at<_Tp>(i0);
+}
+
+template <typename _Tp>
+inline _Tp &Mat_<_Tp>::operator()(int i0, int i1, int i2) {
+  return this->at<_Tp>(i0, i1, i2);
+}
+
+template <typename _Tp>
+inline const _Tp &Mat_<_Tp>::operator()(int i0, int i1, int i2) const {
+  return this->at<_Tp>(i0, i1, i2);
+}
+
+template <typename _Tp> inline Mat_<_Tp>::operator std::vector<_Tp>() const {
+  std::vector<_Tp> v;
+  copyTo(v);
+  return v;
+}
+
+template <typename _Tp>
+template <std::size_t _Nm>
+inline Mat_<_Tp>::operator std::array<_Tp, _Nm>() const {
+  std::array<_Tp, _Nm> a;
+  copyTo(a);
+  return a;
+}
+
+template <typename _Tp>
+template <int n>
+inline Mat_<_Tp>::operator Vec<typename DataType<_Tp>::channel_type, n>()
+    const {
+  CV_Assert(n % DataType<_Tp>::channels == 0);
+
+#if defined _MSC_VER
+  const Mat *pMat =
+      (const Mat *)this; // workaround for MSVS <= 2012 compiler bugs (but
+                         // GCC 4.6 dislikes this workaround)
+  return pMat->operator Vec<typename DataType<_Tp>::channel_type, n>();
+#else
+  return this->Mat::operator Vec<typename DataType<_Tp>::channel_type, n>();
+#endif
+}
+
+template <typename _Tp>
+template <int m, int n>
+inline Mat_<_Tp>::operator Matx<typename DataType<_Tp>::channel_type, m, n>()
+    const {
+  CV_Assert(n % DataType<_Tp>::channels == 0);
+
+#if defined _MSC_VER
+  const Mat *pMat =
+      (const Mat *)this; // workaround for MSVS <= 2012 compiler bugs (but
+                         // GCC 4.6 dislikes this workaround)
+  Matx<typename DataType<_Tp>::channel_type, m, n> res =
+      pMat->operator Matx<typename DataType<_Tp>::channel_type, m, n>();
+  return res;
+#else
+  Matx<typename DataType<_Tp>::channel_type, m, n> res =
+      this->Mat::operator Matx<typename DataType<_Tp>::channel_type, m, n>();
+  return res;
+#endif
+}
+
+template <typename _Tp> inline MatConstIterator_<_Tp> Mat_<_Tp>::begin() const {
+  return Mat::begin<_Tp>();
+}
+
+template <typename _Tp>
+inline std::reverse_iterator<MatConstIterator_<_Tp>> Mat_<_Tp>::rbegin() const {
+  return Mat::rbegin<_Tp>();
+}
+
+template <typename _Tp> inline MatConstIterator_<_Tp> Mat_<_Tp>::end() const {
+  return Mat::end<_Tp>();
+}
+
+template <typename _Tp>
+inline std::reverse_iterator<MatConstIterator_<_Tp>> Mat_<_Tp>::rend() const {
+  return Mat::rend<_Tp>();
+}
+
+template <typename _Tp> inline MatIterator_<_Tp> Mat_<_Tp>::begin() {
+  return Mat::begin<_Tp>();
+}
+
+template <typename _Tp>
+inline std::reverse_iterator<MatIterator_<_Tp>> Mat_<_Tp>::rbegin() {
+  return Mat::rbegin<_Tp>();
+}
+
+template <typename _Tp> inline MatIterator_<_Tp> Mat_<_Tp>::end() {
+  return Mat::end<_Tp>();
+}
+
+template <typename _Tp>
+inline std::reverse_iterator<MatIterator_<_Tp>> Mat_<_Tp>::rend() {
+  return Mat::rend<_Tp>();
+}
+
+template <typename _Tp>
+template <typename Functor>
+inline void Mat_<_Tp>::forEach(const Functor &operation) {
+  Mat::forEach<_Tp, Functor>(operation);
+}
+
+template <typename _Tp>
+template <typename Functor>
+inline void Mat_<_Tp>::forEach(const Functor &operation) const {
+  Mat::forEach<_Tp, Functor>(operation);
+}
+
+template <typename _Tp> inline Mat_<_Tp>::Mat_(Mat_ &&m) : Mat(std::move(m)) {}
+
+template <typename _Tp> inline Mat_<_Tp> &Mat_<_Tp>::operator=(Mat_ &&m) {
+  Mat::operator=(std::move(m));
+  return *this;
+}
+
+template <typename _Tp> inline Mat_<_Tp>::Mat_(Mat &&m) : Mat() {
+  flags = (flags & ~CV_MAT_TYPE_MASK) + traits::Type<_Tp>::value;
+  *this = std::move(m);
+}
+
+template <typename _Tp> inline Mat_<_Tp> &Mat_<_Tp>::operator=(Mat &&m) {
+  if (m.empty()) {
+    release();
+    return *this;
+  }
+  if (traits::Type<_Tp>::value == m.type()) {
+    Mat::operator=((Mat &&)m);
+    return *this;
+  }
+  if (traits::Depth<_Tp>::value == m.depth()) {
+    Mat::operator=((Mat &&)m.reshape(DataType<_Tp>::channels, m.dims, 0));
+    return *this;
+  }
+  CV_DbgAssert(DataType<_Tp>::channels == m.channels());
+  m.convertTo(*this, type());
+  return *this;
+}
+
+template <typename _Tp> inline Mat_<_Tp>::Mat_(MatExpr &&e) : Mat() {
+  flags = (flags & ~CV_MAT_TYPE_MASK) + traits::Type<_Tp>::value;
+  *this = Mat(e);
+}
+
+///////////////////////////// SparseMat /////////////////////////////
+
+inline SparseMat SparseMat::clone() const {
+  SparseMat temp;
+  this->copyTo(temp);
+  return temp;
+}
+
+inline size_t SparseMat::elemSize() const { return CV_ELEM_SIZE(flags); }
+
+inline size_t SparseMat::elemSize1() const { return CV_ELEM_SIZE1(flags); }
+
+inline int SparseMat::type() const { return CV_MAT_TYPE(flags); }
+
+inline int SparseMat::depth() const { return CV_MAT_DEPTH(flags); }
+
+inline int SparseMat::channels() const { return CV_MAT_CN(flags); }
+
+inline const int *SparseMat::size() const { return hdr ? hdr->size : 0; }
+
+inline int SparseMat::size(int i) const {
+  if (hdr) {
+    CV_DbgAssert((unsigned)i < (unsigned)hdr->dims);
+    return hdr->size[i];
+  }
+  return 0;
+}
+
+inline int SparseMat::dims() const { return hdr ? hdr->dims : 0; }
+
+inline size_t SparseMat::nzcount() const { return hdr ? hdr->nodeCount : 0; }
+
+template <typename _Tp> inline _Tp &SparseMat::ref(int i0, size_t *hashval) {
+  return *(_Tp *)((SparseMat *)this)->ptr(i0, true, hashval);
+}
+
+template <typename _Tp>
+inline _Tp &SparseMat::ref(int i0, int i1, size_t *hashval) {
+  return *(_Tp *)((SparseMat *)this)->ptr(i0, i1, true, hashval);
+}
+
+template <typename _Tp>
+inline _Tp &SparseMat::ref(int i0, int i1, int i2, size_t *hashval) {
+  return *(_Tp *)((SparseMat *)this)->ptr(i0, i1, i2, true, hashval);
+}
+
+template <typename _Tp>
+inline _Tp &SparseMat::ref(const int *idx, size_t *hashval) {
+  return *(_Tp *)((SparseMat *)this)->ptr(idx, true, hashval);
+}
+
+template <typename _Tp>
+inline _Tp SparseMat::value(int i0, size_t *hashval) const {
+  const _Tp *p = (const _Tp *)((SparseMat *)this)->ptr(i0, false, hashval);
+  return p ? *p : _Tp();
+}
+
+template <typename _Tp>
+inline _Tp SparseMat::value(int i0, int i1, size_t *hashval) const {
+  const _Tp *p = (const _Tp *)((SparseMat *)this)->ptr(i0, i1, false, hashval);
+  return p ? *p : _Tp();
+}
+
+template <typename _Tp>
+inline _Tp SparseMat::value(int i0, int i1, int i2, size_t *hashval) const {
+  const _Tp *p =
+      (const _Tp *)((SparseMat *)this)->ptr(i0, i1, i2, false, hashval);
+  return p ? *p : _Tp();
+}
+
+template <typename _Tp>
+inline _Tp SparseMat::value(const int *idx, size_t *hashval) const {
+  const _Tp *p = (const _Tp *)((SparseMat *)this)->ptr(idx, false, hashval);
+  return p ? *p : _Tp();
+}
+
+template <typename _Tp>
+inline const _Tp *SparseMat::find(int i0, size_t *hashval) const {
+  return (const _Tp *)((SparseMat *)this)->ptr(i0, false, hashval);
+}
+
+template <typename _Tp>
+inline const _Tp *SparseMat::find(int i0, int i1, size_t *hashval) const {
+  return (const _Tp *)((SparseMat *)this)->ptr(i0, i1, false, hashval);
+}
+
+template <typename _Tp>
+inline const _Tp *SparseMat::find(int i0, int i1, int i2,
+                                  size_t *hashval) const {
+  return (const _Tp *)((SparseMat *)this)->ptr(i0, i1, i2, false, hashval);
+}
+
+template <typename _Tp>
+inline const _Tp *SparseMat::find(const int *idx, size_t *hashval) const {
+  return (const _Tp *)((SparseMat *)this)->ptr(idx, false, hashval);
+}
+
+template <typename _Tp> inline _Tp &SparseMat::value(Node *n) {
+  return *(_Tp *)((uchar *)n + hdr->valueOffset);
+}
+
+template <typename _Tp>
+inline const _Tp &SparseMat::value(const Node *n) const {
+  return *(const _Tp *)((const uchar *)n + hdr->valueOffset);
+}
+
+inline SparseMat::Node *SparseMat::node(size_t nidx) {
+  return (Node *)(void *)&hdr->pool[nidx];
+}
+
+inline const SparseMat::Node *SparseMat::node(size_t nidx) const {
+  return (const Node *)(const void *)&hdr->pool[nidx];
+}
+
+inline SparseMatIterator SparseMat::begin() { return SparseMatIterator(this); }
+
+inline SparseMatConstIterator SparseMat::begin() const {
+  return SparseMatConstIterator(this);
+}
+
+inline SparseMatIterator SparseMat::end() {
+  SparseMatIterator it(this);
+  it.seekEnd();
+  return it;
+}
+
+inline SparseMatConstIterator SparseMat::end() const {
+  SparseMatConstIterator it(this);
+  it.seekEnd();
+  return it;
+}
+
+template <typename _Tp> inline SparseMatIterator_<_Tp> SparseMat::begin() {
+  return SparseMatIterator_<_Tp>(this);
+}
+
+template <typename _Tp>
+inline SparseMatConstIterator_<_Tp> SparseMat::begin() const {
+  return SparseMatConstIterator_<_Tp>(this);
+}
+
+template <typename _Tp> inline SparseMatIterator_<_Tp> SparseMat::end() {
+  SparseMatIterator_<_Tp> it(this);
+  it.seekEnd();
+  return it;
+}
+
+template <typename _Tp>
+inline SparseMatConstIterator_<_Tp> SparseMat::end() const {
+  SparseMatConstIterator_<_Tp> it(this);
+  it.seekEnd();
+  return it;
+}
+
+///////////////////////////// SparseMat_ ////////////////////////////
+
+template <typename _Tp> inline SparseMat_<_Tp>::SparseMat_() {
+  flags = +MAGIC_VAL + traits::Type<_Tp>::value;
+}
+
+template <typename _Tp>
+inline SparseMat_<_Tp>::SparseMat_(int _dims, const int *_sizes)
+    : SparseMat(_dims, _sizes, traits::Type<_Tp>::value) {}
+
+template <typename _Tp> inline SparseMat_<_Tp>::SparseMat_(const SparseMat &m) {
+  if (m.type() == traits::Type<_Tp>::value)
+    *this = (const SparseMat_<_Tp> &)m;
+  else
+    m.convertTo(*this, traits::Type<_Tp>::value);
+}
+
+template <typename _Tp>
+inline SparseMat_<_Tp>::SparseMat_(const SparseMat_<_Tp> &m) {
+  this->flags = m.flags;
+  this->hdr = m.hdr;
+  if (this->hdr)
+    CV_XADD(&this->hdr->refcount, 1);
+}
+
+template <typename _Tp> inline SparseMat_<_Tp>::SparseMat_(const Mat &m) {
+  SparseMat sm(m);
+  *this = sm;
+}
+
+template <typename _Tp>
+inline SparseMat_<_Tp> &SparseMat_<_Tp>::operator=(const SparseMat_<_Tp> &m) {
+  if (this != &m) {
+    if (m.hdr)
+      CV_XADD(&m.hdr->refcount, 1);
+    release();
+    flags = m.flags;
+    hdr = m.hdr;
+  }
+  return *this;
+}
+
+template <typename _Tp>
+inline SparseMat_<_Tp> &SparseMat_<_Tp>::operator=(const SparseMat &m) {
+  if (m.type() == traits::Type<_Tp>::value)
+    return (*this = (const SparseMat_<_Tp> &)m);
+  m.convertTo(*this, traits::Type<_Tp>::value);
+  return *this;
+}
+
+template <typename _Tp>
+inline SparseMat_<_Tp> &SparseMat_<_Tp>::operator=(const Mat &m) {
+  return (*this = SparseMat(m));
+}
+
+template <typename _Tp> inline SparseMat_<_Tp> SparseMat_<_Tp>::clone() const {
+  SparseMat_<_Tp> m;
+  this->copyTo(m);
+  return m;
+}
+
+template <typename _Tp>
+inline void SparseMat_<_Tp>::create(int _dims, const int *_sizes) {
+  SparseMat::create(_dims, _sizes, traits::Type<_Tp>::value);
+}
+
+template <typename _Tp> inline int SparseMat_<_Tp>::type() const {
+  return traits::Type<_Tp>::value;
+}
+
+template <typename _Tp> inline int SparseMat_<_Tp>::depth() const {
+  return traits::Depth<_Tp>::value;
+}
+
+template <typename _Tp> inline int SparseMat_<_Tp>::channels() const {
+  return DataType<_Tp>::channels;
+}
+
+template <typename _Tp>
+inline _Tp &SparseMat_<_Tp>::ref(int i0, size_t *hashval) {
+  return SparseMat::ref<_Tp>(i0, hashval);
+}
+
+template <typename _Tp>
+inline _Tp SparseMat_<_Tp>::operator()(int i0, size_t *hashval) const {
+  return SparseMat::value<_Tp>(i0, hashval);
+}
+
+template <typename _Tp>
+inline _Tp &SparseMat_<_Tp>::ref(int i0, int i1, size_t *hashval) {
+  return SparseMat::ref<_Tp>(i0, i1, hashval);
+}
+
+template <typename _Tp>
+inline _Tp SparseMat_<_Tp>::operator()(int i0, int i1, size_t *hashval) const {
+  return SparseMat::value<_Tp>(i0, i1, hashval);
+}
+
+template <typename _Tp>
+inline _Tp &SparseMat_<_Tp>::ref(int i0, int i1, int i2, size_t *hashval) {
+  return SparseMat::ref<_Tp>(i0, i1, i2, hashval);
+}
+
+template <typename _Tp>
+inline _Tp SparseMat_<_Tp>::operator()(int i0, int i1, int i2,
+                                       size_t *hashval) const {
+  return SparseMat::value<_Tp>(i0, i1, i2, hashval);
+}
+
+template <typename _Tp>
+inline _Tp &SparseMat_<_Tp>::ref(const int *idx, size_t *hashval) {
+  return SparseMat::ref<_Tp>(idx, hashval);
+}
+
+template <typename _Tp>
+inline _Tp SparseMat_<_Tp>::operator()(const int *idx, size_t *hashval) const {
+  return SparseMat::value<_Tp>(idx, hashval);
+}
+
+template <typename _Tp>
+inline SparseMatIterator_<_Tp> SparseMat_<_Tp>::begin() {
+  return SparseMatIterator_<_Tp>(this);
+}
+
+template <typename _Tp>
+inline SparseMatConstIterator_<_Tp> SparseMat_<_Tp>::begin() const {
+  return SparseMatConstIterator_<_Tp>(this);
+}
+
+template <typename _Tp> inline SparseMatIterator_<_Tp> SparseMat_<_Tp>::end() {
+  SparseMatIterator_<_Tp> it(this);
+  it.seekEnd();
+  return it;
+}
+
+template <typename _Tp>
+inline SparseMatConstIterator_<_Tp> SparseMat_<_Tp>::end() const {
+  SparseMatConstIterator_<_Tp> it(this);
+  it.seekEnd();
+  return it;
+}
+
+////////////////////////// MatConstIterator /////////////////////////
+
+inline MatConstIterator::MatConstIterator()
+    : m(0), elemSize(0), ptr(0), sliceStart(0), sliceEnd(0) {}
+
+inline MatConstIterator::MatConstIterator(const Mat *_m)
+    : m(_m), elemSize(_m->elemSize()), ptr(0), sliceStart(0), sliceEnd(0) {
+  if (m && m->isContinuous()) {
+    CV_Assert(!m->empty());
+    sliceStart = m->ptr();
+    sliceEnd = sliceStart + m->total() * elemSize;
+  }
+  seek((const int *)0);
+}
+
+inline MatConstIterator::MatConstIterator(const Mat *_m, int _row, int _col)
+    : m(_m), elemSize(_m->elemSize()), ptr(0), sliceStart(0), sliceEnd(0) {
+  CV_Assert(m && m->dims <= 2);
+  if (m->isContinuous()) {
+    CV_Assert(!m->empty());
+    sliceStart = m->ptr();
+    sliceEnd = sliceStart + m->total() * elemSize;
+  }
+  int idx[] = {_row, _col};
+  seek(idx);
+}
+
+inline MatConstIterator::MatConstIterator(const Mat *_m, Point _pt)
+    : m(_m), elemSize(_m->elemSize()), ptr(0), sliceStart(0), sliceEnd(0) {
+  CV_Assert(m && m->dims <= 2);
+  if (m->isContinuous()) {
+    CV_Assert(!m->empty());
+    sliceStart = m->ptr();
+    sliceEnd = sliceStart + m->total() * elemSize;
+  }
+  int idx[] = {_pt.y, _pt.x};
+  seek(idx);
+}
+
+inline MatConstIterator::MatConstIterator(const MatConstIterator &it)
+    : m(it.m), elemSize(it.elemSize), ptr(it.ptr), sliceStart(it.sliceStart),
+      sliceEnd(it.sliceEnd) {}
+
+inline MatConstIterator &
+MatConstIterator::operator=(const MatConstIterator &it) {
+  m = it.m;
+  elemSize = it.elemSize;
+  ptr = it.ptr;
+  sliceStart = it.sliceStart;
+  sliceEnd = it.sliceEnd;
+  return *this;
+}
+
+inline const uchar *MatConstIterator::operator*() const { return ptr; }
+
+inline MatConstIterator &MatConstIterator::operator+=(ptrdiff_t ofs) {
+  if (!m || ofs == 0)
+    return *this;
+  ptrdiff_t ofsb = ofs * elemSize;
+  ptr += ofsb;
+  if (ptr < sliceStart || sliceEnd <= ptr) {
+    ptr -= ofsb;
+    seek(ofs, true);
+  }
+  return *this;
+}
+
+inline MatConstIterator &MatConstIterator::operator-=(ptrdiff_t ofs) {
+  return (*this += -ofs);
+}
+
+inline MatConstIterator &MatConstIterator::operator--() {
+  if (m && (ptr -= elemSize) < sliceStart) {
+    ptr += elemSize;
+    seek(-1, true);
+  }
+  return *this;
+}
+
+inline MatConstIterator MatConstIterator::operator--(int) {
+  MatConstIterator b = *this;
+  *this += -1;
+  return b;
+}
+
+inline MatConstIterator &MatConstIterator::operator++() {
+  if (m && (ptr += elemSize) >= sliceEnd) {
+    ptr -= elemSize;
+    seek(1, true);
+  }
+  return *this;
+}
+
+inline MatConstIterator MatConstIterator::operator++(int) {
+  MatConstIterator b = *this;
+  *this += 1;
+  return b;
+}
+
+static inline bool operator==(const MatConstIterator &a,
+                              const MatConstIterator &b) {
+  return a.m == b.m && a.ptr == b.ptr;
+}
+
+static inline bool operator!=(const MatConstIterator &a,
+                              const MatConstIterator &b) {
+  return !(a == b);
+}
+
+static inline bool operator<(const MatConstIterator &a,
+                             const MatConstIterator &b) {
+  return a.ptr < b.ptr;
+}
+
+static inline bool operator>(const MatConstIterator &a,
+                             const MatConstIterator &b) {
+  return a.ptr > b.ptr;
+}
+
+static inline bool operator<=(const MatConstIterator &a,
+                              const MatConstIterator &b) {
+  return a.ptr <= b.ptr;
+}
+
+static inline bool operator>=(const MatConstIterator &a,
+                              const MatConstIterator &b) {
+  return a.ptr >= b.ptr;
+}
+
+static inline ptrdiff_t operator-(const MatConstIterator &b,
+                                  const MatConstIterator &a) {
+  if (a.m != b.m)
+    return ((size_t)(-1) >> 1);
+  if (a.sliceEnd == b.sliceEnd)
+    return (b.ptr - a.ptr) / static_cast<ptrdiff_t>(b.elemSize);
+
+  return b.lpos() - a.lpos();
+}
+
+static inline MatConstIterator operator+(const MatConstIterator &a,
+                                         ptrdiff_t ofs) {
+  MatConstIterator b = a;
+  return b += ofs;
+}
+
+static inline MatConstIterator operator+(ptrdiff_t ofs,
+                                         const MatConstIterator &a) {
+  MatConstIterator b = a;
+  return b += ofs;
+}
+
+static inline MatConstIterator operator-(const MatConstIterator &a,
+                                         ptrdiff_t ofs) {
+  MatConstIterator b = a;
+  return b += -ofs;
+}
+
+inline const uchar *MatConstIterator::operator[](ptrdiff_t i) const {
+  return *(*this + i);
+}
+
+///////////////////////// MatConstIterator_ /////////////////////////
+
+template <typename _Tp> inline MatConstIterator_<_Tp>::MatConstIterator_() {}
+
+template <typename _Tp>
+inline MatConstIterator_<_Tp>::MatConstIterator_(const Mat_<_Tp> *_m)
+    : MatConstIterator(_m) {}
+
+template <typename _Tp>
+inline MatConstIterator_<_Tp>::MatConstIterator_(const Mat_<_Tp> *_m, int _row,
+                                                 int _col)
+    : MatConstIterator(_m, _row, _col) {}
+
+template <typename _Tp>
+inline MatConstIterator_<_Tp>::MatConstIterator_(const Mat_<_Tp> *_m, Point _pt)
+    : MatConstIterator(_m, _pt) {}
+
+template <typename _Tp>
+inline MatConstIterator_<_Tp>::MatConstIterator_(const MatConstIterator_ &it)
+    : MatConstIterator(it) {}
+
+template <typename _Tp>
+inline MatConstIterator_<_Tp> &
+MatConstIterator_<_Tp>::operator=(const MatConstIterator_ &it) {
+  MatConstIterator::operator=(it);
+  return *this;
+}
+
+template <typename _Tp>
+inline const _Tp &MatConstIterator_<_Tp>::operator*() const {
+  return *(_Tp *)(this->ptr);
+}
+
+template <typename _Tp>
+inline MatConstIterator_<_Tp> &
+MatConstIterator_<_Tp>::operator+=(ptrdiff_t ofs) {
+  MatConstIterator::operator+=(ofs);
+  return *this;
+}
+
+template <typename _Tp>
+inline MatConstIterator_<_Tp> &
+MatConstIterator_<_Tp>::operator-=(ptrdiff_t ofs) {
+  return (*this += -ofs);
+}
+
+template <typename _Tp>
+inline MatConstIterator_<_Tp> &MatConstIterator_<_Tp>::operator--() {
+  MatConstIterator::operator--();
+  return *this;
+}
+
+template <typename _Tp>
+inline MatConstIterator_<_Tp> MatConstIterator_<_Tp>::operator--(int) {
+  MatConstIterator_ b = *this;
+  MatConstIterator::operator--();
+  return b;
+}
+
+template <typename _Tp>
+inline MatConstIterator_<_Tp> &MatConstIterator_<_Tp>::operator++() {
+  MatConstIterator::operator++();
+  return *this;
+}
+
+template <typename _Tp>
+inline MatConstIterator_<_Tp> MatConstIterator_<_Tp>::operator++(int) {
+  MatConstIterator_ b = *this;
+  MatConstIterator::operator++();
+  return b;
+}
+
+template <typename _Tp> inline Point MatConstIterator_<_Tp>::pos() const {
+  if (!m)
+    return Point();
+  CV_DbgAssert(m->dims <= 2);
+  if (m->isContinuous()) {
+    ptrdiff_t ofs = (const _Tp *)ptr - (const _Tp *)m->data;
+    int y = (int)(ofs / m->cols);
+    int x = (int)(ofs - (ptrdiff_t)y * m->cols);
+    return Point(x, y);
+  } else {
+    ptrdiff_t ofs = (uchar *)ptr - m->data;
+    int y = (int)(ofs / m->step);
+    int x = (int)((ofs - y * m->step) / sizeof(_Tp));
+    return Point(x, y);
+  }
+}
+
+template <typename _Tp>
+static inline bool operator==(const MatConstIterator_<_Tp> &a,
+                              const MatConstIterator_<_Tp> &b) {
+  return a.m == b.m && a.ptr == b.ptr;
+}
+
+template <typename _Tp>
+static inline bool operator!=(const MatConstIterator_<_Tp> &a,
+                              const MatConstIterator_<_Tp> &b) {
+  return a.m != b.m || a.ptr != b.ptr;
+}
+
+template <typename _Tp>
+static inline MatConstIterator_<_Tp> operator+(const MatConstIterator_<_Tp> &a,
+                                               ptrdiff_t ofs) {
+  MatConstIterator t = (const MatConstIterator &)a + ofs;
+  return (MatConstIterator_<_Tp> &)t;
+}
+
+template <typename _Tp>
+static inline MatConstIterator_<_Tp>
+operator+(ptrdiff_t ofs, const MatConstIterator_<_Tp> &a) {
+  MatConstIterator t = (const MatConstIterator &)a + ofs;
+  return (MatConstIterator_<_Tp> &)t;
+}
+
+template <typename _Tp>
+static inline MatConstIterator_<_Tp> operator-(const MatConstIterator_<_Tp> &a,
+                                               ptrdiff_t ofs) {
+  MatConstIterator t = (const MatConstIterator &)a - ofs;
+  return (MatConstIterator_<_Tp> &)t;
+}
+
+template <typename _Tp>
+inline const _Tp &MatConstIterator_<_Tp>::operator[](ptrdiff_t i) const {
+  return *(_Tp *)MatConstIterator::operator[](i);
+}
+
+//////////////////////////// MatIterator_ ///////////////////////////
+
+template <typename _Tp>
+inline MatIterator_<_Tp>::MatIterator_() : MatConstIterator_<_Tp>() {}
+
+template <typename _Tp>
+inline MatIterator_<_Tp>::MatIterator_(Mat_<_Tp> *_m)
+    : MatConstIterator_<_Tp>(_m) {}
+
+template <typename _Tp>
+inline MatIterator_<_Tp>::MatIterator_(Mat_<_Tp> *_m, int _row, int _col)
+    : MatConstIterator_<_Tp>(_m, _row, _col) {}
+
+template <typename _Tp>
+inline MatIterator_<_Tp>::MatIterator_(Mat_<_Tp> *_m, Point _pt)
+    : MatConstIterator_<_Tp>(_m, _pt) {}
+
+template <typename _Tp>
+inline MatIterator_<_Tp>::MatIterator_(Mat_<_Tp> *_m, const int *_idx)
+    : MatConstIterator_<_Tp>(_m, _idx) {}
+
+template <typename _Tp>
+inline MatIterator_<_Tp>::MatIterator_(const MatIterator_ &it)
+    : MatConstIterator_<_Tp>(it) {}
+
+template <typename _Tp>
+inline MatIterator_<_Tp> &
+MatIterator_<_Tp>::operator=(const MatIterator_<_Tp> &it) {
+  MatConstIterator::operator=(it);
+  return *this;
+}
+
+template <typename _Tp> inline _Tp &MatIterator_<_Tp>::operator*() const {
+  return *(_Tp *)(this->ptr);
+}
+
+template <typename _Tp>
+inline MatIterator_<_Tp> &MatIterator_<_Tp>::operator+=(ptrdiff_t ofs) {
+  MatConstIterator::operator+=(ofs);
+  return *this;
+}
+
+template <typename _Tp>
+inline MatIterator_<_Tp> &MatIterator_<_Tp>::operator-=(ptrdiff_t ofs) {
+  MatConstIterator::operator+=(-ofs);
+  return *this;
+}
+
+template <typename _Tp>
+inline MatIterator_<_Tp> &MatIterator_<_Tp>::operator--() {
+  MatConstIterator::operator--();
+  return *this;
+}
+
+template <typename _Tp>
+inline MatIterator_<_Tp> MatIterator_<_Tp>::operator--(int) {
+  MatIterator_ b = *this;
+  MatConstIterator::operator--();
+  return b;
+}
+
+template <typename _Tp>
+inline MatIterator_<_Tp> &MatIterator_<_Tp>::operator++() {
+  MatConstIterator::operator++();
+  return *this;
+}
+
+template <typename _Tp>
+inline MatIterator_<_Tp> MatIterator_<_Tp>::operator++(int) {
+  MatIterator_ b = *this;
+  MatConstIterator::operator++();
+  return b;
+}
+
+template <typename _Tp>
+inline _Tp &MatIterator_<_Tp>::operator[](ptrdiff_t i) const {
+  return *(*this + i);
+}
+
+template <typename _Tp>
+static inline bool operator==(const MatIterator_<_Tp> &a,
+                              const MatIterator_<_Tp> &b) {
+  return a.m == b.m && a.ptr == b.ptr;
+}
+
+template <typename _Tp>
+static inline bool operator!=(const MatIterator_<_Tp> &a,
+                              const MatIterator_<_Tp> &b) {
+  return a.m != b.m || a.ptr != b.ptr;
+}
+
+template <typename _Tp>
+static inline MatIterator_<_Tp> operator+(const MatIterator_<_Tp> &a,
+                                          ptrdiff_t ofs) {
+  MatConstIterator t = (const MatConstIterator &)a + ofs;
+  return (MatIterator_<_Tp> &)t;
+}
+
+template <typename _Tp>
+static inline MatIterator_<_Tp> operator+(ptrdiff_t ofs,
+                                          const MatIterator_<_Tp> &a) {
+  MatConstIterator t = (const MatConstIterator &)a + ofs;
+  return (MatIterator_<_Tp> &)t;
+}
+
+template <typename _Tp>
+static inline MatIterator_<_Tp> operator-(const MatIterator_<_Tp> &a,
+                                          ptrdiff_t ofs) {
+  MatConstIterator t = (const MatConstIterator &)a - ofs;
+  return (MatIterator_<_Tp> &)t;
+}
+
+/////////////////////// SparseMatConstIterator //////////////////////
+
+inline SparseMatConstIterator::SparseMatConstIterator()
+    : m(0), hashidx(0), ptr(0) {}
+
+inline SparseMatConstIterator::SparseMatConstIterator(
+    const SparseMatConstIterator &it)
+    : m(it.m), hashidx(it.hashidx), ptr(it.ptr) {}
+
+inline SparseMatConstIterator &
+SparseMatConstIterator::operator=(const SparseMatConstIterator &it) {
+  if (this != &it) {
+    m = it.m;
+    hashidx = it.hashidx;
+    ptr = it.ptr;
+  }
+  return *this;
+}
+
+template <typename _Tp>
+inline const _Tp &SparseMatConstIterator::value() const {
+  return *(const _Tp *)ptr;
+}
+
+inline const SparseMat::Node *SparseMatConstIterator::node() const {
+  return (ptr && m && m->hdr)
+             ? (const SparseMat::Node *)(const void *)(ptr -
+                                                       m->hdr->valueOffset)
+             : 0;
+}
+
+inline SparseMatConstIterator SparseMatConstIterator::operator++(int) {
+  SparseMatConstIterator it = *this;
+  ++*this;
+  return it;
+}
+
+inline void SparseMatConstIterator::seekEnd() {
+  if (m && m->hdr) {
+    hashidx = m->hdr->hashtab.size();
+    ptr = 0;
+  }
+}
+
+static inline bool operator==(const SparseMatConstIterator &it1,
+                              const SparseMatConstIterator &it2) {
+  return it1.m == it2.m && it1.ptr == it2.ptr;
+}
+
+static inline bool operator!=(const SparseMatConstIterator &it1,
+                              const SparseMatConstIterator &it2) {
+  return !(it1 == it2);
+}
+
+///////////////////////// SparseMatIterator /////////////////////////
+
+inline SparseMatIterator::SparseMatIterator() {}
+
+inline SparseMatIterator::SparseMatIterator(SparseMat *_m)
+    : SparseMatConstIterator(_m) {}
+
+inline SparseMatIterator::SparseMatIterator(const SparseMatIterator &it)
+    : SparseMatConstIterator(it) {}
+
+inline SparseMatIterator &
+SparseMatIterator::operator=(const SparseMatIterator &it) {
+  (SparseMatConstIterator &)*this = it;
+  return *this;
+}
+
+template <typename _Tp> inline _Tp &SparseMatIterator::value() const {
+  return *(_Tp *)ptr;
+}
+
+inline SparseMat::Node *SparseMatIterator::node() const {
+  return (SparseMat::Node *)SparseMatConstIterator::node();
+}
+
+inline SparseMatIterator &SparseMatIterator::operator++() {
+  SparseMatConstIterator::operator++();
+  return *this;
+}
+
+inline SparseMatIterator SparseMatIterator::operator++(int) {
+  SparseMatIterator it = *this;
+  ++*this;
+  return it;
+}
+
+////////////////////// SparseMatConstIterator_ //////////////////////
+
+template <typename _Tp>
+inline SparseMatConstIterator_<_Tp>::SparseMatConstIterator_() {}
+
+template <typename _Tp>
+inline SparseMatConstIterator_<_Tp>::SparseMatConstIterator_(
+    const SparseMat_<_Tp> *_m)
+    : SparseMatConstIterator(_m) {}
+
+template <typename _Tp>
+inline SparseMatConstIterator_<_Tp>::SparseMatConstIterator_(
+    const SparseMat *_m)
+    : SparseMatConstIterator(_m) {
+  CV_Assert(_m->type() == traits::Type<_Tp>::value);
+}
+
+template <typename _Tp>
+inline SparseMatConstIterator_<_Tp>::SparseMatConstIterator_(
+    const SparseMatConstIterator_<_Tp> &it)
+    : SparseMatConstIterator(it) {}
+
+template <typename _Tp>
+inline SparseMatConstIterator_<_Tp> &SparseMatConstIterator_<_Tp>::operator=(
+    const SparseMatConstIterator_<_Tp> &it) {
+  return reinterpret_cast<SparseMatConstIterator_<_Tp> &>(
+      *reinterpret_cast<SparseMatConstIterator *>(this) =
+          reinterpret_cast<const SparseMatConstIterator &>(it));
+}
+
+template <typename _Tp>
+inline const _Tp &SparseMatConstIterator_<_Tp>::operator*() const {
+  return *(const _Tp *)this->ptr;
+}
+
+template <typename _Tp>
+inline SparseMatConstIterator_<_Tp> &
+SparseMatConstIterator_<_Tp>::operator++() {
+  SparseMatConstIterator::operator++();
+  return *this;
+}
+
+template <typename _Tp>
+inline SparseMatConstIterator_<_Tp>
+SparseMatConstIterator_<_Tp>::operator++(int) {
+  SparseMatConstIterator_<_Tp> it = *this;
+  SparseMatConstIterator::operator++();
+  return it;
+}
+
+///////////////////////// SparseMatIterator_ ////////////////////////
+
+template <typename _Tp> inline SparseMatIterator_<_Tp>::SparseMatIterator_() {}
+
+template <typename _Tp>
+inline SparseMatIterator_<_Tp>::SparseMatIterator_(SparseMat_<_Tp> *_m)
+    : SparseMatConstIterator_<_Tp>(_m) {}
+
+template <typename _Tp>
+inline SparseMatIterator_<_Tp>::SparseMatIterator_(SparseMat *_m)
+    : SparseMatConstIterator_<_Tp>(_m) {}
+
+template <typename _Tp>
+inline SparseMatIterator_<_Tp>::SparseMatIterator_(
+    const SparseMatIterator_<_Tp> &it)
+    : SparseMatConstIterator_<_Tp>(it) {}
+
+template <typename _Tp>
+inline SparseMatIterator_<_Tp> &
+SparseMatIterator_<_Tp>::operator=(const SparseMatIterator_<_Tp> &it) {
+  return reinterpret_cast<SparseMatIterator_<_Tp> &>(
+      *reinterpret_cast<SparseMatConstIterator *>(this) =
+          reinterpret_cast<const SparseMatConstIterator &>(it));
+}
+
+template <typename _Tp> inline _Tp &SparseMatIterator_<_Tp>::operator*() const {
+  return *(_Tp *)this->ptr;
+}
+
+template <typename _Tp>
+inline SparseMatIterator_<_Tp> &SparseMatIterator_<_Tp>::operator++() {
+  SparseMatConstIterator::operator++();
+  return *this;
+}
+
+template <typename _Tp>
+inline SparseMatIterator_<_Tp> SparseMatIterator_<_Tp>::operator++(int) {
+  SparseMatIterator_<_Tp> it = *this;
+  SparseMatConstIterator::operator++();
+  return it;
+}
+
+//////////////////////// MatCommaInitializer_ ///////////////////////
+
+template <typename _Tp>
+inline MatCommaInitializer_<_Tp>::MatCommaInitializer_(Mat_<_Tp> *_m)
+    : it(_m) {}
+
+template <typename _Tp>
+template <typename T2>
+inline MatCommaInitializer_<_Tp> &MatCommaInitializer_<_Tp>::operator,(T2 v) {
+  CV_DbgAssert(this->it < ((const Mat_<_Tp> *)this->it.m)->end());
+  *this->it = _Tp(v);
+  ++this->it;
+  return *this;
+}
+
+template <typename _Tp>
+inline MatCommaInitializer_<_Tp>::operator Mat_<_Tp>() const {
+  CV_DbgAssert(this->it == ((const Mat_<_Tp> *)this->it.m)->end());
+  return Mat_<_Tp>(*this->it.m);
+}
+
+template <typename _Tp, typename T2>
+static inline MatCommaInitializer_<_Tp> operator<<(const Mat_<_Tp> &m, T2 val) {
+  MatCommaInitializer_<_Tp> commaInitializer((Mat_<_Tp> *)&m);
+  return (commaInitializer, val);
+}
+
+///////////////////////// Matrix Expressions ////////////////////////
+
+inline Mat &Mat::operator=(const MatExpr &e) {
+  e.op->assign(e, *this);
+  return *this;
+}
+
+template <typename _Tp> inline Mat_<_Tp>::Mat_(const MatExpr &e) {
+  e.op->assign(e, *this, traits::Type<_Tp>::value);
+}
+
+template <typename _Tp>
+inline Mat_<_Tp> &Mat_<_Tp>::operator=(const MatExpr &e) {
+  e.op->assign(e, *this, traits::Type<_Tp>::value);
+  return *this;
+}
+
+template <typename _Tp> inline MatExpr Mat_<_Tp>::zeros(int rows, int cols) {
+  return Mat::zeros(rows, cols, traits::Type<_Tp>::value);
+}
+
+template <typename _Tp> inline MatExpr Mat_<_Tp>::zeros(Size sz) {
+  return Mat::zeros(sz, traits::Type<_Tp>::value);
+}
+
+template <typename _Tp> inline MatExpr Mat_<_Tp>::ones(int rows, int cols) {
+  return Mat::ones(rows, cols, traits::Type<_Tp>::value);
+}
+
+template <typename _Tp> inline MatExpr Mat_<_Tp>::ones(Size sz) {
+  return Mat::ones(sz, traits::Type<_Tp>::value);
+}
+
+template <typename _Tp> inline MatExpr Mat_<_Tp>::eye(int rows, int cols) {
+  return Mat::eye(rows, cols, traits::Type<_Tp>::value);
+}
+
+template <typename _Tp> inline MatExpr Mat_<_Tp>::eye(Size sz) {
+  return Mat::eye(sz, traits::Type<_Tp>::value);
+}
+
+inline MatExpr::MatExpr()
+    : op(0), flags(0), a(Mat()), b(Mat()), c(Mat()), alpha(0), beta(0), s() {}
+
+inline MatExpr::MatExpr(const MatOp *_op, int _flags, const Mat &_a,
+                        const Mat &_b, const Mat &_c, double _alpha,
+                        double _beta, const Scalar &_s)
+    : op(_op), flags(_flags), a(_a), b(_b), c(_c), alpha(_alpha), beta(_beta),
+      s(_s) {}
+
+inline MatExpr::operator Mat() const {
+  Mat m;
+  op->assign(*this, m);
+  return m;
+}
+
+template <typename _Tp> inline MatExpr::operator Mat_<_Tp>() const {
+  Mat_<_Tp> m;
+  op->assign(*this, m, traits::Type<_Tp>::value);
+  return m;
+}
+
+template <typename _Tp>
+static inline MatExpr min(const Mat_<_Tp> &a, const Mat_<_Tp> &b) {
+  return cv::min((const Mat &)a, (const Mat &)b);
+}
+
+template <typename _Tp>
+static inline MatExpr min(const Mat_<_Tp> &a, double s) {
+  return cv::min((const Mat &)a, s);
+}
+
+template <typename _Tp>
+static inline MatExpr min(double s, const Mat_<_Tp> &a) {
+  return cv::min((const Mat &)a, s);
+}
+
+template <typename _Tp>
+static inline MatExpr max(const Mat_<_Tp> &a, const Mat_<_Tp> &b) {
+  return cv::max((const Mat &)a, (const Mat &)b);
+}
+
+template <typename _Tp>
+static inline MatExpr max(const Mat_<_Tp> &a, double s) {
+  return cv::max((const Mat &)a, s);
+}
+
+template <typename _Tp>
+static inline MatExpr max(double s, const Mat_<_Tp> &a) {
+  return cv::max((const Mat &)a, s);
+}
+
+template <typename _Tp> static inline MatExpr abs(const Mat_<_Tp> &m) {
+  return cv::abs((const Mat &)m);
+}
+
+static inline Mat &operator+=(Mat &a, const MatExpr &b) {
+  b.op->augAssignAdd(b, a);
+  return a;
+}
+
+static inline const Mat &operator+=(const Mat &a, const MatExpr &b) {
+  b.op->augAssignAdd(b, (Mat &)a);
+  return a;
+}
+
+template <typename _Tp>
+static inline Mat_<_Tp> &operator+=(Mat_<_Tp> &a, const MatExpr &b) {
+  b.op->augAssignAdd(b, a);
+  return a;
+}
+
+template <typename _Tp>
+static inline const Mat_<_Tp> &operator+=(const Mat_<_Tp> &a,
+                                          const MatExpr &b) {
+  b.op->augAssignAdd(b, (Mat &)a);
+  return a;
+}
+
+static inline Mat &operator-=(Mat &a, const MatExpr &b) {
+  b.op->augAssignSubtract(b, a);
+  return a;
+}
+
+static inline const Mat &operator-=(const Mat &a, const MatExpr &b) {
+  b.op->augAssignSubtract(b, (Mat &)a);
+  return a;
+}
+
+template <typename _Tp>
+static inline Mat_<_Tp> &operator-=(Mat_<_Tp> &a, const MatExpr &b) {
+  b.op->augAssignSubtract(b, a);
+  return a;
+}
+
+template <typename _Tp>
+static inline const Mat_<_Tp> &operator-=(const Mat_<_Tp> &a,
+                                          const MatExpr &b) {
+  b.op->augAssignSubtract(b, (Mat &)a);
+  return a;
+}
+
+static inline Mat &operator*=(Mat &a, const MatExpr &b) {
+  b.op->augAssignMultiply(b, a);
+  return a;
+}
+
+static inline const Mat &operator*=(const Mat &a, const MatExpr &b) {
+  b.op->augAssignMultiply(b, (Mat &)a);
+  return a;
+}
+
+template <typename _Tp>
+static inline Mat_<_Tp> &operator*=(Mat_<_Tp> &a, const MatExpr &b) {
+  b.op->augAssignMultiply(b, a);
+  return a;
+}
+
+template <typename _Tp>
+static inline const Mat_<_Tp> &operator*=(const Mat_<_Tp> &a,
+                                          const MatExpr &b) {
+  b.op->augAssignMultiply(b, (Mat &)a);
+  return a;
+}
+
+static inline Mat &operator/=(Mat &a, const MatExpr &b) {
+  b.op->augAssignDivide(b, a);
+  return a;
+}
+
+static inline const Mat &operator/=(const Mat &a, const MatExpr &b) {
+  b.op->augAssignDivide(b, (Mat &)a);
+  return a;
+}
+
+template <typename _Tp>
+static inline Mat_<_Tp> &operator/=(Mat_<_Tp> &a, const MatExpr &b) {
+  b.op->augAssignDivide(b, a);
+  return a;
+}
+
+template <typename _Tp>
+static inline const Mat_<_Tp> &operator/=(const Mat_<_Tp> &a,
+                                          const MatExpr &b) {
+  b.op->augAssignDivide(b, (Mat &)a);
+  return a;
+}
+
+//////////////////////////////// UMat ////////////////////////////////
+
+inline bool UMatData::hostCopyObsolete() const {
+  return (flags & HOST_COPY_OBSOLETE) != 0;
+}
+inline bool UMatData::deviceCopyObsolete() const {
+  return (flags & DEVICE_COPY_OBSOLETE) != 0;
+}
+inline bool UMatData::deviceMemMapped() const {
+  return (flags & DEVICE_MEM_MAPPED) != 0;
+}
+inline bool UMatData::copyOnMap() const { return (flags & COPY_ON_MAP) != 0; }
+inline bool UMatData::tempUMat() const { return (flags & TEMP_UMAT) != 0; }
+inline bool UMatData::tempCopiedUMat() const {
+  return (flags & TEMP_COPIED_UMAT) == TEMP_COPIED_UMAT;
+}
+
+inline void UMatData::markDeviceMemMapped(bool flag) {
+  if (flag)
+    flags |= DEVICE_MEM_MAPPED;
+  else
+    flags &= ~DEVICE_MEM_MAPPED;
+}
+
+inline void UMatData::markHostCopyObsolete(bool flag) {
+  if (flag)
+    flags |= HOST_COPY_OBSOLETE;
+  else
+    flags &= ~HOST_COPY_OBSOLETE;
+}
+inline void UMatData::markDeviceCopyObsolete(bool flag) {
+  if (flag)
+    flags |= DEVICE_COPY_OBSOLETE;
+  else
+    flags &= ~DEVICE_COPY_OBSOLETE;
+}
+
+//! @endcond
+
+static inline void swap(MatExpr &a, MatExpr &b) { a.swap(b); }
+
+} // namespace cv
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+#ifdef CV_DISABLE_CLANG_ENUM_WARNINGS
+#undef CV_DISABLE_CLANG_ENUM_WARNINGS
+#pragma clang diagnostic pop
+#endif
+
+#endif