react-native-executorch 0.4.10 → 0.5.0-nightly-6f4dd53-20251211

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

@@ -0,0 +1,279 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level
+// directory of this distribution and at http://opencv.org/license.html.
+
+#ifndef OPENCV_CORE_BINDINGS_UTILS_HPP
+#define OPENCV_CORE_BINDINGS_UTILS_HPP
+
+#include <opencv2/core/async.hpp>
+#include <opencv2/core/detail/async_promise.hpp>
+#include <opencv2/core/utils/logger.hpp>
+
+#include <stdexcept>
+
+namespace cv {
+namespace utils {
+//! @addtogroup core_utils
+//! @{
+
+CV_EXPORTS_W String dumpInputArray(InputArray argument);
+
+CV_EXPORTS_W String dumpInputArrayOfArrays(InputArrayOfArrays argument);
+
+CV_EXPORTS_W String dumpInputOutputArray(InputOutputArray argument);
+
+CV_EXPORTS_W String
+dumpInputOutputArrayOfArrays(InputOutputArrayOfArrays argument);
+
+CV_WRAP static inline String dumpBool(bool argument) {
+  return (argument) ? String("Bool: True") : String("Bool: False");
+}
+
+CV_WRAP static inline String dumpInt(int argument) {
+  return cv::format("Int: %d", argument);
+}
+
+CV_WRAP static inline String dumpInt64(int64 argument) {
+  std::ostringstream oss("Int64: ", std::ios::ate);
+  oss << argument;
+  return oss.str();
+}
+
+CV_WRAP static inline String dumpSizeT(size_t argument) {
+  std::ostringstream oss("size_t: ", std::ios::ate);
+  oss << argument;
+  return oss.str();
+}
+
+CV_WRAP static inline String dumpFloat(float argument) {
+  return cv::format("Float: %.2f", argument);
+}
+
+CV_WRAP static inline String dumpDouble(double argument) {
+  return cv::format("Double: %.2f", argument);
+}
+
+CV_WRAP static inline String dumpCString(const char *argument) {
+  return cv::format("String: %s", argument);
+}
+
+CV_WRAP static inline String dumpString(const String &argument) {
+  return cv::format("String: %s", argument.c_str());
+}
+
+CV_WRAP static inline String dumpRect(const Rect &argument) {
+  return format("rect: (x=%d, y=%d, w=%d, h=%d)", argument.x, argument.y,
+                argument.width, argument.height);
+}
+
+CV_WRAP static inline String dumpTermCriteria(const TermCriteria &argument) {
+  return format("term_criteria: (type=%d, max_count=%d, epsilon=%lf",
+                argument.type, argument.maxCount, argument.epsilon);
+}
+
+CV_WRAP static inline String dumpRotatedRect(const RotatedRect &argument) {
+  return format("rotated_rect: (c_x=%f, c_y=%f, w=%f, h=%f, a=%f)",
+                argument.center.x, argument.center.y, argument.size.width,
+                argument.size.height, argument.angle);
+}
+
+CV_WRAP static inline String dumpRange(const Range &argument) {
+  if (argument == Range::all()) {
+    return "range: all";
+  } else {
+    return format("range: (s=%d, e=%d)", argument.start, argument.end);
+  }
+}
+
+CV_EXPORTS_W String dumpVectorOfInt(const std::vector<int> &vec);
+
+CV_EXPORTS_W String dumpVectorOfDouble(const std::vector<double> &vec);
+
+CV_EXPORTS_W String dumpVectorOfRect(const std::vector<Rect> &vec);
+
+//! @cond IGNORED
+
+CV_WRAP static inline String
+testOverloadResolution(int value, const Point &point = Point(42, 24)) {
+  return format("overload (int=%d, point=(x=%d, y=%d))", value, point.x,
+                point.y);
+}
+
+CV_WRAP static inline String testOverloadResolution(const Rect &rect) {
+  return format("overload (rect=(x=%d, y=%d, w=%d, h=%d))", rect.x, rect.y,
+                rect.width, rect.height);
+}
+
+CV_WRAP static inline RotatedRect testRotatedRect(float x, float y, float w,
+                                                  float h, float angle) {
+  return RotatedRect(Point2f(x, y), Size2f(w, h), angle);
+}
+
+CV_WRAP static inline std::vector<RotatedRect>
+testRotatedRectVector(float x, float y, float w, float h, float angle) {
+  std::vector<RotatedRect> result;
+  for (int i = 0; i < 10; i++)
+    result.push_back(
+        RotatedRect(Point2f(x + i, y + 2 * i), Size2f(w, h), angle + 10 * i));
+  return result;
+}
+
+CV_WRAP static inline int testOverwriteNativeMethod(int argument) {
+  return argument;
+}
+
+CV_WRAP static inline String
+testReservedKeywordConversion(int positional_argument, int lambda = 2,
+                              int from = 3) {
+  return format("arg=%d, lambda=%d, from=%d", positional_argument, lambda,
+                from);
+}
+
+CV_WRAP static inline void generateVectorOfRect(size_t len,
+                                                CV_OUT std::vector<Rect> &vec) {
+  vec.resize(len);
+  if (len > 0) {
+    RNG rng(12345);
+    Mat tmp(static_cast<int>(len), 1, CV_32SC4);
+    rng.fill(tmp, RNG::UNIFORM, 10, 20);
+    tmp.copyTo(vec);
+  }
+}
+
+CV_WRAP static inline void generateVectorOfInt(size_t len,
+                                               CV_OUT std::vector<int> &vec) {
+  vec.resize(len);
+  if (len > 0) {
+    RNG rng(554433);
+    Mat tmp(static_cast<int>(len), 1, CV_32SC1);
+    rng.fill(tmp, RNG::UNIFORM, -10, 10);
+    tmp.copyTo(vec);
+  }
+}
+
+CV_WRAP static inline void generateVectorOfMat(size_t len, int rows, int cols,
+                                               int dtype,
+                                               CV_OUT std::vector<Mat> &vec) {
+  vec.resize(len);
+  if (len > 0) {
+    RNG rng(65431);
+    for (size_t i = 0; i < len; ++i) {
+      vec[i].create(rows, cols, dtype);
+      rng.fill(vec[i], RNG::UNIFORM, 0, 10);
+    }
+  }
+}
+
+CV_WRAP static inline AsyncArray testAsyncArray(InputArray argument) {
+  AsyncPromise p;
+  p.setValue(argument);
+  return p.getArrayResult();
+}
+
+CV_WRAP static inline AsyncArray testAsyncException() {
+  AsyncPromise p;
+  return p.getArrayResult();
+}
+
+CV_WRAP static inline String dumpVec2i(const cv::Vec2i value = cv::Vec2i(42,
+                                                                         24)) {
+  return format("Vec2i(%d, %d)", value[0], value[1]);
+}
+
+struct CV_EXPORTS_W_SIMPLE ClassWithKeywordProperties {
+  CV_PROP_RW int lambda;
+  CV_PROP int except;
+
+  CV_WRAP explicit ClassWithKeywordProperties(int lambda_arg = 24,
+                                              int except_arg = 42) {
+    lambda = lambda_arg;
+    except = except_arg;
+  }
+};
+
+struct CV_EXPORTS_W_PARAMS FunctionParams {
+  CV_PROP_RW int lambda = -1;
+  CV_PROP_RW float sigma = 0.0f;
+
+  FunctionParams &setLambda(int value) CV_NOEXCEPT {
+    lambda = value;
+    return *this;
+  }
+
+  FunctionParams &setSigma(float value) CV_NOEXCEPT {
+    sigma = value;
+    return *this;
+  }
+};
+
+CV_WRAP static inline String
+copyMatAndDumpNamedArguments(InputArray src, OutputArray dst,
+                             const FunctionParams &params = FunctionParams()) {
+  src.copyTo(dst);
+  return format("lambda=%d, sigma=%.1f", params.lambda, params.sigma);
+}
+
+namespace nested {
+CV_WRAP static inline bool testEchoBooleanFunction(bool flag) { return flag; }
+
+class CV_EXPORTS_W CV_WRAP_AS(ExportClassName) OriginalClassName {
+public:
+  struct CV_EXPORTS_W_SIMPLE Params {
+    CV_PROP_RW int int_value;
+    CV_PROP_RW float float_value;
+
+    CV_WRAP explicit Params(int int_param = 123, float float_param = 3.5f) {
+      int_value = int_param;
+      float_value = float_param;
+    }
+  };
+
+  explicit OriginalClassName(
+      const OriginalClassName::Params &params = OriginalClassName::Params()) {
+    params_ = params;
+  }
+
+  CV_WRAP int getIntParam() const { return params_.int_value; }
+
+  CV_WRAP float getFloatParam() const { return params_.float_value; }
+
+  CV_WRAP static std::string originalName() { return "OriginalClassName"; }
+
+  CV_WRAP static Ptr<OriginalClassName> create(
+      const OriginalClassName::Params &params = OriginalClassName::Params()) {
+    return makePtr<OriginalClassName>(params);
+  }
+
+private:
+  OriginalClassName::Params params_;
+};
+
+typedef OriginalClassName::Params OriginalClassName_Params;
+} // namespace nested
+
+//! @endcond IGNORED
+
+namespace fs {
+CV_EXPORTS_W cv::String getCacheDirectoryForDownloads();
+} // namespace fs
+
+//! @}  // core_utils
+} // namespace utils
+
+//! @cond IGNORED
+
+CV_WRAP static inline int setLogLevel(int level) {
+  // NB: Binding generators doesn't work with enums properly yet, so we define
+  // separate overload here
+  return cv::utils::logging::setLogLevel((cv::utils::logging::LogLevel)level);
+}
+
+CV_WRAP static inline int getLogLevel() {
+  return cv::utils::logging::getLogLevel();
+}
+
+//! @endcond IGNORED
+
+} // namespace cv
+
+#endif // OPENCV_CORE_BINDINGS_UTILS_HPP

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

@@ -0,0 +1,39 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level
+// directory of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2014, Advanced Micro Devices, Inc., all rights reserved.
+
+#ifndef OPENCV_CORE_BUFFER_POOL_HPP
+#define OPENCV_CORE_BUFFER_POOL_HPP
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4265)
+#endif
+
+namespace cv {
+
+//! @addtogroup core_opencl
+//! @{
+
+class BufferPoolController {
+protected:
+  ~BufferPoolController() {}
+
+public:
+  virtual size_t getReservedSize() const = 0;
+  virtual size_t getMaxReservedSize() const = 0;
+  virtual void setMaxReservedSize(size_t size) = 0;
+  virtual void freeAllReservedBuffers() = 0;
+};
+
+//! @}
+
+} // namespace cv
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+#endif // OPENCV_CORE_BUFFER_POOL_HPP

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

@@ -0,0 +1,231 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level
+// directory of this distribution and at http://opencv.org/license.html.
+
+#ifndef OPENCV_CORE_CHECK_HPP
+#define OPENCV_CORE_CHECK_HPP
+
+#include <opencv2/core/base.hpp>
+
+namespace cv {
+
+/** Returns string of cv::Mat depth value: CV_8U -> "CV_8U" or "<invalid depth>"
+ */
+CV_EXPORTS const char *depthToString(int depth);
+
+/** Returns string of cv::Mat depth value: CV_8UC3 -> "CV_8UC3" or "<invalid
+ * type>" */
+CV_EXPORTS String typeToString(int type);
+
+//! @cond IGNORED
+namespace detail {
+
+/** Returns string of cv::Mat depth value: CV_8U -> "CV_8U" or NULL */
+CV_EXPORTS const char *depthToString_(int depth);
+
+/** Returns string of cv::Mat depth value: CV_8UC3 -> "CV_8UC3" or cv::String()
+ */
+CV_EXPORTS cv::String typeToString_(int type);
+
+enum TestOp {
+  TEST_CUSTOM = 0,
+  TEST_EQ = 1,
+  TEST_NE = 2,
+  TEST_LE = 3,
+  TEST_LT = 4,
+  TEST_GE = 5,
+  TEST_GT = 6,
+  CV__LAST_TEST_OP
+};
+
+struct CheckContext {
+  const char *func;
+  const char *file;
+  int line;
+  enum TestOp testOp;
+  const char *message;
+  const char *p1_str;
+  const char *p2_str;
+};
+
+#ifndef CV__CHECK_FILENAME
+#define CV__CHECK_FILENAME __FILE__
+#endif
+
+#ifndef CV__CHECK_FUNCTION
+#if defined _MSC_VER
+#define CV__CHECK_FUNCTION __FUNCSIG__
+#elif defined __GNUC__
+#define CV__CHECK_FUNCTION __PRETTY_FUNCTION__
+#else
+#define CV__CHECK_FUNCTION "<unknown>"
+#endif
+#endif
+
+#define CV__CHECK_LOCATION_VARNAME(id)                                         \
+  CVAUX_CONCAT(CVAUX_CONCAT(__cv_check_, id), __LINE__)
+#define CV__DEFINE_CHECK_CONTEXT(id, message, testOp, p1_str, p2_str)          \
+  static const cv::detail::CheckContext CV__CHECK_LOCATION_VARNAME(id) = {     \
+      CV__CHECK_FUNCTION, CV__CHECK_FILENAME, __LINE__, testOp,                \
+      "" message,         "" p1_str,          "" p2_str}
+
+CV_EXPORTS void CV_NORETURN check_failed_auto(const bool v1, const bool v2,
+                                              const CheckContext &ctx);
+CV_EXPORTS void CV_NORETURN check_failed_auto(const int v1, const int v2,
+                                              const CheckContext &ctx);
+CV_EXPORTS void CV_NORETURN check_failed_auto(const size_t v1, const size_t v2,
+                                              const CheckContext &ctx);
+CV_EXPORTS void CV_NORETURN check_failed_auto(const float v1, const float v2,
+                                              const CheckContext &ctx);
+CV_EXPORTS void CV_NORETURN check_failed_auto(const double v1, const double v2,
+                                              const CheckContext &ctx);
+CV_EXPORTS void CV_NORETURN check_failed_auto(const Size_<int> v1,
+                                              const Size_<int> v2,
+                                              const CheckContext &ctx);
+CV_EXPORTS void CV_NORETURN check_failed_MatDepth(const int v1, const int v2,
+                                                  const CheckContext &ctx);
+CV_EXPORTS void CV_NORETURN check_failed_MatType(const int v1, const int v2,
+                                                 const CheckContext &ctx);
+CV_EXPORTS void CV_NORETURN check_failed_MatChannels(const int v1, const int v2,
+                                                     const CheckContext &ctx);
+
+CV_EXPORTS void CV_NORETURN check_failed_true(const bool v,
+                                              const CheckContext &ctx);
+CV_EXPORTS void CV_NORETURN check_failed_false(const bool v,
+                                               const CheckContext &ctx);
+
+CV_EXPORTS void CV_NORETURN check_failed_auto(const int v,
+                                              const CheckContext &ctx);
+CV_EXPORTS void CV_NORETURN check_failed_auto(const size_t v,
+                                              const CheckContext &ctx);
+CV_EXPORTS void CV_NORETURN check_failed_auto(const float v,
+                                              const CheckContext &ctx);
+CV_EXPORTS void CV_NORETURN check_failed_auto(const double v,
+                                              const CheckContext &ctx);
+CV_EXPORTS void CV_NORETURN check_failed_auto(const Size_<int> v,
+                                              const CheckContext &ctx);
+CV_EXPORTS void CV_NORETURN check_failed_auto(const std::string &v1,
+                                              const CheckContext &ctx);
+CV_EXPORTS void CV_NORETURN check_failed_MatDepth(const int v,
+                                                  const CheckContext &ctx);
+CV_EXPORTS void CV_NORETURN check_failed_MatType(const int v,
+                                                 const CheckContext &ctx);
+CV_EXPORTS void CV_NORETURN check_failed_MatChannels(const int v,
+                                                     const CheckContext &ctx);
+
+#define CV__TEST_EQ(v1, v2) ((v1) == (v2))
+#define CV__TEST_NE(v1, v2) ((v1) != (v2))
+#define CV__TEST_LE(v1, v2) ((v1) <= (v2))
+#define CV__TEST_LT(v1, v2) ((v1) < (v2))
+#define CV__TEST_GE(v1, v2) ((v1) >= (v2))
+#define CV__TEST_GT(v1, v2) ((v1) > (v2))
+
+#define CV__CHECK(id, op, type, v1, v2, v1_str, v2_str, msg_str)               \
+  do {                                                                         \
+    if (CV__TEST_##op((v1), (v2)))                                             \
+      ;                                                                        \
+    else {                                                                     \
+      CV__DEFINE_CHECK_CONTEXT(id, msg_str, cv::detail::TEST_##op, v1_str,     \
+                               v2_str);                                        \
+      cv::detail::check_failed_##type((v1), (v2),                              \
+                                      CV__CHECK_LOCATION_VARNAME(id));         \
+    }                                                                          \
+  } while (0)
+
+#define CV__CHECK_CUSTOM_TEST(id, type, v, test_expr, v_str, test_expr_str,    \
+                              msg_str)                                         \
+  do {                                                                         \
+    if (!!(test_expr))                                                         \
+      ;                                                                        \
+    else {                                                                     \
+      CV__DEFINE_CHECK_CONTEXT(id, msg_str, cv::detail::TEST_CUSTOM, v_str,    \
+                               test_expr_str);                                 \
+      cv::detail::check_failed_##type((v), CV__CHECK_LOCATION_VARNAME(id));    \
+    }                                                                          \
+  } while (0)
+
+} // namespace detail
+//! @endcond
+
+/// Supported values of these types: int, float, double
+#define CV_CheckEQ(v1, v2, msg) CV__CHECK(_, EQ, auto, v1, v2, #v1, #v2, msg)
+#define CV_CheckNE(v1, v2, msg) CV__CHECK(_, NE, auto, v1, v2, #v1, #v2, msg)
+#define CV_CheckLE(v1, v2, msg) CV__CHECK(_, LE, auto, v1, v2, #v1, #v2, msg)
+#define CV_CheckLT(v1, v2, msg) CV__CHECK(_, LT, auto, v1, v2, #v1, #v2, msg)
+#define CV_CheckGE(v1, v2, msg) CV__CHECK(_, GE, auto, v1, v2, #v1, #v2, msg)
+#define CV_CheckGT(v1, v2, msg) CV__CHECK(_, GT, auto, v1, v2, #v1, #v2, msg)
+
+/// Check with additional "decoding" of type values in error message
+#define CV_CheckTypeEQ(t1, t2, msg)                                            \
+  CV__CHECK(_, EQ, MatType, t1, t2, #t1, #t2, msg)
+/// Check with additional "decoding" of depth values in error message
+#define CV_CheckDepthEQ(d1, d2, msg)                                           \
+  CV__CHECK(_, EQ, MatDepth, d1, d2, #d1, #d2, msg)
+
+#define CV_CheckChannelsEQ(c1, c2, msg)                                        \
+  CV__CHECK(_, EQ, MatChannels, c1, c2, #c1, #c2, msg)
+
+/// Example: type == CV_8UC1 || type == CV_8UC3
+#define CV_CheckType(t, test_expr, msg)                                        \
+  CV__CHECK_CUSTOM_TEST(_, MatType, t, (test_expr), #t, #test_expr, msg)
+
+/// Example: depth == CV_32F || depth == CV_64F
+#define CV_CheckDepth(t, test_expr, msg)                                       \
+  CV__CHECK_CUSTOM_TEST(_, MatDepth, t, (test_expr), #t, #test_expr, msg)
+
+/// Example: channel == 1 || channel == 3
+#define CV_CheckChannels(t, test_expr, msg)                                    \
+  CV__CHECK_CUSTOM_TEST(_, MatChannels, t, (test_expr), #t, #test_expr, msg)
+
+/// Example: v == A || v == B
+#define CV_Check(v, test_expr, msg)                                            \
+  CV__CHECK_CUSTOM_TEST(_, auto, v, (test_expr), #v, #test_expr, msg)
+
+/// Example: v == true
+#define CV_CheckTrue(v, msg) CV__CHECK_CUSTOM_TEST(_, true, v, v, #v, "", msg)
+
+/// Example: v == false
+#define CV_CheckFalse(v, msg)                                                  \
+  CV__CHECK_CUSTOM_TEST(_, false, v, (!(v)), #v, "", msg)
+
+/// Some complex conditions: CV_Check(src2, src2.empty() || (src2.type() ==
+/// src1.type() && src2.size() == src1.size()), "src2 should have same size/type
+/// as src1")
+// TODO define pretty-printers
+
+#ifndef NDEBUG
+#define CV_DbgCheck(v, test_expr, msg)                                         \
+  CV__CHECK_CUSTOM_TEST(_, auto, v, (test_expr), #v, #test_expr, msg)
+#define CV_DbgCheckEQ(v1, v2, msg) CV__CHECK(_, EQ, auto, v1, v2, #v1, #v2, msg)
+#define CV_DbgCheckNE(v1, v2, msg) CV__CHECK(_, NE, auto, v1, v2, #v1, #v2, msg)
+#define CV_DbgCheckLE(v1, v2, msg) CV__CHECK(_, LE, auto, v1, v2, #v1, #v2, msg)
+#define CV_DbgCheckLT(v1, v2, msg) CV__CHECK(_, LT, auto, v1, v2, #v1, #v2, msg)
+#define CV_DbgCheckGE(v1, v2, msg) CV__CHECK(_, GE, auto, v1, v2, #v1, #v2, msg)
+#define CV_DbgCheckGT(v1, v2, msg) CV__CHECK(_, GT, auto, v1, v2, #v1, #v2, msg)
+#else
+#define CV_DbgCheck(v, test_expr, msg)                                         \
+  do {                                                                         \
+  } while (0)
+#define CV_DbgCheckEQ(v1, v2, msg)                                             \
+  do {                                                                         \
+  } while (0)
+#define CV_DbgCheckNE(v1, v2, msg)                                             \
+  do {                                                                         \
+  } while (0)
+#define CV_DbgCheckLE(v1, v2, msg)                                             \
+  do {                                                                         \
+  } while (0)
+#define CV_DbgCheckLT(v1, v2, msg)                                             \
+  do {                                                                         \
+  } while (0)
+#define CV_DbgCheckGE(v1, v2, msg)                                             \
+  do {                                                                         \
+  } while (0)
+#define CV_DbgCheckGT(v1, v2, msg)                                             \
+  do {                                                                         \
+  } while (0)
+#endif
+
+} // namespace cv
+
+#endif // OPENCV_CORE_CHECK_HPP

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

@@ -0,0 +1,55 @@
+/*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*/
+
+#ifdef __OPENCV_BUILD
+#error this is a compatibility header which should not be used inside the OpenCV library
+#endif
+
+#include "opencv2/core.hpp"