node-native-win-utils 1.4.0 → 2.1.1

package/include/opencv2/core/optim.hpp

@@ -1,302 +0,0 @@
-/*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_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.
-@return One of cv::SolveLPResult
- */
-CV_EXPORTS_W int solveLP(InputArray Func, InputArray Constr, OutputArray z);
-
-//! @}
-
-}// cv
-
-#endif

package/include/opencv2/core/ovx.hpp

@@ -1,28 +0,0 @@
-// 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) 2016, Intel Corporation, all rights reserved.
-// Third party copyrights are property of their respective owners.
-
-// OpenVX related definitions and declarations
-
-#pragma once
-#ifndef OPENCV_OVX_HPP
-#define OPENCV_OVX_HPP
-
-#include "cvdef.h"
-
-namespace cv
-{
-/// Check if use of OpenVX is possible
-CV_EXPORTS_W bool haveOpenVX();
-
-/// Check if use of OpenVX is enabled
-CV_EXPORTS_W bool useOpenVX();
-
-/// Enable/disable use of OpenVX
-CV_EXPORTS_W void setUseOpenVX(bool flag);
-} // namespace cv
-
-#endif // OPENCV_OVX_HPP

package/include/opencv2/core/parallel/backend/parallel_for.openmp.hpp

@@ -1,72 +0,0 @@
-// 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
-
-#endif  // OPENCV_CORE_PARALLEL_FOR_OPENMP_HPP

package/include/opencv2/core/parallel/backend/parallel_for.tbb.hpp

@@ -1,153 +0,0 @@
-// 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
-
-#endif  // OPENCV_CORE_PARALLEL_FOR_TBB_HPP

package/include/opencv2/core/parallel/parallel_backend.hpp

@@ -1,90 +0,0 @@
-// 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
-#endif  // OPENCV_CORE_PARALLEL_BACKEND_HPP