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

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

@@ -0,0 +1,362 @@
+/*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) 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 OpenCV Foundation 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_OPTIM_HPP
+#define OPENCV_OPTIM_HPP
+
+#include "opencv2/core.hpp"
+
+namespace cv {
+
+/** @addtogroup core_optim
+The algorithms in this section minimize or maximize function value within
+specified constraints or without any constraints.
+@{
+*/
+
+/** @brief Basic interface for all solvers
+ */
+class CV_EXPORTS MinProblemSolver : public Algorithm {
+public:
+  /** @brief Represents function being optimized
+   */
+  class CV_EXPORTS Function {
+  public:
+    virtual ~Function() {}
+    virtual int getDims() const = 0;
+    virtual double getGradientEps() const;
+    virtual double calc(const double *x) const = 0;
+    virtual void getGradient(const double *x, double *grad);
+  };
+
+  /** @brief Getter for the optimized function.
+
+  The optimized function is represented by Function interface, which requires
+  derivatives to implement the calc(double*) and getDim() methods to evaluate
+  the function.
+
+  @return Smart-pointer to an object that implements Function interface - it
+  represents the function that is being optimized. It can be empty, if no
+  function was given so far.
+   */
+  virtual Ptr<Function> getFunction() const = 0;
+
+  /** @brief Setter for the optimized function.
+
+  *It should be called at least once before the call to* minimize(), as default
+  value is not usable.
+
+  @param f The new function to optimize.
+   */
+  virtual void setFunction(const Ptr<Function> &f) = 0;
+
+  /** @brief Getter for the previously set terminal criteria for this algorithm.
+
+  @return Deep copy of the terminal criteria used at the moment.
+   */
+  virtual TermCriteria getTermCriteria() const = 0;
+
+  /** @brief Set terminal criteria for solver.
+
+  This method *is not necessary* to be called before the first call to
+  minimize(), as the default value is sensible.
+
+  Algorithm stops when the number of function evaluations done exceeds
+  termcrit.maxCount, when the function values at the vertices of simplex are
+  within termcrit.epsilon range or simplex becomes so small that it can enclosed
+  in a box with termcrit.epsilon sides, whatever comes first.
+  @param termcrit Terminal criteria to be used, represented as cv::TermCriteria
+  structure.
+   */
+  virtual void setTermCriteria(const TermCriteria &termcrit) = 0;
+
+  /** @brief actually runs the algorithm and performs the minimization.
+
+  The sole input parameter determines the centroid of the starting simplex
+  (roughly, it tells where to start), all the others (terminal criteria, initial
+  step, function to be minimized) are supposed to be set via the setters before
+  the call to this method or the default values (not always sensible) will be
+  used.
+
+  @param x The initial point, that will become a centroid of an initial simplex.
+  After the algorithm will terminate, it will be set to the point where the
+  algorithm stops, the point of possible minimum.
+  @return The value of a function at the point found.
+   */
+  virtual double minimize(InputOutputArray x) = 0;
+};
+
+/** @brief This class is used to perform the non-linear non-constrained
+minimization of a function,
+
+defined on an `n`-dimensional Euclidean space, using the **Nelder-Mead method**,
+also known as
+**downhill simplex method**. The basic idea about the method can be obtained
+from <http://en.wikipedia.org/wiki/Nelder-Mead_method>.
+
+It should be noted, that this method, although deterministic, is rather a
+heuristic and therefore may converge to a local minima, not necessary a global
+one. It is iterative optimization technique, which at each step uses an
+information about the values of a function evaluated only at `n+1` points,
+arranged as a *simplex* in `n`-dimensional space (hence the second name of the
+method). At each step new point is chosen to evaluate function at, obtained
+value is compared with previous ones and based on this information simplex
+changes it's shape , slowly moving to the local minimum. Thus this method is
+using *only* function values to make decision, on contrary to, say, Nonlinear
+Conjugate Gradient method (which is also implemented in optim).
+
+Algorithm stops when the number of function evaluations done exceeds
+termcrit.maxCount, when the function values at the vertices of simplex are
+within termcrit.epsilon range or simplex becomes so small that it can enclosed
+in a box with termcrit.epsilon sides, whatever comes first, for some defined by
+user positive integer termcrit.maxCount and positive non-integer
+termcrit.epsilon.
+
+@note DownhillSolver is a derivative of the abstract interface
+cv::MinProblemSolver, which in turn is derived from the Algorithm interface and
+is used to encapsulate the functionality, common to all non-linear optimization
+algorithms in the optim module.
+
+@note term criteria should meet following condition:
+@code
+    termcrit.type == (TermCriteria::MAX_ITER + TermCriteria::EPS) &&
+termcrit.epsilon > 0 && termcrit.maxCount > 0
+@endcode
+ */
+class CV_EXPORTS DownhillSolver : public MinProblemSolver {
+public:
+  /** @brief Returns the initial step that will be used in downhill simplex
+  algorithm.
+
+  @param step Initial step that will be used in algorithm. Note, that although
+  corresponding setter accepts column-vectors as well as row-vectors, this
+  method will return a row-vector.
+  @see DownhillSolver::setInitStep
+   */
+  virtual void getInitStep(OutputArray step) const = 0;
+
+  /** @brief Sets the initial step that will be used in downhill simplex
+  algorithm.
+
+  Step, together with initial point (given in DownhillSolver::minimize) are two
+  `n`-dimensional vectors that are used to determine the shape of initial
+  simplex. Roughly said, initial point determines the position of a simplex (it
+  will become simplex's centroid), while step determines the spread (size in
+  each dimension) of a simplex. To be more precise, if
+  \f$s,x_0\in\mathbb{R}^n\f$ are the initial step and initial point
+  respectively, the vertices of a simplex will be:
+  \f$v_0:=x_0-\frac{1}{2} s\f$ and \f$v_i:=x_0+s_i\f$ for \f$i=1,2,\dots,n\f$
+  where \f$s_i\f$ denotes projections of the initial step of *n*-th coordinate
+  (the result of projection is treated to be vector given by
+  \f$s_i:=e_i\cdot\left<e_i\cdot s\right>\f$, where \f$e_i\f$ form canonical
+  basis)
+
+  @param step Initial step that will be used in algorithm. Roughly said, it
+  determines the spread (size in each dimension) of an initial simplex.
+   */
+  virtual void setInitStep(InputArray step) = 0;
+
+  /** @brief This function returns the reference to the ready-to-use
+  DownhillSolver object.
+
+  All the parameters are optional, so this procedure can be called even without
+  parameters at all. In this case, the default values will be used. As default
+  value for terminal criteria are the only sensible ones,
+  MinProblemSolver::setFunction() and DownhillSolver::setInitStep() should be
+  called upon the obtained object, if the respective parameters were not given
+  to create(). Otherwise, the two ways (give parameters to
+  createDownhillSolver() or miss them out and call the
+  MinProblemSolver::setFunction() and DownhillSolver::setInitStep()) are
+  absolutely equivalent (and will drop the same errors in the same way, should
+  invalid input be detected).
+  @param f Pointer to the function that will be minimized, similarly to the one
+  you submit via MinProblemSolver::setFunction.
+  @param initStep Initial step, that will be used to construct the initial
+  simplex, similarly to the one you submit via MinProblemSolver::setInitStep.
+  @param termcrit Terminal criteria to the algorithm, similarly to the one you
+  submit via MinProblemSolver::setTermCriteria.
+   */
+  static Ptr<DownhillSolver>
+  create(const Ptr<MinProblemSolver::Function> &f =
+             Ptr<MinProblemSolver::Function>(),
+         InputArray initStep = Mat_<double>(1, 1, 0.0),
+         TermCriteria termcrit = TermCriteria(TermCriteria::MAX_ITER +
+                                                  TermCriteria::EPS,
+                                              5000, 0.000001));
+};
+
+/** @brief This class is used to perform the non-linear non-constrained
+minimization of a function with known gradient,
+
+defined on an *n*-dimensional Euclidean space, using the **Nonlinear Conjugate
+Gradient method**. The implementation was done based on the beautifully clear
+explanatory article [An Introduction to the Conjugate Gradient Method Without
+the Agonizing
+Pain](http://www.cs.cmu.edu/~quake-papers/painless-conjugate-gradient.pdf) by
+Jonathan Richard Shewchuk. The method can be seen as an adaptation of a standard
+Conjugate Gradient method (see, for example
+<http://en.wikipedia.org/wiki/Conjugate_gradient_method>) for numerically
+solving the systems of linear equations.
+
+It should be noted, that this method, although deterministic, is rather a
+heuristic method and therefore may converge to a local minima, not necessary a
+global one. What is even more disastrous, most of its behaviour is ruled by
+gradient, therefore it essentially cannot distinguish between local minima and
+maxima. Therefore, if it starts sufficiently near to the local maximum, it may
+converge to it. Another obvious restriction is that it should be possible to
+compute the gradient of a function at any point, thus it is preferable to have
+analytic expression for gradient and computational burden should be born by the
+user.
+
+The latter responsibility is accomplished via the getGradient method of a
+MinProblemSolver::Function interface (which represents function being
+optimized). This method takes point a point in *n*-dimensional space (first
+argument represents the array of coordinates of that point) and compute its
+gradient (it should be stored in the second argument as an array).
+
+@note class ConjGradSolver thus does not add any new methods to the basic
+MinProblemSolver interface.
+
+@note term criteria should meet following condition:
+@code
+    termcrit.type == (TermCriteria::MAX_ITER + TermCriteria::EPS) &&
+termcrit.epsilon > 0 && termcrit.maxCount > 0
+    // or
+    termcrit.type == TermCriteria::MAX_ITER) && termcrit.maxCount > 0
+@endcode
+ */
+class CV_EXPORTS ConjGradSolver : public MinProblemSolver {
+public:
+  /** @brief This function returns the reference to the ready-to-use
+  ConjGradSolver object.
+
+  All the parameters are optional, so this procedure can be called even without
+  parameters at all. In this case, the default values will be used. As default
+  value for terminal criteria are the only sensible ones,
+  MinProblemSolver::setFunction() should be called upon the obtained object, if
+  the function was not given to create(). Otherwise, the two ways (submit it to
+  create() or miss it out and call the MinProblemSolver::setFunction()) are
+  absolutely equivalent (and will drop the same errors in the same way, should
+  invalid input be detected).
+  @param f Pointer to the function that will be minimized, similarly to the one
+  you submit via MinProblemSolver::setFunction.
+  @param termcrit Terminal criteria to the algorithm, similarly to the one you
+  submit via MinProblemSolver::setTermCriteria.
+  */
+  static Ptr<ConjGradSolver>
+  create(const Ptr<MinProblemSolver::Function> &f =
+             Ptr<ConjGradSolver::Function>(),
+         TermCriteria termcrit = TermCriteria(TermCriteria::MAX_ITER +
+                                                  TermCriteria::EPS,
+                                              5000, 0.000001));
+};
+
+//! return codes for cv::solveLP() function
+enum SolveLPResult {
+  SOLVELP_LOST = -3, //!< problem is feasible, but solver lost solution due to
+                     //!< floating-point arithmetic errors
+  SOLVELP_UNBOUNDED = -2, //!< problem is unbounded (target function can achieve
+                          //!< arbitrary high values)
+  SOLVELP_UNFEASIBLE = -1, //!< problem is unfeasible (there are no points that
+                           //!< satisfy all the constraints imposed)
+  SOLVELP_SINGLE = 0,      //!< there is only one maximum for target function
+  SOLVELP_MULTI = 1 //!< there are multiple maxima for target function - the
+                    //!< arbitrary one is returned
+};
+
+/** @brief Solve given (non-integer) linear programming problem using the
+Simplex Algorithm (Simplex Method).
+
+What we mean here by "linear programming problem" (or LP problem, for short) can
+be formulated as:
+
+\f[\mbox{Maximize } c\cdot x\\
+ \mbox{Subject to:}\\
+ Ax\leq b\\
+ x\geq 0\f]
+
+Where \f$c\f$ is fixed `1`-by-`n` row-vector, \f$A\f$ is fixed `m`-by-`n`
+matrix, \f$b\f$ is fixed `m`-by-`1` column vector and \f$x\f$ is an arbitrary
+`n`-by-`1` column vector, which satisfies the constraints.
+
+Simplex algorithm is one of many algorithms that are designed to handle this
+sort of problems efficiently. Although it is not optimal in theoretical sense
+(there exist algorithms that can solve any problem written as above in
+polynomial time, while simplex method degenerates to exponential time for some
+special cases), it is well-studied, easy to implement and is shown to work well
+for real-life purposes.
+
+The particular implementation is taken almost verbatim from **Introduction to
+Algorithms, third edition** by T. H. Cormen, C. E. Leiserson, R. L. Rivest and
+Clifford Stein. In particular, the Bland's rule
+<http://en.wikipedia.org/wiki/Bland%27s_rule> is used to prevent cycling.
+
+@param Func This row-vector corresponds to \f$c\f$ in the LP problem formulation
+(see above). It should contain 32- or 64-bit floating point numbers. As a
+convenience, column-vector may be also submitted, in the latter case it is
+understood to correspond to \f$c^T\f$.
+@param Constr `m`-by-`n+1` matrix, whose rightmost column corresponds to \f$b\f$
+in formulation above and the remaining to \f$A\f$. It should contain 32- or
+64-bit floating point numbers.
+@param z The solution will be returned here as a column-vector - it corresponds
+to \f$c\f$ in the formulation above. It will contain 64-bit floating point
+numbers.
+@param constr_eps allowed numeric disparity for constraints
+@return One of cv::SolveLPResult
+ */
+CV_EXPORTS_W int solveLP(InputArray Func, InputArray Constr, OutputArray z,
+                         double constr_eps);
+
+/** @overload */
+CV_EXPORTS_W int solveLP(InputArray Func, InputArray Constr, OutputArray z);
+
+//! @}
+
+} // namespace cv
+
+#endif

package/third-party/include/opencv2/core/parallel/backend/parallel_for.openmp.hpp

@@ -0,0 +1,66 @@
+// 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_PARALLEL_FOR_OPENMP_HPP
+#define OPENCV_CORE_PARALLEL_FOR_OPENMP_HPP
+
+#include "opencv2/core/parallel/parallel_backend.hpp"
+
+#if !defined(_OPENMP) && !defined(OPENCV_SKIP_OPENMP_PRESENSE_CHECK)
+#error "This file must be compiled with enabled OpenMP"
+#endif
+
+#include <omp.h>
+
+namespace cv {
+namespace parallel {
+namespace openmp {
+
+/** OpenMP parallel_for API implementation
+ *
+ * @sa setParallelForBackend
+ * @ingroup core_parallel_backend
+ */
+class ParallelForBackend : public ParallelForAPI {
+protected:
+  int numThreads;
+  int numThreadsMax;
+
+public:
+  ParallelForBackend() {
+    numThreads = 0;
+    numThreadsMax = omp_get_max_threads();
+  }
+
+  virtual ~ParallelForBackend() {}
+
+  virtual void parallel_for(int tasks, FN_parallel_for_body_cb_t body_callback,
+                            void *callback_data) CV_OVERRIDE {
+#pragma omp parallel for schedule(dynamic)                                     \
+    num_threads(numThreads > 0 ? numThreads : numThreadsMax)
+    for (int i = 0; i < tasks; ++i)
+      body_callback(i, i + 1, callback_data);
+  }
+
+  virtual int getThreadNum() const CV_OVERRIDE { return omp_get_thread_num(); }
+
+  virtual int getNumThreads() const CV_OVERRIDE {
+    return numThreads > 0 ? numThreads : numThreadsMax;
+  }
+
+  virtual int setNumThreads(int nThreads) CV_OVERRIDE {
+    int oldNumThreads = numThreads;
+    numThreads = nThreads;
+    // nothing needed as numThreads is used in #pragma omp parallel for directly
+    return oldNumThreads;
+  }
+
+  const char *getName() const CV_OVERRIDE { return "openmp"; }
+};
+
+} // namespace openmp
+} // namespace parallel
+} // namespace cv
+
+#endif // OPENCV_CORE_PARALLEL_FOR_OPENMP_HPP

package/third-party/include/opencv2/core/parallel/backend/parallel_for.tbb.hpp

@@ -0,0 +1,148 @@
+// 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_PARALLEL_FOR_TBB_HPP
+#define OPENCV_CORE_PARALLEL_FOR_TBB_HPP
+
+#include "opencv2/core/parallel/parallel_backend.hpp"
+#include <opencv2/core/utils/logger.hpp>
+
+#ifndef TBB_SUPPRESS_DEPRECATED_MESSAGES // supress warning
+#define TBB_SUPPRESS_DEPRECATED_MESSAGES 1
+#endif
+#include "tbb/tbb.h"
+#if !defined(TBB_INTERFACE_VERSION)
+#error "Unknows/unsupported TBB version"
+#endif
+
+#if TBB_INTERFACE_VERSION >= 8000
+#include "tbb/task_arena.h"
+#endif
+
+namespace cv {
+namespace parallel {
+namespace tbb {
+
+using namespace ::tbb;
+
+#if TBB_INTERFACE_VERSION >= 8000
+static tbb::task_arena &getArena() {
+  static tbb::task_arena tbbArena(tbb::task_arena::automatic);
+  return tbbArena;
+}
+#else
+static tbb::task_scheduler_init &getScheduler() {
+  static tbb::task_scheduler_init tbbScheduler(
+      tbb::task_scheduler_init::deferred);
+  return tbbScheduler;
+}
+#endif
+
+/** TBB parallel_for API implementation
+ *
+ * @sa setParallelForBackend
+ * @ingroup core_parallel_backend
+ */
+class ParallelForBackend : public ParallelForAPI {
+protected:
+  int numThreads;
+  int numThreadsMax;
+
+public:
+  ParallelForBackend() {
+    CV_LOG_INFO(NULL,
+                "Initializing TBB parallel backend: TBB_INTERFACE_VERSION="
+                    << TBB_INTERFACE_VERSION);
+    numThreads = 0;
+#if TBB_INTERFACE_VERSION >= 8000
+    (void)getArena();
+#else
+    (void)getScheduler();
+#endif
+  }
+
+  virtual ~ParallelForBackend() {}
+
+  class CallbackProxy {
+    const FN_parallel_for_body_cb_t &callback;
+    void *const callback_data;
+    const int tasks;
+
+  public:
+    inline CallbackProxy(int tasks_, FN_parallel_for_body_cb_t &callback_,
+                         void *callback_data_)
+        : callback(callback_), callback_data(callback_data_), tasks(tasks_) {
+      // nothing
+    }
+
+    void operator()(const tbb::blocked_range<int> &range) const {
+      this->callback(range.begin(), range.end(), callback_data);
+    }
+
+    void operator()() const {
+      tbb::parallel_for(tbb::blocked_range<int>(0, tasks), *this);
+    }
+  };
+
+  virtual void parallel_for(int tasks, FN_parallel_for_body_cb_t body_callback,
+                            void *callback_data) CV_OVERRIDE {
+    CallbackProxy task(tasks, body_callback, callback_data);
+#if TBB_INTERFACE_VERSION >= 8000
+    getArena().execute(task);
+#else
+    task();
+#endif
+  }
+
+  virtual int getThreadNum() const CV_OVERRIDE {
+#if TBB_INTERFACE_VERSION >= 9100
+    return tbb::this_task_arena::current_thread_index();
+#elif TBB_INTERFACE_VERSION >= 8000
+    return tbb::task_arena::current_thread_index();
+#else
+    return 0;
+#endif
+  }
+
+  virtual int getNumThreads() const CV_OVERRIDE {
+#if TBB_INTERFACE_VERSION >= 9100
+    return getArena().max_concurrency();
+#elif TBB_INTERFACE_VERSION >= 8000
+    return numThreads > 0 ? numThreads
+                          : tbb::task_scheduler_init::default_num_threads();
+#else
+    return getScheduler().is_active()
+               ? numThreads
+               : tbb::task_scheduler_init::default_num_threads();
+#endif
+  }
+
+  virtual int setNumThreads(int nThreads) CV_OVERRIDE {
+    int oldNumThreads = numThreads;
+    numThreads = nThreads;
+
+#if TBB_INTERFACE_VERSION >= 8000
+    auto &tbbArena = getArena();
+    if (tbbArena.is_active())
+      tbbArena.terminate();
+    if (numThreads > 0)
+      tbbArena.initialize(numThreads);
+#else
+    auto &tbbScheduler = getScheduler();
+    if (tbbScheduler.is_active())
+      tbbScheduler.terminate();
+    if (numThreads > 0)
+      tbbScheduler.initialize(numThreads);
+#endif
+    return oldNumThreads;
+  }
+
+  const char *getName() const CV_OVERRIDE { return "tbb"; }
+};
+
+} // namespace tbb
+} // namespace parallel
+} // namespace cv
+
+#endif // OPENCV_CORE_PARALLEL_FOR_TBB_HPP

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

@@ -0,0 +1,108 @@
+// 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_PARALLEL_BACKEND_HPP
+#define OPENCV_CORE_PARALLEL_BACKEND_HPP
+
+#include "opencv2/core/cvdef.h"
+#include <memory>
+
+namespace cv {
+namespace parallel {
+#ifndef CV_API_CALL
+#define CV_API_CALL
+#endif
+
+/** @addtogroup core_parallel_backend
+ * @{
+ * API below is provided to resolve problem of CPU resource over-subscription by
+ * multiple thread pools from different multi-threading frameworks. This is
+ * common problem for cases when OpenCV compiled threading framework is
+ * different from the Users Applications framework.
+ *
+ * Applications can replace OpenCV `parallel_for()` backend with own
+ * implementation (to reuse Application's thread pool).
+ *
+ *
+ * ### Backend API usage examples
+ *
+ * #### Intel TBB
+ *
+ * - include header with simple implementation of TBB backend:
+ *   @snippet parallel_backend/example-tbb.cpp tbb_include
+ * - execute backend replacement code:
+ *   @snippet parallel_backend/example-tbb.cpp tbb_backend
+ * - configuration of compiler/linker options is responsibility of Application's
+ * scripts
+ *
+ * #### OpenMP
+ *
+ * - include header with simple implementation of OpenMP backend:
+ *   @snippet parallel_backend/example-openmp.cpp openmp_include
+ * - execute backend replacement code:
+ *   @snippet parallel_backend/example-openmp.cpp openmp_backend
+ * - Configuration of compiler/linker options is responsibility of Application's
+ * scripts
+ *
+ *
+ * ### Plugins support
+ *
+ * Runtime configuration options:
+ * - change backend priority: `OPENCV_PARALLEL_PRIORITY_<backend>=9999`
+ * - disable backend: `OPENCV_PARALLEL_PRIORITY_<backend>=0`
+ * - specify list of backends with high priority (>100000):
+ * `OPENCV_PARALLEL_PRIORITY_LIST=TBB,OPENMP`. Unknown backends are registered
+ * as new plugins.
+ *
+ */
+
+/** Interface for parallel_for backends implementations
+ *
+ * @sa setParallelForBackend
+ */
+class CV_EXPORTS ParallelForAPI {
+public:
+  virtual ~ParallelForAPI();
+
+  typedef void(CV_API_CALL *FN_parallel_for_body_cb_t)(int start, int end,
+                                                       void *data);
+
+  virtual void parallel_for(int tasks, FN_parallel_for_body_cb_t body_callback,
+                            void *callback_data) = 0;
+
+  virtual int getThreadNum() const = 0;
+
+  virtual int getNumThreads() const = 0;
+
+  virtual int setNumThreads(int nThreads) = 0;
+
+  virtual const char *getName() const = 0;
+};
+
+/** @brief Replace OpenCV parallel_for backend
+ *
+ * Application can replace OpenCV `parallel_for()` backend with own
+ * implementation.
+ *
+ * @note This call is not thread-safe. Consider calling this function from the
+ * `main()` before any other OpenCV processing functions (and without any other
+ * created threads).
+ */
+CV_EXPORTS void
+setParallelForBackend(const std::shared_ptr<ParallelForAPI> &api,
+                      bool propagateNumThreads = true);
+
+/** @brief Change OpenCV parallel_for backend
+ *
+ * @note This call is not thread-safe. Consider calling this function from the
+ * `main()` before any other OpenCV processing functions (and without any other
+ * created threads).
+ */
+CV_EXPORTS_W bool setParallelForBackend(const std::string &backendName,
+                                        bool propagateNumThreads = true);
+
+//! @}
+} // namespace parallel
+} // namespace cv
+#endif // OPENCV_CORE_PARALLEL_BACKEND_HPP