// disabled until fix crash
// support all types
CV_EXPORTS Scalar sum(const oclMat &m);
-
+ CV_EXPORTS Scalar absSum(const oclMat &m);
CV_EXPORTS Scalar sqrSum(const oclMat &m);
//! finds global minimum and maximum array elements and returns their values
}
}
+#if _MSC_VER >= 1200
+#pragma warning( push)
+#pragma warning( disable: 4267)
+#endif
#include "opencv2/ocl/matrix_operations.hpp"
+#if _MSC_VER >= 1200
+#pragma warning( pop)
+#endif
#endif /* __OPENCV_GPU_HPP__ */
printf( "cpudetection time = %g ms\n", t / (LOOP_TIMES * (double)cvGetTickFrequency() * 1000.) );
cv::ocl::oclMat image;
- CvSeq *_objects;
+ CvSeq *_objects=NULL;
t = (double)cvGetTickCount();
for(int k = 0; k < LOOP_TIMES; k++)
{
ASSERT_FALSE(img.empty());
// define HOG related arguments
- float scale = 1.05;
+ float scale = 1.05f;
//int nlevels = 13;
- float gr_threshold = 8;
- float hit_threshold = 1.4;
+ int gr_threshold = 8;
+ float hit_threshold = 1.4f;
//bool hit_threshold_auto = true;
int win_width = is48 ? 48 : 64;
using namespace testing;
using namespace std;
-extern std::string workdir;
+#define FILTER_IMAGE "../../../samples/gpu/road.png"
TEST(SURF, Performance)
{
- cv::Mat img = readImage(workdir+"lena.jpg", cv::IMREAD_GRAYSCALE);
+ cv::Mat img = readImage(FILTER_IMAGE, cv::IMREAD_GRAYSCALE);
ASSERT_FALSE(img.empty());
ocl::SURF_OCL d_surf;
#include "cvconfig.h"
#include "opencv2/core/core.hpp"
#include "opencv2/highgui/highgui.hpp"
-#include "opencv2/calib3d/calib3d.hpp"
+//#include "opencv2/calib3d/calib3d.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/video/video.hpp"
#include "opencv2/ts/ts.hpp"
#include "opencv2/ts/ts_perf.hpp"
#include "opencv2/ocl/ocl.hpp"
-#include "opencv2/nonfree/nonfree.hpp"
+//#include "opencv2/nonfree/nonfree.hpp"
#include "utility.hpp"
#include "interpolation.hpp"
#ifdef PRINT_KERNEL_RUN_TIME
#define LOOP_TIMES 1
#else
-#define LOOP_TIMES 100
+#define LOOP_TIMES 1
#endif
#define MWIDTH 1920
#define MHEIGHT 1080
return func(src, 0);
}
+Scalar cv::ocl::absSum(const oclMat &src)
+{
+ if(src.clCxt->impl->double_support == 0 && src.depth() == CV_64F)
+ {
+ CV_Error(CV_GpuNotSupported, "select device don't support double");
+ }
+ static sumFunc functab[2] =
+ {
+ arithmetic_sum<float>,
+ arithmetic_sum<double>
+ };
+
+ sumFunc func;
+ func = functab[src.clCxt->impl->double_support];
+ return func(src, 1);
+}
Scalar cv::ocl::sqrSum(const oclMat &src)
{
T *p = new T[groupnum * vlen * 2];
memset(p, 0, dbsize);
openCLReadBuffer(clCxt, dstBuffer, (void *)p, dbsize);
- for(int i = 0; i < vlen * (int)groupnum; i++)
- {
- *minVal = *minVal < p[i] ? *minVal : p[i];
+ if(minVal != NULL){
+ for(int i = 0; i < vlen * (int)groupnum; i++)
+ {
+ *minVal = *minVal < p[i] ? *minVal : p[i];
+ }
}
- for(int i = vlen * (int)groupnum; i < 2 * vlen * (int)groupnum; i++)
- {
- *maxVal = *maxVal > p[i] ? *maxVal : p[i];
+ if(maxVal != NULL){
+ for(int i = vlen * (int)groupnum; i < 2 * vlen * (int)groupnum; i++)
+ {
+ *maxVal = *maxVal > p[i] ? *maxVal : p[i];
+ }
}
delete[] p;
openCLFree(dstBuffer);
temp.reserve(2 * k);
matches.resize(query.rows);
- for(size_t queryIdx = 0; queryIdx < matches.size(); queryIdx++ )
- matches[queryIdx].reserve(k);
+ for_each(matches.begin(), matches.end(), bind2nd(mem_fun_ref(&vector<DMatch>::reserve), k));
for (size_t imgIdx = 0, size = trainDescCollection.size(); imgIdx < size; ++imgIdx)
{
if (compactResult)
{
- size_t i, j = 0;
- for( i = 0; i < matches.size(); i++ )
- if( !matches[i].empty() )
- {
- if( i > j )
- matches[j] = matches[i];
- j++;
- }
- matches.resize(j);
+ vector< vector<DMatch> >::iterator new_end = remove_if(matches.begin(), matches.end(), mem_fun_ref(&vector<DMatch>::empty));
+ matches.erase(new_end, matches.end());
}
}
}
//////////////////////////////////////////////////////////////////////////////
// buildWarpPlaneMaps
-void cv::ocl::buildWarpPlaneMaps(Size src_size, Rect dst_roi, const Mat &K, const Mat &R, const Mat &T,
+void cv::ocl::buildWarpPlaneMaps(Size /*src_size*/, Rect dst_roi, const Mat &K, const Mat &R, const Mat &T,
float scale, oclMat &map_x, oclMat &map_y)
{
CV_Assert(K.size() == Size(3, 3) && K.type() == CV_32F);
//////////////////////////////////////////////////////////////////////////////
// buildWarpCylyndricalMaps
-void cv::ocl::buildWarpCylindricalMaps(Size src_size, Rect dst_roi, const Mat &K, const Mat &R, float scale,
+void cv::ocl::buildWarpCylindricalMaps(Size /*src_size*/, Rect dst_roi, const Mat &K, const Mat &R, float scale,
oclMat &map_x, oclMat &map_y)
{
CV_Assert(K.size() == Size(3, 3) && K.type() == CV_32F);
//////////////////////////////////////////////////////////////////////////////
// buildWarpSphericalMaps
-void cv::ocl::buildWarpSphericalMaps(Size src_size, Rect dst_roi, const Mat &K, const Mat &R, float scale,
+void cv::ocl::buildWarpSphericalMaps(Size /*src_size*/, Rect dst_roi, const Mat &K, const Mat &R, float scale,
oclMat &map_x, oclMat &map_y)
{
CV_Assert(K.size() == Size(3, 3) && K.type() == CV_32F);
size_t gt[3] = {src.cols, src.rows, 1}, lt[3] = {16, 16, 1};
openCLExecuteKernel(src.clCxt, &cvt_color, "RGB2Gray", gt, lt, args, -1, -1, build_options);
}
- void cvtColor_caller(const oclMat &src, oclMat &dst, int code, int dcn)
+ void cvtColor_caller(const oclMat &src, oclMat &dst, int code, int /*dcn*/)
{
Size sz = src.size();
int scn = src.oclchannels(), depth = src.depth(), bidx;
args.push_back( make_pair( sizeof(cl_int), (void *)&dst.step));
size_t globalThreads[3] = {dst.cols, 1, 1};
- size_t localThreads[3] = {16, 16, 1};
+ size_t localThreads[3] = {256, 1, 1};
openCLExecuteKernel(clCxt, &imgproc_columnsum, kernelName, globalThreads, localThreads, args, src.channels(), src.depth());
openCLExecuteKernel(clCxt, &filter_sep_row, kernelName, globalThreads, localThreads, args, channels, src.depth(), compile_option);
}
-Ptr<BaseRowFilter_GPU> cv::ocl::getLinearRowFilter_GPU(int srcType, int bufType, const Mat &rowKernel, int anchor, int bordertype)
+Ptr<BaseRowFilter_GPU> cv::ocl::getLinearRowFilter_GPU(int srcType, int /*bufType*/, const Mat &rowKernel, int anchor, int bordertype)
{
static const gpuFilter1D_t gpuFilter1D_callers[6] =
{
openCLExecuteKernel(clCxt, &filter_sep_col, kernelName, globalThreads, localThreads, args, -1, -1, compile_option);
}
-Ptr<BaseColumnFilter_GPU> cv::ocl::getLinearColumnFilter_GPU(int bufType, int dstType, const Mat &columnKernel, int anchor, int bordertype, double delta)
+Ptr<BaseColumnFilter_GPU> cv::ocl::getLinearColumnFilter_GPU(int /*bufType*/, int dstType, const Mat &columnKernel, int anchor, int bordertype, double /*delta*/)
{
static const gpuFilter1D_t gpuFilter1D_callers[6] =
{
_ALIGNED_ON(4) int p3 ;
_ALIGNED_ON(4) float weight ;
}
- _ALIGNED_ON(32) rect[CV_HAAR_FEATURE_MAX] ;
+ /*_ALIGNED_ON(32)*/ rect[CV_HAAR_FEATURE_MAX] ;
}
GpuHidHaarFeature;
std::vector<cv::Rect> rectList;
std::vector<int> rweights;
double factor;
- int datasize;
- int totalclassifier;
+ int datasize=0;
+ int totalclassifier=0;
void *out;
GpuHidHaarClassifierCascade *gcascade;
size_t kernelWorkGroupSize;
openCLSafeCall(clGetKernelWorkGroupInfo(kernel, clCxt->impl->devices[0],
CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &kernelWorkGroupSize, 0));
- CV_DbgAssert( (localThreads[0] <= clCxt->impl->maxWorkItemSizes[0]) &&
+ CV_Assert( (localThreads[0] <= clCxt->impl->maxWorkItemSizes[0]) &&
(localThreads[1] <= clCxt->impl->maxWorkItemSizes[1]) &&
(localThreads[2] <= clCxt->impl->maxWorkItemSizes[2]) &&
((localThreads[0] * localThreads[1] * localThreads[2]) <= kernelWorkGroupSize) &&
normalizeKernel(buffer, src.rows, b_offset, d_offset);
}
-void interpolate::blendFrames(const oclMat &frame0, const oclMat &frame1, const oclMat &buffer, float pos, oclMat &newFrame, cl_mem &tex_src0, cl_mem &tex_src1)
+void interpolate::blendFrames(const oclMat &frame0, const oclMat &/*frame1*/, const oclMat &buffer, float pos, oclMat &newFrame, cl_mem &tex_src0, cl_mem &tex_src1)
{
int step = buffer.step / sizeof(float);
// Implementation
//
- DjSets DjSets::operator = (const DjSets &obj)
+ DjSets DjSets::operator = (const DjSets &/*obj*/)
{
//cout << "Invalid DjSets constructor\n";
CV_Error(-1, "Invalid DjSets constructor\n");
#define __OPENCV_PRECOMP_H__
#if _MSC_VER >= 1200
-#pragma warning( disable: 4244 4251 4710 4711 4514 4996 )
+#pragma warning( disable: 4267 4324 4244 4251 4710 4711 4514 4996 )
#endif
#ifdef HAVE_CVCONFIG_H
//
//void callF(const oclMat& src, oclMat& dst, MultiplyScalar op, int mask)
//{
-// Mat srcTemp;
-// Mat dstTemp;
-// src.download(srcTemp);
-// dst.download(dstTemp);
+// Mat srcTemp;
+// Mat dstTemp;
+// src.download(srcTemp);
+// dst.download(dstTemp);
//
-// int i;
-// int j;
-// int k;
-// for(i = 0; i < srcTemp.rows; i++)
-// {
-// for(j = 0; j < srcTemp.cols; j++)
-// {
-// for(k = 0; k < srcTemp.channels(); k++)
-// {
-// ((float*)dstTemp.data)[srcTemp.channels() * (i * srcTemp.rows + j) + k] = (float)op(((float*)srcTemp.data)[srcTemp.channels() * (i * srcTemp.rows + j) + k]);
-// }
-// }
-// }
+// int i;
+// int j;
+// int k;
+// for(i = 0; i < srcTemp.rows; i++)
+// {
+// for(j = 0; j < srcTemp.cols; j++)
+// {
+// for(k = 0; k < srcTemp.channels(); k++)
+// {
+// ((float*)dstTemp.data)[srcTemp.channels() * (i * srcTemp.rows + j) + k] = (float)op(((float*)srcTemp.data)[srcTemp.channels() * (i * srcTemp.rows + j) + k]);
+// }
+// }
+// }
//
-// dst = dstTemp;
+// dst = dstTemp;
//}
//
//static inline bool isAligned(const unsigned char* ptr, size_t size)
// return;
// }
//
-// Mat srcTemp;
-// Mat dstTemp;
-// src.download(srcTemp);
-// dst.download(dstTemp);
+// Mat srcTemp;
+// Mat dstTemp;
+// src.download(srcTemp);
+// dst.download(dstTemp);
//
-// int x_shifted;
+// int x_shifted;
//
-// int i;
-// int j;
-// for(i = 0; i < srcTemp.rows; i++)
-// {
-// const double* srcRow = (const double*)srcTemp.data + i * srcTemp.rows;
+// int i;
+// int j;
+// for(i = 0; i < srcTemp.rows; i++)
+// {
+// const double* srcRow = (const double*)srcTemp.data + i * srcTemp.rows;
// double* dstRow = (double*)dstTemp.data + i * dstTemp.rows;;
//
-// for(j = 0; j < srcTemp.cols; j++)
-// {
-// x_shifted = j * 4;
+// for(j = 0; j < srcTemp.cols; j++)
+// {
+// x_shifted = j * 4;
//
-// if(x_shifted + 4 - 1 < srcTemp.cols)
-// {
-// dstRow[x_shifted ] = op(srcRow[x_shifted ]);
-// dstRow[x_shifted + 1] = op(srcRow[x_shifted + 1]);
-// dstRow[x_shifted + 2] = op(srcRow[x_shifted + 2]);
-// dstRow[x_shifted + 3] = op(srcRow[x_shifted + 3]);
-// }
-// else
-// {
-// for (int real_x = x_shifted; real_x < srcTemp.cols; ++real_x)
-// {
-// ((float*)dstTemp.data)[i * srcTemp.rows + real_x] = op(((float*)srcTemp.data)[i * srcTemp.rows + real_x]);
-// }
-// }
-// }
-// }
+// if(x_shifted + 4 - 1 < srcTemp.cols)
+// {
+// dstRow[x_shifted ] = op(srcRow[x_shifted ]);
+// dstRow[x_shifted + 1] = op(srcRow[x_shifted + 1]);
+// dstRow[x_shifted + 2] = op(srcRow[x_shifted + 2]);
+// dstRow[x_shifted + 3] = op(srcRow[x_shifted + 3]);
+// }
+// else
+// {
+// for (int real_x = x_shifted; real_x < srcTemp.cols; ++real_x)
+// {
+// ((float*)dstTemp.data)[i * srcTemp.rows + real_x] = op(((float*)srcTemp.data)[i * srcTemp.rows + real_x]);
+// }
+// }
+// }
+// }
//}
//
//void multiply(const oclMat& src1, double val, oclMat& dst, double scale = 1.0f);
//void multiply(const oclMat& src1, double val, oclMat& dst, double scale)
//{
// MultiplyScalar op(val, scale);
-// //if(src1.channels() == 1 && dst.channels() == 1)
-// //{
-// // callT(src1, dst, op, 0);
-// //}
-// //else
-// //{
-// callF(src1, dst, op, 0);
-// //}
+// //if(src1.channels() == 1 && dst.channels() == 1)
+// //{
+// // callT(src1, dst, op, 0);
+// //}
+// //else
+// //{
+// callF(src1, dst, op, 0);
+// //}
//}
cl_mem bindTexture(const oclMat &mat, int depth, int channels)
void cv::ocl::PyrLKOpticalFlow::sparse(const oclMat &prevImg, const oclMat &nextImg, const oclMat &prevPts, oclMat &nextPts, oclMat &status, oclMat *err)
{
+ if (prevImg.clCxt->impl->devName.find("Intel(R) HD Graphics") != string::npos)
+ {
+ cout << " Intel HD GPU device unsupported " << endl;
+ return;
+ }
+
if (prevPts.empty())
{
nextPts.release();
throw std::exception();
//!FIXME
// temp fix for missing min overload
- oclMat temp(mask.size(), mask.type());
- temp.setTo(Scalar::all(1.0));
- //cv::ocl::min(mask, temp, surf_.mask1); ///////// disable this
- integral(surf_.mask1, surf_.maskSum);
- bindImgTex(surf_.maskSum, maskSumTex);
+ //oclMat temp(mask.size(), mask.type());
+ //temp.setTo(Scalar::all(1.0));
+ ////cv::ocl::min(mask, temp, surf_.mask1); ///////// disable this
+ //integral(surf_.mask1, surf_.maskSum);
+ //bindImgTex(surf_.maskSum, maskSumTex);
}
}
{
if (!img.empty())
{
+ if (img.clCxt->impl->devName.find("Intel(R) HD Graphics") != string::npos)
+ {
+ cout << " Intel HD GPU device unsupported " << endl;
+ return;
+ }
SURF_OCL_Invoker surf(*this, img, mask);
surf.detectKeypoints(keypoints);
{
if (!img.empty())
{
+ if (img.clCxt->impl->devName.find("Intel(R) HD Graphics") != string::npos)
+ {
+ cout << " Intel HD GPU device unsupported " << endl;
+ return;
+ }
SURF_OCL_Invoker surf(*this, img, mask);
if (!useProvidedKeypoints)
#include "cvconfig.h"
#include "opencv2/core/core.hpp"
#include "opencv2/highgui/highgui.hpp"
-#include "opencv2/calib3d/calib3d.hpp"
+//#include "opencv2/calib3d/calib3d.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/video/video.hpp"
#include "opencv2/ts/ts.hpp"
#include "opencv2/ts/ts_perf.hpp"
#include "opencv2/ocl/ocl.hpp"
-#include "opencv2/nonfree/nonfree.hpp"
+//#include "opencv2/nonfree/nonfree.hpp"
#include "utility.hpp"
#include "interpolation.hpp"
int threshold = 10;
int val = 32;
- d_comp[0] = d_found.size();
- comp[0] = found.size();
+ d_comp[0] = (int)d_found.size();
+ comp[0] = (int)found.size();
if (winSize == cv::Size(48, 96))
{
for(int i = 0; i < (int)d_found.size(); i++)
dptr[3] = (uchar)c3;
COOR coor;
- coor.x = x0;
- coor.y = y0;
+ coor.x = (short)x0;
+ coor.y = (short)y0;
return coor;
}