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

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

@@ -0,0 +1,196 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this
+license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without
+modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright
+notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote
+products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is"
+and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are
+disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any
+direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef OPENCV_CORE_CVSTD_HPP
+#define OPENCV_CORE_CVSTD_HPP
+
+#ifndef __cplusplus
+#error cvstd.hpp header must be compiled as C++
+#endif
+
+#include "opencv2/core/cvdef.h"
+#include <cctype>
+#include <cstddef>
+#include <cstring>
+
+#include <string>
+
+// import useful primitives from stl
+#include <algorithm>
+#include <cmath>
+#include <cstdlib> //for abs(int)
+#include <utility>
+
+namespace cv {
+static inline uchar abs(uchar a) { return a; }
+static inline ushort abs(ushort a) { return a; }
+static inline unsigned abs(unsigned a) { return a; }
+static inline uint64 abs(uint64 a) { return a; }
+
+using std::abs;
+using std::exp;
+using std::log;
+using std::max;
+using std::min;
+using std::pow;
+using std::sqrt;
+using std::swap;
+} // namespace cv
+
+#include "cvstd_wrapper.hpp"
+
+namespace cv {
+
+//! @addtogroup core_utils
+//! @{
+
+//////////////////////////// memory management functions
+///////////////////////////////
+
+/** @brief Allocates an aligned memory buffer.
+
+The function allocates the buffer of the specified size and returns it. When the
+buffer size is 16 bytes or more, the returned buffer is aligned to 16 bytes.
+@param bufSize Allocated buffer size.
+ */
+CV_EXPORTS void *fastMalloc(size_t bufSize);
+
+/** @brief Deallocates a memory buffer.
+
+The function deallocates the buffer allocated with fastMalloc . If NULL pointer
+is passed, the function does nothing. C version of the function clears the
+pointer *pptr* to avoid problems with double memory deallocation.
+@param ptr Pointer to the allocated buffer.
+ */
+CV_EXPORTS void fastFree(void *ptr);
+
+/*!
+  The STL-compliant memory Allocator based on cv::fastMalloc() and
+  cv::fastFree()
+*/
+template <typename _Tp> class Allocator {
+public:
+  typedef _Tp value_type;
+  typedef value_type *pointer;
+  typedef const value_type *const_pointer;
+  typedef value_type &reference;
+  typedef const value_type &const_reference;
+  typedef size_t size_type;
+  typedef ptrdiff_t difference_type;
+  template <typename U> class rebind {
+    typedef Allocator<U> other;
+  };
+
+  explicit Allocator() {}
+  ~Allocator() {}
+  explicit Allocator(Allocator const &) {}
+  template <typename U> explicit Allocator(Allocator<U> const &) {}
+
+  // address
+  pointer address(reference r) { return &r; }
+  const_pointer address(const_reference r) { return &r; }
+
+  pointer allocate(size_type count, const void * = 0) {
+    return reinterpret_cast<pointer>(fastMalloc(count * sizeof(_Tp)));
+  }
+  void deallocate(pointer p, size_type) { fastFree(p); }
+
+  void construct(pointer p, const _Tp &v) {
+    new (static_cast<void *>(p)) _Tp(v);
+  }
+  void destroy(pointer p) { p->~_Tp(); }
+
+  size_type max_size() const {
+    return cv::max(static_cast<_Tp>(-1) / sizeof(_Tp), 1);
+  }
+};
+
+//! @} core_utils
+
+//! @addtogroup core_basic
+//! @{
+
+//////////////////////////////// string class ////////////////////////////////
+
+class CV_EXPORTS FileNode; // for string constructor from FileNode
+
+typedef std::string String;
+
+#ifndef OPENCV_DISABLE_STRING_LOWER_UPPER_CONVERSIONS
+
+//! @cond IGNORED
+namespace details {
+// std::tolower is int->int
+static inline char char_tolower(char ch) { return (char)std::tolower((int)ch); }
+// std::toupper is int->int
+static inline char char_toupper(char ch) { return (char)std::toupper((int)ch); }
+} // namespace details
+//! @endcond
+
+static inline std::string toLowerCase(const std::string &str) {
+  std::string result(str);
+  std::transform(result.begin(), result.end(), result.begin(),
+                 details::char_tolower);
+  return result;
+}
+
+static inline std::string toUpperCase(const std::string &str) {
+  std::string result(str);
+  std::transform(result.begin(), result.end(), result.begin(),
+                 details::char_toupper);
+  return result;
+}
+
+#endif // OPENCV_DISABLE_STRING_LOWER_UPPER_CONVERSIONS
+
+//! @} core_basic
+} // namespace cv
+
+#endif // OPENCV_CORE_CVSTD_HPP

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

@@ -0,0 +1,188 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this
+license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without
+modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright
+notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote
+products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is"
+and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are
+disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any
+direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef OPENCV_CORE_CVSTDINL_HPP
+#define OPENCV_CORE_CVSTDINL_HPP
+
+#include <complex>
+#include <ostream>
+#include <sstream>
+
+//! @cond IGNORED
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4127)
+#endif
+
+namespace cv {
+
+template <typename _Tp> class DataType<std::complex<_Tp>> {
+public:
+  typedef std::complex<_Tp> value_type;
+  typedef value_type work_type;
+  typedef _Tp channel_type;
+
+  enum {
+    generic_type = 0,
+    depth = DataType<channel_type>::depth,
+    channels = 2,
+    fmt = DataType<channel_type>::fmt + ((channels - 1) << 8),
+    type = CV_MAKETYPE(depth, channels)
+  };
+
+  typedef Vec<channel_type, channels> vec_type;
+};
+
+static inline std::ostream &operator<<(std::ostream &out, Ptr<Formatted> fmtd) {
+  fmtd->reset();
+  for (const char *str = fmtd->next(); str; str = fmtd->next())
+    out << str;
+  return out;
+}
+
+static inline std::ostream &operator<<(std::ostream &out, const Mat &mtx) {
+  return out << Formatter::get()->format(mtx);
+}
+
+template <typename _Tp>
+static inline std::ostream &operator<<(std::ostream &out,
+                                       const Complex<_Tp> &c) {
+  return out << "(" << c.re << "," << c.im << ")";
+}
+
+template <typename _Tp>
+static inline std::ostream &operator<<(std::ostream &out,
+                                       const std::vector<Point_<_Tp>> &vec) {
+  return out << Formatter::get()->format(Mat(vec));
+}
+
+template <typename _Tp>
+static inline std::ostream &operator<<(std::ostream &out,
+                                       const std::vector<Point3_<_Tp>> &vec) {
+  return out << Formatter::get()->format(Mat(vec));
+}
+
+template <typename _Tp, int m, int n>
+static inline std::ostream &operator<<(std::ostream &out,
+                                       const Matx<_Tp, m, n> &matx) {
+  return out << Formatter::get()->format(Mat(matx));
+}
+
+template <typename _Tp>
+static inline std::ostream &operator<<(std::ostream &out,
+                                       const Point_<_Tp> &p) {
+  out << "[" << p.x << ", " << p.y << "]";
+  return out;
+}
+
+template <typename _Tp>
+static inline std::ostream &operator<<(std::ostream &out,
+                                       const Point3_<_Tp> &p) {
+  out << "[" << p.x << ", " << p.y << ", " << p.z << "]";
+  return out;
+}
+
+template <typename _Tp, int n>
+static inline std::ostream &operator<<(std::ostream &out,
+                                       const Vec<_Tp, n> &vec) {
+  out << "[";
+  if (cv::traits::Depth<_Tp>::value <= CV_32S) {
+    for (int i = 0; i < n - 1; ++i) {
+      out << (int)vec[i] << ", ";
+    }
+    out << (int)vec[n - 1] << "]";
+  } else {
+    for (int i = 0; i < n - 1; ++i) {
+      out << vec[i] << ", ";
+    }
+    out << vec[n - 1] << "]";
+  }
+
+  return out;
+}
+
+template <typename _Tp>
+static inline std::ostream &operator<<(std::ostream &out,
+                                       const Size_<_Tp> &size) {
+  return out << "[" << size.width << " x " << size.height << "]";
+}
+
+template <typename _Tp>
+static inline std::ostream &operator<<(std::ostream &out,
+                                       const Rect_<_Tp> &rect) {
+  return out << "[" << rect.width << " x " << rect.height << " from (" << rect.x
+             << ", " << rect.y << ")]";
+}
+
+static inline std::ostream &operator<<(std::ostream &out,
+                                       const MatSize &msize) {
+  int i, dims = msize.dims();
+  for (i = 0; i < dims; i++) {
+    out << msize[i];
+    if (i < dims - 1)
+      out << " x ";
+  }
+  return out;
+}
+
+static inline std::ostream &operator<<(std::ostream &s, cv::Range &r) {
+  return s << "[" << r.start << " : " << r.end << ")";
+}
+
+} // namespace cv
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+//! @endcond
+
+#endif // OPENCV_CORE_CVSTDINL_HPP

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

@@ -0,0 +1,187 @@
+// 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_CVSTD_WRAPPER_HPP
+#define OPENCV_CORE_CVSTD_WRAPPER_HPP
+
+#include "opencv2/core/cvdef.h"
+
+#include <memory> // std::shared_ptr
+#include <string>
+#include <type_traits> // std::enable_if
+
+namespace cv {
+
+using std::nullptr_t;
+
+//! @addtogroup core_basic
+//! @{
+
+#ifdef CV_DOXYGEN
+
+template <typename _Tp>
+using Ptr =
+    std::shared_ptr<_Tp>; // In ideal world it should look like this, but we
+                          // need some compatibility workarounds below
+
+template <typename _Tp, typename... A1>
+static inline Ptr<_Tp> makePtr(const A1 &...a1) {
+  return std::make_shared<_Tp>(a1...);
+}
+
+#else // cv::Ptr with compatibility workarounds
+
+// It should be defined for C-API types only.
+// C++ types should use regular "delete" operator.
+template <typename Y> struct DefaultDeleter;
+#if 0
+{
+    void operator()(Y* p) const;
+};
+#endif
+
+namespace sfinae {
+template <typename C, typename Ret, typename... Args>
+struct has_parenthesis_operator {
+private:
+  template <typename T>
+  static CV_CONSTEXPR std::true_type has_parenthesis_operator_check(
+      typename std::is_same<
+          typename std::decay<decltype(std::declval<T>().operator()(
+              std::declval<Args>()...))>::type,
+          Ret>::type *);
+
+  template <typename>
+  static CV_CONSTEXPR std::false_type has_parenthesis_operator_check(...);
+
+  typedef decltype(has_parenthesis_operator_check<C>(0)) type;
+
+public:
+#if __cplusplus >= 201103L ||                                                  \
+    (defined(_MSC_VER) && _MSC_VER >= 1900 /*MSVS 2015*/)
+  static CV_CONSTEXPR bool value = type::value;
+#else
+  // support MSVS 2013
+  static const int value = type::value;
+#endif
+};
+} // namespace sfinae
+
+template <typename T, typename = void>
+struct has_custom_delete : public std::false_type {};
+
+// Force has_custom_delete to std::false_type when NVCC is compiling CUDA source
+// files
+#ifndef __CUDACC__
+template <typename T>
+struct has_custom_delete<
+    T, typename std::enable_if<sfinae::has_parenthesis_operator<
+           DefaultDeleter<T>, void, T *>::value>::type>
+    : public std::true_type {};
+#endif
+
+template <typename T> struct Ptr : public std::shared_ptr<T> {
+#if 0
+    using std::shared_ptr<T>::shared_ptr;  // GCC 5.x can't handle this
+#else
+  inline Ptr() CV_NOEXCEPT : std::shared_ptr<T>() {}
+  inline Ptr(nullptr_t) CV_NOEXCEPT : std::shared_ptr<T>(nullptr) {}
+  template <typename Y, typename D>
+  inline Ptr(Y *p, D d) : std::shared_ptr<T>(p, d) {}
+  template <typename D>
+  inline Ptr(nullptr_t, D d) : std::shared_ptr<T>(nullptr, d) {}
+
+  template <typename Y>
+  inline Ptr(const Ptr<Y> &r, T *ptr) CV_NOEXCEPT : std::shared_ptr<T>(r, ptr) {
+  }
+
+  inline Ptr(const Ptr<T> &o) CV_NOEXCEPT : std::shared_ptr<T>(o) {}
+  inline Ptr(Ptr<T> &&o) CV_NOEXCEPT : std::shared_ptr<T>(std::move(o)) {}
+
+  template <typename Y>
+  inline Ptr(const Ptr<Y> &o) CV_NOEXCEPT : std::shared_ptr<T>(o) {}
+  template <typename Y>
+  inline Ptr(Ptr<Y> &&o) CV_NOEXCEPT : std::shared_ptr<T>(std::move(o)) {}
+#endif
+  inline Ptr(const std::shared_ptr<T> &o) CV_NOEXCEPT : std::shared_ptr<T>(o) {}
+  inline Ptr(std::shared_ptr<T> &&o) CV_NOEXCEPT
+      : std::shared_ptr<T>(std::move(o)) {}
+
+  // Overload with custom DefaultDeleter: Ptr<IplImage>(...)
+  template <typename Y>
+  inline Ptr(const std::true_type &, Y *ptr)
+      : std::shared_ptr<T>(ptr, DefaultDeleter<Y>()) {}
+
+  // Overload without custom deleter: Ptr<std::string>(...);
+  template <typename Y>
+  inline Ptr(const std::false_type &, Y *ptr) : std::shared_ptr<T>(ptr) {}
+
+  template <typename Y = T>
+  inline Ptr(Y *ptr) : Ptr(has_custom_delete<Y>(), ptr) {}
+
+  // Overload with custom DefaultDeleter: Ptr<IplImage>(...)
+  template <typename Y> inline void reset(const std::true_type &, Y *ptr) {
+    std::shared_ptr<T>::reset(ptr, DefaultDeleter<Y>());
+  }
+
+  // Overload without custom deleter: Ptr<std::string>(...);
+  template <typename Y> inline void reset(const std::false_type &, Y *ptr) {
+    std::shared_ptr<T>::reset(ptr);
+  }
+
+  template <typename Y> inline void reset(Y *ptr) {
+    Ptr<T>::reset(has_custom_delete<Y>(), ptr);
+  }
+
+  template <class Y, class Deleter> void reset(Y *ptr, Deleter d) {
+    std::shared_ptr<T>::reset(ptr, d);
+  }
+
+  void reset() CV_NOEXCEPT { std::shared_ptr<T>::reset(); }
+
+  Ptr &operator=(const Ptr &o) {
+    std::shared_ptr<T>::operator=(o);
+    return *this;
+  }
+  template <typename Y> inline Ptr &operator=(const Ptr<Y> &o) {
+    std::shared_ptr<T>::operator=(o);
+    return *this;
+  }
+
+  T *operator->() const CV_NOEXCEPT { return std::shared_ptr<T>::get(); }
+  typename std::add_lvalue_reference<T>::type operator*() const CV_NOEXCEPT {
+    return *std::shared_ptr<T>::get();
+  }
+
+  // OpenCV 3.x methods (not a part of standard C++ library)
+  inline void release() { std::shared_ptr<T>::reset(); }
+  inline operator T *() const { return std::shared_ptr<T>::get(); }
+  inline bool empty() const { return std::shared_ptr<T>::get() == nullptr; }
+
+  template <typename Y> inline Ptr<Y> staticCast() const CV_NOEXCEPT {
+    return std::static_pointer_cast<Y>(*this);
+  }
+
+  template <typename Y> inline Ptr<Y> constCast() const CV_NOEXCEPT {
+    return std::const_pointer_cast<Y>(*this);
+  }
+
+  template <typename Y> inline Ptr<Y> dynamicCast() const CV_NOEXCEPT {
+    return std::dynamic_pointer_cast<Y>(*this);
+  }
+};
+
+template <typename _Tp, typename... A1>
+static inline Ptr<_Tp> makePtr(const A1 &...a1) {
+  static_assert(!has_custom_delete<_Tp>::value,
+                "Can't use this makePtr with custom DefaultDeleter");
+  return (Ptr<_Tp>)std::make_shared<_Tp>(a1...);
+}
+
+#endif // CV_DOXYGEN
+
+//! @} core_basic
+} // namespace cv
+
+#endif // OPENCV_CORE_CVSTD_WRAPPER_HPP

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

@@ -0,0 +1,73 @@
+// 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_ASYNC_PROMISE_HPP
+#define OPENCV_CORE_ASYNC_PROMISE_HPP
+
+#include "../async.hpp"
+
+#include "exception_ptr.hpp"
+
+namespace cv {
+
+/** @addtogroup core_async
+@{
+*/
+
+/** @brief Provides result of asynchronous operations
+
+*/
+class CV_EXPORTS AsyncPromise {
+public:
+  ~AsyncPromise() CV_NOEXCEPT;
+  AsyncPromise() CV_NOEXCEPT;
+  explicit AsyncPromise(const AsyncPromise &o) CV_NOEXCEPT;
+  AsyncPromise &operator=(const AsyncPromise &o) CV_NOEXCEPT;
+  void release() CV_NOEXCEPT;
+
+  /** Returns associated AsyncArray
+  @note Can be called once
+  */
+  AsyncArray getArrayResult();
+
+  /** Stores asynchronous result.
+  @param[in] value result
+  */
+  void setValue(InputArray value);
+
+  // TODO "move" setters
+
+#if CV__EXCEPTION_PTR
+  /** Stores exception.
+  @param[in] exception exception to be raised in AsyncArray
+  */
+  void setException(std::exception_ptr exception);
+#endif
+
+  /** Stores exception.
+  @param[in] exception exception to be raised in AsyncArray
+  */
+  void setException(const cv::Exception &exception);
+
+  explicit AsyncPromise(AsyncPromise &&o) {
+    p = o.p;
+    o.p = NULL;
+  }
+  AsyncPromise &operator=(AsyncPromise &&o) CV_NOEXCEPT {
+    std::swap(p, o.p);
+    return *this;
+  }
+
+  // PImpl
+  typedef struct AsyncArray::Impl Impl;
+  friend struct AsyncArray::Impl;
+  inline void *_getImpl() const CV_NOEXCEPT { return p; }
+
+protected:
+  Impl *p;
+};
+
+//! @}
+} // namespace cv
+#endif // OPENCV_CORE_ASYNC_PROMISE_HPP

package/third-party/include/opencv2/core/detail/dispatch_helper.impl.hpp

@@ -0,0 +1,48 @@
+// 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_DETAIL_DISPATCH_HELPER_IMPL_HPP
+#define OPENCV_CORE_DETAIL_DISPATCH_HELPER_IMPL_HPP
+
+//! @cond IGNORED
+
+namespace cv {
+namespace detail {
+
+template <template <typename> class Functor, typename... Args>
+static inline void depthDispatch(const int depth, Args &&...args) {
+  switch (depth) {
+  case CV_8U:
+    Functor<uint8_t>{}(std::forward<Args>(args)...);
+    break;
+  case CV_8S:
+    Functor<int8_t>{}(std::forward<Args>(args)...);
+    break;
+  case CV_16U:
+    Functor<uint16_t>{}(std::forward<Args>(args)...);
+    break;
+  case CV_16S:
+    Functor<int16_t>{}(std::forward<Args>(args)...);
+    break;
+  case CV_32S:
+    Functor<int32_t>{}(std::forward<Args>(args)...);
+    break;
+  case CV_32F:
+    Functor<float>{}(std::forward<Args>(args)...);
+    break;
+  case CV_64F:
+    Functor<double>{}(std::forward<Args>(args)...);
+    break;
+  case CV_16F:
+  default:
+    CV_Error(cv::Error::BadDepth, "Unsupported matrix type.");
+  };
+}
+
+} // namespace detail
+} // namespace cv
+
+//! @endcond
+
+#endif // OPENCV_CORE_DETAIL_DISPATCH_HELPER_IMPL_HPP