#define CV_CPU_NEON 11
#define CV_HARDWARE_MAX_FEATURE 255
+// disable SSE/AVX/NEON headers for NVCC compiler
+#ifndef __CUDACC__
+
#if defined __SSE2__ || defined _M_X64 || (defined _M_IX86_FP && _M_IX86_FP >= 2)
# include <emmintrin.h>
# define CV_SSE 1
# define CV_NEON 1
#endif
+#endif // __CUDACC__
+
#ifndef CV_SSE
# define CV_SSE 0
#endif
CV_INLINE int cvRound( double value )
{
-#if (defined _MSC_VER && defined _M_X64) || (defined __GNUC__ && defined __x86_64__ && defined __SSE2__ && !defined __APPLE__)
+#if ((defined _MSC_VER && defined _M_X64) || (defined __GNUC__ && defined __x86_64__ && defined __SSE2__ && !defined __APPLE__)) && !defined(__CUDACC__)
__m128d t = _mm_set_sd( value );
return _mm_cvtsd_si32(t);
#elif defined _MSC_VER && defined _M_IX86
CV_INLINE int cvFloor( double value )
{
-#if defined _MSC_VER && defined _M_X64 || (defined __GNUC__ && defined __SSE2__ && !defined __APPLE__)
+#if (defined _MSC_VER && defined _M_X64 || (defined __GNUC__ && defined __SSE2__ && !defined __APPLE__)) && !defined(__CUDACC__)
__m128d t = _mm_set_sd( value );
int i = _mm_cvtsd_si32(t);
return i - _mm_movemask_pd(_mm_cmplt_sd(t, _mm_cvtsi32_sd(t,i)));
CV_INLINE int cvCeil( double value )
{
-#if defined _MSC_VER && defined _M_X64 || (defined __GNUC__ && defined __SSE2__&& !defined __APPLE__)
+#if (defined _MSC_VER && defined _M_X64 || (defined __GNUC__ && defined __SSE2__&& !defined __APPLE__)) && !defined(__CUDACC__)
__m128d t = _mm_set_sd( value );
int i = _mm_cvtsd_si32(t);
return i + _mm_movemask_pd(_mm_cmplt_sd(_mm_cvtsi32_sd(t,i), t));
#include <cstddef>
#include <cstring>
+#include <cctype>
#ifndef OPENCV_NOSTL
# include <string>
friend String operator+ (const String& lhs, char rhs);
friend String operator+ (char lhs, const String& rhs);
+ String toLowerCase() const;
+
#ifndef OPENCV_NOSTL
String(const std::string& str);
String(const std::string& str, size_t pos, size_t len = npos);
return npos;
}
+inline String String::toLowerCase() const
+{
+ String res(cstr_, len_);
+
+ for (size_t i = 0; i < len_; ++i)
+ res.cstr_[i] = (char) ::tolower(cstr_[i]);
+
+ return res;
+}
+
// ************************* cv::String non-member functions *************************
inline String operator+ (const String& lhs, const String& rhs)
{
ptr = buf;
sz = fixed_size;
- allocate(abuf.size);
+ allocate(abuf.size());
for( size_t i = 0; i < sz; i++ )
ptr[i] = abuf.ptr[i];
}
if( this != &abuf )
{
deallocate();
- allocate(abuf.size);
+ allocate(abuf.size());
for( size_t i = 0; i < sz; i++ )
ptr[i] = abuf.ptr[i];
}
//M*/
#include "precomp.hpp"
-#include "opencv2/core/gpumat.hpp"
using namespace cv;
using namespace cv::gpu;
convertTo(src, dst, alpha, beta, stream);
}
-#if CUDA_VERSION >= 5000
+#if CUDART_VERSION >= 5000
namespace
{
void cv::gpu::Stream::enqueueHostCallback(StreamCallback callback, void* userData)
{
-#if CUDA_VERSION >= 5000
+#if CUDART_VERSION >= 5000
CallbackData* data = new CallbackData;
data->callback = callback;
data->userData = userData;
//M*/
#include "precomp.hpp"
-#include "opencv2/core/gpumat.hpp"
-#include <cctype>
-
-#ifdef HAVE_CUDA
- #include <cuda_runtime.h>
- #include <npp.h>
-
- #define CUDART_MINIMUM_REQUIRED_VERSION 4020
- #define NPP_MINIMUM_REQUIRED_VERSION 4200
-
- #if (CUDART_VERSION < CUDART_MINIMUM_REQUIRED_VERSION)
- #error "Insufficient Cuda Runtime library version, please update it."
- #endif
-
- #if (NPP_VERSION_MAJOR * 1000 + NPP_VERSION_MINOR * 100 + NPP_VERSION_BUILD < NPP_MINIMUM_REQUIRED_VERSION)
- #error "Insufficient NPP version, please update it."
- #endif
-#endif
using namespace cv;
using namespace cv::gpu;
int cur_value;
int chars_read;
int args_read = sscanf(set_as_str.c_str() + pos, "%d%n", &cur_value, &chars_read);
- CV_Assert(args_read == 2);
+ CV_Assert(args_read == 1);
arr.push_back(cur_value);
pos += chars_read;
#include "opencv2/core/utility.hpp"
#include "opencv2/core/core_c.h"
#include "opencv2/core/internal.hpp"
+#include "opencv2/core/gpumat.hpp"
#include <assert.h>
#include <ctype.h>
#endif
#ifdef HAVE_CUDA
-# include <cuda_runtime_api.h>
-# include "opencv2/core/gpumat.hpp"
+
+# include <cuda_runtime.h>
+# include <npp.h>
+
+# define CUDART_MINIMUM_REQUIRED_VERSION 4020
+# define NPP_MINIMUM_REQUIRED_VERSION 4200
+
+# if (CUDART_VERSION < CUDART_MINIMUM_REQUIRED_VERSION)
+# error "Insufficient Cuda Runtime library version, please update it."
+# endif
+
+# if (NPP_VERSION_MAJOR * 1000 + NPP_VERSION_MINOR * 100 + NPP_VERSION_BUILD < NPP_MINIMUM_REQUIRED_VERSION)
+# error "Insufficient NPP version, please update it."
+# endif
# if defined(__GNUC__)
# define cudaSafeCall(expr) ___cudaSafeCall(expr, __FILE__, __LINE__, __func__)
release();
String fext = filename.substr(filename.find_last_of(".") + 1);
- std::transform(fext.begin(), fext.end(), fext.begin(), ::tolower);
+ fext = fext.toLowerCase();
if (fext == "nvbin")
{
struct ErrorEntry
{
int code;
- String str;
+ const char* str;
};
class ErrorEntryComparer
int code_;
};
- String getErrorString(int code, const ErrorEntry* errors, size_t n)
+ cv::String getErrorString(int code, const ErrorEntry* errors, size_t n)
{
size_t idx = std::find_if(errors, errors + n, ErrorEntryComparer(code)) - errors;
- const String& msg = (idx != n) ? errors[idx].str : String("Unknown error code");
+ const char* msg = (idx != n) ? errors[idx].str : "Unknown error code";
+ cv::String str = cv::format("%s [Code = %d]", msg, code);
- std::ostringstream ostr;
- ostr << msg << " [Code = " << code << "]";
-
- return ostr.str();
+ return str;
}
const ErrorEntry cu_errors [] =
const size_t cu_errors_num = sizeof(cu_errors) / sizeof(cu_errors[0]);
}
-String cv::gpu::detail::cuGetErrString(CUresult res)
+cv::String cv::gpu::detail::cuGetErrString(CUresult res)
{
return getErrorString(res, cu_errors, cu_errors_num);
}
__device__ __forceinline__ bool operator()(const int4& r1, const int4& r2) const
{
- float delta = eps * (min(r1.z, r2.z) + min(r1.w, r2.w)) * 0.5f;
+ float delta = eps * (::min(r1.z, r2.z) + ::min(r1.w, r2.w)) * 0.5f;
- return abs(r1.x - r2.x) <= delta && abs(r1.y - r2.y) <= delta
- && abs(r1.x + r1.z - r2.x - r2.z) <= delta && abs(r1.y + r1.w - r2.y - r2.w) <= delta;
+ return ::abs(r1.x - r2.x) <= delta && ::abs(r1.y - r2.y) <= delta
+ && ::abs(r1.x + r1.z - r2.x - r2.z) <= delta && ::abs(r1.y + r1.w - r2.y - r2.w) <= delta;
}
float eps;
};
} } }// namespaces
-#endif
\ No newline at end of file
+#endif
struct ErrorEntry
{
int code;
- String str;
+ const char* str;
};
struct ErrorEntryComparer
{
size_t idx = std::find_if(errors, errors + n, ErrorEntryComparer(code)) - errors;
- const String& msg = (idx != n) ? errors[idx].str : String("Unknown error code");
+ const char* msg = (idx != n) ? errors[idx].str : "Unknown error code";
+ String str = cv::format("%s [Code = %d]", msg, code);
- std::ostringstream ostr;
- ostr << msg << " [Code = " << code << "]";
-
- return ostr.str();
+ return str;
}
//////////////////////////////////////////////////////////////////////////
}
-NCVStatus loadFromXML(const String &filename,
+NCVStatus loadFromXML(const cv::String &filename,
HaarClassifierCascadeDescriptor &haar,
std::vector<HaarStage64> &haarStages,
std::vector<HaarClassifierNode128> &haarClassifierNodes,
#define NVBIN_HAAR_VERSION 0x1
-static NCVStatus loadFromNVBIN(const String &filename,
+static NCVStatus loadFromNVBIN(const cv::String &filename,
HaarClassifierCascadeDescriptor &haar,
std::vector<HaarStage64> &haarStages,
std::vector<HaarClassifierNode128> &haarClassifierNodes,
}
-NCVStatus ncvHaarGetClassifierSize(const String &filename, Ncv32u &numStages,
+NCVStatus ncvHaarGetClassifierSize(const cv::String &filename, Ncv32u &numStages,
Ncv32u &numNodes, Ncv32u &numFeatures)
{
size_t readCount;
NCVStatus ncvStat;
- String fext = filename.substr(filename.find_last_of(".") + 1);
- std::transform(fext.begin(), fext.end(), fext.begin(), ::tolower);
+ cv::String fext = filename.substr(filename.find_last_of(".") + 1);
+ fext = fext.toLowerCase();
if (fext == "nvbin")
{
}
-NCVStatus ncvHaarLoadFromFile_host(const String &filename,
+NCVStatus ncvHaarLoadFromFile_host(const cv::String &filename,
HaarClassifierCascadeDescriptor &haar,
NCVVector<HaarStage64> &h_HaarStages,
NCVVector<HaarClassifierNode128> &h_HaarNodes,
NCVStatus ncvStat;
- String fext = filename.substr(filename.find_last_of(".") + 1);
- std::transform(fext.begin(), fext.end(), fext.begin(), ::tolower);
+ cv::String fext = filename.substr(filename.find_last_of(".") + 1);
+ fext = fext.toLowerCase();
std::vector<HaarStage64> haarStages;
std::vector<HaarClassifierNode128> haarNodes;
}
-NCVStatus ncvHaarStoreNVBIN_host(const String &filename,
+NCVStatus ncvHaarStoreNVBIN_host(const cv::String &filename,
HaarClassifierCascadeDescriptor haar,
NCVVector<HaarStage64> &h_HaarStages,
NCVVector<HaarClassifierNode128> &h_HaarNodes,
Ncv32f curScale);
-NCV_EXPORTS NCVStatus ncvHaarGetClassifierSize(const String &filename, Ncv32u &numStages,
+NCV_EXPORTS NCVStatus ncvHaarGetClassifierSize(const cv::String &filename, Ncv32u &numStages,
Ncv32u &numNodes, Ncv32u &numFeatures);
-NCV_EXPORTS NCVStatus ncvHaarLoadFromFile_host(const String &filename,
+NCV_EXPORTS NCVStatus ncvHaarLoadFromFile_host(const cv::String &filename,
HaarClassifierCascadeDescriptor &haar,
NCVVector<HaarStage64> &h_HaarStages,
NCVVector<HaarClassifierNode128> &h_HaarNodes,
NCVVector<HaarFeature64> &h_HaarFeatures);
-NCV_EXPORTS NCVStatus ncvHaarStoreNVBIN_host(const String &filename,
+NCV_EXPORTS NCVStatus ncvHaarStoreNVBIN_host(const cv::String &filename,
HaarClassifierCascadeDescriptor haar,
NCVVector<HaarStage64> &h_HaarStages,
NCVVector<HaarClassifierNode128> &h_HaarNodes,
-#endif // _ncvhaarobjectdetection_hpp_
\ No newline at end of file
+#endif // _ncvhaarobjectdetection_hpp_
//==============================================================================
-static void stdDebugOutput(const String &msg)
+static void stdDebugOutput(const cv::String &msg)
{
- std::cout << msg;
+ std::cout << msg.c_str() << std::endl;
}
static NCVDebugOutputHandler *debugOutputHandler = stdDebugOutput;
-void ncvDebugOutput(const String &msg)
+void ncvDebugOutput(const cv::String &msg)
{
debugOutputHandler(msg);
}
return drawRectsWrapperDevice(d_dst, dstStride, dstWidth, dstHeight, d_rects, numRects, color, cuStream);
}
-#endif /* CUDA_DISABLER */
\ No newline at end of file
+#endif /* CUDA_DISABLER */
#endif
#include <cuda_runtime.h>
-#include <sstream>
-#include <iostream>
+#include "opencv2/core/cvstd.hpp"
+#include "opencv2/core/utility.hpp"
//==============================================================================
//==============================================================================
-NCV_EXPORTS void ncvDebugOutput(const String &msg);
+NCV_EXPORTS void ncvDebugOutput(const cv::String &msg);
-typedef void NCVDebugOutputHandler(const String &msg);
+typedef void NCVDebugOutputHandler(const cv::String &msg);
NCV_EXPORTS void ncvSetDebugOutputHandler(NCVDebugOutputHandler* func);
{ \
if (!(pred)) \
{ \
- std::ostringstream oss; \
- oss << "NCV Assertion Failed: " << msg << ", file=" << __FILE__ << ", line=" << __LINE__ << std::endl; \
- ncvDebugOutput(oss.str()); \
+ cv::String str = cv::format("NCV Assertion Failed: %s, file=%s, line=%d", msg, __FILE__, __LINE__); \
+ ncvDebugOutput(str); \
} \
} while (0)
#define ncvAssertReturn(pred, err) \
- ncvAssertPrintReturn(pred, "retcode=" << (int)err, err)
+ do \
+ { \
+ cv::String msg = cv::format("retcode=%d", (int)err); \
+ ncvAssertPrintReturn(pred, msg.c_str(), err); \
+ } while (0)
#define ncvAssertReturnNcvStat(ncvOp) \
do \
{ \
NCVStatus _ncvStat = ncvOp; \
- ncvAssertPrintReturn(NCV_SUCCESS==_ncvStat, "NcvStat=" << (int)_ncvStat, _ncvStat); \
+ cv::String msg = cv::format("NcvStat=%d", (int)_ncvStat); \
+ ncvAssertPrintReturn(NCV_SUCCESS==_ncvStat, msg.c_str(), _ncvStat); \
} while (0)
do \
{ \
cudaError_t res = cudacall; \
- ncvAssertPrintReturn(cudaSuccess==res, "cudaError_t=" << (int)res, errCode); \
+ cv::String msg = cv::format("cudaError_t=%d", (int)res); \
+ ncvAssertPrintReturn(cudaSuccess==res, msg.c_str(), errCode); \
} while (0)
do \
{ \
cudaError_t res = cudaGetLastError(); \
- ncvAssertPrintReturn(cudaSuccess==res, "cudaError_t=" << (int)res, errCode); \
+ cv::String msg = cv::format("cudaError_t=%d", (int)res); \
+ ncvAssertPrintReturn(cudaSuccess==res, msg.c_str(), errCode); \
} while (0)
T& at(Ncv32u x, Ncv32u y) const
{
NcvBool bOutRange = (x >= this->_width || y >= this->_height);
- ncvAssertPrintCheck(!bOutRange, "Error addressing matrix at [" << x << ", " << y << "]");
+ ncvAssertPrintCheck(!bOutRange, "Error addressing matrix");
if (bOutRange)
{
return *this->_ptr;
#include <stdexcept>
#include <memory>
+#include "opencv2/core.hpp"
+#include "opencv2/core/utility.hpp"
#include "opencv2/gpu.hpp"
#include "opencv2/imgproc.hpp"
#include "opencv2/imgproc/imgproc_c.h"
class EncoderCallBackFFMPEG : public cv::gpu::VideoWriter_GPU::EncoderCallBack
{
public:
- EncoderCallBackFFMPEG(const String& fileName, cv::Size frameSize, double fps);
+ EncoderCallBackFFMPEG(const cv::String& fileName, cv::Size frameSize, double fps);
~EncoderCallBackFFMPEG();
unsigned char* acquireBitStream(int* bufferSize);
}
}
-EncoderCallBackFFMPEG::EncoderCallBackFFMPEG(const String& fileName, cv::Size frameSize, double fps) :
+EncoderCallBackFFMPEG::EncoderCallBackFFMPEG(const cv::String& fileName, cv::Size frameSize, double fps) :
stream_(0), isKeyFrame_(false)
{
int buf_size = std::max(frameSize.area() * 4, 1024 * 1024);
}
}
-static void devNullOutput(const std::string& msg)
+static void devNullOutput(const cv::String& msg)
{
(void)msg;
}
using namespace cvtest;
-#if CUDA_VERSION >= 5000
+#if CUDART_VERSION >= 5000
struct Async : testing::TestWithParam<cv::gpu::DeviceInfo>
{