|
|
|
|
@@ -0,0 +1,459 @@
|
|
|
|
|
/*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_UTILITY_H__
|
|
|
|
|
#define __OPENCV_CORE_UTILITY_H__
|
|
|
|
|
|
|
|
|
|
#include "opencv2/core.hpp"
|
|
|
|
|
|
|
|
|
|
namespace cv
|
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
Automatically Allocated Buffer Class
|
|
|
|
|
|
|
|
|
|
The class is used for temporary buffers in functions and methods.
|
|
|
|
|
If a temporary buffer is usually small (a few K's of memory),
|
|
|
|
|
but its size depends on the parameters, it makes sense to create a small
|
|
|
|
|
fixed-size array on stack and use it if it's large enough. If the required buffer size
|
|
|
|
|
is larger than the fixed size, another buffer of sufficient size is allocated dynamically
|
|
|
|
|
and released after the processing. Therefore, in typical cases, when the buffer size is small,
|
|
|
|
|
there is no overhead associated with malloc()/free().
|
|
|
|
|
At the same time, there is no limit on the size of processed data.
|
|
|
|
|
|
|
|
|
|
This is what AutoBuffer does. The template takes 2 parameters - type of the buffer elements and
|
|
|
|
|
the number of stack-allocated elements. Here is how the class is used:
|
|
|
|
|
|
|
|
|
|
\code
|
|
|
|
|
void my_func(const cv::Mat& m)
|
|
|
|
|
{
|
|
|
|
|
cv::AutoBuffer<float> buf; // create automatic buffer containing 1000 floats
|
|
|
|
|
|
|
|
|
|
buf.allocate(m.rows); // if m.rows <= 1000, the pre-allocated buffer is used,
|
|
|
|
|
// otherwise the buffer of "m.rows" floats will be allocated
|
|
|
|
|
// dynamically and deallocated in cv::AutoBuffer destructor
|
|
|
|
|
...
|
|
|
|
|
}
|
|
|
|
|
\endcode
|
|
|
|
|
*/
|
|
|
|
|
template<typename _Tp, size_t fixed_size = 1024/sizeof(_Tp)+8> class CV_EXPORTS AutoBuffer
|
|
|
|
|
{
|
|
|
|
|
public:
|
|
|
|
|
typedef _Tp value_type;
|
|
|
|
|
|
|
|
|
|
//! the default contructor
|
|
|
|
|
AutoBuffer();
|
|
|
|
|
//! constructor taking the real buffer size
|
|
|
|
|
AutoBuffer(size_t _size);
|
|
|
|
|
|
|
|
|
|
//! the copy constructor
|
|
|
|
|
AutoBuffer(const AutoBuffer<_Tp, fixed_size>& buf);
|
|
|
|
|
//! the assignment operator
|
|
|
|
|
AutoBuffer<_Tp, fixed_size>& operator = (const AutoBuffer<_Tp, fixed_size>& buf);
|
|
|
|
|
|
|
|
|
|
//! destructor. calls deallocate()
|
|
|
|
|
~AutoBuffer();
|
|
|
|
|
|
|
|
|
|
//! allocates the new buffer of size _size. if the _size is small enough, stack-allocated buffer is used
|
|
|
|
|
void allocate(size_t _size);
|
|
|
|
|
//! deallocates the buffer if it was dynamically allocated
|
|
|
|
|
void deallocate();
|
|
|
|
|
//! resizes the buffer and preserves the content
|
|
|
|
|
void resize(size_t _size);
|
|
|
|
|
//! returns the current buffer size
|
|
|
|
|
size_t size() const;
|
|
|
|
|
//! returns pointer to the real buffer, stack-allocated or head-allocated
|
|
|
|
|
operator _Tp* ();
|
|
|
|
|
//! returns read-only pointer to the real buffer, stack-allocated or head-allocated
|
|
|
|
|
operator const _Tp* () const;
|
|
|
|
|
|
|
|
|
|
protected:
|
|
|
|
|
//! pointer to the real buffer, can point to buf if the buffer is small enough
|
|
|
|
|
_Tp* ptr;
|
|
|
|
|
//! size of the real buffer
|
|
|
|
|
size_t sz;
|
|
|
|
|
//! pre-allocated buffer
|
|
|
|
|
_Tp buf[fixed_size];
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
//! Sets/resets the break-on-error mode.
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
When the break-on-error mode is set, the default error handler
|
|
|
|
|
issues a hardware exception, which can make debugging more convenient.
|
|
|
|
|
|
|
|
|
|
\return the previous state
|
|
|
|
|
*/
|
|
|
|
|
CV_EXPORTS bool setBreakOnError(bool flag);
|
|
|
|
|
|
|
|
|
|
typedef int (CV_CDECL *ErrorCallback)( int status, const char* func_name,
|
|
|
|
|
const char* err_msg, const char* file_name,
|
|
|
|
|
int line, void* userdata );
|
|
|
|
|
|
|
|
|
|
//! Sets the new error handler and the optional user data.
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
The function sets the new error handler, called from cv::error().
|
|
|
|
|
|
|
|
|
|
\param errCallback the new error handler. If NULL, the default error handler is used.
|
|
|
|
|
\param userdata the optional user data pointer, passed to the callback.
|
|
|
|
|
\param prevUserdata the optional output parameter where the previous user data pointer is stored
|
|
|
|
|
|
|
|
|
|
\return the previous error handler
|
|
|
|
|
*/
|
|
|
|
|
CV_EXPORTS ErrorCallback redirectError( ErrorCallback errCallback, void* userdata=0, void** prevUserdata=0);
|
|
|
|
|
|
|
|
|
|
CV_EXPORTS std::string format( const char* fmt, ... );
|
|
|
|
|
CV_EXPORTS std::string tempfile( const char* suffix CV_DEFAULT(0));
|
|
|
|
|
CV_EXPORTS void glob(std::string pattern, std::vector<std::string>& result, bool recursive = false);
|
|
|
|
|
CV_EXPORTS void setNumThreads(int nthreads);
|
|
|
|
|
CV_EXPORTS int getNumThreads();
|
|
|
|
|
CV_EXPORTS int getThreadNum();
|
|
|
|
|
|
|
|
|
|
CV_EXPORTS_W const std::string& getBuildInformation();
|
|
|
|
|
|
|
|
|
|
//! Returns the number of ticks.
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
The function returns the number of ticks since the certain event (e.g. when the machine was turned on).
|
|
|
|
|
It can be used to initialize cv::RNG or to measure a function execution time by reading the tick count
|
|
|
|
|
before and after the function call. The granularity of ticks depends on the hardware and OS used. Use
|
|
|
|
|
cv::getTickFrequency() to convert ticks to seconds.
|
|
|
|
|
*/
|
|
|
|
|
CV_EXPORTS_W int64 getTickCount();
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
Returns the number of ticks per seconds.
|
|
|
|
|
|
|
|
|
|
The function returns the number of ticks (as returned by cv::getTickCount()) per second.
|
|
|
|
|
The following code computes the execution time in milliseconds:
|
|
|
|
|
|
|
|
|
|
\code
|
|
|
|
|
double exec_time = (double)getTickCount();
|
|
|
|
|
// do something ...
|
|
|
|
|
exec_time = ((double)getTickCount() - exec_time)*1000./getTickFrequency();
|
|
|
|
|
\endcode
|
|
|
|
|
*/
|
|
|
|
|
CV_EXPORTS_W double getTickFrequency();
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
Returns the number of CPU ticks.
|
|
|
|
|
|
|
|
|
|
On platforms where the feature is available, the function returns the number of CPU ticks
|
|
|
|
|
since the certain event (normally, the system power-on moment). Using this function
|
|
|
|
|
one can accurately measure the execution time of very small code fragments,
|
|
|
|
|
for which cv::getTickCount() granularity is not enough.
|
|
|
|
|
*/
|
|
|
|
|
CV_EXPORTS_W int64 getCPUTickCount();
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
Returns SSE etc. support status
|
|
|
|
|
|
|
|
|
|
The function returns true if certain hardware features are available.
|
|
|
|
|
Currently, the following features are recognized:
|
|
|
|
|
- CV_CPU_MMX - MMX
|
|
|
|
|
- CV_CPU_SSE - SSE
|
|
|
|
|
- CV_CPU_SSE2 - SSE 2
|
|
|
|
|
- CV_CPU_SSE3 - SSE 3
|
|
|
|
|
- CV_CPU_SSSE3 - SSSE 3
|
|
|
|
|
- CV_CPU_SSE4_1 - SSE 4.1
|
|
|
|
|
- CV_CPU_SSE4_2 - SSE 4.2
|
|
|
|
|
- CV_CPU_POPCNT - POPCOUNT
|
|
|
|
|
- CV_CPU_AVX - AVX
|
|
|
|
|
|
|
|
|
|
\note {Note that the function output is not static. Once you called cv::useOptimized(false),
|
|
|
|
|
most of the hardware acceleration is disabled and thus the function will returns false,
|
|
|
|
|
until you call cv::useOptimized(true)}
|
|
|
|
|
*/
|
|
|
|
|
CV_EXPORTS_W bool checkHardwareSupport(int feature);
|
|
|
|
|
|
|
|
|
|
//! returns the number of CPUs (including hyper-threading)
|
|
|
|
|
CV_EXPORTS_W int getNumberOfCPUs();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
Aligns pointer by the certain number of bytes
|
|
|
|
|
|
|
|
|
|
This small inline function aligns the pointer by the certian number of bytes by shifting
|
|
|
|
|
it forward by 0 or a positive offset.
|
|
|
|
|
*/
|
|
|
|
|
template<typename _Tp> static inline _Tp* alignPtr(_Tp* ptr, int n=(int)sizeof(_Tp))
|
|
|
|
|
{
|
|
|
|
|
return (_Tp*)(((size_t)ptr + n-1) & -n);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
Aligns buffer size by the certain number of bytes
|
|
|
|
|
|
|
|
|
|
This small inline function aligns a buffer size by the certian number of bytes by enlarging it.
|
|
|
|
|
*/
|
|
|
|
|
static inline size_t alignSize(size_t sz, int n)
|
|
|
|
|
{
|
|
|
|
|
return (sz + n-1) & -n;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
Turns on/off available optimization
|
|
|
|
|
|
|
|
|
|
The function turns on or off the optimized code in OpenCV. Some optimization can not be enabled
|
|
|
|
|
or disabled, but, for example, most of SSE code in OpenCV can be temporarily turned on or off this way.
|
|
|
|
|
|
|
|
|
|
\note{Since optimization may imply using special data structures, it may be unsafe
|
|
|
|
|
to call this function anywhere in the code. Instead, call it somewhere at the top level.}
|
|
|
|
|
*/
|
|
|
|
|
CV_EXPORTS_W void setUseOptimized(bool onoff);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
Returns the current optimization status
|
|
|
|
|
|
|
|
|
|
The function returns the current optimization status, which is controlled by cv::setUseOptimized().
|
|
|
|
|
*/
|
|
|
|
|
CV_EXPORTS_W bool useOptimized();
|
|
|
|
|
|
|
|
|
|
static inline size_t getElemSize(int type) { return CV_ELEM_SIZE(type); }
|
|
|
|
|
|
|
|
|
|
/////////////////////////////// Parallel Primitives //////////////////////////////////
|
|
|
|
|
|
|
|
|
|
// a base body class
|
|
|
|
|
class CV_EXPORTS ParallelLoopBody
|
|
|
|
|
{
|
|
|
|
|
public:
|
|
|
|
|
virtual ~ParallelLoopBody();
|
|
|
|
|
virtual void operator() (const Range& range) const = 0;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
CV_EXPORTS void parallel_for_(const Range& range, const ParallelLoopBody& body, double nstripes=-1.);
|
|
|
|
|
|
|
|
|
|
/////////////////////////// Synchronization Primitives ///////////////////////////////
|
|
|
|
|
|
|
|
|
|
class CV_EXPORTS Mutex
|
|
|
|
|
{
|
|
|
|
|
public:
|
|
|
|
|
Mutex();
|
|
|
|
|
~Mutex();
|
|
|
|
|
Mutex(const Mutex& m);
|
|
|
|
|
Mutex& operator = (const Mutex& m);
|
|
|
|
|
|
|
|
|
|
void lock();
|
|
|
|
|
bool trylock();
|
|
|
|
|
void unlock();
|
|
|
|
|
|
|
|
|
|
struct Impl;
|
|
|
|
|
protected:
|
|
|
|
|
Impl* impl;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
class CV_EXPORTS AutoLock
|
|
|
|
|
{
|
|
|
|
|
public:
|
|
|
|
|
AutoLock(Mutex& m) : mutex(&m) { mutex->lock(); }
|
|
|
|
|
~AutoLock() { mutex->unlock(); }
|
|
|
|
|
protected:
|
|
|
|
|
Mutex* mutex;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// The CommandLineParser class is designed for command line arguments parsing
|
|
|
|
|
|
|
|
|
|
class CV_EXPORTS CommandLineParser
|
|
|
|
|
{
|
|
|
|
|
public:
|
|
|
|
|
CommandLineParser(int argc, const char* const argv[], const std::string& keys);
|
|
|
|
|
CommandLineParser(const CommandLineParser& parser);
|
|
|
|
|
CommandLineParser& operator = (const CommandLineParser& parser);
|
|
|
|
|
|
|
|
|
|
std::string getPathToApplication() const;
|
|
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
|
T get(const std::string& name, bool space_delete = true) const
|
|
|
|
|
{
|
|
|
|
|
T val = T();
|
|
|
|
|
getByName(name, space_delete, ParamType<T>::type, (void*)&val);
|
|
|
|
|
return val;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
|
T get(int index, bool space_delete = true) const
|
|
|
|
|
{
|
|
|
|
|
T val = T();
|
|
|
|
|
getByIndex(index, space_delete, ParamType<T>::type, (void*)&val);
|
|
|
|
|
return val;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool has(const std::string& name) const;
|
|
|
|
|
|
|
|
|
|
bool check() const;
|
|
|
|
|
|
|
|
|
|
void about(const std::string& message);
|
|
|
|
|
|
|
|
|
|
void printMessage() const;
|
|
|
|
|
void printErrors() const;
|
|
|
|
|
|
|
|
|
|
protected:
|
|
|
|
|
void getByName(const std::string& name, bool space_delete, int type, void* dst) const;
|
|
|
|
|
void getByIndex(int index, bool space_delete, int type, void* dst) const;
|
|
|
|
|
|
|
|
|
|
struct Impl;
|
|
|
|
|
Impl* impl;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/////////////////////////////// AutoBuffer implementation ////////////////////////////////////////
|
|
|
|
|
|
|
|
|
|
template<typename _Tp, size_t fixed_size> inline
|
|
|
|
|
AutoBuffer<_Tp, fixed_size>::AutoBuffer()
|
|
|
|
|
{
|
|
|
|
|
ptr = buf;
|
|
|
|
|
sz = fixed_size;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template<typename _Tp, size_t fixed_size> inline
|
|
|
|
|
AutoBuffer<_Tp, fixed_size>::AutoBuffer(size_t _size)
|
|
|
|
|
{
|
|
|
|
|
ptr = buf;
|
|
|
|
|
sz = fixed_size;
|
|
|
|
|
allocate(_size);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template<typename _Tp, size_t fixed_size> inline
|
|
|
|
|
AutoBuffer<_Tp, fixed_size>::AutoBuffer(const AutoBuffer<_Tp, fixed_size>& abuf )
|
|
|
|
|
{
|
|
|
|
|
ptr = buf;
|
|
|
|
|
sz = fixed_size;
|
|
|
|
|
allocate(abuf.size);
|
|
|
|
|
for( size_t i = 0; i < sz; i++ )
|
|
|
|
|
ptr[i] = abuf.ptr[i];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template<typename _Tp, size_t fixed_size> inline AutoBuffer<_Tp, fixed_size>&
|
|
|
|
|
AutoBuffer<_Tp, fixed_size>::operator = (const AutoBuffer<_Tp, fixed_size>& abuf)
|
|
|
|
|
{
|
|
|
|
|
if( this != &abuf )
|
|
|
|
|
{
|
|
|
|
|
deallocate();
|
|
|
|
|
allocate(abuf.size);
|
|
|
|
|
for( size_t i = 0; i < sz; i++ )
|
|
|
|
|
ptr[i] = abuf.ptr[i];
|
|
|
|
|
}
|
|
|
|
|
return *this;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template<typename _Tp, size_t fixed_size> inline
|
|
|
|
|
AutoBuffer<_Tp, fixed_size>::~AutoBuffer()
|
|
|
|
|
{ deallocate(); }
|
|
|
|
|
|
|
|
|
|
template<typename _Tp, size_t fixed_size> inline void
|
|
|
|
|
AutoBuffer<_Tp, fixed_size>::allocate(size_t _size)
|
|
|
|
|
{
|
|
|
|
|
if(_size <= sz)
|
|
|
|
|
{
|
|
|
|
|
sz = _size;
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
deallocate();
|
|
|
|
|
if(_size > fixed_size)
|
|
|
|
|
{
|
|
|
|
|
ptr = new _Tp[_size];
|
|
|
|
|
sz = _size;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template<typename _Tp, size_t fixed_size> inline void
|
|
|
|
|
AutoBuffer<_Tp, fixed_size>::deallocate()
|
|
|
|
|
{
|
|
|
|
|
if( ptr != buf )
|
|
|
|
|
{
|
|
|
|
|
delete[] ptr;
|
|
|
|
|
ptr = buf;
|
|
|
|
|
sz = fixed_size;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template<typename _Tp, size_t fixed_size> inline void
|
|
|
|
|
AutoBuffer<_Tp, fixed_size>::resize(size_t _size)
|
|
|
|
|
{
|
|
|
|
|
if(_size <= sz)
|
|
|
|
|
{
|
|
|
|
|
sz = _size;
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
size_t i, prevsize = sz, minsize = MIN(prevsize, _size);
|
|
|
|
|
_Tp* prevptr = ptr;
|
|
|
|
|
|
|
|
|
|
ptr = _size > fixed_size ? new _Tp[_size] : buf;
|
|
|
|
|
sz = _size;
|
|
|
|
|
|
|
|
|
|
if( ptr != prevptr )
|
|
|
|
|
for( i = 0; i < minsize; i++ )
|
|
|
|
|
ptr[i] = prevptr[i];
|
|
|
|
|
for( i = prevsize; i < _size; i++ )
|
|
|
|
|
ptr[i] = _Tp();
|
|
|
|
|
|
|
|
|
|
if( prevptr != buf )
|
|
|
|
|
delete[] prevptr;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template<typename _Tp, size_t fixed_size> inline size_t
|
|
|
|
|
AutoBuffer<_Tp, fixed_size>::size() const
|
|
|
|
|
{ return sz; }
|
|
|
|
|
|
|
|
|
|
template<typename _Tp, size_t fixed_size> inline
|
|
|
|
|
AutoBuffer<_Tp, fixed_size>::operator _Tp* ()
|
|
|
|
|
{ return ptr; }
|
|
|
|
|
|
|
|
|
|
template<typename _Tp, size_t fixed_size> inline
|
|
|
|
|
AutoBuffer<_Tp, fixed_size>::operator const _Tp* () const
|
|
|
|
|
{ return ptr; }
|
|
|
|
|
|
|
|
|
|
// TODO: move them to core_c.h
|
|
|
|
|
//! converts array (CvMat or IplImage) to cv::Mat
|
|
|
|
|
CV_EXPORTS Mat cvarrToMat(const CvArr* arr, bool copyData=false,
|
|
|
|
|
bool allowND=true, int coiMode=0,
|
|
|
|
|
AutoBuffer<double>* buf=0);
|
|
|
|
|
|
|
|
|
|
static inline Mat cvarrToMatND(const CvArr* arr, bool copyData=false, int coiMode=0)
|
|
|
|
|
{
|
|
|
|
|
return cvarrToMat(arr, copyData, true, coiMode);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
} //namespace cv
|
|
|
|
|
|
|
|
|
|
#endif //__OPENCV_CORE_UTILITY_H__
|
Andrey Kamaev