From 23244a35651cd4da7b439b5b82ffc670c369bb7b Mon Sep 17 00:00:00 2001 From: niko Date: Wed, 12 Sep 2012 10:20:04 +0800 Subject: [PATCH] rename all the perf test files fix the channel 3 bug in matrix operation perf and buf fix for LUT haardetect convertC3C4 resize warpaffine copytom settom add convovle remove stereo --- .../include/opencv2/ocl/matrix_operations.hpp | 89 +- modules/ocl/include/opencv2/ocl/ocl.hpp | 178 +-- .../perf/{test_arithm.cpp => perf_arithm.cpp} | 0 .../perf/{test_blend.cpp => perf_blend.cpp} | 0 .../perf/{test_canny.cpp => perf_canny.cpp} | 0 ...{test_columnsum.cpp => perf_columnsum.cpp} | 0 .../ocl/perf/{test_fft.cpp => perf_fft.cpp} | 0 .../{test_filters.cpp => perf_filters.cpp} | 0 .../ocl/perf/{test_gemm.cpp => perf_gemm.cpp} | 0 .../ocl/perf/{test_haar.cpp => perf_haar.cpp} | 0 modules/ocl/perf/perf_hog.cpp | 167 +++ .../{test_imgproc.cpp => perf_imgproc.cpp} | 378 ++++++ ...h_template.cpp => perf_match_template.cpp} | 0 ...peration.cpp => perf_matrix_operation.cpp} | 0 .../{test_pyrdown.cpp => perf_pyrdown.cpp} | 0 .../perf/{test_pyrup.cpp => perf_pyrup.cpp} | 0 ...t_split_merge.cpp => perf_split_merge.cpp} | 0 modules/ocl/perf/perf_surf.cpp | 103 ++ modules/ocl/perf/test_hog.cpp | 218 ---- modules/ocl/src/arithm.cpp | 11 +- modules/ocl/src/canny.cpp | 9 +- modules/ocl/src/imgproc.cpp | 151 ++- modules/ocl/src/initialization.cpp | 8 +- modules/ocl/src/kernels/arithm_LUT.cl | 56 +- modules/ocl/src/kernels/convertC3C4.cl | 96 +- modules/ocl/src/kernels/filter_sep_col.cl | 1 + modules/ocl/src/kernels/filter_sep_row.cl | 1 + modules/ocl/src/kernels/haarobjectdetect.cl | 18 +- modules/ocl/src/kernels/imgproc_convolve.cl | 111 ++ modules/ocl/src/kernels/imgproc_histogram.cl | 187 +-- modules/ocl/src/kernels/imgproc_resize.cl | 16 +- modules/ocl/src/kernels/imgproc_warpAffine.cl | 1012 ++++++++------- .../src/kernels/imgproc_warpPerspective.cl | 4 +- modules/ocl/src/kernels/operator_convertTo.cl | 91 +- modules/ocl/src/kernels/operator_copyToM.cl | 159 +-- modules/ocl/src/kernels/operator_setTo.cl | 38 +- modules/ocl/src/kernels/operator_setToM.cl | 79 +- modules/ocl/src/kernels/pyr_down.cl | 135 +- modules/ocl/src/kernels/stereobm.cl | 427 ------- modules/ocl/src/kernels/stereobp.cl | 580 --------- modules/ocl/src/kernels/stereocsbp.cl | 1131 ----------------- modules/ocl/src/matrix_operations.cpp | 55 +- modules/ocl/src/stereo_csbp.cpp | 786 ------------ modules/ocl/src/stereobm.cpp | 291 ----- modules/ocl/src/stereobp.cpp | 661 ---------- modules/ocl/src/surf.cpp | 20 +- modules/ocl/test/test_imgproc.cpp | 162 ++- modules/ocl/test/test_match_template.cpp | 6 +- modules/ocl/test/utility.cpp | 20 +- modules/ocl/test/utility.hpp | 2 - 50 files changed, 2080 insertions(+), 5377 deletions(-) rename modules/ocl/perf/{test_arithm.cpp => perf_arithm.cpp} (100%) rename modules/ocl/perf/{test_blend.cpp => perf_blend.cpp} (100%) rename modules/ocl/perf/{test_canny.cpp => perf_canny.cpp} (100%) rename modules/ocl/perf/{test_columnsum.cpp => perf_columnsum.cpp} (100%) rename modules/ocl/perf/{test_fft.cpp => perf_fft.cpp} (100%) rename modules/ocl/perf/{test_filters.cpp => perf_filters.cpp} (100%) rename modules/ocl/perf/{test_gemm.cpp => perf_gemm.cpp} (100%) rename modules/ocl/perf/{test_haar.cpp => perf_haar.cpp} (100%) create mode 100644 modules/ocl/perf/perf_hog.cpp rename modules/ocl/perf/{test_imgproc.cpp => perf_imgproc.cpp} (78%) rename modules/ocl/perf/{test_match_template.cpp => perf_match_template.cpp} (100%) rename modules/ocl/perf/{test_matrix_operation.cpp => perf_matrix_operation.cpp} (100%) rename modules/ocl/perf/{test_pyrdown.cpp => perf_pyrdown.cpp} (100%) rename modules/ocl/perf/{test_pyrup.cpp => perf_pyrup.cpp} (100%) rename modules/ocl/perf/{test_split_merge.cpp => perf_split_merge.cpp} (100%) create mode 100644 modules/ocl/perf/perf_surf.cpp delete mode 100644 modules/ocl/perf/test_hog.cpp create mode 100644 modules/ocl/src/kernels/imgproc_convolve.cl delete mode 100644 modules/ocl/src/kernels/stereobm.cl delete mode 100644 modules/ocl/src/kernels/stereobp.cl delete mode 100644 modules/ocl/src/kernels/stereocsbp.cl delete mode 100644 modules/ocl/src/stereo_csbp.cpp delete mode 100644 modules/ocl/src/stereobm.cpp delete mode 100644 modules/ocl/src/stereobp.cpp diff --git a/modules/ocl/include/opencv2/ocl/matrix_operations.hpp b/modules/ocl/include/opencv2/ocl/matrix_operations.hpp index 3d75e14b3e..06eec380a4 100644 --- a/modules/ocl/include/opencv2/ocl/matrix_operations.hpp +++ b/modules/ocl/include/opencv2/ocl/matrix_operations.hpp @@ -55,22 +55,22 @@ namespace cv //////////////////////////////// oclMat //////////////////////////////// //////////////////////////////////////////////////////////////////////// - inline oclMat::oclMat() : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0), offset(0), wholerows(0), wholecols(0) {} + inline oclMat::oclMat() : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0), offset(0), wholerows(0), wholecols(0), download_channels(0) {} - inline oclMat::oclMat(int _rows, int _cols, int _type) : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0), offset(0), wholerows(0), wholecols(0) + inline oclMat::oclMat(int _rows, int _cols, int _type) : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0), offset(0), wholerows(0), wholecols(0), download_channels(0) { if( _rows > 0 && _cols > 0 ) create( _rows, _cols, _type ); } - inline oclMat::oclMat(Size _size, int _type) : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0), offset(0), wholerows(0), wholecols(0) + inline oclMat::oclMat(Size _size, int _type) : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0), offset(0), wholerows(0), wholecols(0), download_channels(0) { if( _size.height > 0 && _size.width > 0 ) create( _size.height, _size.width, _type ); } inline oclMat::oclMat(int _rows, int _cols, int _type, const Scalar &_s) - : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0), offset(0), wholerows(0), wholecols(0) + : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0), offset(0), wholerows(0), wholecols(0), download_channels(0) { if(_rows > 0 && _cols > 0) { @@ -80,7 +80,7 @@ namespace cv } inline oclMat::oclMat(Size _size, int _type, const Scalar &_s) - : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0), offset(0), wholerows(0), wholecols(0) + : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0), offset(0), wholerows(0), wholecols(0), download_channels(0) { if( _size.height > 0 && _size.width > 0 ) { @@ -91,49 +91,53 @@ namespace cv inline oclMat::oclMat(const oclMat &m) : flags(m.flags), rows(m.rows), cols(m.cols), step(m.step), data(m.data), - refcount(m.refcount), datastart(m.datastart), dataend(m.dataend), clCxt(m.clCxt), offset(m.offset), wholerows(m.wholerows), wholecols(m.wholecols) + refcount(m.refcount), datastart(m.datastart), dataend(m.dataend), clCxt(m.clCxt), offset(m.offset), wholerows(m.wholerows), wholecols(m.wholecols), download_channels(m.download_channels) { if( refcount ) CV_XADD(refcount, 1); } - //Fixme, the data is not correct if _data point to the CPU memory + inline oclMat::oclMat(int _rows, int _cols, int _type, void *_data, size_t _step) : flags(Mat::MAGIC_VAL + (_type &TYPE_MASK)), rows(_rows), cols(_cols), step(_step), data((uchar *)_data), refcount(0), - datastart((uchar *)_data), dataend((uchar *)_data), offset(0), wholerows(_rows), wholecols(_cols) + datastart((uchar *)_data), dataend((uchar *)_data), offset(0), wholerows(_rows), wholecols(_cols), download_channels(CV_MAT_CN(_type)) { - size_t minstep = cols * elemSize(); - if( step == Mat::AUTO_STEP ) - { - step = minstep; - flags |= Mat::CONTINUOUS_FLAG; - } - else - { - if( rows == 1 ) step = minstep; - CV_DbgAssert( step >= minstep ); - flags |= step == minstep ? Mat::CONTINUOUS_FLAG : 0; - } - dataend += step * (rows - 1) + minstep; + cv::Mat m(_rows,_cols,_type,_data,_step); + upload(m); + //size_t minstep = cols * elemSize(); + //if( step == Mat::AUTO_STEP ) + //{ + // step = minstep; + // flags |= Mat::CONTINUOUS_FLAG; + //} + //else + //{ + // if( rows == 1 ) step = minstep; + // CV_DbgAssert( step >= minstep ); + // flags |= step == minstep ? Mat::CONTINUOUS_FLAG : 0; + //} + //dataend += step * (rows - 1) + minstep; } - //Fixme, the data is not correct if _data point to the CPU memory + inline oclMat::oclMat(Size _size, int _type, void *_data, size_t _step) : flags(Mat::MAGIC_VAL + (_type &TYPE_MASK)), rows(_size.height), cols(_size.width), step(_step), data((uchar *)_data), refcount(0), - datastart((uchar *)_data), dataend((uchar *)_data), offset(0), wholerows(_size.height), wholecols(_size.width) + datastart((uchar *)_data), dataend((uchar *)_data), offset(0), wholerows(_size.height), wholecols(_size.width), download_channels(CV_MAT_CN(_type)) { - size_t minstep = cols * elemSize(); - if( step == Mat::AUTO_STEP ) - { - step = minstep; - flags |= Mat::CONTINUOUS_FLAG; - } - else - { - if( rows == 1 ) step = minstep; - CV_DbgAssert( step >= minstep ); - flags |= step == minstep ? Mat::CONTINUOUS_FLAG : 0; - } - dataend += step * (rows - 1) + minstep; + cv::Mat m(_size,_type,_data,_step); + upload(m); + //size_t minstep = cols * elemSize(); + //if( step == Mat::AUTO_STEP ) + //{ + // step = minstep; + // flags |= Mat::CONTINUOUS_FLAG; + //} + //else + //{ + // if( rows == 1 ) step = minstep; + // CV_DbgAssert( step >= minstep ); + // flags |= step == minstep ? Mat::CONTINUOUS_FLAG : 0; + //} + //dataend += step * (rows - 1) + minstep; } @@ -148,6 +152,7 @@ namespace cv wholerows = m.wholerows; wholecols = m.wholecols; offset = m.offset; + download_channels = m.download_channels; if( rowRange == Range::all() ) rows = m.rows; else @@ -179,7 +184,7 @@ namespace cv inline oclMat::oclMat(const oclMat &m, const Rect &roi) : flags(m.flags), rows(roi.height), cols(roi.width), step(m.step), data(m.data), refcount(m.refcount), - datastart(m.datastart), dataend(m.dataend), clCxt(m.clCxt), offset(m.offset), wholerows(m.wholerows), wholecols(m.wholecols) + datastart(m.datastart), dataend(m.dataend), clCxt(m.clCxt), offset(m.offset), wholerows(m.wholerows), wholecols(m.wholecols), download_channels(m.download_channels) { flags &= roi.width < m.cols ? ~Mat::CONTINUOUS_FLAG : -1; offset += roi.y * step + roi.x * elemSize(); @@ -192,7 +197,7 @@ namespace cv } inline oclMat::oclMat(const Mat &m) - : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0) , offset(0), wholerows(0), wholecols(0) + : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0) , offset(0), wholerows(0), wholecols(0), download_channels(0) { //clCxt = Context::getContext(); upload(m); @@ -222,6 +227,7 @@ namespace cv wholerows = m.wholerows; wholecols = m.wholecols; refcount = m.refcount; + download_channels = m.download_channels; } return *this; } @@ -323,6 +329,7 @@ namespace cv std::swap( offset, b.offset ); std::swap( wholerows, b.wholerows ); std::swap( wholecols, b.wholecols ); + std::swap( download_channels, b.download_channels); } inline void oclMat::locateROI( Size &wholeSize, Point &ofs ) const @@ -412,28 +419,32 @@ namespace cv } - //fixme, the ROI operation is not correct. + inline uchar *oclMat::ptr(int y) { CV_DbgAssert( (unsigned)y < (unsigned)rows ); + CV_Error(CV_GpuNotSupported,"This function hasn't been supported yet.\n"); return data + step * y; } inline const uchar *oclMat::ptr(int y) const { CV_DbgAssert( (unsigned)y < (unsigned)rows ); + CV_Error(CV_GpuNotSupported,"This function hasn't been supported yet.\n"); return data + step * y; } template inline _Tp *oclMat::ptr(int y) { CV_DbgAssert( (unsigned)y < (unsigned)rows ); + CV_Error(CV_GpuNotSupported,"This function hasn't been supported yet.\n"); return (_Tp *)(data + step * y); } template inline const _Tp *oclMat::ptr(int y) const { CV_DbgAssert( (unsigned)y < (unsigned)rows ); + CV_Error(CV_GpuNotSupported,"This function hasn't been supported yet.\n"); return (const _Tp *)(data + step * y); } diff --git a/modules/ocl/include/opencv2/ocl/ocl.hpp b/modules/ocl/include/opencv2/ocl/ocl.hpp index 3eff7ef679..f946df79bd 100644 --- a/modules/ocl/include/opencv2/ocl/ocl.hpp +++ b/modules/ocl/include/opencv2/ocl/ocl.hpp @@ -370,11 +370,11 @@ namespace cv CV_EXPORTS Scalar sum(const oclMat &m); //! finds global minimum and maximum array elements and returns their values - // support all types + // support all C1 types CV_EXPORTS void minMax(const oclMat &src, double *minVal, double *maxVal = 0, const oclMat &mask = oclMat()); //! finds global minimum and maximum array elements and returns their values with locations - // support all types + // support all C1 types CV_EXPORTS void minMaxLoc(const oclMat &src, double *minVal, double *maxVal = 0, Point *minLoc = 0, Point *maxLoc = 0, const oclMat &mask = oclMat()); @@ -440,6 +440,9 @@ namespace cv // supports all types CV_EXPORTS void bitwise_xor(const oclMat &src1, const oclMat &src2, oclMat &dst, const oclMat &mask = oclMat()); CV_EXPORTS void bitwise_xor(const oclMat &src1, const Scalar &s, oclMat &dst, const oclMat &mask = oclMat()); + //! computes convolution of two images + //! support only CV_32FC1 type + CV_EXPORTS void convolve(const oclMat& image,const oclMat& temp1, oclMat& result); //! Logical operators CV_EXPORTS oclMat operator ~ (const oclMat &src); @@ -644,11 +647,11 @@ namespace cv // supports CV_8UC1, CV_8UC4, CV_32FC1 and CV_32FC4 types CV_EXPORTS void resize(const oclMat &src, oclMat &dst, Size dsize, double fx = 0, double fy = 0, int interpolation = INTER_LINEAR); - //! Applies a generic geometrical transformation to an image. - // Supports INTER_NEAREST, INTER_LINEAR. - // Map1 supports CV_16SC2, CV_32FC2 types. - // Src supports CV_8UC1, CV_8UC2, CV_8UC4. - CV_EXPORTS void remap(const oclMat& src, oclMat& dst, oclMat& map1, oclMat& map2, int interpolation, int bordertype, const Scalar& value = Scalar()); + //! Applies a generic geometrical transformation to an image. + // Supports INTER_NEAREST, INTER_LINEAR. + // Map1 supports CV_16SC2, CV_32FC2 types. + // Src supports CV_8UC1, CV_8UC2, CV_8UC4. + CV_EXPORTS void remap(const oclMat& src, oclMat& dst, oclMat& map1, oclMat& map2, int interpolation, int bordertype, const Scalar& value = Scalar()); //! copies 2D array to a larger destination array and pads borders with user-specifiable constant // supports CV_8UC1, CV_8UC4, CV_32SC1 types CV_EXPORTS void copyMakeBorder(const oclMat &src, oclMat &dst, int top, int bottom, int left, int right, int boardtype, const Scalar &value = Scalar()); @@ -675,158 +678,6 @@ namespace cv CV_EXPORTS void cornerHarris(const oclMat &src, oclMat &dst, int blockSize, int ksize, double k, int bordertype = cv::BORDER_DEFAULT); CV_EXPORTS void cornerMinEigenVal(const oclMat &src, oclMat &dst, int blockSize, int ksize, int bordertype = cv::BORDER_DEFAULT); - - //////////////////////////////// StereoBM_GPU //////////////////////////////// - class CV_EXPORTS StereoBM_GPU - { - public: - enum { BASIC_PRESET = 0, PREFILTER_XSOBEL = 1 }; - - enum { DEFAULT_NDISP = 64, DEFAULT_WINSZ = 19 }; - - //! the default constructor - StereoBM_GPU(); - //! the full constructor taking the camera-specific preset, number of disparities and the SAD window size. ndisparities must be multiple of 8. - StereoBM_GPU(int preset, int ndisparities = DEFAULT_NDISP, int winSize = DEFAULT_WINSZ); - - //! the stereo correspondence operator. Finds the disparity for the specified rectified stereo pair - //! Output disparity has CV_8U type. - void operator() ( const oclMat &left, const oclMat &right, oclMat &disparity); - - //! Some heuristics that tries to estmate - // if current GPU will be faster then CPU in this algorithm. - // It queries current active device. - static bool checkIfGpuCallReasonable(); - - int preset; - int ndisp; - int winSize; - - // If avergeTexThreshold == 0 => post procesing is disabled - // If avergeTexThreshold != 0 then disparity is set 0 in each point (x,y) where for left image - // SumOfHorizontalGradiensInWindow(x, y, winSize) < (winSize * winSize) * avergeTexThreshold - // i.e. input left image is low textured. - float avergeTexThreshold; - private: - oclMat minSSD, leBuf, riBuf; - }; - - ////////////////////////// StereoBeliefPropagation /////////////////////////// - // "Efficient Belief Propagation for Early Vision" - // P.Felzenszwalb - - class CV_EXPORTS StereoBeliefPropagation - { - public: - enum { DEFAULT_NDISP = 64 }; - enum { DEFAULT_ITERS = 5 }; - enum { DEFAULT_LEVELS = 5 }; - - static void estimateRecommendedParams(int width, int height, int &ndisp, int &iters, int &levels); - - //! the default constructor - explicit StereoBeliefPropagation(int ndisp = DEFAULT_NDISP, - int iters = DEFAULT_ITERS, - int levels = DEFAULT_LEVELS, - int msg_type = CV_16S); - - //! the full constructor taking the number of disparities, number of BP iterations on each level, - //! number of levels, truncation of data cost, data weight, - //! truncation of discontinuity cost and discontinuity single jump - //! DataTerm = data_weight * min(fabs(I2-I1), max_data_term) - //! DiscTerm = min(disc_single_jump * fabs(f1-f2), max_disc_term) - //! please see paper for more details - StereoBeliefPropagation(int ndisp, int iters, int levels, - float max_data_term, float data_weight, - float max_disc_term, float disc_single_jump, - int msg_type = CV_32F); - - //! the stereo correspondence operator. Finds the disparity for the specified rectified stereo pair, - //! if disparity is empty output type will be CV_16S else output type will be disparity.type(). - void operator()(const oclMat &left, const oclMat &right, oclMat &disparity); - - //! version for user specified data term - void operator()(const oclMat &data, oclMat &disparity); - - int ndisp; - - int iters; - int levels; - - float max_data_term; - float data_weight; - float max_disc_term; - float disc_single_jump; - - int msg_type; - private: - oclMat u, d, l, r, u2, d2, l2, r2; - std::vector datas; - oclMat out; - }; - - /////////////////////////// StereoConstantSpaceBP /////////////////////////// - // "A Constant-Space Belief Propagation Algorithm for Stereo Matching" - // Qingxiong Yang, Liang Wangï¿? Narendra Ahuja - // http://vision.ai.uiuc.edu/~qyang6/ - - class CV_EXPORTS StereoConstantSpaceBP - { - public: - enum { DEFAULT_NDISP = 128 }; - enum { DEFAULT_ITERS = 8 }; - enum { DEFAULT_LEVELS = 4 }; - enum { DEFAULT_NR_PLANE = 4 }; - - static void estimateRecommendedParams(int width, int height, int &ndisp, int &iters, int &levels, int &nr_plane); - - //! the default constructor - explicit StereoConstantSpaceBP(int ndisp = DEFAULT_NDISP, - int iters = DEFAULT_ITERS, - int levels = DEFAULT_LEVELS, - int nr_plane = DEFAULT_NR_PLANE, - int msg_type = CV_32F); - - //! the full constructor taking the number of disparities, number of BP iterations on each level, - //! number of levels, number of active disparity on the first level, truncation of data cost, data weight, - //! truncation of discontinuity cost, discontinuity single jump and minimum disparity threshold - StereoConstantSpaceBP(int ndisp, int iters, int levels, int nr_plane, - float max_data_term, float data_weight, float max_disc_term, float disc_single_jump, - int min_disp_th = 0, - int msg_type = CV_32F); - - //! the stereo correspondence operator. Finds the disparity for the specified rectified stereo pair, - //! if disparity is empty output type will be CV_16S else output type will be disparity.type(). - void operator()(const oclMat &left, const oclMat &right, oclMat &disparity); - - int ndisp; - - int iters; - int levels; - - int nr_plane; - - float max_data_term; - float data_weight; - float max_disc_term; - float disc_single_jump; - - int min_disp_th; - - int msg_type; - - bool use_local_init_data_cost; - private: - oclMat u[2], d[2], l[2], r[2]; - oclMat disp_selected_pyr[2]; - - oclMat data_cost; - oclMat data_cost_selected; - - oclMat temp; - - oclMat out; - }; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////CascadeClassifier////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -877,6 +728,7 @@ namespace cv // Supports TM_SQDIFF, TM_CCORR for type 32FC1 and 32FC4 CV_EXPORTS void matchTemplate(const oclMat& image, const oclMat& templ, oclMat& result, int method, MatchTemplateBuf& buf); + ///////////////////////////////////////////// Canny ///////////////////////////////////////////// struct CV_EXPORTS CannyBuf; @@ -889,8 +741,12 @@ namespace cv struct CV_EXPORTS CannyBuf { - CannyBuf() {} - explicit CannyBuf(const Size& image_size, int apperture_size = 3) {create(image_size, apperture_size);} + CannyBuf() : counter(NULL) {} + ~CannyBuf() { release(); } + explicit CannyBuf(const Size& image_size, int apperture_size = 3) : counter(NULL) + { + create(image_size, apperture_size); + } CannyBuf(const oclMat& dx_, const oclMat& dy_); void create(const Size& image_size, int apperture_size = 3); diff --git a/modules/ocl/perf/test_arithm.cpp b/modules/ocl/perf/perf_arithm.cpp similarity index 100% rename from modules/ocl/perf/test_arithm.cpp rename to modules/ocl/perf/perf_arithm.cpp diff --git a/modules/ocl/perf/test_blend.cpp b/modules/ocl/perf/perf_blend.cpp similarity index 100% rename from modules/ocl/perf/test_blend.cpp rename to modules/ocl/perf/perf_blend.cpp diff --git a/modules/ocl/perf/test_canny.cpp b/modules/ocl/perf/perf_canny.cpp similarity index 100% rename from modules/ocl/perf/test_canny.cpp rename to modules/ocl/perf/perf_canny.cpp diff --git a/modules/ocl/perf/test_columnsum.cpp b/modules/ocl/perf/perf_columnsum.cpp similarity index 100% rename from modules/ocl/perf/test_columnsum.cpp rename to modules/ocl/perf/perf_columnsum.cpp diff --git a/modules/ocl/perf/test_fft.cpp b/modules/ocl/perf/perf_fft.cpp similarity index 100% rename from modules/ocl/perf/test_fft.cpp rename to modules/ocl/perf/perf_fft.cpp diff --git a/modules/ocl/perf/test_filters.cpp b/modules/ocl/perf/perf_filters.cpp similarity index 100% rename from modules/ocl/perf/test_filters.cpp rename to modules/ocl/perf/perf_filters.cpp diff --git a/modules/ocl/perf/test_gemm.cpp b/modules/ocl/perf/perf_gemm.cpp similarity index 100% rename from modules/ocl/perf/test_gemm.cpp rename to modules/ocl/perf/perf_gemm.cpp diff --git a/modules/ocl/perf/test_haar.cpp b/modules/ocl/perf/perf_haar.cpp similarity index 100% rename from modules/ocl/perf/test_haar.cpp rename to modules/ocl/perf/perf_haar.cpp diff --git a/modules/ocl/perf/perf_hog.cpp b/modules/ocl/perf/perf_hog.cpp new file mode 100644 index 0000000000..e47220477b --- /dev/null +++ b/modules/ocl/perf/perf_hog.cpp @@ -0,0 +1,167 @@ +/*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) 2010-2012, Multicoreware, Inc., all rights reserved. +// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved. +// Third party copyrights are property of their respective owners. +// +// @Authors +// Peng Xiao, pengxiao@multicorewareinc.com +// +// 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 oclMaterials 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*/ + +#include "precomp.hpp" +#include + +#ifdef HAVE_OPENCL + +using namespace cv; +using namespace cv::ocl; +using namespace cvtest; +using namespace testing; +using namespace std; + +#define FILTER_IMAGE "../../../samples/gpu/road.png" + +#ifndef MWC_TEST_UTILITY +#define MWC_TEST_UTILITY + +// Param class +#ifndef IMPLEMENT_PARAM_CLASS +#define IMPLEMENT_PARAM_CLASS(name, type) \ +class name \ + { \ + public: \ + name ( type arg = type ()) : val_(arg) {} \ + operator type () const {return val_;} \ + private: \ + type val_; \ + }; \ + inline void PrintTo( name param, std::ostream* os) \ + { \ + *os << #name << "(" << testing::PrintToString(static_cast< type >(param)) << ")"; \ + } + +#endif // IMPLEMENT_PARAM_CLASS +#endif // MWC_TEST_UTILITY + +IMPLEMENT_PARAM_CLASS(WinSizw48, bool); + +PARAM_TEST_CASE(HOG, WinSizw48, bool) +{ + bool is48; + vector detector; + virtual void SetUp() + { + is48 = GET_PARAM(0); + if(is48) + { + detector = cv::ocl::HOGDescriptor::getPeopleDetector48x96(); + } + else + { + detector = cv::ocl::HOGDescriptor::getPeopleDetector64x128(); + } + } +}; + +TEST_P(HOG, Performance) +{ + cv::Mat img = readImage(FILTER_IMAGE,cv::IMREAD_GRAYSCALE); + ASSERT_FALSE(img.empty()); + + // define HOG related arguments + float scale = 1.05; + int nlevels = 13; + float gr_threshold = 8; + float hit_threshold = 1.4; + bool hit_threshold_auto = true; + + int win_width = is48? 48 : 64; + int win_stride_width = 8; + int win_stride_height = 8; + + bool gamma_corr = true; + + Size win_size(win_width, win_width * 2); //(64, 128) or (48, 96) + Size win_stride(win_stride_width, win_stride_height); + + cv::ocl::HOGDescriptor gpu_hog(win_size, Size(16, 16), Size(8, 8), Size(8, 8), 9, + cv::ocl::HOGDescriptor::DEFAULT_WIN_SIGMA, 0.2, gamma_corr, + cv::ocl::HOGDescriptor::DEFAULT_NLEVELS); + + gpu_hog.setSVMDetector(detector); + + double totalgputick=0; + double totalgputick_kernel=0; + + double t1=0; + double t2=0; + for(int j = 0; j < LOOP_TIMES+1; j ++) + { + t1 = (double)cvGetTickCount();//gpu start1 + + ocl::oclMat d_src(img);//upload + + t2=(double)cvGetTickCount();//kernel + + vector found; + gpu_hog.detectMultiScale(d_src, found, hit_threshold, win_stride, + Size(0, 0), scale, gr_threshold); + + t2 = (double)cvGetTickCount() - t2;//kernel + + // no download time for HOG + + t1 = (double)cvGetTickCount() - t1;//gpu end1 + + if(j == 0) + continue; + + totalgputick=t1+totalgputick; + + totalgputick_kernel=t2+totalgputick_kernel; + + } + + cout << "average gpu runtime is " << totalgputick/((double)cvGetTickFrequency()* LOOP_TIMES *1000.) << "ms" << endl; + cout << "average gpu runtime without data transfer is " << totalgputick_kernel/((double)cvGetTickFrequency()* LOOP_TIMES *1000.) << "ms" << endl; +} + + +INSTANTIATE_TEST_CASE_P(GPU_ObjDetect, HOG, testing::Combine(testing::Values(WinSizw48(false), WinSizw48(true)), testing::Values(false))); + +#endif //Have opencl \ No newline at end of file diff --git a/modules/ocl/perf/test_imgproc.cpp b/modules/ocl/perf/perf_imgproc.cpp similarity index 78% rename from modules/ocl/perf/test_imgproc.cpp rename to modules/ocl/perf/perf_imgproc.cpp index 95eba5f43a..c1faf6f97e 100644 --- a/modules/ocl/perf/test_imgproc.cpp +++ b/modules/ocl/perf/perf_imgproc.cpp @@ -940,6 +940,239 @@ TEST_P(WarpPerspective, Mat) } +///////////////////////////////////////////////////////////////////////////////////////////////// +// remap +////////////////////////////////////////////////////////////////////////////////////////////////// + +PARAM_TEST_CASE(Remap, MatType, MatType, MatType, int, int) +{ + int srcType; + int map1Type; + int map2Type; + cv::Scalar val; + + int interpolation; + int bordertype; + + cv::Mat src; + cv::Mat dst; + cv::Mat map1; + cv::Mat map2; + + + int src_roicols; + int src_roirows; + int dst_roicols; + int dst_roirows; + int map1_roicols; + int map1_roirows; + int map2_roicols; + int map2_roirows; + int srcx; + int srcy; + int dstx; + int dsty; + int map1x; + int map1y; + int map2x; + int map2y; + + cv::Mat src_roi; + cv::Mat dst_roi; + cv::Mat map1_roi; + cv::Mat map2_roi; + + //ocl mat for testing + cv::ocl::oclMat gdst; + + //ocl mat with roi + cv::ocl::oclMat gsrc_roi; + cv::ocl::oclMat gdst_roi; + cv::ocl::oclMat gmap1_roi; + cv::ocl::oclMat gmap2_roi; + + virtual void SetUp() + { + srcType = GET_PARAM(0); + map1Type = GET_PARAM(1); + map2Type = GET_PARAM(2); + interpolation = GET_PARAM(3); + bordertype = GET_PARAM(4); + + cv::RNG& rng = TS::ptr()->get_rng(); + cv::Size srcSize = cv::Size(MWIDTH, MHEIGHT); + cv::Size dstSize = cv::Size(MWIDTH, MHEIGHT); + cv::Size map1Size = cv::Size(MWIDTH, MHEIGHT); + double min = 5, max = 16; + + if(srcType != nulltype) + { + src = randomMat(rng, srcSize, srcType, min, max, false); + } + if((map1Type == CV_16SC2 && map2Type == nulltype) || (map1Type == CV_32FC2&& map2Type == nulltype)) + { + map1 = randomMat(rng, map1Size, map1Type, min, max, false); + + } + else if (map1Type == CV_32FC1 && map2Type == CV_32FC1) + { + map1 = randomMat(rng, map1Size, map1Type, min, max, false); + map2 = randomMat(rng, map1Size, map1Type, min, max, false); + } + + else + cout<<"The wrong input type"< 0); + //if you want to use undefault device, set it here + //setDevice(oclinfo[0]); + //cv::ocl::setBinpath(CLBINPATH); + } + void Has_roi(int b) + { + if(b) + { + //randomize ROI + dst_roicols = dst.cols - 1; + dst_roirows = dst.rows - 1; + + src_roicols = src.cols - 1; + src_roirows = src.rows - 1; + + + srcx = 1; + srcy = 1; + dstx = 1; + dsty = 1; + } + else + { + dst_roicols = dst.cols; + dst_roirows = dst.rows; + + src_roicols = src.cols; + src_roirows = src.rows; + + + srcx = 0; + srcy = 0; + dstx = 0; + dsty = 0; + } + map1_roicols = dst_roicols; + map1_roirows = dst_roirows; + map2_roicols = dst_roicols; + map2_roirows = dst_roirows; + map1x = dstx; + map1y = dsty; + map2x = dstx; + map2y = dsty; + + if((map1Type == CV_16SC2 && map2Type == nulltype) || (map1Type == CV_32FC2&& map2Type == nulltype)) + { + map1_roi = map1(Rect(map1x,map1y,map1_roicols,map1_roirows)); + gmap1_roi = map1_roi; + } + + else if (map1Type == CV_32FC1 && map2Type == CV_32FC1) + { + map1_roi = map1(Rect(map1x,map1y,map1_roicols,map1_roirows)); + map2_roi = map2(Rect(map2x,map2y,map2_roicols,map2_roirows)); + gmap1_roi = map1_roi; + gmap2_roi = map2_roi; + } + dst_roi = dst(Rect(dstx, dsty, dst_roicols, dst_roirows)); + src_roi = dst(Rect(srcx, srcy, src_roicols, src_roirows)); + + } +}; + +TEST_P(Remap, Mat) +{ + if((interpolation == 1 && map1Type == CV_16SC2) ||(map1Type == CV_32FC1 && map2Type == nulltype) || (map1Type == CV_16SC2 && map2Type == CV_32FC1) || (map1Type == CV_32FC2 && map2Type == CV_32FC1)) + { + cout << "LINEAR don't support the map1Type and map2Type" << endl; + return; + } + int bordertype[] = {cv::BORDER_CONSTANT,cv::BORDER_REPLICATE/*,BORDER_REFLECT,BORDER_WRAP,BORDER_REFLECT_101*/}; + const char* borderstr[]={"BORDER_CONSTANT", "BORDER_REPLICATE"/*, "BORDER_REFLECT","BORDER_WRAP","BORDER_REFLECT_101"*/}; +#ifndef PRINT_KERNEL_RUN_TIME + double totalcputick=0; + double totalgputick=0; + double totalgputick_kernel=0; + double t0=0; + double t1=0; + double t2=0; + for(int k = 0; k < 2; k++){ + totalcputick = 0; + totalgputick = 0; + totalgputick_kernel = 0; + for(int j = 0; j < LOOP_TIMES+1; j++) + { + Has_roi(k); + + t0 = (double)cvGetTickCount();//cpu start + cv::remap(src_roi, dst_roi, map1_roi, map2_roi, interpolation, bordertype[0], val); + t0 = (double)cvGetTickCount() - t0;//cpu end + + t1 = (double)cvGetTickCount();//gpu start + gsrc_roi = src_roi; + gdst = dst; + gdst_roi = gdst(Rect(dstx,dsty,dst_roicols,dst_roirows)); + + t2 = (double)cvGetTickCount();//kernel + cv::ocl::remap(gsrc_roi, gdst_roi, gmap1_roi, gmap2_roi, interpolation, bordertype[0], val); + t2 = (double)cvGetTickCount() - t2;//kernel + + cv::Mat cpu_dst; + gdst.download(cpu_dst); + + t1 = (double)cvGetTickCount() - t1;//gpu end + + if (j == 0) + continue; + totalgputick=t1+totalgputick; + totalcputick=t0+totalcputick; + totalgputick_kernel=t2+totalgputick_kernel; + + } + if(k==0){cout<<"no roi\n";}else{cout<<"with roi\n";}; + cout << "average cpu runtime is " << totalcputick/((double)cvGetTickFrequency()* LOOP_TIMES *1000.) << "ms" << endl; + cout << "average gpu runtime is " << totalgputick/((double)cvGetTickFrequency()* LOOP_TIMES *1000.) << "ms" << endl; + cout << "average gpu runtime without data transfer is " << totalgputick_kernel/((double)cvGetTickFrequency()* LOOP_TIMES *1000.) << "ms" << endl; + } +#else + for(int j = 0; j < 2; j ++) + { + Has_roi(j); + gdst = dst; + gdst_roi = gdst(Rect(dstx,dsty,dst_roicols,dst_roirows)); + gsrc_roi = src_roi; + if(j==0){cout<<"no roi:";}else{cout<<"\nwith roi:";}; + cv::ocl::remap(gsrc_roi, gdst_roi, gmap1_roi, gmap2_roi, interpolation, bordertype[0], val); + }; +#endif + +} + ///////////////////////////////////////////////////////////////////////////////////////////////// // resize @@ -1453,6 +1686,141 @@ TEST_P(meanShiftProc, Mat) } +/////////////////////////////////////////////////////////////////////////////////////////// +//hist + +void calcHistGold(const cv::Mat& src, cv::Mat& hist) +{ + hist.create(1, 256, CV_32SC1); + hist.setTo(cv::Scalar::all(0)); + + int* hist_row = hist.ptr(); + for (int y = 0; y < src.rows; ++y) + { + const uchar* src_row = src.ptr(y); + + for (int x = 0; x < src.cols; ++x) + ++hist_row[src_row[x]]; + } +} + +PARAM_TEST_CASE(histTestBase, MatType, MatType) +{ + int type_src; + + //src mat + cv::Mat src; + cv::Mat dst_hist; + //set up roi + int roicols; + int roirows; + int srcx; + int srcy; + //src mat with roi + cv::Mat src_roi; + //ocl dst mat, dst_hist and gdst_hist don't have roi + cv::ocl::oclMat gdst_hist; + + //ocl mat with roi + cv::ocl::oclMat gsrc_roi; + +// std::vector oclinfo; + + virtual void SetUp() + { + type_src = GET_PARAM(0); + + cv::RNG &rng = TS::ptr()->get_rng(); + cv::Size size = cv::Size(MWIDTH, MHEIGHT); + + src = randomMat(rng, size, type_src, 0, 256, false); + +// int devnums = getDevice(oclinfo); +// CV_Assert(devnums > 0); + //if you want to use undefault device, set it here + //setDevice(oclinfo[0]); + } + + void Has_roi(int b) + { + if(b) + { + //randomize ROI + roicols = src.cols-1; + roirows = src.rows-1; + srcx = 1; + srcy = 1; + }else + { + roicols = src.cols; + roirows = src.rows; + srcx = 0; + srcy = 0; + }; + src_roi = src(Rect(srcx, srcy, roicols, roirows)); + } +}; + +///////////////////////////calcHist/////////////////////////////////////// +struct calcHist : histTestBase {}; + +TEST_P(calcHist, Mat) +{ +#ifndef PRINT_KERNEL_RUN_TIME + double t0=0; + double t1=0; + double t2=0; + for(int k=0;k<2;k++) + { + double totalcputick=0; + double totalgputick=0; + double totalgputick_kernel=0; + for(int j = 0; j < LOOP_TIMES+1; j ++) + { + Has_roi(k); + + t0 = (double)cvGetTickCount();//cpu start + calcHistGold(src_roi, dst_hist); + t0 = (double)cvGetTickCount() - t0;//cpu end + + t1 = (double)cvGetTickCount();//gpu start1 + + gsrc_roi = src_roi; + + t2=(double)cvGetTickCount();//kernel + cv::ocl::calcHist(gsrc_roi, gdst_hist); + t2 = (double)cvGetTickCount() - t2;//kernel + + cv::Mat cpu_hist; + gdst_hist.download(cpu_hist);//download + + t1 = (double)cvGetTickCount() - t1;//gpu end1 + + if(j == 0) + continue; + + totalcputick=t0+totalcputick; + totalgputick=t1+totalgputick; + totalgputick_kernel=t2+totalgputick_kernel; + + } + if(k==0){cout<<"no roi\n";}else{cout<<"with roi\n";}; + cout << "average cpu runtime is " << totalcputick/((double)cvGetTickFrequency()* LOOP_TIMES *1000.) << "ms" << endl; + cout << "average gpu runtime is " << totalgputick/((double)cvGetTickFrequency()* LOOP_TIMES *1000.) << "ms" << endl; + cout << "average gpu runtime without data transfer is " << totalgputick_kernel/((double)cvGetTickFrequency()* LOOP_TIMES *1000.) << "ms" << endl; + } +#else + for(int j = 0; j < 2; j ++) + { + Has_roi(j); + + gsrc_roi = src_roi; + + if(j==0){cout<<"no roi:";}else{cout<<"\nwith roi:";}; + cv::ocl::calcHist(gsrc_roi, gdst_hist); + }; +#endif +} //************test******************* @@ -1547,5 +1915,15 @@ INSTANTIATE_TEST_CASE_P(Imgproc, meanShiftProc, Combine( Values(cv::TermCriteria(cv::TermCriteria::COUNT+cv::TermCriteria::EPS, 5, 1)) )); +INSTANTIATE_TEST_CASE_P(Imgproc, Remap, Combine( + Values(CV_8UC1, CV_8UC4, CV_32FC1, CV_32FC4), + Values(CV_32FC1, CV_16SC2, CV_32FC2),Values(-1,CV_32FC1), + Values((int)cv::INTER_NEAREST, (int)cv::INTER_LINEAR), + Values((int)cv::BORDER_CONSTANT))); + +INSTANTIATE_TEST_CASE_P(histTestBase, calcHist, Combine( + ONE_TYPE(CV_8UC1), + ONE_TYPE(CV_32SC1) //no use +)); #endif // HAVE_OPENCL diff --git a/modules/ocl/perf/test_match_template.cpp b/modules/ocl/perf/perf_match_template.cpp similarity index 100% rename from modules/ocl/perf/test_match_template.cpp rename to modules/ocl/perf/perf_match_template.cpp diff --git a/modules/ocl/perf/test_matrix_operation.cpp b/modules/ocl/perf/perf_matrix_operation.cpp similarity index 100% rename from modules/ocl/perf/test_matrix_operation.cpp rename to modules/ocl/perf/perf_matrix_operation.cpp diff --git a/modules/ocl/perf/test_pyrdown.cpp b/modules/ocl/perf/perf_pyrdown.cpp similarity index 100% rename from modules/ocl/perf/test_pyrdown.cpp rename to modules/ocl/perf/perf_pyrdown.cpp diff --git a/modules/ocl/perf/test_pyrup.cpp b/modules/ocl/perf/perf_pyrup.cpp similarity index 100% rename from modules/ocl/perf/test_pyrup.cpp rename to modules/ocl/perf/perf_pyrup.cpp diff --git a/modules/ocl/perf/test_split_merge.cpp b/modules/ocl/perf/perf_split_merge.cpp similarity index 100% rename from modules/ocl/perf/test_split_merge.cpp rename to modules/ocl/perf/perf_split_merge.cpp diff --git a/modules/ocl/perf/perf_surf.cpp b/modules/ocl/perf/perf_surf.cpp new file mode 100644 index 0000000000..d3f0e3c6bf --- /dev/null +++ b/modules/ocl/perf/perf_surf.cpp @@ -0,0 +1,103 @@ +/*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) 2010-2012, Multicoreware, Inc., all rights reserved. +// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved. +// Third party copyrights are property of their respective owners. +// +// @Authors +// Peng Xiao, pengxiao@multicorewareinc.com +// +// 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 oclMaterials 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*/ + +#include "precomp.hpp" +#include + +#ifdef HAVE_OPENCL + +using namespace cv; +using namespace cv::ocl; +using namespace cvtest; +using namespace testing; +using namespace std; + +#define FILTER_IMAGE "../../../samples/gpu/road.png" + +TEST(SURF, Performance) +{ + cv::Mat img = readImage(FILTER_IMAGE,cv::IMREAD_GRAYSCALE); + ASSERT_FALSE(img.empty()); + + ocl::SURF_OCL d_surf; + ocl::oclMat d_keypoints; + ocl::oclMat d_descriptors; + + double totalgputick=0; + double totalgputick_kernel=0; + + double t1=0; + double t2=0; + for(int j = 0; j < LOOP_TIMES+1; j ++) + { + t1 = (double)cvGetTickCount();//gpu start1 + + ocl::oclMat d_src(img);//upload + + t2=(double)cvGetTickCount();//kernel + d_surf(d_src, ocl::oclMat(), d_keypoints, d_descriptors); + t2 = (double)cvGetTickCount() - t2;//kernel + + cv::Mat cpu_kp, cpu_dp; + d_keypoints.download (cpu_kp);//download + d_descriptors.download (cpu_dp);//download + + t1 = (double)cvGetTickCount() - t1;//gpu end1 + + if(j == 0) + continue; + + totalgputick=t1+totalgputick; + + totalgputick_kernel=t2+totalgputick_kernel; + + } + + cout << "average gpu runtime is " << totalgputick/((double)cvGetTickFrequency()* LOOP_TIMES *1000.) << "ms" << endl; + cout << "average gpu runtime without data transfer is " << totalgputick_kernel/((double)cvGetTickFrequency()* LOOP_TIMES *1000.) << "ms" << endl; + + +} +#endif //Have opencl \ No newline at end of file diff --git a/modules/ocl/perf/test_hog.cpp b/modules/ocl/perf/test_hog.cpp deleted file mode 100644 index 9abcb20717..0000000000 --- a/modules/ocl/perf/test_hog.cpp +++ /dev/null @@ -1,218 +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. -// -// -// Intel License Agreement -// For Open Source Computer Vision Library -// -// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved. -// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved. -// Third party copyrights are property of their respective owners. -// -// @Authors -// Fangfang BAI, fangfang@multicorewareinc.com -// -// 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 Intel Corporation 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*/ - -#include "precomp.hpp" -#include "opencv2/core/core.hpp" -#include -using namespace std; - - - -#ifdef HAVE_OPENCL - - -PARAM_TEST_CASE(HOG,cv::Size,int) -{ - cv::Size winSize; - int type; - std::vector oclinfo; - - virtual void SetUp() - { - winSize = GET_PARAM(0); - type = GET_PARAM(1); - int devnums = getDevice(oclinfo); - CV_Assert(devnums > 0); - } -}; - -TEST_P(HOG, GetDescriptors) -{ - // Load image - cv::Mat img_rgb = readImage("D:road.png"); - ASSERT_FALSE(img_rgb.empty()); - - // Convert image - cv::Mat img; - switch (type) - { - case CV_8UC1: - cv::cvtColor(img_rgb, img, CV_BGR2GRAY); - break; - case CV_8UC4: - default: - cv::cvtColor(img_rgb, img, CV_BGR2BGRA); - break; - } - // HOGs - cv::ocl::HOGDescriptor ocl_hog; - ocl_hog.gamma_correction = true; - - - // Compute descriptor - cv::ocl::oclMat d_descriptors; - //down_descriptors = down_descriptors.reshape(0, down_descriptors.cols * down_descriptors.rows); - - double totalgputick=0; - double totalgputick_kernel=0; - double t1=0; - double t2=0; - - for(int j = 0; j < LOOP_TIMES+1; j ++) - { - - t1 = (double)cvGetTickCount();//gpu start1 - - cv::ocl::oclMat d_img=cv::ocl::oclMat(img);//upload - - t2=(double)cvGetTickCount();//kernel - ocl_hog.getDescriptors(d_img, ocl_hog.win_size, d_descriptors, ocl_hog.DESCR_FORMAT_COL_BY_COL); - t2 = (double)cvGetTickCount() - t2;//kernel - - cv::Mat down_descriptors; - d_descriptors.download(down_descriptors); - - t1 = (double)cvGetTickCount() - t1;//gpu end1 - - if(j == 0) - continue; - - totalgputick=t1+totalgputick; - totalgputick_kernel=t2+totalgputick_kernel; - - } - - cout << "average gpu runtime is " << totalgputick/((double)cvGetTickFrequency()* LOOP_TIMES *1000.) << "ms" << endl; - cout << "average gpu runtime without data transfer is " << totalgputick_kernel/((double)cvGetTickFrequency()* LOOP_TIMES *1000.) << "ms" << endl; - - -} - - -TEST_P(HOG, Detect) -{ - // Load image - cv::Mat img_rgb = readImage("D:road.png"); - ASSERT_FALSE(img_rgb.empty()); - - // Convert image - cv::Mat img; - switch (type) - { - case CV_8UC1: - cv::cvtColor(img_rgb, img, CV_BGR2GRAY); - break; - case CV_8UC4: - default: - cv::cvtColor(img_rgb, img, CV_BGR2BGRA); - break; - } - - // HOGs - if ((winSize != cv::Size(48, 96)) && (winSize != cv::Size(64, 128))) - winSize = cv::Size(64, 128); - cv::ocl::HOGDescriptor ocl_hog(winSize); - ocl_hog.gamma_correction = true; - - cv::HOGDescriptor hog; - hog.winSize = winSize; - hog.gammaCorrection = true; - - if (winSize.width == 48 && winSize.height == 96) - { - // daimler's base - ocl_hog.setSVMDetector(ocl_hog.getPeopleDetector48x96()); - hog.setSVMDetector(hog.getDaimlerPeopleDetector()); - } - else if (winSize.width == 64 && winSize.height == 128) - { - ocl_hog.setSVMDetector(ocl_hog.getPeopleDetector64x128()); - hog.setSVMDetector(hog.getDefaultPeopleDetector()); - } - else - { - ocl_hog.setSVMDetector(ocl_hog.getDefaultPeopleDetector()); - hog.setSVMDetector(hog.getDefaultPeopleDetector()); - } - - // OpenCL detection - std::vector d_v_locations; - - double totalgputick=0; - double totalgputick_kernel=0; - double t1=0; - double t2=0; - - for(int j = 0; j < LOOP_TIMES+1; j ++) - { - - t1 = (double)cvGetTickCount();//gpu start1 - - cv::ocl::oclMat d_img=cv::ocl::oclMat(img);//upload - - t2=(double)cvGetTickCount();//kernel - ocl_hog.detect(d_img, d_v_locations, 0); - t2 = (double)cvGetTickCount() - t2;//kernel - - t1 = (double)cvGetTickCount() - t1;//gpu end1 - if(j == 0) - continue; - totalgputick=t1+totalgputick; - totalgputick_kernel=t2+totalgputick_kernel; - - } - - cout << "average gpu runtime is " << totalgputick/((double)cvGetTickFrequency()* LOOP_TIMES *1000.) << "ms" << endl; - cout << "average gpu runtime without data transfer is " << totalgputick_kernel/((double)cvGetTickFrequency()* LOOP_TIMES *1000.) << "ms" << endl; - -} - - -INSTANTIATE_TEST_CASE_P(OCL_ObjDetect, HOG, testing::Combine( - testing::Values(cv::Size(64, 128), cv::Size(48, 96)), - testing::Values(MatType(CV_8UC1), MatType(CV_8UC4)))); - - -#endif //HAVE_OPENCL diff --git a/modules/ocl/src/arithm.cpp b/modules/ocl/src/arithm.cpp index ac1d7b2f19..783afa1c5c 100644 --- a/modules/ocl/src/arithm.cpp +++ b/modules/ocl/src/arithm.cpp @@ -1155,13 +1155,13 @@ void arithmetic_lut_run(const oclMat &src1, const oclMat &src2, oclMat &dst, str int rows = src1.rows; int cols = src1.cols; //int step = src1.step; - int src_step = src1.step; - int dst_step = dst.step; + int src_step = src1.step/ src1.elemSize(); + int dst_step = dst.step/ dst.elemSize(); int whole_rows = src1.wholerows; int whole_cols = src1.wholecols; - int src_offset = src1.offset; - int dst_offset = dst.offset; - int lut_offset = src2.offset; + int src_offset = src1.offset/ src1.elemSize(); + int dst_offset = dst.offset/ dst.elemSize(); + int lut_offset = src2.offset/ src2.elemSize(); int left_col = 0, right_col = 0; size_t localSize[] = {16, 16, 1}; //cl_kernel kernel = openCLGetKernelFromSource(clCxt,&arithm_LUT,kernelName); @@ -2381,4 +2381,5 @@ void cv::ocl::pow(const oclMat &x, double p, oclMat &y) arithmetic_pow_run(x, p, y, kernelName, &arithm_pow); } + #endif /* !defined (HAVE_OPENCL) */ diff --git a/modules/ocl/src/canny.cpp b/modules/ocl/src/canny.cpp index 4fd5a3f3ea..2ff395498b 100644 --- a/modules/ocl/src/canny.cpp +++ b/modules/ocl/src/canny.cpp @@ -171,10 +171,10 @@ void cv::ocl::Canny(const oclMat& src, CannyBuf& buf, oclMat& dst, double low_th std::swap( low_thresh, high_thresh ); dst.create(src.size(), CV_8U); - //dst.setTo(Scalar::all(0)); + dst.setTo(Scalar::all(0)); buf.create(src.size(), apperture_size); - //buf.edgeBuf.setTo(Scalar::all(0)); + buf.edgeBuf.setTo(Scalar::all(0)); if (apperture_size == 3) { @@ -207,11 +207,11 @@ void cv::ocl::Canny(const oclMat& dx, const oclMat& dy, CannyBuf& buf, oclMat& d std::swap( low_thresh, high_thresh); dst.create(dx.size(), CV_8U); - //dst.setTo(Scalar::all(0)); + dst.setTo(Scalar::all(0)); buf.dx = dx; buf.dy = dy; buf.create(dx.size(), -1); - //buf.edgeBuf.setTo(Scalar::all(0)); + buf.edgeBuf.setTo(Scalar::all(0)); calcMagnitude_gpu(buf.dx, buf.dy, buf.edgeBuf, dx.rows, dx.cols, L2gradient); CannyCaller(buf, dst, static_cast(low_thresh), static_cast(high_thresh)); @@ -367,7 +367,6 @@ void canny::edgesHysteresisGlobal_gpu(oclMat& map, oclMat& st1, oclMat& st2, voi while(count > 0) { - //counter.setTo(0); args.clear(); size_t globalThreads[3] = {std::min(count, 65535u) * 128, DIVUP(count, 65535), 1}; args.push_back( make_pair( sizeof(cl_mem), (void *)&map.data)); diff --git a/modules/ocl/src/imgproc.cpp b/modules/ocl/src/imgproc.cpp index 4052f23f96..9a8e05d377 100644 --- a/modules/ocl/src/imgproc.cpp +++ b/modules/ocl/src/imgproc.cpp @@ -103,6 +103,11 @@ void cv::ocl::bilateralFilter(const oclMat &, oclMat &, int, double, double, int { throw_nogpu(); } +void cv::ocl::convolve(const oclMat&, const oclMat&, oclMat&) +{ + throw_nogpu(); +} + #else /* !defined (HAVE_OPENCL) */ namespace cv @@ -126,6 +131,7 @@ namespace cv extern const char *imgproc_bilateral; extern const char *imgproc_calcHarris; extern const char *imgproc_calcMinEigenVal; + extern const char *imgproc_convolve; ////////////////////////////////////OpenCL call wrappers//////////////////////////// template struct index_and_sizeof; @@ -680,6 +686,19 @@ namespace cv size_t localThreads[3] = {256, 1, 1}; openCLExecuteKernel(clCxt, &imgproc_copymakeboder, kernelName, globalThreads, localThreads, args, 1, D); +/* uchar* cputemp=new uchar[32*dst.wholerows]; + //int* cpudata=new int[this->step*this->wholerows/sizeof(int)]; + openCLSafeCall(clEnqueueReadBuffer(clCxt->impl->clCmdQueue, (cl_mem)dst.data, CL_TRUE, + 0, 32*dst.wholerows, cputemp, 0, NULL, NULL)); + for(int i=0;i> 2; int left_col = 0, right_col = 0; - if(cols > 6) - { - left_col = 4 - (src_offset & 3); - left_col &= 3; - //dst_offset +=left_col; - src_offset += left_col; - cols -= left_col; - right_col = cols & 3; - cols -= right_col; - //globalThreads[0] = (cols/4+globalThreads[0]-1)/localThreads[0]*localThreads[0]; - } - else - { - left_col = cols; - right_col = 0; - cols = 0; - globalThreads[0] = 0; - } + + left_col = dataWidth - (src_offset & mask); + left_col &= mask; + src_offset += left_col; + cols -= left_col; + right_col = cols & mask; + cols -= right_col; vector > args; - if(globalThreads[0] != 0) + if(cols > 0) { - int tempcols = cols / 4; - int inc_x = globalThreads[0] % tempcols; - int inc_y = globalThreads[0] / tempcols; - src_offset /= 4; - int src_step = mat_src.step / 4; - int datacount = tempcols * mat_src.rows * mat_src.channels(); - args.push_back( make_pair( sizeof(cl_mem), (void *)&mat_src.data)); - args.push_back( make_pair( sizeof(cl_int), (void *)&src_step)); - args.push_back( make_pair( sizeof(cl_int), (void *)&src_offset)); - args.push_back( make_pair( sizeof(cl_mem), (void *)&mat_sub_hist.data)); - args.push_back( make_pair( sizeof(cl_int), (void *)&datacount)); - args.push_back( make_pair( sizeof(cl_int), (void *)&tempcols)); - args.push_back( make_pair( sizeof(cl_int), (void *)&inc_x)); - args.push_back( make_pair( sizeof(cl_int), (void *)&inc_y)); - args.push_back( make_pair( sizeof(cl_int), (void *)&hist_step)); - openCLExecuteKernel(clCxt, &imgproc_histogram, kernelName, globalThreads, localThreads, args, -1, depth); + int tempcols = cols >> dataWidth_bits; + int inc_x = globalThreads[0] % tempcols; + int inc_y = globalThreads[0] / tempcols; + src_offset >>= dataWidth_bits; + int src_step = mat_src.step >> dataWidth_bits; + int datacount = tempcols * mat_src.rows; + args.push_back( make_pair( sizeof(cl_mem), (void *)&mat_src.data)); + args.push_back( make_pair( sizeof(cl_int), (void *)&src_step)); + args.push_back( make_pair( sizeof(cl_int), (void *)&src_offset)); + args.push_back( make_pair( sizeof(cl_mem), (void *)&mat_sub_hist.data)); + args.push_back( make_pair( sizeof(cl_int), (void *)&datacount)); + args.push_back( make_pair( sizeof(cl_int), (void *)&tempcols)); + args.push_back( make_pair( sizeof(cl_int), (void *)&inc_x)); + args.push_back( make_pair( sizeof(cl_int), (void *)&inc_y)); + args.push_back( make_pair( sizeof(cl_int), (void *)&hist_step)); + openCLExecuteKernel(clCxt, &imgproc_histogram, kernelName, globalThreads, localThreads, args, -1, depth); } if(left_col != 0 || right_col != 0) { - kernelName = "calc_sub_hist2"; + kernelName = "calc_sub_hist_border"; src_offset = mat_src.offset; - //dst_offset = dst.offset; localThreads[0] = 1; localThreads[1] = 256; globalThreads[0] = left_col + right_col; globalThreads[1] = (mat_src.rows + localThreads[1] - 1) / localThreads[1] * localThreads[1]; - //kernel = openCLGetKernelFromSource(clCxt,&arithm_LUT,"LUT2"); + args.clear(); args.push_back( make_pair( sizeof(cl_mem), (void *)&mat_src.data)); args.push_back( make_pair( sizeof(cl_int), (void *)&mat_src.step)); @@ -1370,7 +1384,8 @@ namespace cv mat_hist.create(1, 256, CV_32SC1); oclMat buf(PARTIAL_HISTOGRAM256_COUNT, HISTOGRAM256_BIN_COUNT, CV_32SC1); - //buf.setTo(0); + buf.setTo(0); + calc_sub_hist(mat_src, buf); merge_sub_hist(buf, mat_hist); } @@ -1484,4 +1499,58 @@ namespace cv } } +//////////////////////////////////convolve//////////////////////////////////////////////////// +inline int divUp(int total, int grain) +{ + return (total + grain - 1) / grain; +} +void convolve_run(const oclMat &src, const oclMat &temp1,oclMat &dst,string kernelName,const char** kernelString) +{ + CV_Assert(src.depth() == CV_32FC1); + CV_Assert(temp1.depth() == CV_32F); + CV_Assert(temp1.cols <= 17 && temp1.rows <=17); + + dst.create(src.size(),src.type()); + + CV_Assert(src.cols == dst.cols && src.rows == dst.rows); + CV_Assert(src.type() == dst.type()); + + Context *clCxt = src.clCxt; + int channels = dst.channels(); + int depth = dst.depth(); + + size_t vector_length =1; + int offset_cols = ((dst.offset % dst.step) / dst.elemSize1()) & (vector_length-1); + int cols = divUp(dst.cols * channels + offset_cols, vector_length); + int rows = dst.rows; + + size_t localThreads[3] = { 16, 16, 1 }; + size_t globalThreads[3] = { divUp(cols, localThreads[0]) * localThreads[0], + divUp(rows, localThreads[1]) * localThreads[1], + 1}; + + vector > args; + args.push_back( make_pair( sizeof(cl_mem), (void *)&src.data )); + args.push_back( make_pair( sizeof(cl_mem), (void *)&temp1.data )); + args.push_back( make_pair( sizeof(cl_mem), (void *)&dst.data )); + args.push_back( make_pair( sizeof(cl_int), (void *)&src.rows )); + args.push_back( make_pair( sizeof(cl_int), (void *)&cols )); + args.push_back( make_pair( sizeof(cl_int), (void *)&src.step )); + args.push_back( make_pair( sizeof(cl_int), (void *)&dst.step )); + args.push_back( make_pair( sizeof(cl_int), (void *)&temp1.step )); + args.push_back( make_pair( sizeof(cl_int), (void *)&temp1.rows )); + args.push_back( make_pair( sizeof(cl_int), (void *)&temp1.cols )); + + openCLExecuteKernel(clCxt, kernelString, kernelName, globalThreads, localThreads, args, -1, depth); +} +void cv::ocl::convolve(const oclMat& x, const oclMat& t, oclMat& y) +{ + CV_Assert(x.depth() == CV_32F); + CV_Assert(t.depth() == CV_32F); + CV_Assert(x.type() == y.type() && x.size() == y.size()); + y.create(x.size(),x.type()); + string kernelName = "convolve"; + + convolve_run(x, t, y, kernelName, &imgproc_convolve); +} #endif /* !defined (HAVE_OPENCL) */ diff --git a/modules/ocl/src/initialization.cpp b/modules/ocl/src/initialization.cpp index 42ad8bc120..008633be9b 100644 --- a/modules/ocl/src/initialization.cpp +++ b/modules/ocl/src/initialization.cpp @@ -538,11 +538,11 @@ namespace cv if(NULL != build_options) { - src_sign << (int64)source << clCxt->impl->clContext << "_" << build_options; + src_sign << (int64)(*source) << clCxt->impl->clContext << "_" << build_options; } else { - src_sign << (int64)source << clCxt->impl->clContext; + src_sign << (int64)(*source) << clCxt->impl->clContext; } srcsign = src_sign.str(); @@ -562,11 +562,11 @@ namespace cv strcat(all_build_options, build_options); if(all_build_options != NULL) { - filename = clCxt->impl->Binpath + "\\" + kernelName + "_" + clCxt->impl->devName + all_build_options + ".clb"; + filename = clCxt->impl->Binpath + kernelName + "_" + clCxt->impl->devName + all_build_options + ".clb"; } else { - filename = clCxt->impl->Binpath + "\\" + kernelName + "_" + clCxt->impl->devName + ".clb"; + filename = clCxt->impl->Binpath + kernelName + "_" + clCxt->impl->devName + ".clb"; } FILE *fp; diff --git a/modules/ocl/src/kernels/arithm_LUT.cl b/modules/ocl/src/kernels/arithm_LUT.cl index 9400ac641a..a5d30df7f2 100644 --- a/modules/ocl/src/kernels/arithm_LUT.cl +++ b/modules/ocl/src/kernels/arithm_LUT.cl @@ -125,38 +125,38 @@ __kernel void LUT_C4_D0( __global uchar4 *dst, __global uchar4 *src, __constant uchar *table, - uint rows, - uint cols, - uint channels, - uint whole_rows, - uint whole_cols, - uint src_offset, - uint dst_offset, - uint lut_offset, - uint src_step, - uint dst_step) + int rows, + int cols, + int channels, + int whole_rows, + int whole_cols, + int src_offset, + int dst_offset, + int lut_offset, + int src_step, + int dst_step) { - uint gidx = get_global_id(0); - uint gidy = get_global_id(1); + int gidx = get_global_id(0); + int gidy = get_global_id(1); - uint lidx = get_local_id(0); - uint lidy = get_local_id(1); - + int lidx = get_local_id(0); + int lidy = get_local_id(1); + + int src_index = mad24(gidy,src_step,gidx+src_offset); + int dst_index = mad24(gidy,dst_step,gidx+dst_offset); __local uchar l[256]; l[lidy*16+lidx] = table[lidy*16+lidx+lut_offset]; - mem_fence(CLK_LOCAL_MEM_FENCE); + //mem_fence(CLK_LOCAL_MEM_FENCE); barrier(CLK_LOCAL_MEM_FENCE); - - gidx = gidx >= cols?cols-1:gidx; - gidy = gidy >= rows?rows-1:gidy; - uint src_index = src_offset/4 + gidy * src_step/4 + gidx; - - uint dst_index = dst_offset/4 + gidy * dst_step/4 + gidx; - - uchar4 p = src[src_index]; - dst[dst_index].x = l[p.x]; - dst[dst_index].y = l[p.y]; - dst[dst_index].z = l[p.z]; - dst[dst_index].w = l[p.w]; + if(gidx=cols); + outx = select(outx,outx-cols,outx>=cols); + //outpix3 = select(outpix3, outpix0, (uchar4)(outy.w>=rows)); + //outpix2 = select(outpix2, outpix0, (uchar4)(outy.z>=rows)); + //outpix1 = select(outpix1, outpix0, (uchar4)(outy.y>=rows)); + //outx = select(outx,(int4)outx.x,outy>=rows); + //outy = select(outy,(int4)outy.x,outy>=rows); + int4 addr = mad24(outy,(int4)dstStep_in_piexl,outx); if(outx.w=(int4)cols); + y4=clamp(y4,(int4)0,(int4)(rows-1)); x4 = select(x4,x4-(int4)cols,x4>=(int4)cols); int4 addr = mad24(y4,(int4)srcStep_in_pixel,x4); GENTYPE4 pixel0,pixel1,pixel2,pixel3, outpixel1, outpixel2; - //read data from src pixel0 = src[addr.x]; pixel1 = src[addr.y]; pixel2 = src[addr.z]; @@ -137,40 +120,23 @@ __kernel void convertC4C3(__global const GENTYPE4 * restrict src, __global GENTY outpixel2.y = pixel3.x; outpixel2.z = pixel3.y; outpixel2.w = pixel3.z; - - //permutate the data in LDS to avoid global memory conflict - __local GENTYPE4 rearrange[WORKGROUPSIZE*3]; - int lid = mul24((int)get_local_id(0),3); - rearrange[lid++] = pixel0; - rearrange[lid++] = outpixel1; - rearrange[lid] = outpixel2; - barrier(CLK_LOCAL_MEM_FENCE); - lid = get_local_id(0); - pixel0 = rearrange[lid]; - lid+=WORKGROUPSIZE; - outpixel1 = rearrange[lid]; - lid+=WORKGROUPSIZE; - outpixel2 = rearrange[lid]; - - //calcultate output index - int3 startid = mad24((int)get_group_id(0),WORKGROUPSIZE*3,(int)get_local_id(0)); - startid.y+=WORKGROUPSIZE; - startid.z+=WORKGROUPSIZE*2; - //id = mul24(id>>2 , 3); - - if(startid.z <= pixel_end) + int4 outaddr = mul24(id>>2 , 3); + outaddr.y++; + outaddr.z+=2; + //printf("%d ",outaddr.z); + if(outaddr.z <= pixel_end) { - dst[startid.x] = pixel0; - dst[startid.y] = outpixel1; - dst[startid.z] = outpixel2; + dst[outaddr.x] = pixel0; + dst[outaddr.y] = outpixel1; + dst[outaddr.z] = outpixel2; } - else if(startid.y <= pixel_end) + else if(outaddr.y <= pixel_end) { - dst[startid.x] = pixel0; - dst[startid.y] = outpixel1; + dst[outaddr.x] = pixel0; + dst[outaddr.y] = outpixel1; } - else if(startid.x <= pixel_end) + else if(outaddr.x <= pixel_end) { - dst[startid.x] = pixel0; - } + dst[outaddr.x] = pixel0; + } } diff --git a/modules/ocl/src/kernels/filter_sep_col.cl b/modules/ocl/src/kernels/filter_sep_col.cl index bfb8cac179..71c8c6d484 100644 --- a/modules/ocl/src/kernels/filter_sep_col.cl +++ b/modules/ocl/src/kernels/filter_sep_col.cl @@ -87,6 +87,7 @@ The length of the convovle kernel supported is only related to the MAX size of L which is HW related. Niko 6/29/2011 +The info above maybe obsolete. ***********************************************************************************/ diff --git a/modules/ocl/src/kernels/filter_sep_row.cl b/modules/ocl/src/kernels/filter_sep_row.cl index 348ac5c216..ab1d233bfc 100644 --- a/modules/ocl/src/kernels/filter_sep_row.cl +++ b/modules/ocl/src/kernels/filter_sep_row.cl @@ -92,6 +92,7 @@ For channels = 2, the RADIUS is no more than LSIZE0 For channels = 4, arbitary RADIUS is supported unless the LDS is not enough Niko 6/29/2011 +The info above maybe obsolete. ***********************************************************************************/ __kernel __attribute__((reqd_work_group_size(LSIZE0,LSIZE1,1))) void row_filter_C1_D0 diff --git a/modules/ocl/src/kernels/haarobjectdetect.cl b/modules/ocl/src/kernels/haarobjectdetect.cl index d0f6cebc89..b4f469f528 100644 --- a/modules/ocl/src/kernels/haarobjectdetect.cl +++ b/modules/ocl/src/kernels/haarobjectdetect.cl @@ -302,7 +302,9 @@ __kernel void __attribute__((reqd_work_group_size(8,8,1)))gpuRunHaarClassifierCa nodecounter = splitnode; for(int stageloop = split_stage; stageloop< end_stage && queuecount>0;stageloop++) { - lclcount[0]=0; + //barrier(CLK_LOCAL_MEM_FENCE); + //if(lcl_id == 0) + lclcount[0]=0; barrier(CLK_LOCAL_MEM_FENCE); int2 stageinfo = *(global int2*)(stagecascadeptr+stageloop); @@ -314,14 +316,17 @@ __kernel void __attribute__((reqd_work_group_size(8,8,1)))gpuRunHaarClassifierCa int lcl_compute_win_id = (lcl_id >>(6-perfscale)); int lcl_loops = (stageinfo.x + lcl_compute_win -1) >> (6-perfscale); int lcl_compute_id = lcl_id - (lcl_compute_win_id << (6-perfscale)); - for(int queueloop=0;queueloop>16),readwidth,temp_coord & 0xffff); - int tempnodecounter = lcl_compute_id; + //barrier(CLK_LOCAL_MEM_FENCE); + if(lcl_compute_win_id < queuecount) { + + int tempnodecounter = lcl_compute_id; float part_sum = 0.f; for(int lcl_loop=0;lcl_loop= nodethreshold ? alpha2.y : alpha2.x; - tempnodecounter+=lcl_compute_win; + tempnodecounter +=lcl_compute_win; }//end for(int lcl_loop=0;lcl_loop0;stageloop++) + //barrier(CLK_LOCAL_MEM_FENCE); if(lcl_id> 2) + min(max(gx - 8, 0), cols - 1)]; + + // 0 | 0 x | x + // ----------- + // 0 | 0 x | x + // 0 | 0 0 | 0 + // ----------- + // 0 | 0 0 | 0 + smem[y][x + 16] = src[min(max(gy - 8, 0), rows - 1)*(src_step >> 2) + min(gx + 8, cols - 1)]; + + // 0 | 0 0 | 0 + // ----------- + // 0 | 0 0 | 0 + // x | x 0 | 0 + // ----------- + // x | x 0 | 0 + smem[y + 16][x] = src[min(gy + 8, rows - 1)*(src_step >> 2) + min(max(gx - 8, 0), cols - 1)]; + + // 0 | 0 0 | 0 + // ----------- + // 0 | 0 0 | 0 + // 0 | 0 x | x + // ----------- + // 0 | 0 x | x + smem[y + 16][x + 16] = src[min(gy + 8, rows - 1)*(src_step >> 2) + min(gx + 8, cols - 1)]; + + barrier(CLK_LOCAL_MEM_FENCE); + + if (gx < cols && gy < rows) + { + float res = 0; + + for (int i = 0; i < kHeight; ++i) + { + for (int j = 0; j < kWidth; ++j) + { + res += smem[y + 8 - kHeight / 2 + i][x + 8 - kWidth / 2 + j] * temp1[i * (k_step>>2) + j]; + } + } + dst[gy*(dst_step >> 2)+gx] = res; + } +} + + diff --git a/modules/ocl/src/kernels/imgproc_histogram.cl b/modules/ocl/src/kernels/imgproc_histogram.cl index 25c9034061..83f50c22a3 100644 --- a/modules/ocl/src/kernels/imgproc_histogram.cl +++ b/modules/ocl/src/kernels/imgproc_histogram.cl @@ -8,6 +8,7 @@ // @Authors // Niko Li, newlife20080214@gmail.com // Jia Haipeng, jiahaipeng95@gmail.com +// Xu Pang, pangxu010@163.com // Redistribution and use in source and binary forms, with or without modification, // are permitted provided that the following conditions are met: // @@ -33,89 +34,127 @@ // the use of this software, even if advised of the possibility of such damage. // // -#define PARTITAL_HISTGRAM256_COUNT (256) +#define PARTIAL_HISTOGRAM256_COUNT (256) #define HISTOGRAM256_BIN_COUNT (256) -#define HISTGRAM256_WORK_GROUP_SIZE (256) -#define HISTGRAM256_LOCAL_MEM_SIZE (HISTOGRAM256_BIN_COUNT) +#define HISTOGRAM256_WORK_GROUP_SIZE (256) +#define HISTOGRAM256_LOCAL_MEM_SIZE (HISTOGRAM256_BIN_COUNT) -__kernel __attribute__((reqd_work_group_size(256,1,1)))void calc_sub_hist_D0(__global const uchar4* src, - int src_step, - int src_offset, - __global int* buf, - int data_count, - int cols, - int inc_x, - int inc_y, - int dst_offset) +#define NBANKS (16) +#define NBANKS_BIT (4) + + +__kernel __attribute__((reqd_work_group_size(HISTOGRAM256_BIN_COUNT,1,1)))void calc_sub_hist_D0( + __global const uint4* src, + int src_step, int src_offset, + __global int* globalHist, + int dataCount, int cols, + int inc_x, int inc_y, + int hist_step) { - int x = get_global_id(0); - int lx = get_local_id(0); - int gx = get_group_id(0); - int total_threads = get_global_size(0); - src += src_offset; - __local int s_hist[HISTGRAM256_LOCAL_MEM_SIZE]; - s_hist[lx] = 0; - - int pos_y = x / cols; - int pos_x = x - mul24(pos_y, cols); - barrier(CLK_LOCAL_MEM_FENCE); - for(int pos = x; pos < data_count; pos += total_threads) - { - int4 data = convert_int4(src[mad24(pos_y,src_step,pos_x)]); - atomic_inc(s_hist + data.x); - atomic_inc(s_hist + data.y); - atomic_inc(s_hist + data.z); - atomic_inc(s_hist + data.w); - - pos_x +=inc_x; - int off = (pos_x >= cols ? -1 : 0); - pos_x = mad24(off,cols,pos_x); - pos_y += inc_y - off; - - //pos_x = pos_x > cols ? pos_x - cols : pos_x; - //pos_y = pos_x > cols ? pos_y + 1 : pos_y; - } - barrier(CLK_LOCAL_MEM_FENCE); - buf[ mad24(gx, dst_offset, lx)] = s_hist[lx]; + __local int subhist[(HISTOGRAM256_BIN_COUNT << NBANKS_BIT)]; // NBINS*NBANKS + int gid = get_global_id(0); + int lid = get_local_id(0); + int gx = get_group_id(0); + int gsize = get_global_size(0); + int lsize = get_local_size(0); + const int shift = 8; + const int mask = HISTOGRAM256_BIN_COUNT-1; + int offset = (lid & (NBANKS-1));// lid % NBANKS + uint4 data, temp1, temp2, temp3, temp4; + src += src_offset; + + //clear LDS + for(int i=0, idx=lid; i<(NBANKS >> 2); i++, idx += lsize) + { + subhist[idx] = 0; + subhist[idx+=lsize] = 0; + subhist[idx+=lsize] = 0; + subhist[idx+=lsize] = 0; + } + barrier(CLK_LOCAL_MEM_FENCE); + + //read and scatter + int y = gid/cols; + int x = gid - mul24(y, cols); + for(int idx=gid; idx>= shift; + temp2 = ((data & mask) << NBANKS_BIT) + offset; + data >>= shift; + temp3 = ((data & mask) << NBANKS_BIT) + offset; + data >>= shift; + temp4 = ((data & mask) << NBANKS_BIT) + offset; + + atomic_inc(subhist + temp1.x); + atomic_inc(subhist + temp1.y); + atomic_inc(subhist + temp1.z); + atomic_inc(subhist + temp1.w); + + atomic_inc(subhist + temp2.x); + atomic_inc(subhist + temp2.y); + atomic_inc(subhist + temp2.z); + atomic_inc(subhist + temp2.w); + + atomic_inc(subhist + temp3.x); + atomic_inc(subhist + temp3.y); + atomic_inc(subhist + temp3.z); + atomic_inc(subhist + temp3.w); + + atomic_inc(subhist + temp4.x); + atomic_inc(subhist + temp4.y); + atomic_inc(subhist + temp4.z); + atomic_inc(subhist + temp4.w); + + x += inc_x; + int off = ((x>=cols) ? -1 : 0); + x = mad24(off, cols, x); + y += inc_y - off; + } + barrier(CLK_LOCAL_MEM_FENCE); + + //reduce local banks to single histogram per workgroup + int bin1=0, bin2=0, bin3=0, bin4=0; + for(int i=0; ileft_col) ? (gidx+cols) : gidx); + int src_index = src_offset + mad24(gidy, src_step, gidx); + int p = (int)src[src_index]; + atomic_inc(subhist + p); + barrier(CLK_LOCAL_MEM_FENCE); - //clamp(gidx,mask,cols-1); - gidx = gidx >= left_col ? cols+gidx : gidx; - //gidy = gidy >= rows?rows-1:gidy; - - int src_index = src_offset + mad24(gidy,src_step,gidx); - //int dst_index = dst_offset + mad24(gidy,dst_step,gidx); - //uchar4 p,q; - barrier(CLK_LOCAL_MEM_FENCE); - int p = (int)src[src_index]; - p = gidy >= rows ? HISTGRAM256_LOCAL_MEM_SIZE : p; - atomic_inc(s_hist + p); - barrier(CLK_LOCAL_MEM_FENCE); - buf[ mad24(output_row, dst_offset, lidy)] += s_hist[lidy]; + globalHist[mad24(rowIndex, hist_step, lidy)] += subhist[lidy]; } __kernel __attribute__((reqd_work_group_size(256,1,1)))void merge_hist(__global int* buf, __global int* hist, @@ -126,13 +165,13 @@ __kernel __attribute__((reqd_work_group_size(256,1,1)))void merge_hist(__global int sum = 0; - for(int i = lx; i < PARTITAL_HISTGRAM256_COUNT; i += HISTGRAM256_WORK_GROUP_SIZE) + for(int i = lx; i < PARTIAL_HISTOGRAM256_COUNT; i += HISTOGRAM256_WORK_GROUP_SIZE) sum += buf[ mad24(i, src_step, gx)]; - __local int data[HISTGRAM256_WORK_GROUP_SIZE]; + __local int data[HISTOGRAM256_WORK_GROUP_SIZE]; data[lx] = sum; - for(int stride = HISTGRAM256_WORK_GROUP_SIZE /2; stride > 0; stride >>= 1) + for(int stride = HISTOGRAM256_WORK_GROUP_SIZE /2; stride > 0; stride >>= 1) { barrier(CLK_LOCAL_MEM_FENCE); if(lx < stride) diff --git a/modules/ocl/src/kernels/imgproc_resize.cl b/modules/ocl/src/kernels/imgproc_resize.cl index 995ce967d7..abfbfbedba 100644 --- a/modules/ocl/src/kernels/imgproc_resize.cl +++ b/modules/ocl/src/kernels/imgproc_resize.cl @@ -109,10 +109,10 @@ __kernel void resizeLN_C1_D0(__global uchar * dst, __global uchar const * restri int4 val1, val2, val; int4 sdata1, sdata2, sdata3, sdata4; - int4 pos1 = mad24(y, srcstep_in_pixel, x+srcoffset_in_pixel); - int4 pos2 = mad24(y, srcstep_in_pixel, x_+srcoffset_in_pixel); - int4 pos3 = mad24(y_, srcstep_in_pixel, x+srcoffset_in_pixel); - int4 pos4 = mad24(y_, srcstep_in_pixel, x_+srcoffset_in_pixel); + int4 pos1 = mad24((int4)y, (int4)srcstep_in_pixel, x+(int4)srcoffset_in_pixel); + int4 pos2 = mad24((int4)y, (int4)srcstep_in_pixel, x_+(int4)srcoffset_in_pixel); + int4 pos3 = mad24((int4)y_, (int4)srcstep_in_pixel, x+(int4)srcoffset_in_pixel); + int4 pos4 = mad24((int4)y_, (int4)srcstep_in_pixel, x_+(int4)srcoffset_in_pixel); sdata1.s0 = src[pos1.s0]; sdata1.s1 = src[pos1.s1]; @@ -136,7 +136,7 @@ __kernel void resizeLN_C1_D0(__global uchar * dst, __global uchar const * restri val1 = mul24(U1 , sdata1) + mul24(U , sdata2); val2 = mul24(U1 , sdata3) + mul24(U , sdata4); - val = mul24(V1 , val1) + mul24(V , val2); + val = mul24((int4)V1 , val1) + mul24((int4)V , val2); //__global uchar4* d = (__global uchar4*)(dst + dstoffset_in_pixel + dy * dststep_in_pixel + gx); //uchar4 dVal = *d; @@ -205,8 +205,8 @@ __kernel void resizeLN_C4_D0(__global uchar4 * dst, __global uchar4 * src, int4 data1 = convert_int4(src[srcpos.y]); int4 data2 = convert_int4(src[srcpos.z]); int4 data3 = convert_int4(src[srcpos.w]); - int4 val = mul24(mul24(U1, V1) , data0) + mul24(mul24(U, V1) , data1) - +mul24(mul24(U1, V) , data2)+mul24(mul24(U, V) , data3); + int4 val = mul24((int4)mul24(U1, V1) , data0) + mul24((int4)mul24(U, V1) , data1) + +mul24((int4)mul24(U1, V) , data2)+mul24((int4)mul24(U, V) , data3); int dstpos = mad24(dy, dststep_in_pixel, dx+dstoffset_in_pixel); uchar4 uval = convert_uchar4((val + (1<<(CAST_BITS-1)))>>CAST_BITS); if(dx>=0 && dx=0 && dy>1); - - int4 X, Y; - int4 sx, sy; - int4 DX = (int4)(dx, dx+1, dx+2, dx+3); - DX = (DX << AB_BITS); - F4 M0DX, M3DX; - M0DX = M[0] * convert_F4(DX); - M3DX = M[3] * convert_F4(DX); - X = convert_int4(rint(M0DX)); - Y = convert_int4(rint(M3DX)); - int tmp1, tmp2; - tmp1 = rint((M[1]*dy + M[2]) * AB_SCALE); - tmp2 = rint((M[4]*dy + M[5]) * AB_SCALE); - - X += tmp1 + round_delta; - Y += tmp2 + round_delta; - - sx = convert_int4(convert_short4(X >> AB_BITS)); - sy = convert_int4(convert_short4(Y >> AB_BITS)); - - __global uchar4 * d = (__global uchar4 *)(dst+dst_offset+dy*dstStep+dx); - uchar4 dval = *d; - DX = (int4)(dx, dx+1, dx+2, dx+3); - int4 dcon = DX >= 0 && DX < dst_cols && dy >= 0 && dy < dst_rows; - int4 scon = sx >= 0 && sx < src_cols && sy >= 0 && sy < src_rows; - int4 spos = src_offset + sy * srcStep + sx; - uchar4 sval; - sval.s0 = scon.s0 ? src[spos.s0] : 0; - sval.s1 = scon.s1 ? src[spos.s1] : 0; - sval.s2 = scon.s2 ? src[spos.s2] : 0; - sval.s3 = scon.s3 ? src[spos.s3] : 0; - dval = convert_uchar4(dcon != 0) ? sval : dval; - *d = dval; + int round_delta = (AB_SCALE>>1); + + int4 X, Y; + int4 sx, sy; + int4 DX = (int4)(dx, dx+1, dx+2, dx+3); + DX = (DX << AB_BITS); + F4 M0DX, M3DX; + M0DX = M[0] * convert_F4(DX); + M3DX = M[3] * convert_F4(DX); + X = convert_int4(rint(M0DX)); + Y = convert_int4(rint(M3DX)); + int tmp1, tmp2; + tmp1 = rint((M[1]*dy + M[2]) * AB_SCALE); + tmp2 = rint((M[4]*dy + M[5]) * AB_SCALE); + + X += tmp1 + round_delta; + Y += tmp2 + round_delta; + + sx = convert_int4(convert_short4(X >> AB_BITS)); + sy = convert_int4(convert_short4(Y >> AB_BITS)); + + __global uchar4 * d = (__global uchar4 *)(dst+dst_offset+dy*dstStep+dx); + uchar4 dval = *d; + DX = (int4)(dx, dx+1, dx+2, dx+3); + int4 dcon = DX >= 0 && DX < dst_cols && dy >= 0 && dy < dst_rows; + int4 scon = sx >= 0 && sx < src_cols && sy >= 0 && sy < src_rows; + int4 spos = src_offset + sy * srcStep + sx; + uchar4 sval; + sval.s0 = scon.s0 ? src[spos.s0] : 0; + sval.s1 = scon.s1 ? src[spos.s1] : 0; + sval.s2 = scon.s2 ? src[spos.s2] : 0; + sval.s3 = scon.s3 ? src[spos.s3] : 0; + dval = convert_uchar4(dcon != 0) ? sval : dval; + *d = dval; + } } __kernel void warpAffineLinear_C1_D0(__global const uchar * restrict src, __global uchar * dst, int src_cols, int src_rows, int dst_cols, int dst_rows, int srcStep, int dstStep, - int src_offset, int dst_offset, __constant F * M ) + int src_offset, int dst_offset, __constant F * M, int threadCols ) { int dx = get_global_id(0); int dy = get_global_id(1); - dx = (dx<<2) - (dst_offset&3); + + + if( dx < threadCols && dy < dst_rows) + { + dx = (dx<<2) - (dst_offset&3); + + int round_delta = ((AB_SCALE >> INTER_BITS) >> 1); + + int4 X, Y; + short4 ax, ay; + int4 sx, sy; + int4 DX = (int4)(dx, dx+1, dx+2, dx+3); + DX = (DX << AB_BITS); + F4 M0DX, M3DX; + M0DX = M[0] * convert_F4(DX); + M3DX = M[3] * convert_F4(DX); + X = convert_int4(rint(M0DX)); + Y = convert_int4(rint(M3DX)); + + int tmp1, tmp2; + tmp1 = rint((M[1]*dy + M[2]) * AB_SCALE); + tmp2 = rint((M[4]*dy + M[5]) * AB_SCALE); + + X += tmp1 + round_delta; + Y += tmp2 + round_delta; + + X = X >> (AB_BITS - INTER_BITS); + Y = Y >> (AB_BITS - INTER_BITS); + + sx = convert_int4(convert_short4(X >> INTER_BITS)); + sy = convert_int4(convert_short4(Y >> INTER_BITS)); + ax = convert_short4(X & (INTER_TAB_SIZE-1)); + ay = convert_short4(Y & (INTER_TAB_SIZE-1)); + + uchar4 v0, v1, v2,v3; + int4 scon0, scon1, scon2, scon3; + int4 spos0, spos1, spos2, spos3; + + scon0 = (sx >= 0 && sx < src_cols && sy >= 0 && sy < src_rows); + scon1 = (sx+1 >= 0 && sx+1 < src_cols && sy >= 0 && sy < src_rows); + scon2 = (sx >= 0 && sx < src_cols && sy+1 >= 0 && sy+1 < src_rows); + scon3 = (sx+1 >= 0 && sx+1 < src_cols && sy+1 >= 0 && sy+1 < src_rows); + spos0 = src_offset + sy * srcStep + sx; + spos1 = src_offset + sy * srcStep + sx + 1; + spos2 = src_offset + (sy+1) * srcStep + sx; + spos3 = src_offset + (sy+1) * srcStep + sx + 1; + + v0.s0 = scon0.s0 ? src[spos0.s0] : 0; + v1.s0 = scon1.s0 ? src[spos1.s0] : 0; + v2.s0 = scon2.s0 ? src[spos2.s0] : 0; + v3.s0 = scon3.s0 ? src[spos3.s0] : 0; + + v0.s1 = scon0.s1 ? src[spos0.s1] : 0; + v1.s1 = scon1.s1 ? src[spos1.s1] : 0; + v2.s1 = scon2.s1 ? src[spos2.s1] : 0; + v3.s1 = scon3.s1 ? src[spos3.s1] : 0; + + v0.s2 = scon0.s2 ? src[spos0.s2] : 0; + v1.s2 = scon1.s2 ? src[spos1.s2] : 0; + v2.s2 = scon2.s2 ? src[spos2.s2] : 0; + v3.s2 = scon3.s2 ? src[spos3.s2] : 0; + + v0.s3 = scon0.s3 ? src[spos0.s3] : 0; + v1.s3 = scon1.s3 ? src[spos1.s3] : 0; + v2.s3 = scon2.s3 ? src[spos2.s3] : 0; + v3.s3 = scon3.s3 ? src[spos3.s3] : 0; + + short4 itab0, itab1, itab2, itab3; + float4 taby, tabx; + taby = INTER_SCALE * convert_float4(ay); + tabx = INTER_SCALE * convert_float4(ax); - int round_delta = ((AB_SCALE >> INTER_BITS) >> 1); - - int4 X, Y; - short4 ax, ay; - int4 sx, sy; - int4 DX = (int4)(dx, dx+1, dx+2, dx+3); - DX = (DX << AB_BITS); - F4 M0DX, M3DX; - M0DX = M[0] * convert_F4(DX); - M3DX = M[3] * convert_F4(DX); - X = convert_int4(rint(M0DX)); - Y = convert_int4(rint(M3DX)); - - int tmp1, tmp2; - tmp1 = rint((M[1]*dy + M[2]) * AB_SCALE); - tmp2 = rint((M[4]*dy + M[5]) * AB_SCALE); - - X += tmp1 + round_delta; - Y += tmp2 + round_delta; - - X = X >> (AB_BITS - INTER_BITS); - Y = Y >> (AB_BITS - INTER_BITS); - - sx = convert_int4(convert_short4(X >> INTER_BITS)); - sy = convert_int4(convert_short4(Y >> INTER_BITS)); - ax = convert_short4(X & (INTER_TAB_SIZE-1)); - ay = convert_short4(Y & (INTER_TAB_SIZE-1)); - - uchar4 v0, v1, v2,v3; - int4 scon0, scon1, scon2, scon3; - int4 spos0, spos1, spos2, spos3; - - scon0 = (sx >= 0 && sx < src_cols && sy >= 0 && sy < src_rows); - scon1 = (sx+1 >= 0 && sx+1 < src_cols && sy >= 0 && sy < src_rows); - scon2 = (sx >= 0 && sx < src_cols && sy+1 >= 0 && sy+1 < src_rows); - scon3 = (sx+1 >= 0 && sx+1 < src_cols && sy+1 >= 0 && sy+1 < src_rows); - spos0 = src_offset + sy * srcStep + sx; - spos1 = src_offset + sy * srcStep + sx + 1; - spos2 = src_offset + (sy+1) * srcStep + sx; - spos3 = src_offset + (sy+1) * srcStep + sx + 1; - - v0.s0 = scon0.s0 ? src[spos0.s0] : 0; - v1.s0 = scon1.s0 ? src[spos1.s0] : 0; - v2.s0 = scon2.s0 ? src[spos2.s0] : 0; - v3.s0 = scon3.s0 ? src[spos3.s0] : 0; - - v0.s1 = scon0.s1 ? src[spos0.s1] : 0; - v1.s1 = scon1.s1 ? src[spos1.s1] : 0; - v2.s1 = scon2.s1 ? src[spos2.s1] : 0; - v3.s1 = scon3.s1 ? src[spos3.s1] : 0; - - v0.s2 = scon0.s2 ? src[spos0.s2] : 0; - v1.s2 = scon1.s2 ? src[spos1.s2] : 0; - v2.s2 = scon2.s2 ? src[spos2.s2] : 0; - v3.s2 = scon3.s2 ? src[spos3.s2] : 0; - - v0.s3 = scon0.s3 ? src[spos0.s3] : 0; - v1.s3 = scon1.s3 ? src[spos1.s3] : 0; - v2.s3 = scon2.s3 ? src[spos2.s3] : 0; - v3.s3 = scon3.s3 ? src[spos3.s3] : 0; - - short4 itab0, itab1, itab2, itab3; - float4 taby, tabx; - taby = INTER_SCALE * convert_float4(ay); - tabx = INTER_SCALE * convert_float4(ax); - - itab0 = convert_short4_sat(( (1.0f-taby)*(1.0f-tabx) * INTER_REMAP_COEF_SCALE )); - itab1 = convert_short4_sat(( (1.0f-taby)*tabx * INTER_REMAP_COEF_SCALE )); - itab2 = convert_short4_sat(( taby*(1.0f-tabx) * INTER_REMAP_COEF_SCALE )); - itab3 = convert_short4_sat(( taby*tabx * INTER_REMAP_COEF_SCALE )); + itab0 = convert_short4_sat(( (1.0f-taby)*(1.0f-tabx) * INTER_REMAP_COEF_SCALE )); + itab1 = convert_short4_sat(( (1.0f-taby)*tabx * INTER_REMAP_COEF_SCALE )); + itab2 = convert_short4_sat(( taby*(1.0f-tabx) * INTER_REMAP_COEF_SCALE )); + itab3 = convert_short4_sat(( taby*tabx * INTER_REMAP_COEF_SCALE )); - int4 val; - uchar4 tval; - val = convert_int4(v0) * convert_int4(itab0) + convert_int4(v1) * convert_int4(itab1) - + convert_int4(v2) * convert_int4(itab2) + convert_int4(v3) * convert_int4(itab3); - tval = convert_uchar4_sat ( (val + (1 << (INTER_REMAP_COEF_BITS-1))) >> INTER_REMAP_COEF_BITS ) ; - - __global uchar4 * d =(__global uchar4 *)(dst+dst_offset+dy*dstStep+dx); - uchar4 dval = *d; - DX = (int4)(dx, dx+1, dx+2, dx+3); - int4 dcon = DX >= 0 && DX < dst_cols && dy >= 0 && dy < dst_rows; - dval = convert_uchar4(dcon != 0) ? tval : dval; - *d = dval; - + int4 val; + uchar4 tval; + val = convert_int4(v0) * convert_int4(itab0) + convert_int4(v1) * convert_int4(itab1) + + convert_int4(v2) * convert_int4(itab2) + convert_int4(v3) * convert_int4(itab3); + tval = convert_uchar4_sat ( (val + (1 << (INTER_REMAP_COEF_BITS-1))) >> INTER_REMAP_COEF_BITS ) ; + + __global uchar4 * d =(__global uchar4 *)(dst+dst_offset+dy*dstStep+dx); + uchar4 dval = *d; + DX = (int4)(dx, dx+1, dx+2, dx+3); + int4 dcon = DX >= 0 && DX < dst_cols && dy >= 0 && dy < dst_rows; + dval = convert_uchar4(dcon != 0) ? tval : dval; + *d = dval; + } } __kernel void warpAffineCubic_C1_D0(__global uchar * src, __global uchar * dst, int src_cols, int src_rows, int dst_cols, int dst_rows, int srcStep, int dstStep, - int src_offset, int dst_offset, __constant F * M ) + int src_offset, int dst_offset, __constant F * M, int threadCols ) { int dx = get_global_id(0); int dy = get_global_id(1); - int round_delta = ((AB_SCALE>>INTER_BITS)>>1); - - int X0 = rint(M[0] * dx * AB_SCALE); - int Y0 = rint(M[3] * dx * AB_SCALE); - X0 += rint((M[1]*dy + M[2]) * AB_SCALE) + round_delta; - Y0 += rint((M[4]*dy + M[5]) * AB_SCALE) + round_delta; - int X = X0 >> (AB_BITS - INTER_BITS); - int Y = Y0 >> (AB_BITS - INTER_BITS); + if( dx < threadCols && dy < dst_rows) + { + int round_delta = ((AB_SCALE>>INTER_BITS)>>1); + + int X0 = rint(M[0] * dx * AB_SCALE); + int Y0 = rint(M[3] * dx * AB_SCALE); + X0 += rint((M[1]*dy + M[2]) * AB_SCALE) + round_delta; + Y0 += rint((M[4]*dy + M[5]) * AB_SCALE) + round_delta; + int X = X0 >> (AB_BITS - INTER_BITS); + int Y = Y0 >> (AB_BITS - INTER_BITS); - short sx = (short)(X >> INTER_BITS) - 1; - short sy = (short)(Y >> INTER_BITS) - 1; - short ay = (short)(Y & (INTER_TAB_SIZE-1)); - short ax = (short)(X & (INTER_TAB_SIZE-1)); - - uchar v[16]; - int i, j; - + short sx = (short)(X >> INTER_BITS) - 1; + short sy = (short)(Y >> INTER_BITS) - 1; + short ay = (short)(Y & (INTER_TAB_SIZE-1)); + short ax = (short)(X & (INTER_TAB_SIZE-1)); + + uchar v[16]; + int i, j; + #pragma unroll 4 - for(i=0; i<4; i++) - for(j=0; j<4; j++) - { - v[i*4+j] = (sx+j >= 0 && sx+j < src_cols && sy+i >= 0 && sy+i < src_rows) ? src[src_offset+(sy+i) * srcStep + (sx+j)] : 0; - } - - short itab[16]; - float tab1y[4], tab1x[4]; - float axx, ayy; - - ayy = 1.f/INTER_TAB_SIZE * ay; - axx = 1.f/INTER_TAB_SIZE * ax; - interpolateCubic(ayy, tab1y); - interpolateCubic(axx, tab1x); - int isum = 0; - -#pragma unroll 16 - for( i=0; i<16; i++ ) - { - F v = tab1y[(i>>2)] * tab1x[(i&3)]; - isum += itab[i] = convert_short_sat( rint( v * INTER_REMAP_COEF_SCALE ) ); - } - - if( isum != INTER_REMAP_COEF_SCALE ) - { - int k1, k2; - int diff = isum - INTER_REMAP_COEF_SCALE; - int Mk1=2, Mk2=2, mk1=2, mk2=2; - for( k1 = 2; k1 < 4; k1++ ) - for( k2 = 2; k2 < 4; k2++ ) - { - if( itab[(k1<<2)+k2] < itab[(mk1<<2)+mk2] ) - mk1 = k1, mk2 = k2; - else if( itab[(k1<<2)+k2] > itab[(Mk1<<2)+Mk2] ) - Mk1 = k1, Mk2 = k2; - } - diff<0 ? (itab[(Mk1<<2)+Mk2]=(short)(itab[(Mk1<<2)+Mk2]-diff)) : (itab[(mk1<<2)+mk2]=(short)(itab[(mk1<<2)+mk2]-diff)); - } - - if( dx >= 0 && dx < dst_cols && dy >= 0 && dy < dst_rows) - { - int sum=0; - for ( i =0; i<16; i++ ) + for(i=0; i<4; i++) + for(j=0; j<4; j++) { - sum += v[i] * itab[i] ; + v[i*4+j] = (sx+j >= 0 && sx+j < src_cols && sy+i >= 0 && sy+i < src_rows) ? src[src_offset+(sy+i) * srcStep + (sx+j)] : 0; + } + + short itab[16]; + float tab1y[4], tab1x[4]; + float axx, ayy; + + ayy = 1.f/INTER_TAB_SIZE * ay; + axx = 1.f/INTER_TAB_SIZE * ax; + interpolateCubic(ayy, tab1y); + interpolateCubic(axx, tab1x); + int isum = 0; + +#pragma unroll 16 + for( i=0; i<16; i++ ) + { + F v = tab1y[(i>>2)] * tab1x[(i&3)]; + isum += itab[i] = convert_short_sat( rint( v * INTER_REMAP_COEF_SCALE ) ); + } + + if( isum != INTER_REMAP_COEF_SCALE ) + { + int k1, k2; + int diff = isum - INTER_REMAP_COEF_SCALE; + int Mk1=2, Mk2=2, mk1=2, mk2=2; + for( k1 = 2; k1 < 4; k1++ ) + for( k2 = 2; k2 < 4; k2++ ) + { + if( itab[(k1<<2)+k2] < itab[(mk1<<2)+mk2] ) + mk1 = k1, mk2 = k2; + else if( itab[(k1<<2)+k2] > itab[(Mk1<<2)+Mk2] ) + Mk1 = k1, Mk2 = k2; + } + diff<0 ? (itab[(Mk1<<2)+Mk2]=(short)(itab[(Mk1<<2)+Mk2]-diff)) : (itab[(mk1<<2)+mk2]=(short)(itab[(mk1<<2)+mk2]-diff)); + } + + if( dx >= 0 && dx < dst_cols && dy >= 0 && dy < dst_rows) + { + int sum=0; + for ( i =0; i<16; i++ ) + { + sum += v[i] * itab[i] ; + } + dst[dst_offset+dy*dstStep+dx] = convert_uchar_sat( (sum + (1 << (INTER_REMAP_COEF_BITS-1))) >> INTER_REMAP_COEF_BITS ) ; } - dst[dst_offset+dy*dstStep+dx] = convert_uchar_sat( (sum + (1 << (INTER_REMAP_COEF_BITS-1))) >> INTER_REMAP_COEF_BITS ) ; } } @@ -299,154 +310,165 @@ __kernel void warpAffineCubic_C1_D0(__global uchar * src, __global uchar * dst, __kernel void warpAffineNN_C4_D0(__global uchar4 const * restrict src, __global uchar4 * dst, int src_cols, int src_rows, int dst_cols, int dst_rows, int srcStep, int dstStep, - int src_offset, int dst_offset, __constant F * M ) + int src_offset, int dst_offset, __constant F * M, int threadCols ) { int dx = get_global_id(0); int dy = get_global_id(1); - int round_delta = (AB_SCALE >> 1); - - int X0 = rint(M[0] * dx * AB_SCALE); - int Y0 = rint(M[3] * dx * AB_SCALE); - X0 += rint((M[1]*dy + M[2]) * AB_SCALE) + round_delta; - Y0 += rint((M[4]*dy + M[5]) * AB_SCALE) + round_delta; + if( dx < threadCols && dy < dst_rows) + { + int round_delta = (AB_SCALE >> 1); + + int X0 = rint(M[0] * dx * AB_SCALE); + int Y0 = rint(M[3] * dx * AB_SCALE); + X0 += rint((M[1]*dy + M[2]) * AB_SCALE) + round_delta; + Y0 += rint((M[4]*dy + M[5]) * AB_SCALE) + round_delta; - int sx0 = (short)(X0 >> AB_BITS); - int sy0 = (short)(Y0 >> AB_BITS); - - if(dx >= 0 && dx < dst_cols && dy >= 0 && dy < dst_rows) - dst[(dst_offset>>2)+dy*(dstStep>>2)+dx]= (sx0>=0 && sx0=0 && sy0>2)+sy0*(srcStep>>2)+sx0] : (uchar4)0; + int sx0 = (short)(X0 >> AB_BITS); + int sy0 = (short)(Y0 >> AB_BITS); + + if(dx >= 0 && dx < dst_cols && dy >= 0 && dy < dst_rows) + dst[(dst_offset>>2)+dy*(dstStep>>2)+dx]= (sx0>=0 && sx0=0 && sy0>2)+sy0*(srcStep>>2)+sx0] : (uchar4)0; + } } __kernel void warpAffineLinear_C4_D0(__global uchar4 const * restrict src, __global uchar4 * dst, int src_cols, int src_rows, int dst_cols, int dst_rows, int srcStep, int dstStep, - int src_offset, int dst_offset, __constant F * M ) + int src_offset, int dst_offset, __constant F * M, int threadCols ) { int dx = get_global_id(0); int dy = get_global_id(1); - int round_delta = AB_SCALE/INTER_TAB_SIZE/2; - - src_offset = (src_offset>>2); - srcStep = (srcStep>>2); - int tmp = (dx << AB_BITS); - int X0 = rint(M[0] * tmp); - int Y0 = rint(M[3] * tmp); - X0 += rint((M[1]*dy + M[2]) * AB_SCALE) + round_delta; - Y0 += rint((M[4]*dy + M[5]) * AB_SCALE) + round_delta; - X0 = X0 >> (AB_BITS - INTER_BITS); - Y0 = Y0 >> (AB_BITS - INTER_BITS); - - short sx0 = (short)(X0 >> INTER_BITS); - short sy0 = (short)(Y0 >> INTER_BITS); - short ax0 = (short)(X0 & (INTER_TAB_SIZE-1)); - short ay0 = (short)(Y0 & (INTER_TAB_SIZE-1)); - - int4 v0, v1, v2, v3; - - v0 = (sx0 >= 0 && sx0 < src_cols && sy0 >= 0 && sy0 < src_rows) ? convert_int4(src[src_offset+sy0 * srcStep + sx0]) : 0; - v1 = (sx0+1 >= 0 && sx0+1 < src_cols && sy0 >= 0 && sy0 < src_rows) ? convert_int4(src[src_offset+sy0 * srcStep + sx0+1]) : 0; - v2 = (sx0 >= 0 && sx0 < src_cols && sy0+1 >= 0 && sy0+1 < src_rows) ? convert_int4(src[src_offset+(sy0+1) * srcStep + sx0]) : 0; - v3 = (sx0+1 >= 0 && sx0+1 < src_cols && sy0+1 >= 0 && sy0+1 < src_rows) ? convert_int4(src[src_offset+(sy0+1) * srcStep + sx0+1]) : 0; - - int itab0, itab1, itab2, itab3; - float taby, tabx; - taby = 1.f/INTER_TAB_SIZE*ay0; - tabx = 1.f/INTER_TAB_SIZE*ax0; - - itab0 = convert_short_sat(rint( (1.0f-taby)*(1.0f-tabx) * INTER_REMAP_COEF_SCALE )); - itab1 = convert_short_sat(rint( (1.0f-taby)*tabx * INTER_REMAP_COEF_SCALE )); - itab2 = convert_short_sat(rint( taby*(1.0f-tabx) * INTER_REMAP_COEF_SCALE )); - itab3 = convert_short_sat(rint( taby*tabx * INTER_REMAP_COEF_SCALE )); - - int4 val; - val = v0 * itab0 + v1 * itab1 + v2 * itab2 + v3 * itab3; - if(dx >= 0 && dx < dst_cols && dy >= 0 && dy < dst_rows) - dst[(dst_offset>>2)+dy*(dstStep>>2)+dx] = convert_uchar4_sat ( (val + (1 << (INTER_REMAP_COEF_BITS-1))) >> INTER_REMAP_COEF_BITS ) ; + if( dx < threadCols && dy < dst_rows) + { + int round_delta = AB_SCALE/INTER_TAB_SIZE/2; + + src_offset = (src_offset>>2); + srcStep = (srcStep>>2); + + int tmp = (dx << AB_BITS); + int X0 = rint(M[0] * tmp); + int Y0 = rint(M[3] * tmp); + X0 += rint((M[1]*dy + M[2]) * AB_SCALE) + round_delta; + Y0 += rint((M[4]*dy + M[5]) * AB_SCALE) + round_delta; + X0 = X0 >> (AB_BITS - INTER_BITS); + Y0 = Y0 >> (AB_BITS - INTER_BITS); + + short sx0 = (short)(X0 >> INTER_BITS); + short sy0 = (short)(Y0 >> INTER_BITS); + short ax0 = (short)(X0 & (INTER_TAB_SIZE-1)); + short ay0 = (short)(Y0 & (INTER_TAB_SIZE-1)); + + int4 v0, v1, v2, v3; + + v0 = (sx0 >= 0 && sx0 < src_cols && sy0 >= 0 && sy0 < src_rows) ? convert_int4(src[src_offset+sy0 * srcStep + sx0]) : 0; + v1 = (sx0+1 >= 0 && sx0+1 < src_cols && sy0 >= 0 && sy0 < src_rows) ? convert_int4(src[src_offset+sy0 * srcStep + sx0+1]) : 0; + v2 = (sx0 >= 0 && sx0 < src_cols && sy0+1 >= 0 && sy0+1 < src_rows) ? convert_int4(src[src_offset+(sy0+1) * srcStep + sx0]) : 0; + v3 = (sx0+1 >= 0 && sx0+1 < src_cols && sy0+1 >= 0 && sy0+1 < src_rows) ? convert_int4(src[src_offset+(sy0+1) * srcStep + sx0+1]) : 0; + + int itab0, itab1, itab2, itab3; + float taby, tabx; + taby = 1.f/INTER_TAB_SIZE*ay0; + tabx = 1.f/INTER_TAB_SIZE*ax0; + + itab0 = convert_short_sat(rint( (1.0f-taby)*(1.0f-tabx) * INTER_REMAP_COEF_SCALE )); + itab1 = convert_short_sat(rint( (1.0f-taby)*tabx * INTER_REMAP_COEF_SCALE )); + itab2 = convert_short_sat(rint( taby*(1.0f-tabx) * INTER_REMAP_COEF_SCALE )); + itab3 = convert_short_sat(rint( taby*tabx * INTER_REMAP_COEF_SCALE )); + + int4 val; + val = v0 * itab0 + v1 * itab1 + v2 * itab2 + v3 * itab3; + + if(dx >= 0 && dx < dst_cols && dy >= 0 && dy < dst_rows) + dst[(dst_offset>>2)+dy*(dstStep>>2)+dx] = convert_uchar4_sat ( (val + (1 << (INTER_REMAP_COEF_BITS-1))) >> INTER_REMAP_COEF_BITS ) ; + } } __kernel void warpAffineCubic_C4_D0(__global uchar4 const * restrict src, __global uchar4 * dst, int src_cols, int src_rows, int dst_cols, int dst_rows, int srcStep, int dstStep, - int src_offset, int dst_offset, __constant F * M ) + int src_offset, int dst_offset, __constant F * M, int threadCols ) { int dx = get_global_id(0); int dy = get_global_id(1); - int round_delta = ((AB_SCALE>>INTER_BITS)>>1); - - src_offset = (src_offset>>2); - srcStep = (srcStep>>2); - dst_offset = (dst_offset>>2); - dstStep = (dstStep>>2); - - int tmp = (dx << AB_BITS); - int X0 = rint(M[0] * tmp); - int Y0 = rint(M[3] * tmp); - X0 += rint((M[1]*dy + M[2]) * AB_SCALE) + round_delta; - Y0 += rint((M[4]*dy + M[5]) * AB_SCALE) + round_delta; - X0 = X0 >> (AB_BITS - INTER_BITS); - Y0 = Y0 >> (AB_BITS - INTER_BITS); - - int sx = (short)(X0 >> INTER_BITS) - 1; - int sy = (short)(Y0 >> INTER_BITS) - 1; - int ay = (short)(Y0 & (INTER_TAB_SIZE-1)); - int ax = (short)(X0 & (INTER_TAB_SIZE-1)); - - uchar4 v[16]; - int i,j; -#pragma unroll 4 - for(i=0; i<4; i++) - for(j=0; j<4; j++) + if( dx < threadCols && dy < dst_rows) { - v[i*4+j] = (sx+j >= 0 && sx+j < src_cols && sy+i >= 0 && sy+i < src_rows) ? (src[src_offset+(sy+i) * srcStep + (sx+j)]) : (uchar4)0; - } - int itab[16]; - float tab1y[4], tab1x[4]; - float axx, ayy; - - ayy = INTER_SCALE * ay; - axx = INTER_SCALE * ax; - interpolateCubic(ayy, tab1y); - interpolateCubic(axx, tab1x); - int isum = 0; - -#pragma unroll 16 - for( i=0; i<16; i++ ) - { - float tmp; - tmp = tab1y[(i>>2)] * tab1x[(i&3)] * INTER_REMAP_COEF_SCALE; - itab[i] = rint(tmp); - isum += itab[i]; - } - - if( isum != INTER_REMAP_COEF_SCALE ) - { - int k1, k2; - int diff = isum - INTER_REMAP_COEF_SCALE; - int Mk1=2, Mk2=2, mk1=2, mk2=2; + int round_delta = ((AB_SCALE>>INTER_BITS)>>1); - for( k1 = 2; k1 < 4; k1++ ) - for( k2 = 2; k2 < 4; k2++ ) - { - - if( itab[(k1<<2)+k2] < itab[(mk1<<2)+mk2] ) - mk1 = k1, mk2 = k2; - else if( itab[(k1<<2)+k2] > itab[(Mk1<<2)+Mk2] ) - Mk1 = k1, Mk2 = k2; - } - - diff<0 ? (itab[(Mk1<<2)+Mk2]=(short)(itab[(Mk1<<2)+Mk2]-diff)) : (itab[(mk1<<2)+mk2]=(short)(itab[(mk1<<2)+mk2]-diff)); - } + src_offset = (src_offset>>2); + srcStep = (srcStep>>2); + dst_offset = (dst_offset>>2); + dstStep = (dstStep>>2); + + int tmp = (dx << AB_BITS); + int X0 = rint(M[0] * tmp); + int Y0 = rint(M[3] * tmp); + X0 += rint((M[1]*dy + M[2]) * AB_SCALE) + round_delta; + Y0 += rint((M[4]*dy + M[5]) * AB_SCALE) + round_delta; + X0 = X0 >> (AB_BITS - INTER_BITS); + Y0 = Y0 >> (AB_BITS - INTER_BITS); - if( dx >= 0 && dx < dst_cols && dy >= 0 && dy < dst_rows) - { - int4 sum=0; - for ( i =0; i<16; i++ ) + int sx = (short)(X0 >> INTER_BITS) - 1; + int sy = (short)(Y0 >> INTER_BITS) - 1; + int ay = (short)(Y0 & (INTER_TAB_SIZE-1)); + int ax = (short)(X0 & (INTER_TAB_SIZE-1)); + + uchar4 v[16]; + int i,j; +#pragma unroll 4 + for(i=0; i<4; i++) + for(j=0; j<4; j++) { - sum += convert_int4(v[i]) * itab[i]; + v[i*4+j] = (sx+j >= 0 && sx+j < src_cols && sy+i >= 0 && sy+i < src_rows) ? (src[src_offset+(sy+i) * srcStep + (sx+j)]) : (uchar4)0; + } + int itab[16]; + float tab1y[4], tab1x[4]; + float axx, ayy; + + ayy = INTER_SCALE * ay; + axx = INTER_SCALE * ax; + interpolateCubic(ayy, tab1y); + interpolateCubic(axx, tab1x); + int isum = 0; + +#pragma unroll 16 + for( i=0; i<16; i++ ) + { + float tmp; + tmp = tab1y[(i>>2)] * tab1x[(i&3)] * INTER_REMAP_COEF_SCALE; + itab[i] = rint(tmp); + isum += itab[i]; + } + + if( isum != INTER_REMAP_COEF_SCALE ) + { + int k1, k2; + int diff = isum - INTER_REMAP_COEF_SCALE; + int Mk1=2, Mk2=2, mk1=2, mk2=2; + + for( k1 = 2; k1 < 4; k1++ ) + for( k2 = 2; k2 < 4; k2++ ) + { + + if( itab[(k1<<2)+k2] < itab[(mk1<<2)+mk2] ) + mk1 = k1, mk2 = k2; + else if( itab[(k1<<2)+k2] > itab[(Mk1<<2)+Mk2] ) + Mk1 = k1, Mk2 = k2; + } + + diff<0 ? (itab[(Mk1<<2)+Mk2]=(short)(itab[(Mk1<<2)+Mk2]-diff)) : (itab[(mk1<<2)+mk2]=(short)(itab[(mk1<<2)+mk2]-diff)); + } + + if( dx >= 0 && dx < dst_cols && dy >= 0 && dy < dst_rows) + { + int4 sum=0; + for ( i =0; i<16; i++ ) + { + sum += convert_int4(v[i]) * itab[i]; + } + dst[dst_offset+dy*dstStep+dx] = convert_uchar4_sat( (sum + (1 << (INTER_REMAP_COEF_BITS-1))) >> INTER_REMAP_COEF_BITS ) ; } - dst[dst_offset+dy*dstStep+dx] = convert_uchar4_sat( (sum + (1 << (INTER_REMAP_COEF_BITS-1))) >> INTER_REMAP_COEF_BITS ) ; } } @@ -456,128 +478,137 @@ __kernel void warpAffineCubic_C4_D0(__global uchar4 const * restrict src, __glob __kernel void warpAffineNN_C1_D5(__global float * src, __global float * dst, int src_cols, int src_rows, int dst_cols, int dst_rows, int srcStep, int dstStep, - int src_offset, int dst_offset, __constant F * M ) + int src_offset, int dst_offset, __constant F * M, int threadCols ) { int dx = get_global_id(0); int dy = get_global_id(1); - int round_delta = AB_SCALE/2; - - int X0 = rint(M[0] * dx * AB_SCALE); - int Y0 = rint(M[3] * dx * AB_SCALE); - X0 += rint((M[1]*dy + M[2]) * AB_SCALE) + round_delta; - Y0 += rint((M[4]*dy + M[5]) * AB_SCALE) + round_delta; + if( dx < threadCols && dy < dst_rows) + { + int round_delta = AB_SCALE/2; + + int X0 = rint(M[0] * dx * AB_SCALE); + int Y0 = rint(M[3] * dx * AB_SCALE); + X0 += rint((M[1]*dy + M[2]) * AB_SCALE) + round_delta; + Y0 += rint((M[4]*dy + M[5]) * AB_SCALE) + round_delta; - short sx0 = (short)(X0 >> AB_BITS); - short sy0 = (short)(Y0 >> AB_BITS); - - if(dx >= 0 && dx < dst_cols && dy >= 0 && dy < dst_rows) - dst[(dst_offset>>2)+dy*dstStep+dx]= (sx0>=0 && sx0=0 && sy0>2)+sy0*srcStep+sx0] : 0; + short sx0 = (short)(X0 >> AB_BITS); + short sy0 = (short)(Y0 >> AB_BITS); + + if(dx >= 0 && dx < dst_cols && dy >= 0 && dy < dst_rows) + dst[(dst_offset>>2)+dy*dstStep+dx]= (sx0>=0 && sx0=0 && sy0>2)+sy0*srcStep+sx0] : 0; + } } __kernel void warpAffineLinear_C1_D5(__global float * src, __global float * dst, int src_cols, int src_rows, int dst_cols, int dst_rows, int srcStep, int dstStep, - int src_offset, int dst_offset, __constant F * M ) + int src_offset, int dst_offset, __constant F * M, int threadCols ) { int dx = get_global_id(0); int dy = get_global_id(1); - int round_delta = AB_SCALE/INTER_TAB_SIZE/2; - - src_offset = (src_offset>>2); - - int X0 = rint(M[0] * dx * AB_SCALE); - int Y0 = rint(M[3] * dx * AB_SCALE); - X0 += rint((M[1]*dy + M[2]) * AB_SCALE) + round_delta; - Y0 += rint((M[4]*dy + M[5]) * AB_SCALE) + round_delta; - X0 = X0 >> (AB_BITS - INTER_BITS); - Y0 = Y0 >> (AB_BITS - INTER_BITS); + if( dx < threadCols && dy < dst_rows) + { + int round_delta = AB_SCALE/INTER_TAB_SIZE/2; + + src_offset = (src_offset>>2); + + int X0 = rint(M[0] * dx * AB_SCALE); + int Y0 = rint(M[3] * dx * AB_SCALE); + X0 += rint((M[1]*dy + M[2]) * AB_SCALE) + round_delta; + Y0 += rint((M[4]*dy + M[5]) * AB_SCALE) + round_delta; + X0 = X0 >> (AB_BITS - INTER_BITS); + Y0 = Y0 >> (AB_BITS - INTER_BITS); - short sx0 = (short)(X0 >> INTER_BITS); - short sy0 = (short)(Y0 >> INTER_BITS); - short ax0 = (short)(X0 & (INTER_TAB_SIZE-1)); - short ay0 = (short)(Y0 & (INTER_TAB_SIZE-1)); - - float v0, v1, v2, v3; + short sx0 = (short)(X0 >> INTER_BITS); + short sy0 = (short)(Y0 >> INTER_BITS); + short ax0 = (short)(X0 & (INTER_TAB_SIZE-1)); + short ay0 = (short)(Y0 & (INTER_TAB_SIZE-1)); + + float v0, v1, v2, v3; - v0 = (sx0 >= 0 && sx0 < src_cols && sy0 >= 0 && sy0 < src_rows) ? src[src_offset+sy0 * srcStep + sx0] : 0; - v1 = (sx0+1 >= 0 && sx0+1 < src_cols && sy0 >= 0 && sy0 < src_rows) ? src[src_offset+sy0 * srcStep + sx0+1] : 0; - v2 = (sx0 >= 0 && sx0 < src_cols && sy0+1 >= 0 && sy0+1 < src_rows) ? src[src_offset+(sy0+1) * srcStep + sx0] : 0; - v3 = (sx0+1 >= 0 && sx0+1 < src_cols && sy0+1 >= 0 && sy0+1 < src_rows) ? src[src_offset+(sy0+1) * srcStep + sx0+1] : 0; + v0 = (sx0 >= 0 && sx0 < src_cols && sy0 >= 0 && sy0 < src_rows) ? src[src_offset+sy0 * srcStep + sx0] : 0; + v1 = (sx0+1 >= 0 && sx0+1 < src_cols && sy0 >= 0 && sy0 < src_rows) ? src[src_offset+sy0 * srcStep + sx0+1] : 0; + v2 = (sx0 >= 0 && sx0 < src_cols && sy0+1 >= 0 && sy0+1 < src_rows) ? src[src_offset+(sy0+1) * srcStep + sx0] : 0; + v3 = (sx0+1 >= 0 && sx0+1 < src_cols && sy0+1 >= 0 && sy0+1 < src_rows) ? src[src_offset+(sy0+1) * srcStep + sx0+1] : 0; - float tab[4]; - float taby[2], tabx[2]; - taby[0] = 1.0 - 1.f/INTER_TAB_SIZE*ay0; - taby[1] = 1.f/INTER_TAB_SIZE*ay0; - tabx[0] = 1.0 - 1.f/INTER_TAB_SIZE*ax0; - tabx[1] = 1.f/INTER_TAB_SIZE*ax0; - - tab[0] = taby[0] * tabx[0]; - tab[1] = taby[0] * tabx[1]; - tab[2] = taby[1] * tabx[0]; - tab[3] = taby[1] * tabx[1]; + float tab[4]; + float taby[2], tabx[2]; + taby[0] = 1.0 - 1.f/INTER_TAB_SIZE*ay0; + taby[1] = 1.f/INTER_TAB_SIZE*ay0; + tabx[0] = 1.0 - 1.f/INTER_TAB_SIZE*ax0; + tabx[1] = 1.f/INTER_TAB_SIZE*ax0; + + tab[0] = taby[0] * tabx[0]; + tab[1] = taby[0] * tabx[1]; + tab[2] = taby[1] * tabx[0]; + tab[3] = taby[1] * tabx[1]; - float sum = 0; - sum += v0 * tab[0] + v1 * tab[1] + v2 * tab[2] + v3 * tab[3]; - if(dx >= 0 && dx < dst_cols && dy >= 0 && dy < dst_rows) - dst[(dst_offset>>2)+dy*dstStep+dx] = sum; + float sum = 0; + sum += v0 * tab[0] + v1 * tab[1] + v2 * tab[2] + v3 * tab[3]; + if(dx >= 0 && dx < dst_cols && dy >= 0 && dy < dst_rows) + dst[(dst_offset>>2)+dy*dstStep+dx] = sum; + } } __kernel void warpAffineCubic_C1_D5(__global float * src, __global float * dst, int src_cols, int src_rows, int dst_cols, int dst_rows, int srcStep, int dstStep, - int src_offset, int dst_offset, __constant F * M ) + int src_offset, int dst_offset, __constant F * M, int threadCols ) { int dx = get_global_id(0); int dy = get_global_id(1); - int round_delta = AB_SCALE/INTER_TAB_SIZE/2; - - src_offset = (src_offset>>2); - dst_offset = (dst_offset>>2); - - int X0 = rint(M[0] * dx * AB_SCALE); - int Y0 = rint(M[3] * dx * AB_SCALE); - X0 += rint((M[1]*dy + M[2]) * AB_SCALE) + round_delta; - Y0 += rint((M[4]*dy + M[5]) * AB_SCALE) + round_delta; - X0 = X0 >> (AB_BITS - INTER_BITS); - Y0 = Y0 >> (AB_BITS - INTER_BITS); + if( dx < threadCols && dy < dst_rows) + { + int round_delta = AB_SCALE/INTER_TAB_SIZE/2; + + src_offset = (src_offset>>2); + dst_offset = (dst_offset>>2); + + int X0 = rint(M[0] * dx * AB_SCALE); + int Y0 = rint(M[3] * dx * AB_SCALE); + X0 += rint((M[1]*dy + M[2]) * AB_SCALE) + round_delta; + Y0 += rint((M[4]*dy + M[5]) * AB_SCALE) + round_delta; + X0 = X0 >> (AB_BITS - INTER_BITS); + Y0 = Y0 >> (AB_BITS - INTER_BITS); - short sx = (short)(X0 >> INTER_BITS) - 1; - short sy = (short)(Y0 >> INTER_BITS) - 1; - short ay = (short)(Y0 & (INTER_TAB_SIZE-1)); - short ax = (short)(X0 & (INTER_TAB_SIZE-1)); - - float v[16]; - int i; + short sx = (short)(X0 >> INTER_BITS) - 1; + short sy = (short)(Y0 >> INTER_BITS) - 1; + short ay = (short)(Y0 & (INTER_TAB_SIZE-1)); + short ax = (short)(X0 & (INTER_TAB_SIZE-1)); + + float v[16]; + int i; - for(i=0; i<16; i++) - v[i] = (sx+(i&3) >= 0 && sx+(i&3) < src_cols && sy+(i>>2) >= 0 && sy+(i>>2) < src_rows) ? src[src_offset+(sy+(i>>2)) * srcStep + (sx+(i&3))] : 0; + for(i=0; i<16; i++) + v[i] = (sx+(i&3) >= 0 && sx+(i&3) < src_cols && sy+(i>>2) >= 0 && sy+(i>>2) < src_rows) ? src[src_offset+(sy+(i>>2)) * srcStep + (sx+(i&3))] : 0; - float tab[16]; - float tab1y[4], tab1x[4]; - float axx, ayy; + float tab[16]; + float tab1y[4], tab1x[4]; + float axx, ayy; - ayy = 1.f/INTER_TAB_SIZE * ay; - axx = 1.f/INTER_TAB_SIZE * ax; - interpolateCubic(ayy, tab1y); - interpolateCubic(axx, tab1x); + ayy = 1.f/INTER_TAB_SIZE * ay; + axx = 1.f/INTER_TAB_SIZE * ax; + interpolateCubic(ayy, tab1y); + interpolateCubic(axx, tab1x); #pragma unroll 4 - for( i=0; i<16; i++ ) - { - tab[i] = tab1y[(i>>2)] * tab1x[(i&3)]; - } - - if( dx >= 0 && dx < dst_cols && dy >= 0 && dy < dst_rows) - { - float sum = 0; -#pragma unroll 4 - for ( i =0; i<16; i++ ) + for( i=0; i<16; i++ ) { - sum += v[i] * tab[i]; + tab[i] = tab1y[(i>>2)] * tab1x[(i&3)]; } - dst[dst_offset+dy*dstStep+dx] = sum; + + if( dx >= 0 && dx < dst_cols && dy >= 0 && dy < dst_rows) + { + float sum = 0; +#pragma unroll 4 + for ( i =0; i<16; i++ ) + { + sum += v[i] * tab[i]; + } + dst[dst_offset+dy*dstStep+dx] = sum; + } } } @@ -587,132 +618,141 @@ __kernel void warpAffineCubic_C1_D5(__global float * src, __global float * dst, __kernel void warpAffineNN_C4_D5(__global float4 * src, __global float4 * dst, int src_cols, int src_rows, int dst_cols, int dst_rows, int srcStep, int dstStep, - int src_offset, int dst_offset, __constant F * M ) + int src_offset, int dst_offset, __constant F * M, int threadCols ) { int dx = get_global_id(0); int dy = get_global_id(1); - int round_delta = AB_SCALE/2; - - int X0 = rint(M[0] * dx * AB_SCALE); - int Y0 = rint(M[3] * dx * AB_SCALE); - X0 += rint((M[1]*dy + M[2]) * AB_SCALE) + round_delta; - Y0 += rint((M[4]*dy + M[5]) * AB_SCALE) + round_delta; + if( dx < threadCols && dy < dst_rows) + { + int round_delta = AB_SCALE/2; + + int X0 = rint(M[0] * dx * AB_SCALE); + int Y0 = rint(M[3] * dx * AB_SCALE); + X0 += rint((M[1]*dy + M[2]) * AB_SCALE) + round_delta; + Y0 += rint((M[4]*dy + M[5]) * AB_SCALE) + round_delta; - short sx0 = (short)(X0 >> AB_BITS); - short sy0 = (short)(Y0 >> AB_BITS); - - if(dx >= 0 && dx < dst_cols && dy >= 0 && dy < dst_rows) - dst[(dst_offset>>4)+dy*(dstStep>>2)+dx]= (sx0>=0 && sx0=0 && sy0>4)+sy0*(srcStep>>2)+sx0] : 0; + short sx0 = (short)(X0 >> AB_BITS); + short sy0 = (short)(Y0 >> AB_BITS); + + if(dx >= 0 && dx < dst_cols && dy >= 0 && dy < dst_rows) + dst[(dst_offset>>4)+dy*(dstStep>>2)+dx]= (sx0>=0 && sx0=0 && sy0>4)+sy0*(srcStep>>2)+sx0] : 0; + } } __kernel void warpAffineLinear_C4_D5(__global float4 * src, __global float4 * dst, int src_cols, int src_rows, int dst_cols, int dst_rows, int srcStep, int dstStep, - int src_offset, int dst_offset, __constant F * M ) + int src_offset, int dst_offset, __constant F * M, int threadCols ) { int dx = get_global_id(0); int dy = get_global_id(1); - int round_delta = AB_SCALE/INTER_TAB_SIZE/2; - - src_offset = (src_offset>>4); - dst_offset = (dst_offset>>4); - srcStep = (srcStep>>2); - dstStep = (dstStep>>2); - - int X0 = rint(M[0] * dx * AB_SCALE); - int Y0 = rint(M[3] * dx * AB_SCALE); - X0 += rint((M[1]*dy + M[2]) * AB_SCALE) + round_delta; - Y0 += rint((M[4]*dy + M[5]) * AB_SCALE) + round_delta; - X0 = X0 >> (AB_BITS - INTER_BITS); - Y0 = Y0 >> (AB_BITS - INTER_BITS); + if( dx < threadCols && dy < dst_rows) + { + int round_delta = AB_SCALE/INTER_TAB_SIZE/2; + + src_offset = (src_offset>>4); + dst_offset = (dst_offset>>4); + srcStep = (srcStep>>2); + dstStep = (dstStep>>2); + + int X0 = rint(M[0] * dx * AB_SCALE); + int Y0 = rint(M[3] * dx * AB_SCALE); + X0 += rint((M[1]*dy + M[2]) * AB_SCALE) + round_delta; + Y0 += rint((M[4]*dy + M[5]) * AB_SCALE) + round_delta; + X0 = X0 >> (AB_BITS - INTER_BITS); + Y0 = Y0 >> (AB_BITS - INTER_BITS); - short sx0 = (short)(X0 >> INTER_BITS); - short sy0 = (short)(Y0 >> INTER_BITS); - short ax0 = (short)(X0 & (INTER_TAB_SIZE-1)); - short ay0 = (short)(Y0 & (INTER_TAB_SIZE-1)); - - float4 v0, v1, v2, v3; + short sx0 = (short)(X0 >> INTER_BITS); + short sy0 = (short)(Y0 >> INTER_BITS); + short ax0 = (short)(X0 & (INTER_TAB_SIZE-1)); + short ay0 = (short)(Y0 & (INTER_TAB_SIZE-1)); + + float4 v0, v1, v2, v3; - v0 = (sx0 >= 0 && sx0 < src_cols && sy0 >= 0 && sy0 < src_rows) ? src[src_offset+sy0 * srcStep + sx0] : 0; - v1 = (sx0+1 >= 0 && sx0+1 < src_cols && sy0 >= 0 && sy0 < src_rows) ? src[src_offset+sy0 * srcStep + sx0+1] : 0; - v2 = (sx0 >= 0 && sx0 < src_cols && sy0+1 >= 0 && sy0+1 < src_rows) ? src[src_offset+(sy0+1) * srcStep + sx0] : 0; - v3 = (sx0+1 >= 0 && sx0+1 < src_cols && sy0+1 >= 0 && sy0+1 < src_rows) ? src[src_offset+(sy0+1) * srcStep + sx0+1] : 0; + v0 = (sx0 >= 0 && sx0 < src_cols && sy0 >= 0 && sy0 < src_rows) ? src[src_offset+sy0 * srcStep + sx0] : 0; + v1 = (sx0+1 >= 0 && sx0+1 < src_cols && sy0 >= 0 && sy0 < src_rows) ? src[src_offset+sy0 * srcStep + sx0+1] : 0; + v2 = (sx0 >= 0 && sx0 < src_cols && sy0+1 >= 0 && sy0+1 < src_rows) ? src[src_offset+(sy0+1) * srcStep + sx0] : 0; + v3 = (sx0+1 >= 0 && sx0+1 < src_cols && sy0+1 >= 0 && sy0+1 < src_rows) ? src[src_offset+(sy0+1) * srcStep + sx0+1] : 0; - float tab[4]; - float taby[2], tabx[2]; - taby[0] = 1.0 - 1.f/INTER_TAB_SIZE*ay0; - taby[1] = 1.f/INTER_TAB_SIZE*ay0; - tabx[0] = 1.0 - 1.f/INTER_TAB_SIZE*ax0; - tabx[1] = 1.f/INTER_TAB_SIZE*ax0; - - tab[0] = taby[0] * tabx[0]; - tab[1] = taby[0] * tabx[1]; - tab[2] = taby[1] * tabx[0]; - tab[3] = taby[1] * tabx[1]; + float tab[4]; + float taby[2], tabx[2]; + taby[0] = 1.0 - 1.f/INTER_TAB_SIZE*ay0; + taby[1] = 1.f/INTER_TAB_SIZE*ay0; + tabx[0] = 1.0 - 1.f/INTER_TAB_SIZE*ax0; + tabx[1] = 1.f/INTER_TAB_SIZE*ax0; + + tab[0] = taby[0] * tabx[0]; + tab[1] = taby[0] * tabx[1]; + tab[2] = taby[1] * tabx[0]; + tab[3] = taby[1] * tabx[1]; - float4 sum = 0; - sum += v0 * tab[0] + v1 * tab[1] + v2 * tab[2] + v3 * tab[3]; - if(dx >= 0 && dx < dst_cols && dy >= 0 && dy < dst_rows) - dst[dst_offset+dy*dstStep+dx] = sum; + float4 sum = 0; + sum += v0 * tab[0] + v1 * tab[1] + v2 * tab[2] + v3 * tab[3]; + if(dx >= 0 && dx < dst_cols && dy >= 0 && dy < dst_rows) + dst[dst_offset+dy*dstStep+dx] = sum; + } } __kernel void warpAffineCubic_C4_D5(__global float4 * src, __global float4 * dst, int src_cols, int src_rows, int dst_cols, int dst_rows, int srcStep, int dstStep, - int src_offset, int dst_offset, __constant F * M ) + int src_offset, int dst_offset, __constant F * M, int threadCols ) { int dx = get_global_id(0); int dy = get_global_id(1); - int round_delta = AB_SCALE/INTER_TAB_SIZE/2; - - src_offset = (src_offset>>4); - dst_offset = (dst_offset>>4); - srcStep = (srcStep>>2); - dstStep = (dstStep>>2); - - int X0 = rint(M[0] * dx * AB_SCALE); - int Y0 = rint(M[3] * dx * AB_SCALE); - X0 += rint((M[1]*dy + M[2]) * AB_SCALE) + round_delta; - Y0 += rint((M[4]*dy + M[5]) * AB_SCALE) + round_delta; - X0 = X0 >> (AB_BITS - INTER_BITS); - Y0 = Y0 >> (AB_BITS - INTER_BITS); + if( dx < threadCols && dy < dst_rows) + { + int round_delta = AB_SCALE/INTER_TAB_SIZE/2; + + src_offset = (src_offset>>4); + dst_offset = (dst_offset>>4); + srcStep = (srcStep>>2); + dstStep = (dstStep>>2); + + int X0 = rint(M[0] * dx * AB_SCALE); + int Y0 = rint(M[3] * dx * AB_SCALE); + X0 += rint((M[1]*dy + M[2]) * AB_SCALE) + round_delta; + Y0 += rint((M[4]*dy + M[5]) * AB_SCALE) + round_delta; + X0 = X0 >> (AB_BITS - INTER_BITS); + Y0 = Y0 >> (AB_BITS - INTER_BITS); - short sx = (short)(X0 >> INTER_BITS) - 1; - short sy = (short)(Y0 >> INTER_BITS) - 1; - short ay = (short)(Y0 & (INTER_TAB_SIZE-1)); - short ax = (short)(X0 & (INTER_TAB_SIZE-1)); - - float4 v[16]; - int i; + short sx = (short)(X0 >> INTER_BITS) - 1; + short sy = (short)(Y0 >> INTER_BITS) - 1; + short ay = (short)(Y0 & (INTER_TAB_SIZE-1)); + short ax = (short)(X0 & (INTER_TAB_SIZE-1)); + + float4 v[16]; + int i; - for(i=0; i<16; i++) - v[i] = (sx+(i&3) >= 0 && sx+(i&3) < src_cols && sy+(i>>2) >= 0 && sy+(i>>2) < src_rows) ? src[src_offset+(sy+(i>>2)) * srcStep + (sx+(i&3))] : 0; + for(i=0; i<16; i++) + v[i] = (sx+(i&3) >= 0 && sx+(i&3) < src_cols && sy+(i>>2) >= 0 && sy+(i>>2) < src_rows) ? src[src_offset+(sy+(i>>2)) * srcStep + (sx+(i&3))] : 0; - float tab[16]; - float tab1y[4], tab1x[4]; - float axx, ayy; + float tab[16]; + float tab1y[4], tab1x[4]; + float axx, ayy; - ayy = 1.f/INTER_TAB_SIZE * ay; - axx = 1.f/INTER_TAB_SIZE * ax; - interpolateCubic(ayy, tab1y); - interpolateCubic(axx, tab1x); + ayy = 1.f/INTER_TAB_SIZE * ay; + axx = 1.f/INTER_TAB_SIZE * ax; + interpolateCubic(ayy, tab1y); + interpolateCubic(axx, tab1x); #pragma unroll 4 - for( i=0; i<16; i++ ) - { - tab[i] = tab1y[(i>>2)] * tab1x[(i&3)]; - } - - if( dx >= 0 && dx < dst_cols && dy >= 0 && dy < dst_rows) - { - float4 sum = 0; -#pragma unroll 4 - for ( i =0; i<16; i++ ) + for( i=0; i<16; i++ ) { - sum += v[i] * tab[i]; + tab[i] = tab1y[(i>>2)] * tab1x[(i&3)]; } - dst[dst_offset+dy*dstStep+dx] = sum; + + if( dx >= 0 && dx < dst_cols && dy >= 0 && dy < dst_rows) + { + float4 sum = 0; +#pragma unroll 4 + for ( i =0; i<16; i++ ) + { + sum += v[i] * tab[i]; + } + dst[dst_offset+dy*dstStep+dx] = sum; - } + } + } } diff --git a/modules/ocl/src/kernels/imgproc_warpPerspective.cl b/modules/ocl/src/kernels/imgproc_warpPerspective.cl index e6521d6cc4..b8835d01ec 100644 --- a/modules/ocl/src/kernels/imgproc_warpPerspective.cl +++ b/modules/ocl/src/kernels/imgproc_warpPerspective.cl @@ -91,8 +91,8 @@ __kernel void warpPerspectiveNN_C1_D0(__global uchar const * restrict src, __glo F4 DX = (F4)(dx, dx+1, dx+2, dx+3); F4 X0 = M[0]*DX + M[1]*dy + M[2]; F4 Y0 = M[3]*DX + M[4]*dy + M[5]; - F4 W = M[6]*DX + M[7]*dy + M[8]; - W = (W!=0) ? 1./W : 0; + F4 W = M[6]*DX + M[7]*dy + M[8],one=1,zero=0; + W = (W!=zero) ? one/W : zero; short4 X = convert_short4(rint(X0*W)); short4 Y = convert_short4(rint(Y0*W)); int4 sx = convert_int4(X); diff --git a/modules/ocl/src/kernels/operator_convertTo.cl b/modules/ocl/src/kernels/operator_convertTo.cl index 52f576ef94..de8c1f97bd 100644 --- a/modules/ocl/src/kernels/operator_convertTo.cl +++ b/modules/ocl/src/kernels/operator_convertTo.cl @@ -34,7 +34,8 @@ // // #define F float - +#define F2 float2 +#define F4 float4 __kernel void convert_to_S4_C1_D0( __global const int* restrict srcMat, __global uchar* dstMat, @@ -56,17 +57,41 @@ __kernel void convert_to_S4_C1_D0( int dst_addr_start = mad24(y,dstStep_in_pixel,dstoffset_in_pixel); int dst_addr_end = mad24(y,dstStep_in_pixel,cols+dstoffset_in_pixel); int dstidx = mad24(y,dstStep_in_pixel,x+ dstoffset_in_pixel & (int)0xfffffffc); - - if ( (x < cols + off_src) & (y < rows) ) + if(x+3=dst_addr_start)&(dstidx=dst_addr_start)&(dstidx+1=dst_addr_start)&(dstidx+2=dst_addr_start)&(dstidx+3=dst_addr_start)&(dstidx=dst_addr_start)&(dstidx+1=dst_addr_start)&(dstidx+2=dst_addr_start)&(dstidx+3= mask_addr_start) && (maskidx + 0 < mask_addr_end)) ? mask_data.x : 0; - mask_data.y = ((maskidx + 1 >= mask_addr_start) && (maskidx + 1 < mask_addr_end)) ? mask_data.y : 0; - mask_data.z = ((maskidx + 2 >= mask_addr_start) && (maskidx + 2 < mask_addr_end)) ? mask_data.z : 0; - mask_data.w = ((maskidx + 3 >= mask_addr_start) && (maskidx + 3 < mask_addr_end)) ? mask_data.w : 0; - - tmp_data.x = ((dstidx + 0 >= dst_addr_start) && (dstidx + 0 < dst_addr_end) && (mask_data.x)) - ? src_data.x : dst_data.x; - tmp_data.y = ((dstidx + 1 >= dst_addr_start) && (dstidx + 1 < dst_addr_end) && (mask_data.y)) - ? src_data.y : dst_data.y; - tmp_data.z = ((dstidx + 2 >= dst_addr_start) && (dstidx + 2 < dst_addr_end) && (mask_data.z)) - ? src_data.z : dst_data.z; - tmp_data.w = ((dstidx + 3 >= dst_addr_start) && (dstidx + 3 < dst_addr_end) && (mask_data.w)) - ? src_data.w : dst_data.w; - - (*(__global uchar4*)(dstMat+dstidx)) = tmp_data; - } -} - -__kernel void copy_to_with_mask_C4_D0( - __global const uchar4* restrict srcMat, - __global uchar4* dstMat, +__kernel void copy_to_with_mask( + __global const GENTYPE* restrict srcMat, + __global GENTYPE* dstMat, __global const uchar* restrict maskMat, int cols, int rows, @@ -102,107 +49,13 @@ __kernel void copy_to_with_mask_C4_D0( { int x=get_global_id(0); int y=get_global_id(1); + x = x< cols ? x: cols-1; + y = y< rows ? y: rows-1; int srcidx = mad24(y,srcStep_in_pixel,x+ srcoffset_in_pixel); int dstidx = mad24(y,dstStep_in_pixel,x+ dstoffset_in_pixel); int maskidx = mad24(y,maskStep,x+ maskoffset); uchar mask = maskMat[maskidx]; - if ( (x < cols) & (y < rows) & mask) - { - dstMat[dstidx] = srcMat[srcidx]; - } -} -__kernel void copy_to_with_mask_C1_D4( - __global const int* restrict srcMat, - __global int* dstMat, - __global const uchar* restrict maskMat, - int cols, - int rows, - int srcStep_in_pixel, - int srcoffset_in_pixel, - int dstStep_in_pixel, - int dstoffset_in_pixel, - int maskStep, - int maskoffset) -{ - int x=get_global_id(0); - int y=get_global_id(1); - int srcidx = mad24(y,srcStep_in_pixel,x+ srcoffset_in_pixel); - int dstidx = mad24(y,dstStep_in_pixel,x+ dstoffset_in_pixel); - int maskidx = mad24(y,maskStep,x+ maskoffset); - uchar mask = maskMat[maskidx]; - if ( (x < cols) & (y < rows) & mask) - { - dstMat[dstidx] = srcMat[srcidx]; - } -} -__kernel void copy_to_with_mask_C4_D4( - __global const int4* restrict srcMat, - __global int4* dstMat, - __global const uchar* restrict maskMat, - int cols, - int rows, - int srcStep_in_pixel, - int srcoffset_in_pixel, - int dstStep_in_pixel, - int dstoffset_in_pixel, - int maskStep, - int maskoffset) -{ - int x=get_global_id(0); - int y=get_global_id(1); - int srcidx = mad24(y,srcStep_in_pixel,x+ srcoffset_in_pixel); - int dstidx = mad24(y,dstStep_in_pixel,x+ dstoffset_in_pixel); - int maskidx = mad24(y,maskStep,x+ maskoffset); - uchar mask = maskMat[maskidx]; - if ( (x < cols) & (y < rows) & mask) - { - dstMat[dstidx] = srcMat[srcidx]; - } -} -__kernel void copy_to_with_mask_C1_D5( - __global const float* restrict srcMat, - __global float* dstMat, - __global const uchar* restrict maskMat, - int cols, - int rows, - int srcStep_in_pixel, - int srcoffset_in_pixel, - int dstStep_in_pixel, - int dstoffset_in_pixel, - int maskStep, - int maskoffset) -{ - int x=get_global_id(0); - int y=get_global_id(1); - int srcidx = mad24(y,srcStep_in_pixel,x+ srcoffset_in_pixel); - int dstidx = mad24(y,dstStep_in_pixel,x+ dstoffset_in_pixel); - int maskidx = mad24(y,maskStep,x+ maskoffset); - uchar mask = maskMat[maskidx]; - if ( (x < cols) & (y < rows) & mask) - { - dstMat[dstidx] = srcMat[srcidx]; - } -} -__kernel void copy_to_with_mask_C4_D5( - __global const float4* restrict srcMat, - __global float4* dstMat, - __global const uchar* restrict maskMat, - int cols, - int rows, - int srcStep_in_pixel, - int srcoffset_in_pixel, - int dstStep_in_pixel, - int dstoffset_in_pixel, - int maskStep, - int maskoffset) -{ - int x=get_global_id(0); - int y=get_global_id(1); - int srcidx = mad24(y,srcStep_in_pixel,x+ srcoffset_in_pixel); - int dstidx = mad24(y,dstStep_in_pixel,x+ dstoffset_in_pixel); - int maskidx = mad24(y,maskStep,x+ maskoffset); - uchar mask = maskMat[maskidx]; - if ( (x < cols) & (y < rows) & mask) + if (mask) { dstMat[dstidx] = srcMat[srcidx]; } diff --git a/modules/ocl/src/kernels/operator_setTo.cl b/modules/ocl/src/kernels/operator_setTo.cl index edc5f015f8..ddff321ffc 100644 --- a/modules/ocl/src/kernels/operator_setTo.cl +++ b/modules/ocl/src/kernels/operator_setTo.cl @@ -40,24 +40,40 @@ __kernel void set_to_without_mask_C1_D0(uchar scalar,__global uchar * dstMat, { int x=get_global_id(0)<<2; int y=get_global_id(1); - int addr_start = mad24(y,dstStep_in_pixel,offset_in_pixel); - int addr_end = mad24(y,dstStep_in_pixel,cols+offset_in_pixel); - int idx = mad24(y,dstStep_in_pixel,(int)(x+ offset_in_pixel & (int)0xfffffffc)); + //int addr_start = mad24(y,dstStep_in_pixel,offset_in_pixel); + //int addr_end = mad24(y,dstStep_in_pixel,cols+offset_in_pixel); + int idx = mad24(y,dstStep_in_pixel,x+ offset_in_pixel); uchar4 out; out.x = out.y = out.z = out.w = scalar; - if ( (idx>=addr_start)&(idx+3 < addr_end) & (y < rows)) + if ( (x+3 < cols) && (y < rows)&& ((offset_in_pixel&3) == 0)) { *(__global uchar4*)(dstMat+idx) = out; } - else if(y < rows) + else { - uchar4 temp = *(__global uchar4*)(dstMat+idx); - temp.x = (idx>=addr_start)&(idx < addr_end)? out.x : temp.x; - temp.y = (idx+1>=addr_start)&(idx+1 < addr_end)? out.y : temp.y; - temp.z = (idx+2>=addr_start)&(idx+2 < addr_end)? out.z : temp.z; - temp.w = (idx+3>=addr_start)&(idx+3 < addr_end)? out.w : temp.w; - *(__global uchar4*)(dstMat+idx) = temp; + if((x+3 < cols) && (y < rows)) + { + dstMat[idx] = out.x; + dstMat[idx+1] = out.y; + dstMat[idx+2] = out.z; + dstMat[idx+3] = out.w; + } + if((x+2 < cols) && (y < rows)) + { + dstMat[idx] = out.x; + dstMat[idx+1] = out.y; + dstMat[idx+2] = out.z; + } + else if((x+1 < cols) && (y < rows)) + { + dstMat[idx] = out.x; + dstMat[idx+1] = out.y; + } + else if((x < cols) && (y < rows)) + { + dstMat[idx] = out.x; + } } } diff --git a/modules/ocl/src/kernels/operator_setToM.cl b/modules/ocl/src/kernels/operator_setToM.cl index 56a579b3f3..a0a1ca79e8 100644 --- a/modules/ocl/src/kernels/operator_setToM.cl +++ b/modules/ocl/src/kernels/operator_setToM.cl @@ -33,81 +33,6 @@ // the use of this software, even if advised of the possibility of such damage. // // - - -/* -__kernel void set_to_with_mask_C1_D0( - float4 scalar, - __global uchar* dstMat, - int cols, - int rows, - int dstStep_in_pixel, - int dstoffset_in_pixel, - __global const uchar * maskMat, - int maskStep, - int maskoffset) -{ - int x=get_global_id(0); - int y=get_global_id(1); - int dstidx = mad24(y,dstStep_in_pixel,x+ dstoffset_in_pixel); - int maskidx = mad24(y,maskStep,x+ maskoffset); - uchar mask = maskMat[maskidx]; - if ( (x < cols) & (y < rows) & mask) - { - dstMat[dstidx] = convert_uchar_sat(scalar.x); - } - -} -*/ -//#pragma OPENCL EXTENSION cl_amd_printf : enable -__kernel void set_to_with_mask_C1_D0( - uchar scalar, - __global uchar* dstMat, - int cols, - int rows, - int dstStep_in_pixel, - int dstoffset_in_pixel, - __global const uchar * restrict maskMat, - int maskStep, - int maskoffset) -{ - int x=get_global_id(0)<<2; - int y=get_global_id(1); - int dst_addr_start = mad24(y,dstStep_in_pixel,dstoffset_in_pixel); - int dst_addr_end = mad24(y,dstStep_in_pixel,cols+dstoffset_in_pixel); - int dstidx = mad24(y,dstStep_in_pixel,x+ dstoffset_in_pixel & (int)0xfffffffc); - int mask_addr_start = mad24(y,maskStep,maskoffset); - int mask_addr_end = mad24(y,maskStep,cols+maskoffset); - int maskidx = mad24(y,maskStep,x+ maskoffset & (int)0xfffffffc); - - int off_mask = (maskoffset & 3) - (dstoffset_in_pixel & 3) +3; - - if ( (x < cols) & (y < rows) ) - { - uchar4 temp_dst = *(__global uchar4*)(dstMat+dstidx); - uchar4 temp_mask1 = *(__global uchar4*)(maskMat+maskidx-4); - uchar4 temp_mask = *(__global uchar4*)(maskMat+maskidx); - uchar4 temp_mask2 = *(__global uchar4*)(maskMat+maskidx+4); - temp_mask1.x = (maskidx-4 >=mask_addr_start)&(maskidx-4 < mask_addr_end) ? temp_mask1.x : 0; - temp_mask1.y = (maskidx-3 >=mask_addr_start)&(maskidx-3 < mask_addr_end) ? temp_mask1.y : 0; - temp_mask1.z = (maskidx-2 >=mask_addr_start)&(maskidx-2 < mask_addr_end) ? temp_mask1.z : 0; - temp_mask1.w = (maskidx-1 >=mask_addr_start)&(maskidx-1 < mask_addr_end) ? temp_mask1.w : 0; - temp_mask.x = (maskidx >=mask_addr_start)&(maskidx < mask_addr_end) ? temp_mask.x : 0; - temp_mask.y = (maskidx+1 >=mask_addr_start)&(maskidx+1 < mask_addr_end) ? temp_mask.y : 0; - temp_mask.z = (maskidx+2 >=mask_addr_start)&(maskidx+2 < mask_addr_end) ? temp_mask.z : 0; - temp_mask.w = (maskidx+3 >=mask_addr_start)&(maskidx+3 < mask_addr_end) ? temp_mask.w : 0; - temp_mask2.x = (maskidx+4 >=mask_addr_start)&(maskidx+4 < mask_addr_end) ? temp_mask2.x : 0; - temp_mask2.y = (maskidx+5 >=mask_addr_start)&(maskidx+5 < mask_addr_end) ? temp_mask2.y : 0; - temp_mask2.z = (maskidx+6 >=mask_addr_start)&(maskidx+6 < mask_addr_end) ? temp_mask2.z : 0; - temp_mask2.w = (maskidx+7 >=mask_addr_start)&(maskidx+7 < mask_addr_end) ? temp_mask2.w : 0; - uchar trans_mask[10] = {temp_mask1.y,temp_mask1.z,temp_mask1.w,temp_mask.x,temp_mask.y,temp_mask.z,temp_mask.w,temp_mask2.x,temp_mask2.y,temp_mask2.z}; - temp_dst.x = (dstidx>=dst_addr_start)&(dstidx=dst_addr_start)&(dstidx+1=dst_addr_start)&(dstidx+2=dst_addr_start)&(dstidx+3= cwidth) - return; - - for(int d = STEREO_MIND; d < maxdisp; d += STEREO_DISP_STEP) - { - y_tex = Y - radius; - - InitColSSD(x_tex, y_tex, img_step, left, right, d, col_ssd, radius); - if (col_ssd_extra > 0) - if (x_tex + BLOCK_W < cwidth) - InitColSSD(x_tex + BLOCK_W, y_tex, img_step, left, right, d, col_ssd_extra, radius); - - barrier(CLK_LOCAL_MEM_FENCE); //before MinSSD function - - if (X < cwidth - radius && Y < cheight - radius) - { - uint2 minSSD = MinSSD(col_ssd_cache + get_local_id(0), col_ssd, radius); - if (minSSD.x < minSSDImage[0]) - { - disparImage[0] = (unsigned char)(d + minSSD.y); - minSSDImage[0] = minSSD.x; - } - } - - for(int row = 1; row < end_row; row++) - { - int idx1 = y_tex * img_step + x_tex; - int idx2 = (y_tex + (2 * radius + 1)) * img_step + x_tex; - - barrier(CLK_GLOBAL_MEM_FENCE); - barrier(CLK_LOCAL_MEM_FENCE); - - StepDown(idx1, idx2, left, right, d, col_ssd, radius); - if (col_ssd_extra > 0) - if (x_tex + BLOCK_W < cwidth) - StepDown(idx1, idx2, left + BLOCK_W, right + BLOCK_W, d, col_ssd_extra, radius); - - y_tex += 1; - - barrier(CLK_LOCAL_MEM_FENCE); - - if (X < cwidth - radius && row < cheight - radius - Y) - { - int idx = row * cminSSD_step; - uint2 minSSD = MinSSD(col_ssd_cache + get_local_id(0), col_ssd, radius); - if (minSSD.x < minSSDImage[idx]) - { - disparImage[disp_step * row] = (unsigned char)(d + minSSD.y); - minSSDImage[idx] = minSSD.x; - } - } - } // for row loop - } // for d loop -} - -////////////////////////////////////////////////////////////////////////////////////////////////// -//////////////////////////// Sobel Prefiler (signal channel)////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////// - -__kernel void prefilter_xsobel(__global unsigned char *input, __global unsigned char *output, - int rows, int cols, int prefilterCap) -{ - int x = get_global_id(0); - int y = get_global_id(1); - - if(x < cols && y < rows) - { - int cov = input[(y-1) * cols + (x-1)] * (-1) + input[(y-1) * cols + (x+1)] * (1) + - input[(y) * cols + (x-1)] * (-2) + input[(y) * cols + (x+1)] * (2) + - input[(y+1) * cols + (x-1)] * (-1) + input[(y+1) * cols + (x+1)] * (1); - - cov = min(min(max(-prefilterCap, cov), prefilterCap) + prefilterCap, 255); - output[y * cols + x] = cov & 0xFF; - } -} - - -////////////////////////////////////////////////////////////////////////////////////////////////// -/////////////////////////////////// Textureness filtering //////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////// - -float sobel(__global unsigned char *input, int x, int y, int rows, int cols) -{ - float conv = 0; - int y1 = y==0? 0 : y-1; - int x1 = x==0? 0 : x-1; - if(x < cols && y < rows) - { - conv = (float)input[(y1) * cols + (x1)] * (-1) + (float)input[(y1) * cols + (x+1)] * (1) + - (float)input[(y) * cols + (x1)] * (-2) + (float)input[(y) * cols + (x+1)] * (2) + - (float)input[(y+1) * cols + (x1)] * (-1) + (float)input[(y+1) * cols + (x+1)] * (1); - - } - return fabs(conv); -} - -float CalcSums(__local float *cols, __local float *cols_cache, int winsz) -{ - float cache = 0; - float cache2 = 0; - int winsz2 = winsz/2; - - int x = get_local_id(0); - int group_size_x = get_local_size(0); - - for(int i = 1; i <= winsz2; i++) - cache += cols[i]; - - cols_cache[0] = cache; - - barrier(CLK_LOCAL_MEM_FENCE); - - if (x < group_size_x - winsz2) - cache2 = cols_cache[winsz2]; - else - for(int i = winsz2 + 1; i < winsz; i++) - cache2 += cols[i]; - - return cols[0] + cache + cache2; -} - -#define RpT (2 * ROWSperTHREAD) // got experimentally -__kernel void textureness_kernel(__global unsigned char *disp, int disp_rows, int disp_cols, - int disp_step, __global unsigned char *input, int input_rows, - int input_cols,int winsz, float threshold, - __local float *cols_cache) -{ - int winsz2 = winsz/2; - int n_dirty_pixels = (winsz2) * 2; - - int local_id_x = get_local_id(0); - int group_size_x = get_local_size(0); - int group_id_y = get_group_id(1); - - __local float *cols = cols_cache + group_size_x + local_id_x; - __local float *cols_extra = local_id_x < n_dirty_pixels ? cols + group_size_x : 0; - - int x = get_global_id(0); - int beg_row = group_id_y * RpT; - int end_row = min(beg_row + RpT, disp_rows); - - if (x < disp_cols) - { - int y = beg_row; - - float sum = 0; - float sum_extra = 0; - - for(int i = y - winsz2; i <= y + winsz2; ++i) - { - sum += sobel(input, x - winsz2, i, input_rows, input_cols); - if (cols_extra) - sum_extra += sobel(input, x + group_size_x - winsz2, i, input_rows, input_cols); - } - *cols = sum; - if (cols_extra) - *cols_extra = sum_extra; - - barrier(CLK_LOCAL_MEM_FENCE); - - float sum_win = CalcSums(cols, cols_cache + local_id_x, winsz) * 255; - if (sum_win < threshold) - disp[y * disp_step + x] = 0; - - barrier(CLK_LOCAL_MEM_FENCE); - - for(int y = beg_row + 1; y < end_row; ++y) - { - sum = sum - sobel(input, x - winsz2, y - winsz2 - 1, input_rows, input_cols) + - sobel(input, x - winsz2, y + winsz2, input_rows, input_cols); - *cols = sum; - - if (cols_extra) - { - sum_extra = sum_extra - sobel(input, x + group_size_x - winsz2, y - winsz2 - 1,input_rows, input_cols) - + sobel(input, x + group_size_x - winsz2, y + winsz2, input_rows, input_cols); - *cols_extra = sum_extra; - } - - barrier(CLK_LOCAL_MEM_FENCE); - float sum_win = CalcSums(cols, cols_cache + local_id_x, winsz) * 255; - if (sum_win < threshold) - disp[y * disp_step + x] = 0; - - barrier(CLK_LOCAL_MEM_FENCE); - } - } -} diff --git a/modules/ocl/src/kernels/stereobp.cl b/modules/ocl/src/kernels/stereobp.cl deleted file mode 100644 index 9118e50852..0000000000 --- a/modules/ocl/src/kernels/stereobp.cl +++ /dev/null @@ -1,580 +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) 2010-2012, Institute Of Software Chinese Academy Of Science, all rights reserved. -// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved. -// Third party copyrights are property of their respective owners. -// -// @Authors -// Jia Haipeng, jiahaipeng95@gmail.com -// -// 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 GpuMaterials 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*/ - -#if defined (__ATI__) -#pragma OPENCL EXTENSION cl_amd_fp64:enable -#elif defined (__NVIDIA__) -#pragma OPENCL EXTENSION cl_khr_fp64:enable -#endif -/////////////////////////////////////////////////////////////// -/////////////////common/////////////////////////////////////// -///////////////////////////////////////////////////////////// -short round_short(float v){ - return convert_short_sat_rte(v); -} -#define FLOAT_MAX 3.402823466e+38f -typedef struct -{ - int cndisp; - float cmax_data_term; - float cdata_weight; - float cmax_disc_term; - float cdisc_single_jump; -}con_srtuct_t; -/////////////////////////////////////////////////////////////// -////////////////////////// comp data ////////////////////////// -/////////////////////////////////////////////////////////////// - -float pix_diff_1(__global const uchar *ls, __global const uchar *rs) -{ - return abs((int)(*ls) - *rs); -} - -float pix_diff_3(__global const uchar *ls, __global const uchar *rs) -{ - const float tr = 0.299f; - const float tg = 0.587f; - const float tb = 0.114f; - - float val; - - val = tb * abs((int)ls[0] - rs[0]); - val += tg * abs((int)ls[1] - rs[1]); - val += tr * abs((int)ls[2] - rs[2]); - - return val; -} -float pix_diff_4(__global const uchar *ls, __global const uchar *rs) -{ - uchar4 l, r; - l = *((__global uchar4 *)ls); - r = *((__global uchar4 *)rs); - - const float tr = 0.299f; - const float tg = 0.587f; - const float tb = 0.114f; - - float val; - - val = tb * abs((int)l.x - r.x); - val += tg * abs((int)l.y - r.y); - val += tr * abs((int)l.z - r.z); - - return val; -} - -__kernel void comp_data_0(__global uchar *left, int left_rows, int left_cols, int left_step, - __global uchar *right, int right_step, - __global short *data, int data_cols, int data_step, - __constant con_srtuct_t *con_st, int cn) - // int cndisp, float cmax_data_term, float cdata_weight, int cn) -{ - int x = get_global_id(0); - int y = get_global_id(1); - - if (y > 0 && y < (left_rows - 1) && x > 0 && x < (left_cols - 1)) - { - const __global uchar* ls = left + y * left_step + x * cn; - const __global uchar* rs = right + y * right_step + x * cn; - - __global short *ds = (__global short *)((__global uchar *)data + y * data_step) + x; - - const unsigned int disp_step = data_cols * left_rows ; - - for (int disp = 0; disp < con_st -> cndisp; disp++) - { - if (x - disp >= 1) - { - float val = 0; - if(cn == 1) - val = pix_diff_1(ls, rs - disp * cn); - if(cn == 3) - val = pix_diff_3(ls, rs - disp * cn); - if(cn == 4) - val = pix_diff_4(ls, rs - disp *cn); - - ds[disp * disp_step] = round_short(fmin(con_st -> cdata_weight * val, - con_st -> cdata_weight * con_st -> cmax_data_term)); - } - else - { - ds[disp * disp_step] = round_short(con_st -> cdata_weight * con_st -> cmax_data_term); - } - } - } -} - -__kernel void comp_data_1(__global uchar *left, int left_rows, int left_cols, int left_step, - __global uchar *right, int right_step, - __global float *data, int data_cols, int data_step, - __constant con_srtuct_t *con_st, int cn) - //int cndisp, float cmax_data_term, float cdata_weight, int cn) -{ - int x = get_global_id(0); - int y = get_global_id(1); - - if (y > 0 && y < left_rows - 1 && x > 0 && x < left_cols - 1) - { - const __global uchar* ls = left + y * left_step + x * cn; - const __global uchar* rs = right + y * right_step + x * cn; - - __global float *ds = (__global float *)((__global char *)data + y * data_step) + x; - - const unsigned int disp_step = data_cols * left_rows; - - for (int disp = 0; disp < con_st -> cndisp; disp++) - { - if (x - disp >= 1) - { - float val = 0; - if(cn == 1) - val = pix_diff_1(ls, rs - disp * cn); - if(cn == 3) - val = pix_diff_3(ls, rs - disp * cn); - if(cn == 4) - val = pix_diff_4(ls, rs - disp *cn); - - ds[disp * disp_step] = fmin(con_st -> cdata_weight * val, - con_st -> cdata_weight * con_st -> cmax_data_term); - } - else - { - ds[disp * disp_step] = con_st -> cdata_weight * con_st -> cmax_data_term; - } - } - } -} - -/////////////////////////////////////////////////////////////// -//////////////////////// data step down /////////////////////// -/////////////////////////////////////////////////////////////// -__kernel void data_step_down_0(__global short *src, int src_rows, int src_cols, - __global short *dst, int dst_rows, int dst_cols, int dst_real_cols, - int cndisp) -{ - const int x = get_global_id(0); - const int y = get_global_id(1);; - - if (x < dst_cols && y < dst_rows) - { - for (int d = 0; d < cndisp; ++d) - { - //float dst_reg = src.ptr(d * src_rows + (2*y+0))[(2*x+0)]; - float dst_reg; - dst_reg = src[(d * src_rows + (2*y+0)) * src_cols + 2*x+0]; - dst_reg += src[(d * src_rows + (2*y+1)) * src_cols + 2*x+0]; - dst_reg += src[(d * src_rows + (2*y+0)) * src_cols + 2*x+1]; - dst_reg += src[(d * src_rows + (2*y+1)) * src_cols + 2*x+1]; - - //dst.ptr(d * dst_rows + y)[x] = saturate_cast(dst_reg); - dst[(d * dst_rows + y) * dst_real_cols + x] = round_short(dst_reg); - } - } -} -__kernel void data_step_down_1(__global float *src, int src_rows, int src_cols, - __global float *dst, int dst_rows, int dst_cols, int dst_real_cols, - int cndisp) -{ - const int x = get_global_id(0); - const int y = get_global_id(1);; - - if (x < dst_cols && y < dst_rows) - { - for (int d = 0; d < cndisp; ++d) - { - //float dst_reg = src.ptr(d * src_rows + (2*y+0))[(2*x+0)]; - float dst_reg; - dst_reg = src[(d * src_rows + (2*y+0)) * src_cols + 2*x+0]; - dst_reg += src[(d * src_rows + (2*y+1)) * src_cols + 2*x+0]; - dst_reg += src[(d * src_rows + (2*y+0)) * src_cols + 2*x+1]; - dst_reg += src[(d * src_rows + (2*y+1)) * src_cols + 2*x+1]; - - //dst.ptr(d * dst_rows + y)[x] = saturate_cast(dst_reg); - dst[(d * dst_rows + y) * dst_real_cols + x] = round_short(dst_reg); - } - } -} - -/////////////////////////////////////////////////////////////// -/////////////////// level up messages //////////////////////// -/////////////////////////////////////////////////////////////// -__kernel void level_up_message_0(__global short *src, int src_rows, int src_step, - __global short *dst, int dst_rows, int dst_cols, int dst_step, - int cndisp) - -{ - const int x = get_global_id(0); - const int y = get_global_id(1); - - if (x < dst_cols && y < dst_rows) - { - const int dst_disp_step = (dst_step / sizeof(short)) * dst_rows; - const int src_disp_step = (src_step / sizeof(short)) * src_rows; - - __global short *dstr = (__global short *)((__global char *)dst + y * dst_step) + x; - __global const short *srcr = (__global short *)((__global char *)src + y/2 * src_step) + x/2; - - for (int d = 0; d < cndisp; ++d) - dstr[d * dst_disp_step] = srcr[d * src_disp_step]; - } -} -__kernel void level_up_message_1(__global float *src, int src_rows, int src_step, - __global float *dst, int dst_rows, int dst_cols, int dst_step, - int cndisp) - -{ - const int x = get_global_id(0); - const int y = get_global_id(1); - - if (x < dst_cols && y < dst_rows) - { - const int dst_disp_step = (dst_step/sizeof(float)) * dst_rows; - const int src_disp_step = (src_step/sizeof(float)) * src_rows; - - __global float *dstr = (__global float *)((__global char *)dst + y * dst_step) + x; - __global const float *srcr = (__global float *)((__global char *)src + y/2 * src_step) + x/2; - - for (int d = 0; d < cndisp; ++d) - dstr[d * dst_disp_step] = srcr[d * src_disp_step]; - } -} - -/////////////////////////////////////////////////////////////// -//////////////////// calc all iterations ///////////////////// -/////////////////////////////////////////////////////////////// -void calc_min_linear_penalty_0(__global short * dst, int disp_step, - int cndisp, float cdisc_single_jump) -{ - float prev = dst[0]; - float cur; - - for (int disp = 1; disp < cndisp; ++disp) - { - prev += cdisc_single_jump; - cur = dst[disp_step * disp]; - - if (prev < cur) - { - cur = prev; - dst[disp_step * disp] = round_short(prev); - } - - prev = cur; - } - - prev = dst[(cndisp - 1) * disp_step]; - for (int disp = cndisp - 2; disp >= 0; disp--) - { - prev += cdisc_single_jump; - cur = dst[disp_step * disp]; - - if (prev < cur) - { - cur = prev; - dst[disp_step * disp] = round_short(prev); - } - prev = cur; - } -} -void message_0(const __global short *msg1, const __global short *msg2, - const __global short *msg3, const __global short *data, __global short *dst, - int msg_disp_step, int data_disp_step, int cndisp, float cmax_disc_term, float cdisc_single_jump) -{ - float minimum = FLOAT_MAX; - - for(int i = 0; i < cndisp; ++i) - { - float dst_reg; - dst_reg = msg1[msg_disp_step * i]; - dst_reg += msg2[msg_disp_step * i]; - dst_reg += msg3[msg_disp_step * i]; - dst_reg += data[data_disp_step * i]; - - if (dst_reg < minimum) - minimum = dst_reg; - - dst[msg_disp_step * i] = round_short(dst_reg); - } - - calc_min_linear_penalty_0(dst, msg_disp_step, cndisp, cdisc_single_jump); - - minimum += cmax_disc_term; - - float sum = 0; - for(int i = 0; i < cndisp; ++i) - { - float dst_reg = dst[msg_disp_step * i]; - if (dst_reg > minimum) - { - dst_reg = minimum; - dst[msg_disp_step * i] = round_short(minimum); - } - sum += dst_reg; - } - sum /= cndisp; - - for(int i = 0; i < cndisp; ++i) - dst[msg_disp_step * i] -= sum; -} -__kernel void one_iteration_0(__global short *u, int u_step, int u_cols, - __global short *data, int data_step, int data_cols, - __global short *d, __global short *l, __global short *r, - int t, int cols, int rows, - int cndisp, float cmax_disc_term, float cdisc_single_jump) -{ - const int y = get_global_id(1); - const int x = ((get_global_id(0)) << 1) + ((y + t) & 1); - - if ((y > 0) && (y < rows - 1) && (x > 0) && (x < cols - 1)) - { - __global short *us = (__global short *)((__global char *)u + y * u_step) + x; - __global short *ds = d + y * u_cols + x; - __global short *ls = l + y * u_cols + x; - __global short *rs = r + y * u_cols + x; - const __global short *dt = (__global short *)((__global char *)data + y * data_step) + x; - - int msg_disp_step = u_cols * rows; - int data_disp_step = data_cols * rows; - - message_0(us + u_cols, ls + 1, rs - 1, dt, us, msg_disp_step, data_disp_step, cndisp, - cmax_disc_term, cdisc_single_jump); - message_0(ds - u_cols, ls + 1, rs - 1, dt, ds, msg_disp_step, data_disp_step, cndisp, - cmax_disc_term, cdisc_single_jump); - - message_0(us + u_cols, ds - u_cols, rs - 1, dt, rs, msg_disp_step, data_disp_step, cndisp, - cmax_disc_term, cdisc_single_jump); - message_0(us + u_cols, ds - u_cols, ls + 1, dt, ls, msg_disp_step, data_disp_step, cndisp, - cmax_disc_term, cdisc_single_jump); - } -} -void calc_min_linear_penalty_1(__global float * dst, int step, - int cndisp, float cdisc_single_jump) -{ - float prev = dst[0]; - float cur; - - for (int disp = 1; disp < cndisp; ++disp) - { - prev += cdisc_single_jump; - cur = dst[step * disp]; - - if (prev < cur) - { - cur = prev; - dst[step * disp] = prev; - } - - prev = cur; - } - - prev = dst[(cndisp - 1) * step]; - for (int disp = cndisp - 2; disp >= 0; disp--) - { - prev += cdisc_single_jump; - cur = dst[step * disp]; - - if (prev < cur) - { - cur = prev; - dst[step * disp] = prev; - } - prev = cur; - } -} -void message_1(const __global float *msg1, const __global float *msg2, - const __global float *msg3, const __global float *data, __global float *dst, - int msg_disp_step, int data_disp_step, int cndisp, float cmax_disc_term, float cdisc_single_jump) -{ - float minimum = FLOAT_MAX; - - for(int i = 0; i < cndisp; ++i) - { - float dst_reg = 0; - dst_reg = msg1[msg_disp_step * i]; - dst_reg += msg2[msg_disp_step * i]; - dst_reg += msg3[msg_disp_step * i]; - dst_reg += data[data_disp_step * i]; - - if (dst_reg < minimum) - minimum = dst_reg; - - dst[msg_disp_step * i] = dst_reg; - } - - calc_min_linear_penalty_1(dst, msg_disp_step, cndisp, cdisc_single_jump); - - minimum += cmax_disc_term; - - float sum = 0; - for(int i = 0; i < cndisp; ++i) - { - float dst_reg = dst[msg_disp_step * i]; - if (dst_reg > minimum) - { - dst_reg = minimum; - dst[msg_disp_step * i] = minimum; - } - sum += dst_reg; - } - sum /= cndisp; - - for(int i = 0; i < cndisp; ++i) - dst[msg_disp_step * i] -= sum; -} -__kernel void one_iteration_1(__global float *u, int u_step, int u_cols, - __global float *data, int data_step, int data_cols, - __global float *d, __global float *l, __global float *r, - int t, int cols, int rows, - int cndisp,float cmax_disc_term, float cdisc_single_jump) -{ - const int y = get_global_id(1); - const int x = ((get_global_id(0)) << 1) + ((y + t) & 1); - - if ((y > 0) && (y < rows - 1) && (x > 0) && (x < cols - 1)) - { - __global float* us = (__global float *)((__global char *)u + y * u_step) + x; - __global float* ds = d + y * u_cols + x; - __global float* ls = l + y * u_cols + x; - __global float* rs = r + y * u_cols + x; - const __global float* dt = (__global float *)((__global char *)data + y * data_step) + x; - - int msg_disp_step = u_cols * rows; - int data_disp_step = data_cols * rows; - - message_1(us + u_cols, ls + 1, rs - 1, dt, us, msg_disp_step, data_disp_step, cndisp, - cmax_disc_term, cdisc_single_jump); - message_1(ds - u_cols, ls + 1, rs - 1, dt, ds, msg_disp_step, data_disp_step, cndisp, - cmax_disc_term, cdisc_single_jump); - message_1(us + u_cols, ds - u_cols, rs - 1, dt, rs, msg_disp_step, data_disp_step, cndisp, - cmax_disc_term, cdisc_single_jump); - message_1(us + u_cols, ds - u_cols, ls + 1, dt, ls, msg_disp_step, data_disp_step, cndisp, - cmax_disc_term, cdisc_single_jump); - } -} - -/////////////////////////////////////////////////////////////// -/////////////////////////// output //////////////////////////// -/////////////////////////////////////////////////////////////// -__kernel void output_0(const __global short *u, int u_step, int u_cols, - const __global short *d, const __global short *l, - const __global short *r, const __global short *data, - __global short *disp, int disp_rows, int disp_cols, int disp_step, - int cndisp) -{ - const int x = get_global_id(0); - const int y = get_global_id(1); - - if (y > 0 && y < disp_rows - 1 && x > 0 && x < disp_cols - 1) - { - const __global short *us =(__global short *)((__global char *)u + (y + 1) * u_step) + x; - const __global short *ds = d + (y - 1) * u_cols + x; - const __global short *ls = l + y * u_cols + (x + 1); - const __global short *rs = r + y * u_cols + (x - 1); - const __global short *dt = data + y * u_cols + x; - - int disp_steps = disp_rows * u_cols; - - int best = 0; - float best_val = FLOAT_MAX; - for (int d = 0; d < cndisp; ++d) - { - float val; - val = us[d * disp_steps]; - val += ds[d * disp_steps]; - val += ls[d * disp_steps]; - val += rs[d * disp_steps]; - val += dt[d * disp_steps]; - - if (val < best_val) - { - best_val = val; - best = d; - } - } - - ((__global short *)((__global char *)disp + y * disp_step))[x] = convert_short_sat(best); - } -} -__kernel void output_1(const __global float *u, int u_step, int u_cols, - const __global float *d, const __global float *l, - const __global float *r, const __global float *data, - __global short *disp, int disp_rows, int disp_cols, int disp_step, - int cndisp) -{ - const int x = get_global_id(0); - const int y = get_global_id(1); - - if (y > 0 && y < disp_rows - 1 && x > 0 && x < disp_cols - 1) - { - const __global float *us =(__global float *)((__global char *)u + (y + 1) * u_step) + x; - const __global float *ds = d + (y - 1) * u_cols + x; - const __global float *ls = l + y * u_cols + (x + 1); - const __global float *rs = r + y * u_cols + (x - 1); - const __global float *dt = data + y * u_cols + x; - - int disp_steps = disp_rows * u_cols; - - int best = 0; - float best_val = FLOAT_MAX; - for (int d = 0; d < cndisp; ++d) - { - float val; - val = us[d * disp_steps]; - val += ds[d * disp_steps]; - val += ls[d * disp_steps]; - val += rs[d * disp_steps]; - val += dt[d * disp_steps]; - - if (val < best_val) - { - best_val = val; - best = d; - } - } - - //disp[y * disp_cols + x] = convert_short_sat(best); - ((__global short *)((__global char *)disp + y * disp_step))[x] = convert_short_sat(best); - } -} diff --git a/modules/ocl/src/kernels/stereocsbp.cl b/modules/ocl/src/kernels/stereocsbp.cl deleted file mode 100644 index cc814050e7..0000000000 --- a/modules/ocl/src/kernels/stereocsbp.cl +++ /dev/null @@ -1,1131 +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) 2010-2012, Institute Of Software Chinese Academy Of Science, all rights reserved. -// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved. -// Third party copyrights are property of their respective owners. -// -// @Authors -// Jia Haipeng, jiahaipeng95@gmail.com -// -// 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 oclMaterials 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 FLT_MAX -#define FLT_MAX CL_FLT_MAX -#endif - -#ifndef SHRT_MAX -#define SHRT_MAX CL_SHORT_MAX -#endif - - -/////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////get_first_k_initial_global////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////// -__kernel void get_first_k_initial_global_0(__global short *data_cost_selected_, __global short *selected_disp_pyr, - __global short *ctemp, int h, int w, int nr_plane, - int cmsg_step1, int cdisp_step1, int cndisp) -{ - int x = get_global_id(0); - int y = get_global_id(1); - - if (y < h && x < w) - { - __global short *selected_disparity = selected_disp_pyr + y * cmsg_step1 + x; - __global short *data_cost_selected = data_cost_selected_ + y * cmsg_step1 + x; - __global short *data_cost = ctemp + y * cmsg_step1 + x; - - for(int i = 0; i < nr_plane; i++) - { - short minimum = SHRT_MAX; - int id = 0; - - for(int d = 0; d < cndisp; d++) - { - short cur = data_cost[d * cdisp_step1]; - if(cur < minimum) - { - minimum = cur; - id = d; - } - } - - data_cost_selected[i * cdisp_step1] = minimum; - selected_disparity[i * cdisp_step1] = id; - data_cost [id * cdisp_step1] = SHRT_MAX; - } - } -} -__kernel void get_first_k_initial_global_1(__global float *data_cost_selected_, __global float *selected_disp_pyr, - __global float *ctemp, int h, int w, int nr_plane, - int cmsg_step1, int cdisp_step1, int cndisp) -{ - int x = get_global_id(0); - int y = get_global_id(1); - - if (y < h && x < w) - { - __global float *selected_disparity = selected_disp_pyr + y * cmsg_step1 + x; - __global float *data_cost_selected = data_cost_selected_ + y * cmsg_step1 + x; - __global float *data_cost = ctemp + y * cmsg_step1 + x; - - for(int i = 0; i < nr_plane; i++) - { - float minimum = FLT_MAX; - int id = 0; - - for(int d = 0; d < cndisp; d++) - { - float cur = data_cost[d * cdisp_step1]; - if(cur < minimum) - { - minimum = cur; - id = d; - } - } - - data_cost_selected[i * cdisp_step1] = minimum; - selected_disparity[i * cdisp_step1] = id; - data_cost [id * cdisp_step1] = FLT_MAX; - } - } -} - -//////////////////////////////////////////////////////////////////////////////////////////////////////// -///////////////////////////////////////////get_first_k_initial_local//////////////////////////////////// -//////////////////////////////////////////////////////////////////////////////////////////////////////// -__kernel void get_first_k_initial_local_0(__global short *data_cost_selected_, __global short *selected_disp_pyr, - __global short *ctemp,int h, int w, int nr_plane, - int cmsg_step1, int cdisp_step1, int cndisp) -{ - int x = get_global_id(0); - int y = get_global_id(1); - - if (y < h && x < w) - { - __global short *selected_disparity = selected_disp_pyr + y * cmsg_step1 + x; - __global short *data_cost_selected = data_cost_selected_ + y * cmsg_step1 + x; - __global short *data_cost = ctemp + y * cmsg_step1 + x; - - int nr_local_minimum = 0; - - short prev = data_cost[0 * cdisp_step1]; - short cur = data_cost[1 * cdisp_step1]; - short next = data_cost[2 * cdisp_step1]; - - for (int d = 1; d < cndisp - 1 && nr_local_minimum < nr_plane; d++) - { - - if (cur < prev && cur < next) - { - data_cost_selected[nr_local_minimum * cdisp_step1] = cur; - selected_disparity[nr_local_minimum * cdisp_step1] = d; - data_cost[d * cdisp_step1] = SHRT_MAX; - - nr_local_minimum++; - } - - prev = cur; - cur = next; - next = data_cost[(d + 1) * cdisp_step1]; - } - - for (int i = nr_local_minimum; i < nr_plane; i++) - { - short minimum = SHRT_MAX; - int id = 0; - - for (int d = 0; d < cndisp; d++) - { - cur = data_cost[d * cdisp_step1]; - if (cur < minimum) - { - minimum = cur; - id = d; - } - } - - data_cost_selected[i * cdisp_step1] = minimum; - selected_disparity[i * cdisp_step1] = id; - data_cost[id * cdisp_step1] = SHRT_MAX; - } - } -} - -__kernel void get_first_k_initial_local_1(__global float *data_cost_selected_, __global float *selected_disp_pyr, - __global float *ctemp,int h, int w, int nr_plane, - int cmsg_step1, int cdisp_step1, int cndisp) -{ - int x = get_global_id(0); - int y = get_global_id(1); - - if (y < h && x < w) - { - __global float *selected_disparity = selected_disp_pyr + y * cmsg_step1 + x; - __global float *data_cost_selected = data_cost_selected_ + y * cmsg_step1 + x; - __global float *data_cost = ctemp + y * cmsg_step1 + x; - - int nr_local_minimum = 0; - - float prev = data_cost[0 * cdisp_step1]; - float cur = data_cost[1 * cdisp_step1]; - float next = data_cost[2 * cdisp_step1]; - - for (int d = 1; d < cndisp - 1 && nr_local_minimum < nr_plane; d++) - { - if (cur < prev && cur < next) - { - data_cost_selected[nr_local_minimum * cdisp_step1] = cur; - selected_disparity[nr_local_minimum * cdisp_step1] = d; - data_cost[d * cdisp_step1] = FLT_MAX ; - - nr_local_minimum++; - } - - prev = cur; - cur = next; - next = data_cost[(d + 1) * cdisp_step1]; - } - for (int i = nr_local_minimum; i < nr_plane; i++) - { - float minimum = FLT_MAX; - int id = 0; - - for (int d = 0; d < cndisp; d++) - { - cur = data_cost[d * cdisp_step1]; - if (cur < minimum) - { - minimum = cur; - id = d; - } - } - - data_cost_selected[i * cdisp_step1] = minimum; - selected_disparity[i * cdisp_step1] = id; - data_cost[id * cdisp_step1] = FLT_MAX; - } - } -} - -/////////////////////////////////////////////////////////////// -/////////////////////// init data cost //////////////////////// -/////////////////////////////////////////////////////////////// -float compute_3(__global uchar* left, __global uchar* right, - float cdata_weight, float cmax_data_term) -{ - float tb = 0.114f * abs((int)left[0] - right[0]); - float tg = 0.587f * abs((int)left[1] - right[1]); - float tr = 0.299f * abs((int)left[2] - right[2]); - - return fmin(cdata_weight * (tr + tg + tb), cdata_weight * cmax_data_term); -} -float compute_1(__global uchar* left, __global uchar* right, - float cdata_weight, float cmax_data_term) -{ - return fmin(cdata_weight * abs((int)*left - (int)*right), cdata_weight * cmax_data_term); -} -short round_short(float v){ - return convert_short_sat_rte(v); -} -/////////////////////////////////////////////////////////////////////////////////////////////// -///////////////////////////////////init_data_cost/////////////////////////////////////////////// -/////////////////////////////////////////////////////////////////////////////////////////////// -__kernel void init_data_cost_0(__global short *ctemp, __global uchar *cleft, __global uchar *cright, - int h, int w, int level, int channels, - int cmsg_step1, float cdata_weight, float cmax_data_term, int cdisp_step1, - int cth, int cimg_step, int cndisp) -{ - int x = get_global_id(0); - int y = get_global_id(1); - - if (y < h && x < w) - { - int y0 = y << level; - int yt = (y + 1) << level; - - int x0 = x << level; - int xt = (x + 1) << level; - - __global short *data_cost = ctemp + y * cmsg_step1 + x; - - for(int d = 0; d < cndisp; ++d) - { - float val = 0.0f; - for(int yi = y0; yi < yt; yi++) - { - for(int xi = x0; xi < xt; xi++) - { - int xr = xi - d; - if(d < cth || xr < 0) - val += cdata_weight * cmax_data_term; - else - { - __global uchar *lle = cleft + yi * cimg_step + xi * channels; - __global uchar *lri = cright + yi * cimg_step + xr * channels; - - if(channels == 1) - val += compute_1(lle, lri, cdata_weight, cmax_data_term); - else - val += compute_3(lle, lri, cdata_weight, cmax_data_term); - } - } - } - data_cost[cdisp_step1 * d] = round_short(val); - } - } -} -__kernel void init_data_cost_1(__global float *ctemp, __global uchar *cleft, __global uchar *cright, - int h, int w, int level, int channels, - int cmsg_step1, float cdata_weight, float cmax_data_term, int cdisp_step1, - int cth, int cimg_step, int cndisp) -{ - int x = get_global_id(0); - int y = get_global_id(1); - - if (y < h && x < w) - { - int y0 = y << level; - int yt = (y + 1) << level; - - int x0 = x << level; - int xt = (x + 1) << level; - - __global float *data_cost = ctemp + y * cmsg_step1 + x; - - for(int d = 0; d < cndisp; ++d) - { - float val = 0.0f; - for(int yi = y0; yi < yt; yi++) - { - for(int xi = x0; xi < xt; xi++) - { - int xr = xi - d; - if(d < cth || xr < 0) - val += cdata_weight * cmax_data_term; - else - { - __global uchar* lle = cleft + yi * cimg_step + xi * channels; - __global uchar* lri = cright + yi * cimg_step + xr * channels; - - if(channels == 1) - val += compute_1(lle, lri, cdata_weight, cmax_data_term); - else - val += compute_3(lle, lri, cdata_weight, cmax_data_term); - } - } - } - data_cost[cdisp_step1 * d] = val; - } - } -} -//////////////////////////////////////////////////////////////////////////////////////////////////////// -//////////////////////////////////init_data_cost_reduce////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////// -__kernel void init_data_cost_reduce_0(__global short *ctemp, __global uchar *cleft, __global uchar *cright, - __local float *smem, int level, int rows, int cols, int h, int winsz, int channels, - int cndisp,int cimg_step, float cdata_weight, float cmax_data_term, int cth, - int cdisp_step1, int cmsg_step1) -{ - int x_out = get_group_id(0); - int y_out = get_group_id(1) % h; - //int d = (blockIdx.y / h) * blockDim.z + threadIdx.z; - int d = (get_group_id(1) / h ) * get_local_size(2) + get_local_id(2); - - int tid = get_local_id(0); - - if (d < cndisp) - { - int x0 = x_out << level; - int y0 = y_out << level; - - int len = min(y0 + winsz, rows) - y0; - - float val = 0.0f; - if (x0 + tid < cols) - { - if (x0 + tid - d < 0 || d < cth) - val = cdata_weight * cmax_data_term * len; - else - { - __global uchar* lle = cleft + y0 * cimg_step + channels * (x0 + tid ); - __global uchar* lri = cright + y0 * cimg_step + channels * (x0 + tid - d); - - for(int y = 0; y < len; ++y) - { - if(channels == 1) - val += compute_1(lle, lri, cdata_weight, cmax_data_term); - else - val += compute_3(lle, lri, cdata_weight, cmax_data_term); - - lle += cimg_step; - lri += cimg_step; - } - } - } - - __local float* dline = smem + winsz * get_local_id(2); - - dline[tid] = val; - - barrier(CLK_LOCAL_MEM_FENCE); - - if (winsz >= 256) { if (tid < 128) { dline[tid] += dline[tid + 128]; } barrier(CLK_LOCAL_MEM_FENCE); } - if (winsz >= 128) { if (tid < 64) { dline[tid] += dline[tid + 64]; } barrier(CLK_LOCAL_MEM_FENCE); } - - __local volatile float* vdline = smem + winsz * get_local_id(2); - - if (winsz >= 64) if (tid < 32) vdline[tid] += vdline[tid + 32]; - if (winsz >= 32) if (tid < 16) vdline[tid] += vdline[tid + 16]; - if (winsz >= 16) if (tid < 8) vdline[tid] += vdline[tid + 8]; - if (winsz >= 8) if (tid < 4) vdline[tid] += vdline[tid + 4]; - if (winsz >= 4) if (tid < 2) vdline[tid] += vdline[tid + 2]; - if (winsz >= 2) if (tid < 1) vdline[tid] += vdline[tid + 1]; - - __global short* data_cost = ctemp + y_out * cmsg_step1 + x_out; - - if (tid == 0) - data_cost[cdisp_step1 * d] = convert_short_sat_rte(dline[0]); - } -} - -__kernel void init_data_cost_reduce_1(__global float *ctemp, __global uchar *cleft, __global uchar *cright, - __local float *smem, int level, int rows, int cols, int h, int winsz, int channels, - int cndisp,int cimg_step, float cdata_weight, float cmax_data_term, int cth, - int cdisp_step1, int cmsg_step1) -{ - int x_out = get_group_id(0); - int y_out = get_group_id(1) % h; - int d = (get_group_id(1) / h ) * get_local_size(2) + get_local_id(2); - - int tid = get_local_id(0); - - if (d < cndisp) - { - int x0 = x_out << level; - int y0 = y_out << level; - - int len = min(y0 + winsz, rows) - y0; - - float val = 0.0f; - - if (x0 + tid < cols) - { - if (x0 + tid - d < 0 || d < cth) - val = cdata_weight * cmax_data_term * len; - else - { - __global uchar* lle = cleft + y0 * cimg_step + channels * (x0 + tid ); - __global uchar* lri = cright + y0 * cimg_step + channels * (x0 + tid - d); - - for(int y = 0; y < len; ++y) - { - if(channels == 1) - val += compute_1(lle, lri, cdata_weight, cmax_data_term); - else - val += compute_3(lle, lri, cdata_weight, cmax_data_term); - - lle += cimg_step; - lri += cimg_step; - } - } - } - - __local float* dline = smem + winsz * get_local_id(2); - - dline[tid] = val; - - barrier(CLK_LOCAL_MEM_FENCE); - - if (winsz >= 256) { if (tid < 128) { dline[tid] += dline[tid + 128]; } barrier(CLK_LOCAL_MEM_FENCE); } - if (winsz >= 128) { if (tid < 64) { dline[tid] += dline[tid + 64]; } barrier(CLK_LOCAL_MEM_FENCE); } - - __local volatile float* vdline = smem + winsz * get_local_id(2); - - if (winsz >= 64) if (tid < 32) vdline[tid] += vdline[tid + 32]; - if (winsz >= 32) if (tid < 16) vdline[tid] += vdline[tid + 16]; - if (winsz >= 16) if (tid < 8) vdline[tid] += vdline[tid + 8]; - if (winsz >= 8) if (tid < 4) vdline[tid] += vdline[tid + 4]; - if (winsz >= 4) if (tid < 2) vdline[tid] += vdline[tid + 2]; - if (winsz >= 2) if (tid < 1) vdline[tid] += vdline[tid + 1]; - - __global float *data_cost = ctemp + y_out * cmsg_step1 + x_out; - - if (tid == 0) - data_cost[cdisp_step1 * d] = dline[0]; - } -} - -/////////////////////////////////////////////////////////////// -////////////////////// compute data cost ////////////////////// -/////////////////////////////////////////////////////////////// -__kernel void compute_data_cost_0(__global const short *selected_disp_pyr, __global short *data_cost_, - __global uchar *cleft, __global uchar *cright, - int h, int w, int level, int nr_plane, int channels, - int cmsg_step1, int cmsg_step2, int cdisp_step1, int cdisp_step2, float cdata_weight, - float cmax_data_term, int cimg_step, int cth) -{ - - int x = get_global_id(0); - int y = get_global_id(1); - - if (y < h && x < w) - { - int y0 = y << level; - int yt = (y + 1) << level; - - int x0 = x << level; - int xt = (x + 1) << level; - - __global const short *selected_disparity = selected_disp_pyr + y/2 * cmsg_step2 + x/2; - __global short *data_cost = data_cost_ + y * cmsg_step1 + x; - - for(int d = 0; d < nr_plane; d++) - { - float val = 0.0f; - for(int yi = y0; yi < yt; yi++) - { - for(int xi = x0; xi < xt; xi++) - { - int sel_disp = selected_disparity[d * cdisp_step2]; - int xr = xi - sel_disp; - - if (xr < 0 || sel_disp < cth) - val += cdata_weight * cmax_data_term; - - else - { - __global uchar* left_x = cleft + yi * cimg_step + xi * channels; - __global uchar* right_x = cright + yi * cimg_step + xr * channels; - - if(channels == 1) - val += compute_1(left_x, right_x, cdata_weight, cmax_data_term); - else - val += compute_3(left_x, right_x, cdata_weight, cmax_data_term); - } - } - } - data_cost[cdisp_step1 * d] = convert_short_sat_rte(val); - } - } -} -__kernel void compute_data_cost_1(__global const float *selected_disp_pyr, __global float *data_cost_, - __global uchar *cleft, __global uchar *cright, - int h, int w, int level, int nr_plane, int channels, - int cmsg_step1, int cmsg_step2, int cdisp_step1, int cdisp_step2, float cdata_weight, - float cmax_data_term, int cimg_step, int cth) -{ - - int x = get_global_id(0); - int y = get_global_id(1); - - if (y < h && x < w) - { - int y0 = y << level; - int yt = (y + 1) << level; - - int x0 = x << level; - int xt = (x + 1) << level; - - __global const float *selected_disparity = selected_disp_pyr + y/2 * cmsg_step2 + x/2; - __global float *data_cost = data_cost_ + y * cmsg_step1 + x; - - for(int d = 0; d < nr_plane; d++) - { - float val = 0.0f; - for(int yi = y0; yi < yt; yi++) - { - for(int xi = x0; xi < xt; xi++) - { - int sel_disp = selected_disparity[d * cdisp_step2]; - int xr = xi - sel_disp; - - if (xr < 0 || sel_disp < cth) - val += cdata_weight * cmax_data_term; - else - { - __global uchar* left_x = cleft + yi * cimg_step + xi * channels; - __global uchar* right_x = cright + yi * cimg_step + xr * channels; - - if(channels == 1) - val += compute_1(left_x, right_x, cdata_weight, cmax_data_term); - else - val += compute_3(left_x, right_x, cdata_weight, cmax_data_term); - } - } - } - data_cost[cdisp_step1 * d] = val; - } - } -} -//////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////compute_data_cost_reduce////////////////////////////////////////// -///////////////////////////////////////////////////////////////////////////////////////////////////////// -__kernel void compute_data_cost_reduce_0(__global const short* selected_disp_pyr, __global short* data_cost_, - __global uchar *cleft, __global uchar *cright,__local float *smem, - int level, int rows, int cols, int h, int nr_plane, - int channels, int winsz, - int cmsg_step1, int cmsg_step2, int cdisp_step1, int cdisp_step2, - float cdata_weight, float cmax_data_term, int cimg_step,int cth) - -{ - int x_out = get_group_id(0); - int y_out = get_group_id(1) % h; - int d = (get_group_id(1)/ h) * get_local_size(2) + get_local_id(2); - - int tid = get_local_id(0); - - __global const short* selected_disparity = selected_disp_pyr + y_out/2 * cmsg_step2 + x_out/2; - __global short* data_cost = data_cost_ + y_out * cmsg_step1 + x_out; - - if (d < nr_plane) - { - int sel_disp = selected_disparity[d * cdisp_step2]; - - int x0 = x_out << level; - int y0 = y_out << level; - - int len = min(y0 + winsz, rows) - y0; - - float val = 0.0f; - if (x0 + tid < cols) - { - if (x0 + tid - sel_disp < 0 || sel_disp < cth) - val = cdata_weight * cmax_data_term * len; - else - { - __global uchar* lle = cleft + y0 * cimg_step + channels * (x0 + tid ); - __global uchar* lri = cright + y0 * cimg_step + channels * (x0 + tid - sel_disp); - - for(int y = 0; y < len; ++y) - { - if(channels == 1) - val += compute_1(lle, lri, cdata_weight, cmax_data_term); - else - val += compute_3(lle, lri, cdata_weight, cmax_data_term); - - lle += cimg_step; - lri += cimg_step; - } - } - } - - __local float* dline = smem + winsz * get_local_id(2); - - dline[tid] = val; - } - - barrier(CLK_LOCAL_MEM_FENCE); - if(d < nr_plane) - { - - // if (winsz >= 256) { if (tid < 128) { dline[tid] += dline[tid + 128]; } barrier(CLK_LOCAL_MEM_FENCE); } - //if (winsz >= 128) { if (tid < 64) { dline[tid] += dline[tid + 64]; } barrier(CLK_LOCAL_MEM_FENCE); } - - __local volatile float* vdline = smem + winsz * get_local_id(2); - - if (winsz >= 64) if (tid < 32) vdline[tid] += vdline[tid + 32]; - if (winsz >= 32) if (tid < 16) vdline[tid] += vdline[tid + 16]; - if (winsz >= 16) if (tid < 8) vdline[tid] += vdline[tid + 8]; - if (winsz >= 8) if (tid < 4) vdline[tid] += vdline[tid + 4]; - if (winsz >= 4) if (tid < 2) vdline[tid] += vdline[tid + 2]; - if (winsz >= 2) if (tid < 1) vdline[tid] += vdline[tid + 1]; - - if (tid == 0) - data_cost[cdisp_step1 * d] = convert_short_sat_rte(vdline[0]); - } -} - -__kernel void compute_data_cost_reduce_1(__global const float *selected_disp_pyr, __global float *data_cost_, - __global uchar *cleft, __global uchar *cright, __local float *smem, - int level, int rows, int cols, int h, int nr_plane, - int channels, int winsz, - int cmsg_step1, int cmsg_step2, int cdisp_step1,int cdisp_step2, float cdata_weight, - float cmax_data_term, int cimg_step, int cth) - -{ - int x_out = get_group_id(0); - int y_out = get_group_id(1) % h; - int d = (get_group_id(1)/ h) * get_local_size(2) + get_local_id(2); - - int tid = get_local_id(0); - - __global const float *selected_disparity = selected_disp_pyr + y_out/2 * cmsg_step2 + x_out/2; - __global float *data_cost = data_cost_ + y_out * cmsg_step1 + x_out; - - if (d < nr_plane) - { - int sel_disp = selected_disparity[d * cdisp_step2]; - - int x0 = x_out << level; - int y0 = y_out << level; - - int len = min(y0 + winsz, rows) - y0; - - float val = 0.0f; - if (x0 + tid < cols) - { - if (x0 + tid - sel_disp < 0 || sel_disp < cth) - val = cdata_weight * cmax_data_term * len; - else - { - __global uchar* lle = cleft + y0 * cimg_step + channels * (x0 + tid ); - __global uchar* lri = cright + y0 * cimg_step + channels * (x0 + tid - sel_disp); - - for(int y = 0; y < len; ++y) - { - if(channels == 1) - val += compute_1(lle, lri, cdata_weight, cmax_data_term); - else - val += compute_3(lle, lri, cdata_weight, cmax_data_term); - - lle += cimg_step; - lri += cimg_step; - } - } - } - - __local float* dline = smem + winsz * get_local_id(2); - - dline[tid] = val; - } - - barrier(CLK_LOCAL_MEM_FENCE); - if(d < nr_plane) - { - - //if (winsz >= 256) { if (tid < 128) { dline[tid] += dline[tid + 128]; } barrier(CLK_LOCAL_MEM_FENCE); } - //if (winsz >= 128) { if (tid < 64) { dline[tid] += dline[tid + 64]; } barrier(CLK_LOCAL_MEM_FENCE); } - - __local volatile float* vdline = smem + winsz * get_local_id(2); - - if (winsz >= 64) if (tid < 32) vdline[tid] += vdline[tid + 32]; - if (winsz >= 32) if (tid < 16) vdline[tid] += vdline[tid + 16]; - if (winsz >= 16) if (tid < 8) vdline[tid] += vdline[tid + 8]; - if (winsz >= 8) if (tid < 4) vdline[tid] += vdline[tid + 4]; - if (winsz >= 4) if (tid < 2) vdline[tid] += vdline[tid + 2]; - if (winsz >= 2) if (tid < 1) vdline[tid] += vdline[tid + 1]; - - if (tid == 0) - data_cost[cdisp_step1 * d] = vdline[0]; - } -} - -/////////////////////////////////////////////////////////////// -//////////////////////// init message ///////////////////////// -/////////////////////////////////////////////////////////////// -void get_first_k_element_increase_0(__global short* u_new, __global short *d_new, __global short *l_new, - __global short *r_new, __global const short *u_cur, __global const short *d_cur, - __global const short *l_cur, __global const short *r_cur, - __global short *data_cost_selected, __global short *disparity_selected_new, - __global short *data_cost_new, __global const short* data_cost_cur, - __global const short *disparity_selected_cur, - int nr_plane, int nr_plane2, - int cdisp_step1, int cdisp_step2) -{ - for(int i = 0; i < nr_plane; i++) - { - short minimum = SHRT_MAX; - int id = 0; - for(int j = 0; j < nr_plane2; j++) - { - short cur = data_cost_new[j * cdisp_step1]; - if(cur < minimum) - { - minimum = cur; - id = j; - } - } - - data_cost_selected[i * cdisp_step1] = data_cost_cur[id * cdisp_step1]; - disparity_selected_new[i * cdisp_step1] = disparity_selected_cur[id * cdisp_step2]; - - u_new[i * cdisp_step1] = u_cur[id * cdisp_step2]; - d_new[i * cdisp_step1] = d_cur[id * cdisp_step2]; - l_new[i * cdisp_step1] = l_cur[id * cdisp_step2]; - r_new[i * cdisp_step1] = r_cur[id * cdisp_step2]; - - data_cost_new[id * cdisp_step1] = SHRT_MAX; - } -} -void get_first_k_element_increase_1(__global float *u_new, __global float *d_new, __global float *l_new, - __global float *r_new, __global const float *u_cur, __global const float *d_cur, - __global const float *l_cur, __global const float *r_cur, - __global float *data_cost_selected, __global float *disparity_selected_new, - __global float *data_cost_new, __global const float *data_cost_cur, - __global const float *disparity_selected_cur, - int nr_plane, int nr_plane2, - int cdisp_step1, int cdisp_step2) -{ - for(int i = 0; i < nr_plane; i++) - { - float minimum = FLT_MAX; - int id = 0; - for(int j = 0; j < nr_plane2; j++) - { - float cur = data_cost_new[j * cdisp_step1]; - if(cur < minimum) - { - minimum = cur; - id = j; - } - } - - data_cost_selected[i * cdisp_step1] = data_cost_cur[id * cdisp_step1]; - disparity_selected_new[i * cdisp_step1] = disparity_selected_cur[id * cdisp_step2]; - - u_new[i * cdisp_step1] = u_cur[id * cdisp_step2]; - d_new[i * cdisp_step1] = d_cur[id * cdisp_step2]; - l_new[i * cdisp_step1] = l_cur[id * cdisp_step2]; - r_new[i * cdisp_step1] = r_cur[id * cdisp_step2]; - - data_cost_new[id * cdisp_step1] = FLT_MAX; - } -} -__kernel void init_message_0(__global short *u_new_, __global short *d_new_, __global short *l_new_, - __global short *r_new_, __global short *u_cur_, __global const short *d_cur_, - __global const short *l_cur_, __global const short *r_cur_, __global short *ctemp, - __global short *selected_disp_pyr_new, __global const short *selected_disp_pyr_cur, - __global short *data_cost_selected_, __global const short *data_cost_, - int h, int w, int nr_plane, int h2, int w2, int nr_plane2, - int cdisp_step1, int cdisp_step2, int cmsg_step1, int cmsg_step2) -{ - int x = get_global_id(0); - int y = get_global_id(1); - - if (y < h && x < w) - { - __global const short *u_cur = u_cur_ + min(h2-1, y/2 + 1) * cmsg_step2 + x/2; - __global const short *d_cur = d_cur_ + max(0, y/2 - 1) * cmsg_step2 + x/2; - __global const short *l_cur = l_cur_ + y/2 * cmsg_step2 + min(w2-1, x/2 + 1); - __global const short *r_cur = r_cur_ + y/2 * cmsg_step2 + max(0, x/2 - 1); - - __global short *data_cost_new = ctemp + y * cmsg_step1 + x; - - __global const short *disparity_selected_cur = selected_disp_pyr_cur + y/2 * cmsg_step2 + x/2; - __global const short *data_cost = data_cost_ + y * cmsg_step1 + x; - - for(int d = 0; d < nr_plane2; d++) - { - int idx2 = d * cdisp_step2; - - short val = data_cost[d * cdisp_step1] + u_cur[idx2] + d_cur[idx2] + l_cur[idx2] + r_cur[idx2]; - data_cost_new[d * cdisp_step1] = val; - } - - __global short *data_cost_selected = data_cost_selected_ + y * cmsg_step1 + x; - __global short *disparity_selected_new = selected_disp_pyr_new + y * cmsg_step1 + x; - - __global short *u_new = u_new_ + y * cmsg_step1 + x; - __global short *d_new = d_new_ + y * cmsg_step1 + x; - __global short *l_new = l_new_ + y * cmsg_step1 + x; - __global short *r_new = r_new_ + y * cmsg_step1 + x; - - u_cur = u_cur_ + y/2 * cmsg_step2 + x/2; - d_cur = d_cur_ + y/2 * cmsg_step2 + x/2; - l_cur = l_cur_ + y/2 * cmsg_step2 + x/2; - r_cur = r_cur_ + y/2 * cmsg_step2 + x/2; - - get_first_k_element_increase_0(u_new, d_new, l_new, r_new, u_cur, d_cur, l_cur, r_cur, - data_cost_selected, disparity_selected_new, data_cost_new, - data_cost, disparity_selected_cur, nr_plane, nr_plane2, - cdisp_step1, cdisp_step2); - } -} -__kernel void init_message_1(__global float *u_new_, __global float *d_new_, __global float *l_new_, - __global float *r_new_, __global float *u_cur_, __global const float *d_cur_, - __global const float *l_cur_, __global const float *r_cur_, __global float *ctemp, - __global float *selected_disp_pyr_new, __global const float *selected_disp_pyr_cur, - __global float *data_cost_selected_, __global const float *data_cost_, - int h, int w, int nr_plane, int h2, int w2, int nr_plane2, - int cdisp_step1, int cdisp_step2, int cmsg_step1, int cmsg_step2) -{ - int x = get_global_id(0); - int y = get_global_id(1); - - if (y < h && x < w) - { - __global const float *u_cur = u_cur_ + min(h2-1, y/2 + 1) * cmsg_step2 + x/2; - __global const float *d_cur = d_cur_ + max(0, y/2 - 1) * cmsg_step2 + x/2; - __global const float *l_cur = l_cur_ + y/2 * cmsg_step2 + min(w2-1, x/2 + 1); - __global const float *r_cur = r_cur_ + y/2 * cmsg_step2 + max(0, x/2 - 1); - - __global float *data_cost_new = ctemp + y * cmsg_step1 + x; - - __global const float *disparity_selected_cur = selected_disp_pyr_cur + y/2 * cmsg_step2 + x/2; - __global const float *data_cost = data_cost_ + y * cmsg_step1 + x; - - for(int d = 0; d < nr_plane2; d++) - { - int idx2 = d * cdisp_step2; - - float val = data_cost[d * cdisp_step1] + u_cur[idx2] + d_cur[idx2] + l_cur[idx2] + r_cur[idx2]; - data_cost_new[d * cdisp_step1] = val; - } - - __global float *data_cost_selected = data_cost_selected_ + y * cmsg_step1 + x; - __global float *disparity_selected_new = selected_disp_pyr_new + y * cmsg_step1 + x; - - __global float *u_new = u_new_ + y * cmsg_step1 + x; - __global float *d_new = d_new_ + y * cmsg_step1 + x; - __global float *l_new = l_new_ + y * cmsg_step1 + x; - __global float *r_new = r_new_ + y * cmsg_step1 + x; - - u_cur = u_cur_ + y/2 * cmsg_step2 + x/2; - d_cur = d_cur_ + y/2 * cmsg_step2 + x/2; - l_cur = l_cur_ + y/2 * cmsg_step2 + x/2; - r_cur = r_cur_ + y/2 * cmsg_step2 + x/2; - - get_first_k_element_increase_1(u_new, d_new, l_new, r_new, u_cur, d_cur, l_cur, r_cur, - data_cost_selected, disparity_selected_new, data_cost_new, - data_cost, disparity_selected_cur, nr_plane, nr_plane2, - cdisp_step1, cdisp_step2); - } -} -/////////////////////////////////////////////////////////////// -//////////////////// calc all iterations ///////////////////// -/////////////////////////////////////////////////////////////// -void message_per_pixel_0(__global const short *data, __global short *msg_dst, __global const short *msg1, - __global const short *msg2, __global const short *msg3, - __global const short *dst_disp, __global const short *src_disp, - int nr_plane, __global short *temp, - float cmax_disc_term, int cdisp_step1, float cdisc_single_jump) -{ - short minimum = SHRT_MAX; - for(int d = 0; d < nr_plane; d++) - { - int idx = d * cdisp_step1; - short val = data[idx] + msg1[idx] + msg2[idx] + msg3[idx]; - - if(val < minimum) - minimum = val; - - msg_dst[idx] = val; - } - - float sum = 0; - for(int d = 0; d < nr_plane; d++) - { - float cost_min = minimum + cmax_disc_term; - short src_disp_reg = src_disp[d * cdisp_step1]; - - for(int d2 = 0; d2 < nr_plane; d2++) - cost_min = fmin(cost_min, (msg_dst[d2 * cdisp_step1] + - cdisc_single_jump * abs(dst_disp[d2 * cdisp_step1] - src_disp_reg))); - - temp[d * cdisp_step1] = convert_short_sat_rte(cost_min); - sum += cost_min; - } - sum /= nr_plane; - - for(int d = 0; d < nr_plane; d++) - msg_dst[d * cdisp_step1] = convert_short_sat_rte(temp[d * cdisp_step1] - sum); -} -void message_per_pixel_1(__global const float *data, __global float *msg_dst, __global const float *msg1, - __global const float *msg2, __global const float *msg3, - __global const float *dst_disp, __global const float *src_disp, - int nr_plane, __global float *temp, - float cmax_disc_term, int cdisp_step1, float cdisc_single_jump) -{ - float minimum = FLT_MAX; - for(int d = 0; d < nr_plane; d++) - { - int idx = d * cdisp_step1; - float val = data[idx] + msg1[idx] + msg2[idx] + msg3[idx]; - - if(val < minimum) - minimum = val; - - msg_dst[idx] = val; - } - - float sum = 0; - for(int d = 0; d < nr_plane; d++) - { - float cost_min = minimum + cmax_disc_term; - float src_disp_reg = src_disp[d * cdisp_step1]; - - for(int d2 = 0; d2 < nr_plane; d2++) - cost_min = fmin(cost_min, (msg_dst[d2 * cdisp_step1] + - cdisc_single_jump * fabs(dst_disp[d2 * cdisp_step1] - src_disp_reg))); - - temp[d * cdisp_step1] = cost_min; - sum += cost_min; - } - sum /= nr_plane; - - for(int d = 0; d < nr_plane; d++) - msg_dst[d * cdisp_step1] = temp[d * cdisp_step1] - sum; -} -__kernel void compute_message_0(__global short *u_, __global short *d_, __global short *l_, __global short *r_, - __global const short *data_cost_selected, __global const short *selected_disp_pyr_cur, - __global short *ctemp, int h, int w, int nr_plane, int i, - float cmax_disc_term, int cdisp_step1, int cmsg_step1, float cdisc_single_jump) -{ - int y = get_global_id(1); - int x = ((get_global_id(0)) << 1) + ((y + i) & 1); - - if (y > 0 && y < h - 1 && x > 0 && x < w - 1) - { - __global const short *data = data_cost_selected + y * cmsg_step1 + x; - - __global short *u = u_ + y * cmsg_step1 + x; - __global short *d = d_ + y * cmsg_step1 + x; - __global short *l = l_ + y * cmsg_step1 + x; - __global short *r = r_ + y * cmsg_step1 + x; - - __global const short *disp = selected_disp_pyr_cur + y * cmsg_step1 + x; - - __global short *temp = ctemp + y * cmsg_step1 + x; - - message_per_pixel_0(data, u, r - 1, u + cmsg_step1, l + 1, disp, disp - cmsg_step1, nr_plane, temp, - cmax_disc_term, cdisp_step1, cdisc_single_jump); - message_per_pixel_0(data, d, d - cmsg_step1, r - 1, l + 1, disp, disp + cmsg_step1, nr_plane, temp, - cmax_disc_term, cdisp_step1, cdisc_single_jump); - message_per_pixel_0(data, l, u + cmsg_step1, d - cmsg_step1, l + 1, disp, disp - 1, nr_plane, temp, - cmax_disc_term, cdisp_step1, cdisc_single_jump); - message_per_pixel_0(data, r, u + cmsg_step1, d - cmsg_step1, r - 1, disp, disp + 1, nr_plane, temp, - cmax_disc_term, cdisp_step1, cdisc_single_jump); - } -} -__kernel void compute_message_1(__global float *u_, __global float *d_, __global float *l_, __global float *r_, - __global const float *data_cost_selected, __global const float *selected_disp_pyr_cur, - __global float *ctemp, int h, int w, int nr_plane, int i, - float cmax_disc_term, int cdisp_step1, int cmsg_step1, float cdisc_single_jump) -{ - int y = get_global_id(1); - int x = ((get_global_id(0)) << 1) + ((y + i) & 1); - - if (y > 0 && y < h - 1 && x > 0 && x < w - 1) - { - __global const float *data = data_cost_selected + y * cmsg_step1 + x; - - __global float *u = u_ + y * cmsg_step1 + x; - __global float *d = d_ + y * cmsg_step1 + x; - __global float *l = l_ + y * cmsg_step1 + x; - __global float *r = r_ + y * cmsg_step1 + x; - - __global const float *disp = selected_disp_pyr_cur + y * cmsg_step1 + x; - __global float *temp = ctemp + y * cmsg_step1 + x; - - message_per_pixel_1(data, u, r - 1, u + cmsg_step1, l + 1, disp, disp - cmsg_step1, nr_plane, temp, - cmax_disc_term, cdisp_step1, cdisc_single_jump); - message_per_pixel_1(data, d, d - cmsg_step1, r - 1, l + 1, disp, disp + cmsg_step1, nr_plane, temp, - cmax_disc_term, cdisp_step1, cdisc_single_jump); - message_per_pixel_1(data, l, u + cmsg_step1, d - cmsg_step1, l + 1, disp, disp - 1, nr_plane, temp, - cmax_disc_term, cdisp_step1, cdisc_single_jump); - message_per_pixel_1(data, r, u + cmsg_step1, d - cmsg_step1, r - 1, disp, disp + 1, nr_plane, temp, - cmax_disc_term, cdisp_step1, cdisc_single_jump); - } -} - -/////////////////////////////////////////////////////////////// -/////////////////////////// output //////////////////////////// -/////////////////////////////////////////////////////////////// -__kernel void compute_disp_0(__global const short *u_, __global const short *d_, __global const short *l_, - __global const short *r_, __global const short * data_cost_selected, - __global const short *disp_selected_pyr, - __global short* disp, - int res_step, int cols, int rows, int nr_plane, - int cmsg_step1, int cdisp_step1) -{ - int x = get_global_id(0); - int y = get_global_id(1); - - if (y > 0 && y < rows - 1 && x > 0 && x < cols - 1) - { - __global const short *data = data_cost_selected + y * cmsg_step1 + x; - __global const short *disp_selected = disp_selected_pyr + y * cmsg_step1 + x; - - __global const short *u = u_ + (y+1) * cmsg_step1 + (x+0); - __global const short *d = d_ + (y-1) * cmsg_step1 + (x+0); - __global const short *l = l_ + (y+0) * cmsg_step1 + (x+1); - __global const short *r = r_ + (y+0) * cmsg_step1 + (x-1); - - short best = 0; - short best_val = SHRT_MAX; - - for (int i = 0; i < nr_plane; ++i) - { - int idx = i * cdisp_step1; - short val = data[idx]+ u[idx] + d[idx] + l[idx] + r[idx]; - - if (val < best_val) - { - best_val = val; - best = disp_selected[idx]; - } - } - disp[res_step * y + x] = best; - } -} -__kernel void compute_disp_1(__global const float *u_, __global const float *d_, __global const float *l_, - __global const float *r_, __global const float *data_cost_selected, - __global const float *disp_selected_pyr, - __global short *disp, - int res_step, int cols, int rows, int nr_plane, - int cmsg_step1, int cdisp_step1) -{ - int x = get_global_id(0); - int y = get_global_id(1); - - if (y > 0 && y < rows - 1 && x > 0 && x < cols - 1) - { - __global const float *data = data_cost_selected + y * cmsg_step1 + x; - __global const float *disp_selected = disp_selected_pyr + y * cmsg_step1 + x; - - __global const float *u = u_ + (y+1) * cmsg_step1 + (x+0); - __global const float *d = d_ + (y-1) * cmsg_step1 + (x+0); - __global const float *l = l_ + (y+0) * cmsg_step1 + (x+1); - __global const float *r = r_ + (y+0) * cmsg_step1 + (x-1); - - short best = 0; - short best_val = SHRT_MAX; - for (int i = 0; i < nr_plane; ++i) - { - int idx = i * cdisp_step1; - float val = data[idx]+ u[idx] + d[idx] + l[idx] + r[idx]; - - if (val < best_val) - { - best_val = val; - best = convert_short_sat_rte(disp_selected[idx]); - } - } - disp[res_step * y + x] = best; - } -} - diff --git a/modules/ocl/src/matrix_operations.cpp b/modules/ocl/src/matrix_operations.cpp index 798d315b1f..a4ef54f940 100644 --- a/modules/ocl/src/matrix_operations.cpp +++ b/modules/ocl/src/matrix_operations.cpp @@ -339,24 +339,22 @@ inline int divUp(int total, int grain) void copy_to_with_mask(const oclMat &src, oclMat &dst, const oclMat &mask, string kernelName) { CV_DbgAssert( dst.rows == mask.rows && dst.cols == mask.cols && - src.rows == dst.rows && src.cols == dst.cols); + src.rows == dst.rows && src.cols == dst.cols + && mask.type() == CV_8UC1); vector > args; - int vector_lengths[4][7] = {{4, 4, 2, 2, 1, 1, 1}, - {2, 2, 1, 1, 1, 1, 1}, - {8, 8, 8, 8 , 4, 4, 4}, //vector length is undefined when channels = 3 - {1, 1, 1, 1, 1, 1, 1} + std::string string_types[4][7] = {{"uchar", "char", "ushort", "short", "int", "float", "double"}, + {"uchar2", "char2", "ushort2", "short2", "int2", "float2", "double2"}, + {"uchar3", "char3", "ushort3", "short3", "int3", "float3", "double3"}, + {"uchar4", "char4", "ushort4", "short4", "int4", "float4", "double4"} }; - + char compile_option[32]; + sprintf(compile_option, "-D GENTYPE=%s", string_types[dst.channels()-1][dst.depth()].c_str()); size_t localThreads[3] = {16, 16, 1}; size_t globalThreads[3]; - int vector_length = vector_lengths[dst.channels() -1][dst.depth()]; - int offset_cols = divUp(dst.offset, dst.elemSize()) & (vector_length - 1); - int cols = vector_length == 1 ? divUp(dst.cols, vector_length) : divUp(dst.cols + offset_cols, vector_length); - - globalThreads[0] = divUp(cols, localThreads[0]) * localThreads[0]; + globalThreads[0] = divUp(dst.cols, localThreads[0]) * localThreads[0]; globalThreads[1] = divUp(dst.rows, localThreads[1]) * localThreads[1]; globalThreads[2] = 1; @@ -376,7 +374,7 @@ void copy_to_with_mask(const oclMat &src, oclMat &dst, const oclMat &mask, strin args.push_back( make_pair( sizeof(cl_int) , (void *)&mask.offset )); openCLExecuteKernel(dst.clCxt , &operator_copyToM, kernelName, globalThreads, - localThreads, args, dst.channels(), dst.depth()); + localThreads, args, -1, -1,compile_option); } void cv::ocl::oclMat::copyTo( oclMat &m ) const @@ -679,10 +677,6 @@ void set_to_withmask_run(const oclMat &dst, const Scalar &scalar, const oclMat & globalThreads[0] = (dst.cols + localThreads[0] - 1) / localThreads[0] * localThreads[0]; globalThreads[1] = (dst.rows + localThreads[1] - 1) / localThreads[1] * localThreads[1]; globalThreads[2] = 1; - if(dst.type() == CV_8UC1) - { - globalThreads[0] = ((dst.cols + 4) / 4 + localThreads[0] - 1) / localThreads[0] * localThreads[0]; - } int step_in_pixel = dst.step / dst.elemSize(), offset_in_pixel = dst.offset / dst.elemSize(); char compile_option[32]; union sc @@ -697,7 +691,7 @@ void set_to_withmask_run(const oclMat &dst, const Scalar &scalar, const oclMat & }val; switch(dst.depth()) { - case 0: + case CV_8U: val.uval.s[0] = saturate_cast(scalar.val[0]); val.uval.s[1] = saturate_cast(scalar.val[1]); val.uval.s[2] = saturate_cast(scalar.val[2]); @@ -716,7 +710,7 @@ void set_to_withmask_run(const oclMat &dst, const Scalar &scalar, const oclMat & CV_Error(CV_StsUnsupportedFormat,"unsupported channels"); } break; - case 1: + case CV_8S: val.cval.s[0] = saturate_cast(scalar.val[0]); val.cval.s[1] = saturate_cast(scalar.val[1]); val.cval.s[2] = saturate_cast(scalar.val[2]); @@ -735,7 +729,7 @@ void set_to_withmask_run(const oclMat &dst, const Scalar &scalar, const oclMat & CV_Error(CV_StsUnsupportedFormat,"unsupported channels"); } break; - case 2: + case CV_16U: val.usval.s[0] = saturate_cast(scalar.val[0]); val.usval.s[1] = saturate_cast(scalar.val[1]); val.usval.s[2] = saturate_cast(scalar.val[2]); @@ -754,7 +748,7 @@ void set_to_withmask_run(const oclMat &dst, const Scalar &scalar, const oclMat & CV_Error(CV_StsUnsupportedFormat,"unsupported channels"); } break; - case 3: + case CV_16S: val.shval.s[0] = saturate_cast(scalar.val[0]); val.shval.s[1] = saturate_cast(scalar.val[1]); val.shval.s[2] = saturate_cast(scalar.val[2]); @@ -773,7 +767,7 @@ void set_to_withmask_run(const oclMat &dst, const Scalar &scalar, const oclMat & CV_Error(CV_StsUnsupportedFormat,"unsupported channels"); } break; - case 4: + case CV_32S: val.ival.s[0] = saturate_cast(scalar.val[0]); val.ival.s[1] = saturate_cast(scalar.val[1]); val.ival.s[2] = saturate_cast(scalar.val[2]); @@ -792,7 +786,7 @@ void set_to_withmask_run(const oclMat &dst, const Scalar &scalar, const oclMat & CV_Error(CV_StsUnsupportedFormat,"unsupported channels"); } break; - case 5: + case CV_32F: val.fval.s[0] = scalar.val[0]; val.fval.s[1] = scalar.val[1]; val.fval.s[2] = scalar.val[2]; @@ -811,7 +805,7 @@ void set_to_withmask_run(const oclMat &dst, const Scalar &scalar, const oclMat & CV_Error(CV_StsUnsupportedFormat,"unsupported channels"); } break; - case 6: + case CV_64F: val.dval.s[0] = scalar.val[0]; val.dval.s[1] = scalar.val[1]; val.dval.s[2] = scalar.val[2]; @@ -872,14 +866,7 @@ oclMat &cv::ocl::oclMat::setTo(const Scalar &scalar, const oclMat &mask) } else { - if(type()==CV_8UC1) - { - set_to_withmask_run(*this, scalar, mask,"set_to_with_mask_C1_D0"); - } - else - { - set_to_withmask_run(*this, scalar, mask, "set_to_with_mask"); - } + set_to_withmask_run(*this, scalar, mask, "set_to_with_mask"); } return *this; @@ -942,6 +929,11 @@ void cv::ocl::oclMat::create(int _rows, int _cols, int _type) /* core logic */ _type &= TYPE_MASK; + download_channels = CV_MAT_CN(_type); + if(download_channels==3) + { + _type = CV_MAKE_TYPE((CV_MAT_DEPTH(_type)),4); + } if( rows == _rows && cols == _cols && type() == _type && data ) return; if( data ) @@ -986,6 +978,7 @@ void cv::ocl::oclMat::release() step = rows = cols = 0; offset = wholerows = wholecols = 0; refcount = 0; + download_channels=0; } #endif /* !defined (HAVE_OPENCL) */ diff --git a/modules/ocl/src/stereo_csbp.cpp b/modules/ocl/src/stereo_csbp.cpp deleted file mode 100644 index ac614e1574..0000000000 --- a/modules/ocl/src/stereo_csbp.cpp +++ /dev/null @@ -1,786 +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) 2010-2012, Institute Of Software Chinese Academy Of Science, all rights reserved. -// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved. -// Third party copyrights are property of their respective owners. -// -// @Authors -// Jia Haipeng, jiahaipeng95@gmail.com -// -// 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 oclMaterials 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*/ - -#include "precomp.hpp" - -using namespace cv; -using namespace cv::ocl; -using namespace std; - -#if !defined (HAVE_OPENCL) - -namespace cv -{ - namespace ocl - { - - void cv::ocl::StereoConstantSpaceBP::estimateRecommendedParams(int, int, int &, int &, int &, int &) - { - throw_nogpu(); - } - cv::ocl::StereoConstantSpaceBP::StereoConstantSpaceBP(int, int, int, int, int) - { - throw_nogpu(); - } - cv::ocl::StereoConstantSpaceBP::StereoConstantSpaceBP(int, int, int, int, float, float, - float, float, int, int) - { - throw_nogpu(); - } - - void cv::ocl::StereoConstantSpaceBP::operator()(const oclMat &, const oclMat &, oclMat &) - { - throw_nogpu(); - } - } -} - -#else /* !defined (HAVE_OPENCL) */ - -namespace cv -{ - namespace ocl - { - - ///////////////////////////OpenCL kernel strings/////////////////////////// - extern const char *stereocsbp; - } - -} -namespace cv -{ - namespace ocl - { - namespace stereoCSBP - { - ////////////////////////////////////////////////////////////////////////// - //////////////////////////////common//////////////////////////////////// - //////////////////////////////////////////////////////////////////////// - static inline int divUp(int total, int grain) - { - return (total + grain - 1) / grain; - } - static string get_kernel_name(string kernel_name, int data_type) - { - stringstream idxStr; - if(data_type == CV_16S) - idxStr << "0"; - else - idxStr << "1"; - kernel_name += idxStr.str(); - - return kernel_name; - } - using cv::ocl::StereoConstantSpaceBP; - ////////////////////////////////////////////////////////////////////////////////// - /////////////////////////////////init_data_cost////////////////////////////////// - ////////////////////////////////////////////////////////////////////////////////// - static void init_data_cost_caller(const oclMat &left, const oclMat &right, oclMat &temp, - StereoConstantSpaceBP &rthis, - int msg_step, int h, int w, int level) - { - Context *clCxt = left.clCxt; - int data_type = rthis.msg_type; - int channels = left.channels(); - - string kernelName = get_kernel_name("init_data_cost_", data_type); - - cl_kernel kernel = openCLGetKernelFromSource(clCxt, &stereocsbp, kernelName); - - size_t blockSize = 256; - size_t localThreads[] = {32, 8}; - size_t globalThreads[] = {divUp(w, localThreads[0]) * localThreads[0], - divUp(h, localThreads[1]) * localThreads[1] - }; - - int cdisp_step1 = msg_step * h; - openCLVerifyKernel(clCxt, kernel, &blockSize, globalThreads, localThreads); - openCLSafeCall(clSetKernelArg(kernel, 0, sizeof(cl_mem), (void *)&temp.data)); - openCLSafeCall(clSetKernelArg(kernel, 1, sizeof(cl_mem), (void *)&left.data)); - openCLSafeCall(clSetKernelArg(kernel, 2, sizeof(cl_mem), (void *)&right.data)); - openCLSafeCall(clSetKernelArg(kernel, 3, sizeof(cl_int), (void *)&h)); - openCLSafeCall(clSetKernelArg(kernel, 4, sizeof(cl_int), (void *)&w)); - openCLSafeCall(clSetKernelArg(kernel, 5, sizeof(cl_int), (void *)&level)); - openCLSafeCall(clSetKernelArg(kernel, 6, sizeof(cl_int), (void *)&channels)); - openCLSafeCall(clSetKernelArg(kernel, 7, sizeof(cl_int), (void *)&msg_step)); - openCLSafeCall(clSetKernelArg(kernel, 8, sizeof(cl_float), (void *)&rthis.data_weight)); - openCLSafeCall(clSetKernelArg(kernel, 9, sizeof(cl_float), (void *)&rthis.max_data_term)); - openCLSafeCall(clSetKernelArg(kernel, 10, sizeof(cl_int), (void *)&cdisp_step1)); - openCLSafeCall(clSetKernelArg(kernel, 11, sizeof(cl_int), (void *)&rthis.min_disp_th)); - openCLSafeCall(clSetKernelArg(kernel, 12, sizeof(cl_int), (void *)&left.step)); - openCLSafeCall(clSetKernelArg(kernel, 13, sizeof(cl_int), (void *)&rthis.ndisp)); - openCLSafeCall(clEnqueueNDRangeKernel(clCxt->impl->clCmdQueue, kernel, 2, NULL, - globalThreads, localThreads, 0, NULL, NULL)); - - clFinish(clCxt->impl->clCmdQueue); - openCLSafeCall(clReleaseKernel(kernel)); - } - - static void init_data_cost_reduce_caller(const oclMat &left, const oclMat &right, oclMat &temp, - StereoConstantSpaceBP &rthis, - int msg_step, int h, int w, int level) - { - Context *clCxt = left.clCxt; - int data_type = rthis.msg_type; - int channels = left.channels(); - int win_size = (int)std::pow(2.f, level); - - string kernelName = get_kernel_name("init_data_cost_reduce_", data_type); - - cl_kernel kernel = openCLGetKernelFromSource(clCxt, &stereocsbp, kernelName); - - const int threadsNum = 256; - size_t blockSize = threadsNum; - size_t localThreads[3] = {win_size, 1, threadsNum / win_size}; - size_t globalThreads[3] = {w *localThreads[0], - h *divUp(rthis.ndisp, localThreads[2]) * localThreads[1], 1 * localThreads[2] - }; - - int local_mem_size = threadsNum * sizeof(float); - int cdisp_step1 = msg_step * h; - - openCLVerifyKernel(clCxt, kernel, &blockSize, globalThreads, localThreads); - openCLSafeCall(clSetKernelArg(kernel, 0, sizeof(cl_mem), (void *)&temp.data)); - openCLSafeCall(clSetKernelArg(kernel, 1, sizeof(cl_mem), (void *)&left.data)); - openCLSafeCall(clSetKernelArg(kernel, 2, sizeof(cl_mem), (void *)&right.data)); - openCLSafeCall(clSetKernelArg(kernel, 3, local_mem_size, (void *)NULL)); - openCLSafeCall(clSetKernelArg(kernel, 4, sizeof(cl_int), (void *)&level)); - openCLSafeCall(clSetKernelArg(kernel, 5, sizeof(cl_int), (void *)&left.rows)); - openCLSafeCall(clSetKernelArg(kernel, 6, sizeof(cl_int), (void *)&left.cols)); - openCLSafeCall(clSetKernelArg(kernel, 7, sizeof(cl_int), (void *)&h)); - openCLSafeCall(clSetKernelArg(kernel, 8, sizeof(cl_int), (void *)&win_size)); - openCLSafeCall(clSetKernelArg(kernel, 9, sizeof(cl_int), (void *)&channels)); - openCLSafeCall(clSetKernelArg(kernel, 10, sizeof(cl_int), (void *)&rthis.ndisp)); - openCLSafeCall(clSetKernelArg(kernel, 11, sizeof(cl_int), (void *)&left.step)); - openCLSafeCall(clSetKernelArg(kernel, 12, sizeof(cl_float), (void *)&rthis.data_weight)); - openCLSafeCall(clSetKernelArg(kernel, 13, sizeof(cl_float), (void *)&rthis.max_data_term)); - openCLSafeCall(clSetKernelArg(kernel, 14, sizeof(cl_int), (void *)&rthis.min_disp_th)); - openCLSafeCall(clSetKernelArg(kernel, 15, sizeof(cl_int), (void *)&cdisp_step1)); - openCLSafeCall(clSetKernelArg(kernel, 16, sizeof(cl_int), (void *)&msg_step)); - openCLSafeCall(clEnqueueNDRangeKernel(clCxt->impl->clCmdQueue, kernel, 3, NULL, - globalThreads, localThreads, 0, NULL, NULL)); - - clFinish(clCxt->impl->clCmdQueue); - openCLSafeCall(clReleaseKernel(kernel)); - - } - - static void get_first_initial_local_caller(uchar *data_cost_selected, uchar *disp_selected_pyr, - oclMat &temp, StereoConstantSpaceBP &rthis, - int h, int w, int nr_plane, int msg_step) - { - Context *clCxt = temp.clCxt; - int data_type = rthis.msg_type; - - string kernelName = get_kernel_name("get_first_k_initial_local_", data_type); - - cl_kernel kernel = openCLGetKernelFromSource(clCxt, &stereocsbp, kernelName); - - size_t blockSize = 256; - size_t localThreads[] = {32, 8}; - size_t globalThreads[] = {divUp(w, localThreads[0]) * localThreads[0], - divUp(h, localThreads[1]) * localThreads[1] - }; - - int disp_step = msg_step * h; - openCLVerifyKernel(clCxt, kernel, &blockSize, globalThreads, localThreads); - openCLSafeCall(clSetKernelArg(kernel, 0, sizeof(cl_mem), (void *)&data_cost_selected)); - openCLSafeCall(clSetKernelArg(kernel, 1, sizeof(cl_mem), (void *)&disp_selected_pyr)); - openCLSafeCall(clSetKernelArg(kernel, 2, sizeof(cl_mem), (void *)&temp.data)); - openCLSafeCall(clSetKernelArg(kernel, 3, sizeof(cl_int), (void *)&h)); - openCLSafeCall(clSetKernelArg(kernel, 4, sizeof(cl_int), (void *)&w)); - openCLSafeCall(clSetKernelArg(kernel, 5, sizeof(cl_int), (void *)&nr_plane)); - openCLSafeCall(clSetKernelArg(kernel, 6, sizeof(cl_int), (void *)&msg_step)); - openCLSafeCall(clSetKernelArg(kernel, 7, sizeof(cl_int), (void *)&disp_step)); - openCLSafeCall(clSetKernelArg(kernel, 8, sizeof(cl_int), (void *)&rthis.ndisp)); - openCLSafeCall(clEnqueueNDRangeKernel(clCxt->impl->clCmdQueue, kernel, 2, NULL, - globalThreads, localThreads, 0, NULL, NULL)); - - clFinish(clCxt->impl->clCmdQueue); - openCLSafeCall(clReleaseKernel(kernel)); - } - static void get_first_initial_global_caller(uchar *data_cost_selected, uchar *disp_selected_pyr, - oclMat &temp, StereoConstantSpaceBP &rthis, - int h, int w, int nr_plane, int msg_step) - { - Context *clCxt = temp.clCxt; - int data_type = rthis.msg_type; - - string kernelName = get_kernel_name("get_first_k_initial_global_", data_type); - - cl_kernel kernel = openCLGetKernelFromSource(clCxt, &stereocsbp, kernelName); - - size_t blockSize = 256; - size_t localThreads[] = {32, 8}; - size_t globalThreads[] = {divUp(w, localThreads[0]) * localThreads[0], - divUp(h, localThreads[1]) * localThreads[1] - }; - - int disp_step = msg_step * h; - openCLVerifyKernel(clCxt, kernel, &blockSize, globalThreads, localThreads); - openCLSafeCall(clSetKernelArg(kernel, 0, sizeof(cl_mem), (void *)&data_cost_selected)); - openCLSafeCall(clSetKernelArg(kernel, 1, sizeof(cl_mem), (void *)&disp_selected_pyr)); - openCLSafeCall(clSetKernelArg(kernel, 2, sizeof(cl_mem), (void *)&temp.data)); - openCLSafeCall(clSetKernelArg(kernel, 3, sizeof(cl_int), (void *)&h)); - openCLSafeCall(clSetKernelArg(kernel, 4, sizeof(cl_int), (void *)&w)); - openCLSafeCall(clSetKernelArg(kernel, 5, sizeof(cl_int), (void *)&nr_plane)); - openCLSafeCall(clSetKernelArg(kernel, 6, sizeof(cl_int), (void *)&msg_step)); - openCLSafeCall(clSetKernelArg(kernel, 7, sizeof(cl_int), (void *)&disp_step)); - openCLSafeCall(clSetKernelArg(kernel, 8, sizeof(cl_int), (void *)&rthis.ndisp)); - openCLSafeCall(clEnqueueNDRangeKernel(clCxt->impl->clCmdQueue, kernel, 2, NULL, - globalThreads, localThreads, 0, NULL, NULL)); - - clFinish(clCxt->impl->clCmdQueue); - openCLSafeCall(clReleaseKernel(kernel)); - } - - void init_data_cost(const oclMat &left, const oclMat &right, oclMat &temp, StereoConstantSpaceBP &rthis, - uchar *disp_selected_pyr, uchar *data_cost_selected, - size_t msg_step, int h, int w, int level, int nr_plane) - { - - if(level <= 1) - init_data_cost_caller(left, right, temp, rthis, msg_step, h, w, level); - else - init_data_cost_reduce_caller(left, right, temp, rthis, msg_step, h, w, level); - - if(rthis.use_local_init_data_cost == true) - get_first_initial_local_caller(data_cost_selected, disp_selected_pyr, temp, rthis, h, w, - nr_plane, msg_step); - else - get_first_initial_global_caller(data_cost_selected, disp_selected_pyr, temp, rthis, h, w, - nr_plane, msg_step); - } - - /////////////////////////////////////////////////////////////////////////////////////////////////// - ///////////////////////////////////compute_data_cost////////////////////////////////////////////// - //////////////////////////////////////////////////////////////////////////////////////////////// - static void compute_data_cost_caller(uchar *disp_selected_pyr, uchar *data_cost, - StereoConstantSpaceBP &rthis, int msg_step1, - int msg_step2, const oclMat &left, const oclMat &right, int h, - int w, int h2, int level, int nr_plane) - { - Context *clCxt = left.clCxt; - int channels = left.channels(); - int data_type = rthis.msg_type; - - string kernelName = get_kernel_name("compute_data_cost_", data_type); - - cl_kernel kernel = openCLGetKernelFromSource(clCxt, &stereocsbp, kernelName); - - size_t blockSize = 256; - size_t localThreads[] = {32, 8}; - size_t globalThreads[] = {divUp(w, localThreads[0]) * localThreads[0], - divUp(h, localThreads[1]) * localThreads[1] - }; - - int disp_step1 = msg_step1 * h; - int disp_step2 = msg_step2 * h2; - openCLVerifyKernel(clCxt, kernel, &blockSize, globalThreads, localThreads); - openCLSafeCall(clSetKernelArg(kernel, 0, sizeof(cl_mem), (void *)&disp_selected_pyr)); - openCLSafeCall(clSetKernelArg(kernel, 1, sizeof(cl_mem), (void *)&data_cost)); - openCLSafeCall(clSetKernelArg(kernel, 2, sizeof(cl_mem), (void *)&left.data)); - openCLSafeCall(clSetKernelArg(kernel, 3, sizeof(cl_mem), (void *)&right.data)); - openCLSafeCall(clSetKernelArg(kernel, 4, sizeof(cl_int), (void *)&h)); - openCLSafeCall(clSetKernelArg(kernel, 5, sizeof(cl_int), (void *)&w)); - openCLSafeCall(clSetKernelArg(kernel, 6, sizeof(cl_int), (void *)&level)); - openCLSafeCall(clSetKernelArg(kernel, 7, sizeof(cl_int), (void *)&nr_plane)); - openCLSafeCall(clSetKernelArg(kernel, 8, sizeof(cl_int), (void *)&channels)); - openCLSafeCall(clSetKernelArg(kernel, 9, sizeof(cl_int), (void *)&msg_step1)); - openCLSafeCall(clSetKernelArg(kernel, 10, sizeof(cl_int), (void *)&msg_step2)); - openCLSafeCall(clSetKernelArg(kernel, 11, sizeof(cl_int), (void *)&disp_step1)); - openCLSafeCall(clSetKernelArg(kernel, 12, sizeof(cl_int), (void *)&disp_step2)); - openCLSafeCall(clSetKernelArg(kernel, 13, sizeof(cl_float), (void *)&rthis.data_weight)); - openCLSafeCall(clSetKernelArg(kernel, 14, sizeof(cl_float), (void *)&rthis.max_data_term)); - openCLSafeCall(clSetKernelArg(kernel, 15, sizeof(cl_int), (void *)&left.step)); - openCLSafeCall(clSetKernelArg(kernel, 16, sizeof(cl_int), (void *)&rthis.min_disp_th)); - openCLSafeCall(clEnqueueNDRangeKernel(clCxt->impl->clCmdQueue, kernel, 2, NULL, - globalThreads, localThreads, 0, NULL, NULL)); - - clFinish(clCxt->impl->clCmdQueue); - openCLSafeCall(clReleaseKernel(kernel)); - } - static void compute_data_cost_reduce_caller(uchar *disp_selected_pyr, uchar *data_cost, - StereoConstantSpaceBP &rthis, int msg_step1, - int msg_step2, const oclMat &left, const oclMat &right, int h, - int w, int h2, int level, int nr_plane) - { - Context *clCxt = left.clCxt; - int data_type = rthis.msg_type; - int channels = left.channels(); - int win_size = (int)std::pow(2.f, level); - - string kernelName = get_kernel_name("compute_data_cost_reduce_", data_type); - - cl_kernel kernel = openCLGetKernelFromSource(clCxt, &stereocsbp, kernelName); - - const size_t threadsNum = 256; - size_t blockSize = threadsNum; - size_t localThreads[3] = {win_size, 1, threadsNum / win_size}; - size_t globalThreads[3] = {w *localThreads[0], - h *divUp(nr_plane, localThreads[2]) * localThreads[1], 1 * localThreads[2] - }; - - int disp_step1 = msg_step1 * h; - int disp_step2 = msg_step2 * h2; - size_t local_mem_size = threadsNum * sizeof(float); - openCLVerifyKernel(clCxt, kernel, &blockSize, globalThreads, localThreads); - openCLSafeCall(clSetKernelArg(kernel, 0, sizeof(cl_mem), (void *)&disp_selected_pyr)); - openCLSafeCall(clSetKernelArg(kernel, 1, sizeof(cl_mem), (void *)&data_cost)); - openCLSafeCall(clSetKernelArg(kernel, 2, sizeof(cl_mem), (void *)&left.data)); - openCLSafeCall(clSetKernelArg(kernel, 3, sizeof(cl_mem), (void *)&right.data)); - openCLSafeCall(clSetKernelArg(kernel, 4, local_mem_size, (void *)NULL)); - openCLSafeCall(clSetKernelArg(kernel, 5, sizeof(cl_int), (void *)&level)); - openCLSafeCall(clSetKernelArg(kernel, 6, sizeof(cl_int), (void *)&left.rows)); - openCLSafeCall(clSetKernelArg(kernel, 7, sizeof(cl_int), (void *)&left.cols)); - openCLSafeCall(clSetKernelArg(kernel, 8, sizeof(cl_int), (void *)&h)); - openCLSafeCall(clSetKernelArg(kernel, 9, sizeof(cl_int), (void *)&nr_plane)); - openCLSafeCall(clSetKernelArg(kernel, 10, sizeof(cl_int), (void *)&channels)); - openCLSafeCall(clSetKernelArg(kernel, 11, sizeof(cl_int), (void *)&win_size)); - openCLSafeCall(clSetKernelArg(kernel, 12, sizeof(cl_int), (void *)&msg_step1)); - openCLSafeCall(clSetKernelArg(kernel, 13, sizeof(cl_int), (void *)&msg_step2)); - openCLSafeCall(clSetKernelArg(kernel, 14, sizeof(cl_int), (void *)&disp_step1)); - openCLSafeCall(clSetKernelArg(kernel, 15, sizeof(cl_int), (void *)&disp_step2)); - openCLSafeCall(clSetKernelArg(kernel, 16, sizeof(cl_float), (void *)&rthis.data_weight)); - openCLSafeCall(clSetKernelArg(kernel, 17, sizeof(cl_float), (void *)&rthis.max_data_term)); - openCLSafeCall(clSetKernelArg(kernel, 18, sizeof(cl_int), (void *)&left.step)); - openCLSafeCall(clSetKernelArg(kernel, 19, sizeof(cl_int), (void *)&rthis.min_disp_th)); - openCLSafeCall(clEnqueueNDRangeKernel(clCxt->impl->clCmdQueue, kernel, 3, NULL, - globalThreads, localThreads, 0, NULL, NULL)); - - clFinish(clCxt->impl->clCmdQueue); - openCLSafeCall(clReleaseKernel(kernel)); - } - void compute_data_cost(uchar *disp_selected_pyr, uchar *data_cost, StereoConstantSpaceBP &rthis, - int msg_step1, int msg_step2, const oclMat &left, const oclMat &right, int h, int w, - int h2, int level, int nr_plane) - { - if(level <= 1) - compute_data_cost_caller(disp_selected_pyr, data_cost, rthis, msg_step1, msg_step2, - left, right, h, w, h2, level, nr_plane); - else - compute_data_cost_reduce_caller(disp_selected_pyr, data_cost, rthis, msg_step1, msg_step2, - left, right, h, w, h2, level, nr_plane); - } - //////////////////////////////////////////////////////////////////////////////////////////////// - //////////////////////////////////////init message////////////////////////////////////////////// - //////////////////////////////////////////////////////////////////////////////////////////////// - void init_message(uchar *u_new, uchar *d_new, uchar *l_new, uchar *r_new, - uchar *u_cur, uchar *d_cur, uchar *l_cur, uchar *r_cur, - uchar *disp_selected_pyr_new, uchar *disp_selected_pyr_cur, - uchar *data_cost_selected, uchar *data_cost, oclMat &temp, StereoConstantSpaceBP rthis, - size_t msg_step1, size_t msg_step2, int h, int w, int nr_plane, - int h2, int w2, int nr_plane2) - { - Context *clCxt = temp.clCxt; - int data_type = rthis.msg_type; - - string kernelName = get_kernel_name("init_message_", data_type); - - cl_kernel kernel = openCLGetKernelFromSource(clCxt, &stereocsbp, kernelName); - - size_t blockSize = 256; - size_t localThreads[] = {32, 8}; - size_t globalThreads[] = {divUp(w, localThreads[0]) * localThreads[0], - divUp(h, localThreads[1]) * localThreads[1] - }; - - int disp_step1 = msg_step1 * h; - int disp_step2 = msg_step2 * h2; - openCLVerifyKernel(clCxt, kernel, &blockSize, globalThreads, localThreads); - openCLSafeCall(clSetKernelArg(kernel, 0, sizeof(cl_mem), (void *)&u_new)); - openCLSafeCall(clSetKernelArg(kernel, 1, sizeof(cl_mem), (void *)&d_new)); - openCLSafeCall(clSetKernelArg(kernel, 2, sizeof(cl_mem), (void *)&l_new)); - openCLSafeCall(clSetKernelArg(kernel, 3, sizeof(cl_mem), (void *)&r_new)); - openCLSafeCall(clSetKernelArg(kernel, 4, sizeof(cl_mem), (void *)&u_cur)); - openCLSafeCall(clSetKernelArg(kernel, 5, sizeof(cl_mem), (void *)&d_cur)); - openCLSafeCall(clSetKernelArg(kernel, 6, sizeof(cl_mem), (void *)&l_cur)); - openCLSafeCall(clSetKernelArg(kernel, 7, sizeof(cl_mem), (void *)&r_cur)); - openCLSafeCall(clSetKernelArg(kernel, 8, sizeof(cl_mem), (void *)&temp.data)); - openCLSafeCall(clSetKernelArg(kernel, 9, sizeof(cl_mem), (void *)&disp_selected_pyr_new)); - openCLSafeCall(clSetKernelArg(kernel, 10, sizeof(cl_mem), (void *)&disp_selected_pyr_cur)); - openCLSafeCall(clSetKernelArg(kernel, 11, sizeof(cl_mem), (void *)&data_cost_selected)); - openCLSafeCall(clSetKernelArg(kernel, 12, sizeof(cl_mem), (void *)&data_cost)); - openCLSafeCall(clSetKernelArg(kernel, 13, sizeof(cl_int), (void *)&h)); - openCLSafeCall(clSetKernelArg(kernel, 14, sizeof(cl_int), (void *)&w)); - openCLSafeCall(clSetKernelArg(kernel, 15, sizeof(cl_int), (void *)&nr_plane)); - openCLSafeCall(clSetKernelArg(kernel, 16, sizeof(cl_int), (void *)&h2)); - openCLSafeCall(clSetKernelArg(kernel, 17, sizeof(cl_int), (void *)&w2)); - openCLSafeCall(clSetKernelArg(kernel, 18, sizeof(cl_int), (void *)&nr_plane2)); - openCLSafeCall(clSetKernelArg(kernel, 19, sizeof(cl_int), (void *)&disp_step1)); - openCLSafeCall(clSetKernelArg(kernel, 20, sizeof(cl_int), (void *)&disp_step2)); - openCLSafeCall(clSetKernelArg(kernel, 21, sizeof(cl_int), (void *)&msg_step1)); - openCLSafeCall(clSetKernelArg(kernel, 22, sizeof(cl_int), (void *)&msg_step2)); - openCLSafeCall(clEnqueueNDRangeKernel(clCxt->impl->clCmdQueue, kernel, 2, NULL, - globalThreads, localThreads, 0, NULL, NULL)); - - clFinish(clCxt->impl->clCmdQueue); - openCLSafeCall(clReleaseKernel(kernel)); - } - //////////////////////////////////////////////////////////////////////////////////////////////// - ///////////////////////////calc_all_iterations//////////////////////////////////////////////// - ////////////////////////////////////////////////////////////////////////////////////////////// - void calc_all_iterations_caller(uchar *u, uchar *d, uchar *l, uchar *r, uchar *data_cost_selected, - uchar *disp_selected_pyr, oclMat &temp, StereoConstantSpaceBP rthis, - int msg_step, int h, int w, int nr_plane, int i) - { - Context *clCxt = temp.clCxt; - int data_type = rthis.msg_type; - - string kernelName = get_kernel_name("compute_message_", data_type); - - cl_kernel kernel = openCLGetKernelFromSource(clCxt, &stereocsbp, kernelName); - - size_t blockSize = 256; - size_t localThreads[] = {32, 8}; - size_t globalThreads[] = {divUp(w, (localThreads[0]) << 1) * localThreads[0], - divUp(h, localThreads[1]) * localThreads[1] - }; - - int disp_step = msg_step * h; - openCLVerifyKernel(clCxt, kernel, &blockSize, globalThreads, localThreads); - openCLSafeCall(clSetKernelArg(kernel, 0, sizeof(cl_mem), (void *)&u)); - openCLSafeCall(clSetKernelArg(kernel, 1, sizeof(cl_mem), (void *)&d)); - openCLSafeCall(clSetKernelArg(kernel, 2, sizeof(cl_mem), (void *)&l)); - openCLSafeCall(clSetKernelArg(kernel, 3, sizeof(cl_mem), (void *)&r)); - openCLSafeCall(clSetKernelArg(kernel, 4, sizeof(cl_mem), (void *)&data_cost_selected)); - openCLSafeCall(clSetKernelArg(kernel, 5, sizeof(cl_mem), (void *)&disp_selected_pyr)); - openCLSafeCall(clSetKernelArg(kernel, 6, sizeof(cl_mem), (void *)&temp.data)); - openCLSafeCall(clSetKernelArg(kernel, 7, sizeof(cl_int), (void *)&h)); - openCLSafeCall(clSetKernelArg(kernel, 8, sizeof(cl_int), (void *)&w)); - openCLSafeCall(clSetKernelArg(kernel, 9, sizeof(cl_int), (void *)&nr_plane)); - openCLSafeCall(clSetKernelArg(kernel, 10, sizeof(cl_int), (void *)&i)); - openCLSafeCall(clSetKernelArg(kernel, 11, sizeof(cl_float), (void *)&rthis.max_disc_term)); - openCLSafeCall(clSetKernelArg(kernel, 12, sizeof(cl_int), (void *)&disp_step)); - openCLSafeCall(clSetKernelArg(kernel, 13, sizeof(cl_int), (void *)&msg_step)); - openCLSafeCall(clSetKernelArg(kernel, 14, sizeof(cl_float), (void *)&rthis.disc_single_jump)); - openCLSafeCall(clEnqueueNDRangeKernel(clCxt->impl->clCmdQueue, kernel, 2, NULL, - globalThreads, localThreads, 0, NULL, NULL)); - - clFinish(clCxt->impl->clCmdQueue); - openCLSafeCall(clReleaseKernel(kernel)); - } - void calc_all_iterations(uchar *u, uchar *d, uchar *l, uchar *r, uchar *data_cost_selected, - uchar *disp_selected_pyr, oclMat &temp, StereoConstantSpaceBP rthis, - int msg_step, int h, int w, int nr_plane) - { - for(int t = 0; t < rthis.iters; t++) - calc_all_iterations_caller(u, d, l, r, data_cost_selected, disp_selected_pyr, temp, rthis, - msg_step, h, w, nr_plane, t & 1); - } - - /////////////////////////////////////////////////////////////////////////////////////////////// - //////////////////////////compute_disp//////////////////////////////////////////////////////// - ///////////////////////////////////////////////////////////////////////////////////////////// - void compute_disp(uchar *u, uchar *d, uchar *l, uchar *r, uchar *data_cost_selected, - uchar *disp_selected_pyr, StereoConstantSpaceBP &rthis, size_t msg_step, - oclMat &disp, int nr_plane) - { - Context *clCxt = disp.clCxt; - int data_type = rthis.msg_type; - - string kernelName = get_kernel_name("compute_disp_", data_type); - - cl_kernel kernel = openCLGetKernelFromSource(clCxt, &stereocsbp, kernelName); - - size_t blockSize = 256; - size_t localThreads[] = {32, 8}; - size_t globalThreads[] = {divUp(disp.cols, localThreads[0]) * localThreads[0], - divUp(disp.rows, localThreads[1]) * localThreads[1] - }; - - int step_size = disp.step / disp.elemSize(); - int disp_step = disp.rows * msg_step; - openCLVerifyKernel(clCxt, kernel, &blockSize, globalThreads, localThreads); - openCLSafeCall(clSetKernelArg(kernel, 0, sizeof(cl_mem), (void *)&u)); - openCLSafeCall(clSetKernelArg(kernel, 1, sizeof(cl_mem), (void *)&d)); - openCLSafeCall(clSetKernelArg(kernel, 2, sizeof(cl_mem), (void *)&l)); - openCLSafeCall(clSetKernelArg(kernel, 3, sizeof(cl_mem), (void *)&r)); - openCLSafeCall(clSetKernelArg(kernel, 4, sizeof(cl_mem), (void *)&data_cost_selected)); - openCLSafeCall(clSetKernelArg(kernel, 5, sizeof(cl_mem), (void *)&disp_selected_pyr)); - openCLSafeCall(clSetKernelArg(kernel, 6, sizeof(cl_mem), (void *)&disp.data)); - openCLSafeCall(clSetKernelArg(kernel, 7, sizeof(cl_int), (void *)&step_size)); - openCLSafeCall(clSetKernelArg(kernel, 8, sizeof(cl_int), (void *)&disp.cols)); - openCLSafeCall(clSetKernelArg(kernel, 9, sizeof(cl_int), (void *)&disp.rows)); - openCLSafeCall(clSetKernelArg(kernel, 10, sizeof(cl_int), (void *)&nr_plane)); - openCLSafeCall(clSetKernelArg(kernel, 11, sizeof(cl_int), (void *)&msg_step)); - openCLSafeCall(clSetKernelArg(kernel, 12, sizeof(cl_int), (void *)&disp_step)); - openCLSafeCall(clEnqueueNDRangeKernel(clCxt->impl->clCmdQueue, kernel, 2, NULL, - globalThreads, localThreads, 0, NULL, NULL)); - - clFinish(clCxt->impl->clCmdQueue); - openCLSafeCall(clReleaseKernel(kernel)); - } - } - } -} -namespace -{ - const float DEFAULT_MAX_DATA_TERM = 30.0f; - const float DEFAULT_DATA_WEIGHT = 1.0f; - const float DEFAULT_MAX_DISC_TERM = 160.0f; - const float DEFAULT_DISC_SINGLE_JUMP = 10.0f; - - template - void print_gpu_mat(const oclMat &mat) - { - T *data_1 = new T[mat.rows * mat.cols * mat.channels()]; - Context *clCxt = mat.clCxt; - int status = clEnqueueReadBuffer(clCxt -> impl->clCmdQueue, (cl_mem)mat.data, CL_TRUE, 0, - mat.rows * mat.cols * mat.channels() * sizeof(T), data_1, 0, NULL, NULL); - - if(status != CL_SUCCESS) - cout << "error " << status << endl; - - cout << ".........................................................." << endl; - cout << "elemSize() " << mat.elemSize() << endl; - cout << "elemSize() " << mat.elemSize1() << endl; - cout << "channels: " << mat.channels() << endl; - cout << "rows: " << mat.rows << endl; - cout << "cols: " << mat.cols << endl; - - for(int i = 0; i < 100; i++) - { - for(int j = 0; j < 30; j++) - { - cout << (int)data_1[i * mat.cols * mat.channels() + j] << " "; - } - cout << endl; - } - } -} - - -void cv::ocl::StereoConstantSpaceBP::estimateRecommendedParams(int width, int height, int &ndisp, int &iters, int &levels, int &nr_plane) -{ - ndisp = (int) ((float) width / 3.14f); - if ((ndisp & 1) != 0) - ndisp++; - - int mm = ::max(width, height); - iters = mm / 100 + ((mm > 1200) ? - 4 : 4); - - levels = (int)::log(static_cast(mm)) * 2 / 3; - if (levels == 0) levels++; - - nr_plane = (int) ((float) ndisp / std::pow(2.0, levels + 1)); -} - -cv::ocl::StereoConstantSpaceBP::StereoConstantSpaceBP(int ndisp_, int iters_, int levels_, int nr_plane_, - int msg_type_) - - : ndisp(ndisp_), iters(iters_), levels(levels_), nr_plane(nr_plane_), - max_data_term(DEFAULT_MAX_DATA_TERM), data_weight(DEFAULT_DATA_WEIGHT), - max_disc_term(DEFAULT_MAX_DISC_TERM), disc_single_jump(DEFAULT_DISC_SINGLE_JUMP), min_disp_th(0), - msg_type(msg_type_), use_local_init_data_cost(true) -{ - CV_Assert(msg_type_ == CV_32F || msg_type_ == CV_16S); -} - - -cv::ocl::StereoConstantSpaceBP::StereoConstantSpaceBP(int ndisp_, int iters_, int levels_, int nr_plane_, - float max_data_term_, float data_weight_, float max_disc_term_, float disc_single_jump_, - int min_disp_th_, int msg_type_) - : ndisp(ndisp_), iters(iters_), levels(levels_), nr_plane(nr_plane_), - max_data_term(max_data_term_), data_weight(data_weight_), - max_disc_term(max_disc_term_), disc_single_jump(disc_single_jump_), min_disp_th(min_disp_th_), - msg_type(msg_type_), use_local_init_data_cost(true) -{ - CV_Assert(msg_type_ == CV_32F || msg_type_ == CV_16S); -} - -template -static void csbp_operator(StereoConstantSpaceBP &rthis, oclMat u[2], oclMat d[2], oclMat l[2], oclMat r[2], - oclMat disp_selected_pyr[2], oclMat &data_cost, oclMat &data_cost_selected, - oclMat &temp, oclMat &out, const oclMat &left, const oclMat &right, oclMat &disp) -{ - CV_DbgAssert(0 < rthis.ndisp && 0 < rthis.iters && 0 < rthis.levels && 0 < rthis.nr_plane - && left.rows == right.rows && left.cols == right.cols && left.type() == right.type()); - - CV_Assert(rthis.levels <= 8 && (left.type() == CV_8UC1 || left.type() == CV_8UC3)); - - const Scalar zero = Scalar::all(0); - - ////////////////////////////////////Init/////////////////////////////////////////////////// - int rows = left.rows; - int cols = left.cols; - - rthis.levels = min(rthis.levels, int(log((double)rthis.ndisp) / log(2.0))); - int levels = rthis.levels; - - AutoBuffer buf(levels * 4); - - int *cols_pyr = buf; - int *rows_pyr = cols_pyr + levels; - int *nr_plane_pyr = rows_pyr + levels; - int *step_pyr = nr_plane_pyr + levels; - - cols_pyr[0] = cols; - rows_pyr[0] = rows; - nr_plane_pyr[0] = rthis.nr_plane; - - const int n = 64; - step_pyr[0] = alignSize(cols * sizeof(T), n) / sizeof(T); - for (int i = 1; i < levels; i++) - { - cols_pyr[i] = (cols_pyr[i-1] + 1) / 2; - rows_pyr[i] = (rows_pyr[i-1] + 1) / 2; - - nr_plane_pyr[i] = nr_plane_pyr[i-1] * 2; - - step_pyr[i] = alignSize(cols_pyr[i] * sizeof(T), n) / sizeof(T); - } - - Size msg_size(step_pyr[0], rows * nr_plane_pyr[0]); - Size data_cost_size(step_pyr[0], rows * nr_plane_pyr[0] * 2); - - u[0].create(msg_size, DataType::type); - d[0].create(msg_size, DataType::type); - l[0].create(msg_size, DataType::type); - r[0].create(msg_size, DataType::type); - - u[1].create(msg_size, DataType::type); - d[1].create(msg_size, DataType::type); - l[1].create(msg_size, DataType::type); - r[1].create(msg_size, DataType::type); - - disp_selected_pyr[0].create(msg_size, DataType::type); - disp_selected_pyr[1].create(msg_size, DataType::type); - - data_cost.create(data_cost_size, DataType::type); - data_cost_selected.create(msg_size, DataType::type); - - step_pyr[0] = data_cost.step / sizeof(T); - - Size temp_size = data_cost_size; - if (data_cost_size.width * data_cost_size.height < step_pyr[levels - 1] * rows_pyr[levels - 1] * rthis.ndisp) - temp_size = Size(step_pyr[levels - 1], rows_pyr[levels - 1] * rthis.ndisp); - - temp.create(temp_size, DataType::type); - - ///////////////////////////////// Compute//////////////////////////////////////////////// - - //csbp::load_constants(rthis.ndisp, rthis.max_data_term, rthis.data_weight, - // rthis.max_disc_term, rthis.disc_single_jump, rthis.min_disp_th, left, right, temp); - - l[0] = zero; - d[0] = zero; - r[0] = zero; - u[0] = zero; - - l[1] = zero; - d[1] = zero; - r[1] = zero; - u[1] = zero; - - data_cost = zero; - data_cost_selected = zero; - - int cur_idx = 0; - - for (int i = levels - 1; i >= 0; i--) - { - if (i == levels - 1) - { - cv::ocl::stereoCSBP::init_data_cost(left, right, temp, rthis, disp_selected_pyr[cur_idx].ptr(), - data_cost_selected.ptr(), step_pyr[i], rows_pyr[i], cols_pyr[i], - i, nr_plane_pyr[i]); - } - else - { - cv::ocl::stereoCSBP::compute_data_cost(disp_selected_pyr[cur_idx].ptr(), data_cost.ptr(), rthis, step_pyr[i], - step_pyr[i+1], left, right, rows_pyr[i], cols_pyr[i], rows_pyr[i+1], i, - nr_plane_pyr[i+1]); - - - int new_idx = (cur_idx + 1) & 1; - - cv::ocl::stereoCSBP::init_message(u[new_idx].ptr(), d[new_idx].ptr(), l[new_idx].ptr(), r[new_idx].ptr(), - u[cur_idx].ptr(), d[cur_idx].ptr(), l[cur_idx].ptr(), r[cur_idx].ptr(), - disp_selected_pyr[new_idx].ptr(), disp_selected_pyr[cur_idx].ptr(), - data_cost_selected.ptr(), data_cost.ptr(), temp, rthis, step_pyr[i], - step_pyr[i+1], rows_pyr[i], cols_pyr[i], nr_plane_pyr[i], rows_pyr[i+1], - cols_pyr[i+1], nr_plane_pyr[i+1]); - - cur_idx = new_idx; - } - - cv::ocl::stereoCSBP::calc_all_iterations(u[cur_idx].ptr(), d[cur_idx].ptr(), l[cur_idx].ptr(), r[cur_idx].ptr(), - data_cost_selected.ptr(), disp_selected_pyr[cur_idx].ptr(), temp, - rthis, step_pyr[i], rows_pyr[i], cols_pyr[i], nr_plane_pyr[i]); - } - - - if (disp.empty()) - disp.create(rows, cols, CV_16S); - - out = ((disp.type() == CV_16S) ? disp : (out.create(rows, cols, CV_16S), out)); - out = zero; - - stereoCSBP::compute_disp(u[cur_idx].ptr(), d[cur_idx].ptr(), l[cur_idx].ptr(), r[cur_idx].ptr(), - data_cost_selected.ptr(), disp_selected_pyr[cur_idx].ptr(), rthis, step_pyr[0], - out, nr_plane_pyr[0]); - - - if (disp.type() != CV_16S) - out.convertTo(disp, disp.type()); -} - - -typedef void (*csbp_operator_t)(StereoConstantSpaceBP &rthis, oclMat u[2], oclMat d[2], oclMat l[2], oclMat r[2], - oclMat disp_selected_pyr[2], oclMat &data_cost, oclMat &data_cost_selected, - oclMat &temp, oclMat &out, const oclMat &left, const oclMat &right, oclMat &disp); - -const static csbp_operator_t operators[] = {0, 0, 0, csbp_operator, 0, csbp_operator, 0, 0}; - -void cv::ocl::StereoConstantSpaceBP::operator()(const oclMat &left, const oclMat &right, oclMat &disp) -{ - - CV_Assert(msg_type == CV_32F || msg_type == CV_16S); - operators[msg_type](*this, u, d, l, r, disp_selected_pyr, data_cost, data_cost_selected, temp, out, - left, right, disp); -} - -#endif /* !defined (HAVE_OPENCL) */ diff --git a/modules/ocl/src/stereobm.cpp b/modules/ocl/src/stereobm.cpp deleted file mode 100644 index a7e06b0d6e..0000000000 --- a/modules/ocl/src/stereobm.cpp +++ /dev/null @@ -1,291 +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) 2010-2012, Institute Of Software Chinese Academy Of Science, all rights reserved. -// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved. -// Third party copyrights are property of their respective owners. -// -// @Authors -// Jia Haipeng, jiahaipeng95@gmail.com -// -// 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 oclMaterials 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*/ - -#include "precomp.hpp" -#include - -using namespace cv; -using namespace cv::ocl; -using namespace std; - -//////////////////////////////////////////////////////////////////////// -///////////////// stereoBM ///////////////////////////////////////////// -//////////////////////////////////////////////////////////////////////// - -#if !defined (HAVE_OPENCL) - -namespace cv -{ - namespace ocl - { - cv::ocl::StereoBM_GPU::StereoBM_GPU() - { - throw_nogpu(); - } - cv::ocl::StereoBM_GPU::StereoBM_GPU(int, int, int) - { - throw_nogpu(); - } - bool cv::ocl::StereoBM_GPU::checkIfGpuCallReasonable() - { - throw_nogpu(); - return false; - } - void cv::ocl::StereoBM_GPU::operator() ( const oclMat &, const oclMat &, oclMat &) - { - throw_nogpu(); - } - } -} - -#else /* !defined (HAVE_OPENCL) */ - -namespace cv -{ - namespace ocl - { - - ///////////////////////////OpenCL kernel strings/////////////////////////// - extern const char *stereobm; - - } -} -namespace cv -{ - namespace ocl - { - namespace stereoBM - { - ///////////////////////////////////////////////////////////////////////// - //////////////////////////prefilter_xsbel//////////////////////////////// - //////////////////////////////////////////////////////////////////////// - void prefilter_xsobel(const oclMat &input, oclMat &output, int prefilterCap) - { - Context *clCxt = input.clCxt; - - string kernelName = "prefilter_xsobel"; - cl_kernel kernel = openCLGetKernelFromSource(clCxt, &stereobm, kernelName); - - size_t blockSize = 1; - size_t globalThreads[3] = { input.cols, input.rows, 1 }; - size_t localThreads[3] = { blockSize, blockSize, 1 }; - - openCLVerifyKernel(clCxt, kernel, &blockSize, globalThreads, localThreads); - openCLSafeCall(clSetKernelArg(kernel, 0, sizeof(cl_mem), (void *)&input.data)); - openCLSafeCall(clSetKernelArg(kernel, 1, sizeof(cl_mem), (void *)&output.data)); - openCLSafeCall(clSetKernelArg(kernel, 2, sizeof(cl_int), (void *)&input.rows)); - openCLSafeCall(clSetKernelArg(kernel, 3, sizeof(cl_int), (void *)&input.cols)); - openCLSafeCall(clSetKernelArg(kernel, 4, sizeof(cl_int), (void *)&prefilterCap)); - - openCLSafeCall(clEnqueueNDRangeKernel(clCxt->impl->clCmdQueue, kernel, 3, NULL, - globalThreads, localThreads, 0, NULL, NULL)); - - clFinish(clCxt->impl->clCmdQueue); - openCLSafeCall(clReleaseKernel(kernel)); - - } - ////////////////////////////////////////////////////////////////////////// - //////////////////////////////common//////////////////////////////////// - //////////////////////////////////////////////////////////////////////// -#define N_DISPARITIES 8 -#define ROWSperTHREAD 21 -#define BLOCK_W 128 - static inline int divUp(int total, int grain) - { - return (total + grain - 1) / grain; - } - //////////////////////////////////////////////////////////////////////////// - ///////////////////////////////stereoBM_GPU//////////////////////////////// - //////////////////////////////////////////////////////////////////////////// - void stereo_bm(const oclMat &left, const oclMat &right, oclMat &disp, - int maxdisp, int winSize, oclMat &minSSD_buf) - { - int winsz2 = winSize >> 1; - - //if(winsz2 == 0 || winsz2 >= calles_num) - //cv::ocl:error("Unsupported window size", __FILE__, __LINE__, __FUNCTION__); - - Context *clCxt = left.clCxt; - - string kernelName = "stereoKernel"; - cl_kernel kernel = openCLGetKernelFromSource(clCxt, &stereobm, kernelName); - - disp.setTo(Scalar_::all(0)); - minSSD_buf.setTo(Scalar_::all(0xFFFFFFFF)); - - size_t minssd_step = minSSD_buf.step / minSSD_buf.elemSize(); - size_t local_mem_size = (BLOCK_W + N_DISPARITIES * (BLOCK_W + 2 * winsz2)) * - sizeof(cl_uint); - size_t blockSize = 1; - size_t localThreads[] = { BLOCK_W, 1}; - size_t globalThreads[] = { divUp(left.cols - maxdisp - 2 * winsz2, BLOCK_W) * BLOCK_W, - divUp(left.rows - 2 * winsz2, ROWSperTHREAD) - }; - - openCLVerifyKernel(clCxt, kernel, &blockSize, globalThreads, localThreads); - openCLSafeCall(clSetKernelArg(kernel, 0, sizeof(cl_mem), (void *)&left.data)); - openCLSafeCall(clSetKernelArg(kernel, 1, sizeof(cl_mem), (void *)&right.data)); - openCLSafeCall(clSetKernelArg(kernel, 2, sizeof(cl_mem), (void *)&minSSD_buf.data)); - openCLSafeCall(clSetKernelArg(kernel, 3, sizeof(cl_int), (void *)&minssd_step)); - openCLSafeCall(clSetKernelArg(kernel, 4, sizeof(cl_mem), (void *)&disp.data)); - openCLSafeCall(clSetKernelArg(kernel, 5, sizeof(cl_int), (void *)&disp.step)); - openCLSafeCall(clSetKernelArg(kernel, 6, sizeof(cl_int), (void *)&left.cols)); - openCLSafeCall(clSetKernelArg(kernel, 7, sizeof(cl_int), (void *)&left.rows)); - openCLSafeCall(clSetKernelArg(kernel, 8, sizeof(cl_int), (void *)&left.step)); - openCLSafeCall(clSetKernelArg(kernel, 9, sizeof(cl_int), (void *)&maxdisp)); - openCLSafeCall(clSetKernelArg(kernel, 10, sizeof(cl_int), (void *)&winsz2)); - openCLSafeCall(clSetKernelArg(kernel, 11, local_mem_size, (void *)NULL)); - - openCLSafeCall(clEnqueueNDRangeKernel(clCxt->impl->clCmdQueue, kernel, 2, NULL, - globalThreads, localThreads, 0, NULL, NULL)); - - - clFinish(clCxt->impl->clCmdQueue); - openCLSafeCall(clReleaseKernel(kernel)); - } - //////////////////////////////////////////////////////////////////////////// - ///////////////////////////////postfilter_textureness/////////////////////// - //////////////////////////////////////////////////////////////////////////// - void postfilter_textureness(oclMat &left, int winSize, - float avergeTexThreshold, oclMat &disparity) - { - Context *clCxt = left.clCxt; - - string kernelName = "textureness_kernel"; - cl_kernel kernel = openCLGetKernelFromSource(clCxt, &stereobm, kernelName); - - size_t blockSize = 1; - size_t localThreads[] = { BLOCK_W, blockSize}; - size_t globalThreads[] = { divUp(left.cols, BLOCK_W) * BLOCK_W, - divUp(left.rows, 2 * ROWSperTHREAD) - }; - - size_t local_mem_size = (localThreads[0] + localThreads[0] + (winSize / 2) * 2) * sizeof(float); - - openCLVerifyKernel(clCxt, kernel, &blockSize, globalThreads, localThreads); - openCLSafeCall(clSetKernelArg(kernel, 0, sizeof(cl_mem), (void *)&disparity.data)); - openCLSafeCall(clSetKernelArg(kernel, 1, sizeof(cl_int), (void *)&disparity.rows)); - openCLSafeCall(clSetKernelArg(kernel, 2, sizeof(cl_int), (void *)&disparity.cols)); - openCLSafeCall(clSetKernelArg(kernel, 3, sizeof(cl_int), (void *)&disparity.step)); - openCLSafeCall(clSetKernelArg(kernel, 4, sizeof(cl_mem), (void *)&left.data)); - openCLSafeCall(clSetKernelArg(kernel, 5, sizeof(cl_int), (void *)&left.rows)); - openCLSafeCall(clSetKernelArg(kernel, 6, sizeof(cl_int), (void *)&left.cols)); - openCLSafeCall(clSetKernelArg(kernel, 7, sizeof(cl_int), (void *)&winSize)); - openCLSafeCall(clSetKernelArg(kernel, 8, sizeof(cl_float), (void *)&avergeTexThreshold)); - openCLSafeCall(clSetKernelArg(kernel, 9, local_mem_size, NULL)); - openCLSafeCall(clEnqueueNDRangeKernel(clCxt->impl->clCmdQueue, kernel, 2, NULL, - globalThreads, localThreads, 0, NULL, NULL)); - - clFinish(clCxt->impl->clCmdQueue); - openCLSafeCall(clReleaseKernel(kernel)); - } - ////////////////////////////////////////////////////////////////////////////// - /////////////////////////////////////operator///////////////////////////////// - ///////////////////////////////////////////////////////////////////////////// - void operator_(oclMat &minSSD, oclMat &leBuf, oclMat &riBuf, int preset, int ndisp, - int winSize, float avergeTexThreshold, const oclMat &left, - const oclMat &right, oclMat &disparity) - - { - CV_DbgAssert(left.rows == right.rows && left.cols == right.cols); - CV_DbgAssert(left.type() == CV_8UC1); - CV_DbgAssert(right.type() == CV_8UC1); - - disparity.create(left.size(), CV_8UC1); - minSSD.create(left.size(), CV_32SC1); - - oclMat le_for_bm = left; - oclMat ri_for_bm = right; - - if (preset == cv::ocl::StereoBM_GPU::PREFILTER_XSOBEL) - { - leBuf.create( left.size(), left.type()); - riBuf.create(right.size(), right.type()); - - prefilter_xsobel( left, leBuf, 31); - prefilter_xsobel(right, riBuf, 31); - - le_for_bm = leBuf; - ri_for_bm = riBuf; - } - - stereo_bm(le_for_bm, ri_for_bm, disparity, ndisp, winSize, minSSD); - - if (avergeTexThreshold) - { - postfilter_textureness(le_for_bm, winSize, avergeTexThreshold, disparity); - } - } - } - } -} -const float defaultAvgTexThreshold = 3; - -cv::ocl::StereoBM_GPU::StereoBM_GPU() - : preset(BASIC_PRESET), ndisp(DEFAULT_NDISP), winSize(DEFAULT_WINSZ), - avergeTexThreshold(defaultAvgTexThreshold) {} - -cv::ocl::StereoBM_GPU::StereoBM_GPU(int preset_, int ndisparities_, int winSize_) - : preset(preset_), ndisp(ndisparities_), winSize(winSize_), - avergeTexThreshold(defaultAvgTexThreshold) -{ - const int max_supported_ndisp = 1 << (sizeof(unsigned char) * 8); - CV_Assert(0 < ndisp && ndisp <= max_supported_ndisp); - CV_Assert(ndisp % 8 == 0); - CV_Assert(winSize % 2 == 1); -} - -bool cv::ocl::StereoBM_GPU::checkIfGpuCallReasonable() -{ - return true; -} - -void cv::ocl::StereoBM_GPU::operator() ( const oclMat &left, const oclMat &right, - oclMat &disparity) -{ - cv::ocl::stereoBM::operator_(minSSD, leBuf, riBuf, preset, ndisp, winSize, avergeTexThreshold, left, right, disparity); -} - -#endif /* !defined (HAVE_OPENCL) */ diff --git a/modules/ocl/src/stereobp.cpp b/modules/ocl/src/stereobp.cpp deleted file mode 100644 index ba53f15d1a..0000000000 --- a/modules/ocl/src/stereobp.cpp +++ /dev/null @@ -1,661 +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) 2010-2012, Institute Of Software Chinese Academy Of Science, all rights reserved. -// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved. -// Third party copyrights are property of their respective owners. -// -// @Authors -// Jia Haipeng, jiahaipeng95@gmail.com -// -// 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 oclMaterials 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*/ - -#include "precomp.hpp" -#include - -using namespace cv; -using namespace cv::ocl; -using namespace std; - -//////////////////////////////////////////////////////////////////////// -///////////////// stereoBP ///////////////////////////////////////////// -//////////////////////////////////////////////////////////////////////// - -#if !defined (HAVE_OPENCL) - -namespace cv -{ - namespace ocl - { - void cv::ocl::StereoBeliefPropagation::estimateRecommendedParams(int, int, int &, int &, int &) - { - throw_nogpu(); - } - - cv::ocl::StereoBeliefPropagation::StereoBeliefPropagation(int, int, int, int) - { - throw_nogpu(); - } - - cv::ocl::StereoBeliefPropagation::StereoBeliefPropagation(int, int, int, float, float, float, float, int) - { - throw_nogpu(); - } - - void cv::ocl::StereoBeliefPropagation::operator()(const oclMat &, const oclMat &, oclMat &) - { - throw_nogpu(); - } - - void cv::ocl::StereoBeliefPropagation::operator()(const oclMat &, oclMat &) - { - throw_nogpu(); - } - } -} - -#else /* !defined (HAVE_OPENCL) */ - -namespace cv -{ - namespace ocl - { - - ///////////////////////////OpenCL kernel strings/////////////////////////// - extern const char *stereobp; - } - -} -namespace cv -{ - namespace ocl - { - namespace stereoBP - { - ////////////////////////////////////////////////////////////////////////// - //////////////////////////////common//////////////////////////////////// - //////////////////////////////////////////////////////////////////////// - typedef struct - { - int cndisp; - float cmax_data_term; - float cdata_weight; - float cmax_disc_term; - float cdisc_single_jump; - } con_struct_t; - - cl_mem cl_con_struct = NULL; - void load_constants(Context *clCxt, int ndisp, float max_data_term, float data_weight, - float max_disc_term, float disc_single_jump) - { - con_struct_t *con_struct = new con_struct_t; - con_struct -> cndisp = ndisp; - con_struct -> cmax_data_term = max_data_term; - con_struct -> cdata_weight = data_weight; - con_struct -> cmax_disc_term = max_data_term; - con_struct -> cdisc_single_jump = disc_single_jump; - - cl_con_struct = load_constant(clCxt->impl->clContext, clCxt->impl->clCmdQueue, (void *)con_struct, - sizeof(con_struct_t)); - - delete con_struct; - } - void release_constants() - { - openCLFree(cl_con_struct); - } - static inline int divUp(int total, int grain) - { - return (total + grain - 1) / grain; - } - ///////////////////////////////////////////////////////////////////////////// - ///////////////////////////comp data//////////////////////////////////////// - ///////////////////////////////////////////////////////////////////////// - void comp_data_call(const oclMat &left, const oclMat &right, oclMat &data, int disp, float cmax_data_term, float cdata_weight) - { - Context *clCxt = left.clCxt; - int channels = left.channels(); - int data_type = data.type(); - - string kernelName = "comp_data_"; - stringstream idxStr; - if(data_type == CV_16S) - idxStr << "0"; - else - idxStr << "1"; - kernelName += idxStr.str(); - - cl_kernel kernel = openCLGetKernelFromSource(clCxt, &stereobp, kernelName); - - size_t blockSize = 32; - size_t localThreads[] = {32, 8}; - size_t globalThreads[] = {divUp(left.cols, localThreads[0]) * localThreads[0], - divUp(left.rows, localThreads[1]) * localThreads[1] - }; - - openCLVerifyKernel(clCxt, kernel, &blockSize, globalThreads, localThreads); - openCLSafeCall(clSetKernelArg(kernel, 0, sizeof(cl_mem), (void *)&left.data)); - openCLSafeCall(clSetKernelArg(kernel, 1, sizeof(cl_int), (void *)&left.rows)); - openCLSafeCall(clSetKernelArg(kernel, 2, sizeof(cl_int), (void *)&left.cols)); - openCLSafeCall(clSetKernelArg(kernel, 3, sizeof(cl_int), (void *)&left.step)); - openCLSafeCall(clSetKernelArg(kernel, 4, sizeof(cl_mem), (void *)&right.data)); - openCLSafeCall(clSetKernelArg(kernel, 5, sizeof(cl_int), (void *)&right.step)); - openCLSafeCall(clSetKernelArg(kernel, 6, sizeof(cl_mem), (void *)&data.data)); - openCLSafeCall(clSetKernelArg(kernel, 7, sizeof(cl_int), (void *)&data.cols)); - openCLSafeCall(clSetKernelArg(kernel, 8, sizeof(cl_int), (void *)&data.step)); - openCLSafeCall(clSetKernelArg(kernel, 9, sizeof(cl_mem), (void *)&cl_con_struct)); - //openCLSafeCall(clSetKernelArg(kernel,12,sizeof(cl_int),(void*)&disp)); - //openCLSafeCall(clSetKernelArg(kernel,13,sizeof(cl_float),(void*)&cmax_data_term)); - //openCLSafeCall(clSetKernelArg(kernel,14,sizeof(cl_float),(void*)&cdata_weight)); - openCLSafeCall(clSetKernelArg(kernel, 10, sizeof(cl_int), (void *)&channels)); - - openCLSafeCall(clEnqueueNDRangeKernel(clCxt->impl->clCmdQueue, kernel, 2, NULL, - globalThreads, localThreads, 0, NULL, NULL)); - - clFinish(clCxt->impl->clCmdQueue); - openCLSafeCall(clReleaseKernel(kernel)); - } - /////////////////////////////////////////////////////////////////////////////////// - /////////////////////////data set down//////////////////////////////////////////// - ///////////////////////////////////////////////////////////////////////////////// - void data_step_down_call(int dst_cols, int dst_rows, int src_rows, - const oclMat &src, oclMat &dst, int disp) - { - Context *clCxt = src.clCxt; - int data_type = src.type(); - - string kernelName = "data_step_down_"; - stringstream idxStr; - if(data_type == CV_16S) - idxStr << "0"; - else - idxStr << "1"; - kernelName += idxStr.str(); - - cl_kernel kernel = openCLGetKernelFromSource(clCxt, &stereobp, kernelName); - - size_t blockSize = 32; - size_t localThreads[] = {32, 8}; - size_t globalThreads[] = {divUp(dst_cols, localThreads[0]) * localThreads[0], - divUp(dst_rows, localThreads[1]) * localThreads[1] - }; - - openCLVerifyKernel(clCxt, kernel, &blockSize, globalThreads, localThreads); - openCLSafeCall(clSetKernelArg(kernel, 0, sizeof(cl_mem), (void *)&src.data)); - openCLSafeCall(clSetKernelArg(kernel, 1, sizeof(cl_int), (void *)&src_rows)); - openCLSafeCall(clSetKernelArg(kernel, 2, sizeof(cl_int), (void *)&src.cols)); - openCLSafeCall(clSetKernelArg(kernel, 3, sizeof(cl_mem), (void *)&dst.data)); - openCLSafeCall(clSetKernelArg(kernel, 4, sizeof(cl_int), (void *)&dst_rows)); - openCLSafeCall(clSetKernelArg(kernel, 5, sizeof(cl_int), (void *)&dst_cols)); - openCLSafeCall(clSetKernelArg(kernel, 6, sizeof(cl_int), (void *)&dst.cols)); - openCLSafeCall(clSetKernelArg(kernel, 7, sizeof(cl_int), (void *)&disp)); - - openCLSafeCall(clEnqueueNDRangeKernel(clCxt->impl->clCmdQueue, kernel, 2, NULL, - globalThreads, localThreads, 0, NULL, NULL)); - - clFinish(clCxt->impl->clCmdQueue); - openCLSafeCall(clReleaseKernel(kernel)); - } - ///////////////////////////////////////////////////////////////////////////////// - ///////////////////////////live up message//////////////////////////////////////// - ///////////////////////////////////////////////////////////////////////////////// - void level_up_message_call(int dst_idx, int dst_cols, int dst_rows, int src_rows, - oclMat &src, oclMat &dst, int ndisp) - { - Context *clCxt = src.clCxt; - int data_type = src.type(); - - string kernelName = "level_up_message_"; - stringstream idxStr; - if(data_type == CV_16S) - idxStr << "0"; - else - idxStr << "1"; - kernelName += idxStr.str(); - - cl_kernel kernel = openCLGetKernelFromSource(clCxt, &stereobp, kernelName); - - size_t blockSize = 32; - size_t localThreads[] = {32, 8}; - size_t globalThreads[] = {divUp(dst_cols, localThreads[0]) * localThreads[0], - divUp(dst_rows, localThreads[1]) * localThreads[1] - }; - - openCLVerifyKernel(clCxt, kernel, &blockSize, globalThreads, localThreads); - openCLSafeCall(clSetKernelArg(kernel, 0, sizeof(cl_mem), (void *)&src.data)); - openCLSafeCall(clSetKernelArg(kernel, 1, sizeof(cl_int), (void *)&src_rows)); - openCLSafeCall(clSetKernelArg(kernel, 2, sizeof(cl_int), (void *)&src.step)); - openCLSafeCall(clSetKernelArg(kernel, 3, sizeof(cl_mem), (void *)&dst.data)); - openCLSafeCall(clSetKernelArg(kernel, 4, sizeof(cl_int), (void *)&dst_rows)); - openCLSafeCall(clSetKernelArg(kernel, 5, sizeof(cl_int), (void *)&dst_cols)); - openCLSafeCall(clSetKernelArg(kernel, 6, sizeof(cl_int), (void *)&dst.step)); - openCLSafeCall(clSetKernelArg(kernel, 7, sizeof(cl_int), (void *)&ndisp)); - - openCLSafeCall(clEnqueueNDRangeKernel(clCxt->impl->clCmdQueue, kernel, 2, NULL, - globalThreads, localThreads, 0, NULL, NULL)); - - clFinish(clCxt->impl->clCmdQueue); - openCLSafeCall(clReleaseKernel(kernel)); - } - void level_up_messages_calls(int dst_idx, int dst_cols, int dst_rows, int src_rows, - oclMat *mus, oclMat *mds, oclMat *mls, oclMat *mrs, - int ndisp) - { - int src_idx = (dst_idx + 1) & 1; - - level_up_message_call(dst_idx, dst_cols, dst_rows, src_rows, - mus[src_idx], mus[dst_idx], ndisp); - - level_up_message_call(dst_idx, dst_cols, dst_rows, src_rows, - mds[src_idx], mds[dst_idx], ndisp); - - level_up_message_call(dst_idx, dst_cols, dst_rows, src_rows, - mls[src_idx], mls[dst_idx], ndisp); - - level_up_message_call(dst_idx, dst_cols, dst_rows, src_rows, - mrs[src_idx], mrs[dst_idx], ndisp); - } - ////////////////////////////////////////////////////////////////////////////////// - //////////////////////////////cals_all_iterations_call/////////////////////////// - ///////////////////////////////////////////////////////////////////////////////// - void calc_all_iterations_call(int cols, int rows, oclMat &u, oclMat &d, - oclMat &l, oclMat &r, oclMat &data, - int t, int cndisp, float cmax_disc_term, - float cdisc_single_jump) - { - Context *clCxt = l.clCxt; - int data_type = u.type(); - - string kernelName = "one_iteration_"; - stringstream idxStr; - if(data_type == CV_16S) - idxStr << "0"; - else - idxStr << "1"; - kernelName += idxStr.str(); - - cl_kernel kernel = openCLGetKernelFromSource(clCxt, &stereobp, kernelName); - - size_t blockSize = 32; - size_t localThreads[] = {32, 8}; - size_t globalThreads[] = {divUp(cols, (localThreads[0] << 1)) * (localThreads[0] << 1), - divUp(rows, localThreads[1]) * localThreads[1] - }; - - openCLVerifyKernel(clCxt, kernel, &blockSize, globalThreads, localThreads); - openCLSafeCall(clSetKernelArg(kernel, 0, sizeof(cl_mem), (void *)&u.data)); - openCLSafeCall(clSetKernelArg(kernel, 1, sizeof(cl_int), (void *)&u.step)); - openCLSafeCall(clSetKernelArg(kernel, 2, sizeof(cl_int), (void *)&u.cols)); - openCLSafeCall(clSetKernelArg(kernel, 3, sizeof(cl_mem), (void *)&data.data)); - openCLSafeCall(clSetKernelArg(kernel, 4, sizeof(cl_int), (void *)&data.step)); - openCLSafeCall(clSetKernelArg(kernel, 5, sizeof(cl_int), (void *)&data.cols)); - openCLSafeCall(clSetKernelArg(kernel, 6, sizeof(cl_mem), (void *)&d.data)); - openCLSafeCall(clSetKernelArg(kernel, 7, sizeof(cl_mem), (void *)&l.data)); - openCLSafeCall(clSetKernelArg(kernel, 8, sizeof(cl_mem), (void *)&r.data)); - openCLSafeCall(clSetKernelArg(kernel, 9, sizeof(cl_int), (void *)&t)); - openCLSafeCall(clSetKernelArg(kernel, 10, sizeof(cl_int), (void *)&cols)); - openCLSafeCall(clSetKernelArg(kernel, 11, sizeof(cl_int), (void *)&rows)); - openCLSafeCall(clSetKernelArg(kernel, 12, sizeof(cl_int), (void *)&cndisp)); - openCLSafeCall(clSetKernelArg(kernel, 13, sizeof(cl_float), (void *)&cmax_disc_term)); - openCLSafeCall(clSetKernelArg(kernel, 14, sizeof(cl_float), (void *)&cdisc_single_jump)); - - openCLSafeCall(clEnqueueNDRangeKernel(clCxt->impl->clCmdQueue, kernel, 2, NULL, - globalThreads, localThreads, 0, NULL, NULL)); - - clFinish(clCxt->impl->clCmdQueue); - openCLSafeCall(clReleaseKernel(kernel)); - } - - void calc_all_iterations_calls(int cols, int rows, int iters, oclMat &u, - oclMat &d, oclMat &l, oclMat &r, - oclMat &data, int cndisp, float cmax_disc_term, - float cdisc_single_jump) - { - for(int t = 0; t < iters; ++t) - calc_all_iterations_call(cols, rows, u, d, l, r, data, t, cndisp, - cmax_disc_term, cdisc_single_jump); - } - /////////////////////////////////////////////////////////////////////////////// - ///////////////////////output/////////////////////////////////////////////////// - //////////////////////////////////////////////////////////////////////////////// - void output_call(const oclMat &u, const oclMat &d, const oclMat l, const oclMat &r, - const oclMat &data, oclMat &disp, int ndisp) - { - Context *clCxt = u.clCxt; - int data_type = u.type(); - - string kernelName = "output_"; - stringstream idxStr; - if(data_type == CV_16S) - idxStr << "0"; - else - idxStr << "1"; - kernelName += idxStr.str(); - - cl_kernel kernel = openCLGetKernelFromSource(clCxt, &stereobp, kernelName); - - size_t blockSize = 32; - size_t localThreads[] = {32, 8}; - size_t globalThreads[] = {divUp(disp.cols, localThreads[0]) * localThreads[0], - divUp(disp.rows, localThreads[1]) * localThreads[1] - }; - - openCLVerifyKernel(clCxt, kernel, &blockSize, globalThreads, localThreads); - openCLSafeCall(clSetKernelArg(kernel, 0, sizeof(cl_mem), (void *)&u.data)); - openCLSafeCall(clSetKernelArg(kernel, 1, sizeof(cl_int), (void *)&u.step)); - openCLSafeCall(clSetKernelArg(kernel, 2, sizeof(cl_int), (void *)&u.cols)); - openCLSafeCall(clSetKernelArg(kernel, 3, sizeof(cl_mem), (void *)&d.data)); - openCLSafeCall(clSetKernelArg(kernel, 4, sizeof(cl_mem), (void *)&l.data)); - openCLSafeCall(clSetKernelArg(kernel, 5, sizeof(cl_mem), (void *)&r.data)); - openCLSafeCall(clSetKernelArg(kernel, 6, sizeof(cl_mem), (void *)&data.data)); - openCLSafeCall(clSetKernelArg(kernel, 7, sizeof(cl_mem), (void *)&disp.data)); - openCLSafeCall(clSetKernelArg(kernel, 8, sizeof(cl_int), (void *)&disp.rows)); - openCLSafeCall(clSetKernelArg(kernel, 9, sizeof(cl_int), (void *)&disp.cols)); - openCLSafeCall(clSetKernelArg(kernel, 10, sizeof(cl_int), (void *)&disp.step)); - openCLSafeCall(clSetKernelArg(kernel, 11, sizeof(cl_int), (void *)&ndisp)); - - openCLSafeCall(clEnqueueNDRangeKernel(clCxt->impl->clCmdQueue, kernel, 2, NULL, - globalThreads, localThreads, 0, NULL, NULL)); - - clFinish(clCxt->impl->clCmdQueue); - openCLSafeCall(clReleaseKernel(kernel)); - - } - } - } -} -namespace -{ - const float DEFAULT_MAX_DATA_TERM = 10.0f; - const float DEFAULT_DATA_WEIGHT = 0.07f; - const float DEFAULT_MAX_DISC_TERM = 1.7f; - const float DEFAULT_DISC_SINGLE_JUMP = 1.0f; - - template - void print_gpu_mat(const oclMat &mat) - { - T *data_1 = new T[mat.rows * mat.cols * mat.channels()]; - Context *clCxt = mat.clCxt; - int status = clEnqueueReadBuffer(clCxt -> impl-> clCmdQueue, (cl_mem)mat.data, CL_TRUE, 0, - mat.rows * mat.cols * mat.channels() * sizeof(T), data_1, 0, NULL, NULL); - - if(status != CL_SUCCESS) - cout << "error " << status << endl; - - cout << ".........................................................." << endl; - cout << "elemSize() " << mat.elemSize() << endl; - cout << "elemSize() " << mat.elemSize1() << endl; - cout << "channels: " << mat.channels() << endl; - cout << "rows: " << mat.rows << endl; - cout << "cols: " << mat.cols << endl; - - for(int i = 0; i < 30; i++) - { - for(int j = 0; j < 30; j++) - { - cout << (int)data_1[i * mat.cols * mat.channels() + j] << " "; - } - cout << endl; - } - } -} - -void cv::ocl::StereoBeliefPropagation::estimateRecommendedParams(int width, int height, int &ndisp, int &iters, int &levels) -{ - ndisp = width / 4; - if ((ndisp & 1) != 0) - ndisp++; - - int mm = ::max(width, height); - iters = mm / 100 + 2; - - levels = (int)(::log(static_cast(mm)) + 1) * 4 / 5; - if (levels == 0) levels++; -} - -cv::ocl::StereoBeliefPropagation::StereoBeliefPropagation(int ndisp_, int iters_, int levels_, int msg_type_) - : ndisp(ndisp_), iters(iters_), levels(levels_), - max_data_term(DEFAULT_MAX_DATA_TERM), data_weight(DEFAULT_DATA_WEIGHT), - max_disc_term(DEFAULT_MAX_DISC_TERM), disc_single_jump(DEFAULT_DISC_SINGLE_JUMP), - msg_type(msg_type_), datas(levels_) -{ -} - -cv::ocl::StereoBeliefPropagation::StereoBeliefPropagation(int ndisp_, int iters_, int levels_, float max_data_term_, float data_weight_, float max_disc_term_, float disc_single_jump_, int msg_type_) - : ndisp(ndisp_), iters(iters_), levels(levels_), - max_data_term(max_data_term_), data_weight(data_weight_), - max_disc_term(max_disc_term_), disc_single_jump(disc_single_jump_), - msg_type(msg_type_), datas(levels_) -{ -} - -namespace -{ - class StereoBeliefPropagationImpl - { - public: - StereoBeliefPropagationImpl(StereoBeliefPropagation &rthis_, - oclMat &u_, oclMat &d_, oclMat &l_, oclMat &r_, - oclMat &u2_, oclMat &d2_, oclMat &l2_, oclMat &r2_, - vector& datas_, oclMat &out_) - : rthis(rthis_), u(u_), d(d_), l(l_), r(r_), u2(u2_), d2(d2_), l2(l2_), r2(r2_), datas(datas_), out(out_), - zero(Scalar::all(0)), scale(rthis_.msg_type == CV_32F ? 1.0f : 10.0f) - { - CV_Assert(0 < rthis.ndisp && 0 < rthis.iters && 0 < rthis.levels); - CV_Assert(rthis.msg_type == CV_32F || rthis.msg_type == CV_16S); - CV_Assert(rthis.msg_type == CV_32F || (1 << (rthis.levels - 1)) * scale * rthis.max_data_term < numeric_limits::max()); - } - - void operator()(const oclMat &left, const oclMat &right, oclMat &disp) - { - CV_Assert(left.size() == right.size() && left.type() == right.type()); - CV_Assert(left.type() == CV_8UC1 || left.type() == CV_8UC3 || left.type() == CV_8UC4); - - rows = left.rows; - cols = left.cols; - - int divisor = (int)pow(2.f, rthis.levels - 1.0f); - int lowest_cols = cols / divisor; - int lowest_rows = rows / divisor; - const int min_image_dim_size = 2; - CV_Assert(min(lowest_cols, lowest_rows) > min_image_dim_size); - - init(); - - datas[0].create(rows * rthis.ndisp, cols, rthis.msg_type); - datas[0].setTo(Scalar_::all(0)); - - cv::ocl::stereoBP::comp_data_call(left, right, datas[0], rthis.ndisp, rthis.max_data_term, scale * rthis.data_weight); - - calcBP(disp); - } - - void operator()(const oclMat &data, oclMat &disp) - { - CV_Assert((data.type() == rthis.msg_type) && (data.rows % rthis.ndisp == 0)); - - rows = data.rows / rthis.ndisp; - cols = data.cols; - - int divisor = (int)pow(2.f, rthis.levels - 1.0f); - int lowest_cols = cols / divisor; - int lowest_rows = rows / divisor; - const int min_image_dim_size = 2; - CV_Assert(min(lowest_cols, lowest_rows) > min_image_dim_size); - - init(); - - datas[0] = data; - - calcBP(disp); - } - private: - void init() - { - u.create(rows * rthis.ndisp, cols, rthis.msg_type); - d.create(rows * rthis.ndisp, cols, rthis.msg_type); - l.create(rows * rthis.ndisp, cols, rthis.msg_type); - r.create(rows * rthis.ndisp, cols, rthis.msg_type); - - if (rthis.levels & 1) - { - //can clear less area - u = zero; - d = zero; - l = zero; - r = zero; - } - - if (rthis.levels > 1) - { - int less_rows = (rows + 1) / 2; - int less_cols = (cols + 1) / 2; - - u2.create(less_rows * rthis.ndisp, less_cols, rthis.msg_type); - d2.create(less_rows * rthis.ndisp, less_cols, rthis.msg_type); - l2.create(less_rows * rthis.ndisp, less_cols, rthis.msg_type); - r2.create(less_rows * rthis.ndisp, less_cols, rthis.msg_type); - - if ((rthis.levels & 1) == 0) - { - u2 = zero; - d2 = zero; - l2 = zero; - r2 = zero; - } - } - - cv::ocl::stereoBP::load_constants(u.clCxt, rthis.ndisp, rthis.max_data_term, scale * rthis.data_weight, - scale * rthis.max_disc_term, scale * rthis.disc_single_jump); - - datas.resize(rthis.levels); - - cols_all.resize(rthis.levels); - rows_all.resize(rthis.levels); - - cols_all[0] = cols; - rows_all[0] = rows; - } - - void calcBP(oclMat &disp) - { - using namespace cv::ocl::stereoBP; - - for (int i = 1; i < rthis.levels; ++i) - { - cols_all[i] = (cols_all[i-1] + 1) / 2; - rows_all[i] = (rows_all[i-1] + 1) / 2; - - datas[i].create(rows_all[i] * rthis.ndisp, cols_all[i], rthis.msg_type); - datas[i].setTo(Scalar_::all(0)); - - data_step_down_call(cols_all[i], rows_all[i], rows_all[i-1], - datas[i-1], datas[i], rthis.ndisp); - } - - oclMat mus[] = {u, u2}; - oclMat mds[] = {d, d2}; - oclMat mrs[] = {r, r2}; - oclMat mls[] = {l, l2}; - - int mem_idx = (rthis.levels & 1) ? 0 : 1; - - for (int i = rthis.levels - 1; i >= 0; --i) - { - // for lower level we have already computed messages by setting to zero - if (i != rthis.levels - 1) - level_up_messages_calls(mem_idx, cols_all[i], rows_all[i], rows_all[i+1], - mus, mds, mls, mrs, rthis.ndisp); - - calc_all_iterations_calls(cols_all[i], rows_all[i], rthis.iters, mus[mem_idx], - mds[mem_idx], mls[mem_idx], mrs[mem_idx], datas[i], - rthis.ndisp, scale * rthis.max_disc_term, - scale * rthis.disc_single_jump); - - mem_idx = (mem_idx + 1) & 1; - } - - if (disp.empty()) - disp.create(rows, cols, CV_16S); - - out = ((disp.type() == CV_16S) ? disp : (out.create(rows, cols, CV_16S), out)); - out = zero; - - output_call(u, d, l, r, datas.front(), out, rthis.ndisp); - - - if (disp.type() != CV_16S) - out.convertTo(disp, disp.type()); - - release_constants(); - } - - StereoBeliefPropagation &rthis; - - oclMat &u; - oclMat &d; - oclMat &l; - oclMat &r; - - oclMat &u2; - oclMat &d2; - oclMat &l2; - oclMat &r2; - - vector& datas; - oclMat &out; - - const Scalar zero; - const float scale; - - int rows, cols; - - vector cols_all, rows_all; - }; -} - -void cv::ocl::StereoBeliefPropagation::operator()(const oclMat &left, const oclMat &right, oclMat &disp) -{ - ::StereoBeliefPropagationImpl impl(*this, u, d, l, r, u2, d2, l2, r2, datas, out); - impl(left, right, disp); -} - -void cv::ocl::StereoBeliefPropagation::operator()(const oclMat &data, oclMat &disp) -{ - ::StereoBeliefPropagationImpl impl(*this, u, d, l, r, u2, d2, l2, r2, datas, out); - impl(data, disp); -} -#endif /* !defined (HAVE_OPENCL) */ diff --git a/modules/ocl/src/surf.cpp b/modules/ocl/src/surf.cpp index af744ff781..3f015e297e 100644 --- a/modules/ocl/src/surf.cpp +++ b/modules/ocl/src/surf.cpp @@ -122,7 +122,8 @@ namespace SURF_OCL_Invoker(SURF_OCL& surf, const oclMat& img, const oclMat& mask) : surf_(surf), img_cols(img.cols), img_rows(img.rows), - use_mask(!mask.empty()) + use_mask(!mask.empty()), + imgTex(NULL), sumTex(NULL), maskSumTex(NULL) { CV_Assert(!img.empty() && img.type() == CV_8UC1); CV_Assert(mask.empty() || (mask.size() == img.size() && mask.type() == CV_8UC1)); @@ -475,6 +476,11 @@ void SURF_OCL_Invoker::bindImgTex(const oclMat& img) format.image_channel_data_type = CL_UNSIGNED_INT8; format.image_channel_order = CL_R; + if(imgTex) + { + openCLFree(imgTex); + } + #if CL_VERSION_1_2 cl_image_desc desc; desc.image_type = CL_MEM_OBJECT_IMAGE2D; @@ -509,6 +515,12 @@ void SURF_OCL_Invoker::bindSumTex(const oclMat& sum) int err; format.image_channel_data_type = CL_UNSIGNED_INT32; format.image_channel_order = CL_R; + + if(sumTex) + { + openCLFree(sumTex); + } + #if CL_VERSION_1_2 cl_image_desc desc; desc.image_type = CL_MEM_OBJECT_IMAGE2D; @@ -542,6 +554,12 @@ void SURF_OCL_Invoker::bindMaskSumTex(const oclMat& maskSum) int err; format.image_channel_data_type = CL_UNSIGNED_INT32; format.image_channel_order = CL_R; + + if(maskSumTex) + { + openCLFree(maskSumTex); + } + #if CL_VERSION_1_2 cl_image_desc desc; desc.image_type = CL_MEM_OBJECT_IMAGE2D; diff --git a/modules/ocl/test/test_imgproc.cpp b/modules/ocl/test/test_imgproc.cpp index 73ff7d18af..9c15e40291 100644 --- a/modules/ocl/test/test_imgproc.cpp +++ b/modules/ocl/test/test_imgproc.cpp @@ -562,7 +562,7 @@ TEST_P(cornerMinEigenVal, Mat) { random_roi(); - int blockSize = 7, apertureSize = 1 + 2 * (rand() % 4); + int blockSize = 7, apertureSize = 3;//1 + 2 * (rand() % 4); //int borderType = cv::BORDER_CONSTANT; //int borderType = cv::BORDER_REPLICATE; int borderType = cv::BORDER_REFLECT; @@ -942,7 +942,7 @@ TEST_P(Remap, Mat) { if((interpolation == 1 && map1Type == CV_16SC2) ||(map1Type == CV_32FC1 && map2Type == nulltype) || (map1Type == CV_16SC2 && map2Type == CV_32FC1) || (map1Type == CV_32FC2 && map2Type == CV_32FC1)) { - cout << "LINEAR don't support the map1Type and map2Type" << endl; + cout << "Don't support the dataType" << endl; return; } int bordertype[] = {cv::BORDER_CONSTANT,cv::BORDER_REPLICATE/*,BORDER_REFLECT,BORDER_WRAP,BORDER_REFLECT_101*/}; @@ -960,7 +960,9 @@ TEST_P(Remap, Mat) sprintf(sss, "src_roicols=%d,src_roirows=%d,dst_roicols=%d,dst_roirows=%d,src1x =%d,src1y=%d,dstx=%d,dsty=%d", src_roicols, src_roirows, dst_roicols, dst_roirows, srcx, srcy, dstx, dsty); - EXPECT_MAT_NEAR(dst, cpu_dst, 1.0, sss); + if(interpolation == 0) + EXPECT_MAT_NEAR(dst, cpu_dst, 1.0, sss); + EXPECT_MAT_NEAR(dst, cpu_dst, 2.0, sss); } } @@ -1433,6 +1435,147 @@ TEST_P(calcHist, Mat) } } +///////////////////////////Convolve////////////////////////////////// +PARAM_TEST_CASE(ConvolveTestBase, MatType, bool) +{ + int type; + //src mat + cv::Mat mat1; + cv::Mat mat2; + cv::Mat dst; + cv::Mat dst1; //bak, for two outputs + // set up roi + int roicols; + int roirows; + int src1x; + int src1y; + int src2x; + int src2y; + int dstx; + int dsty; + //src mat with roi + cv::Mat mat1_roi; + cv::Mat mat2_roi; + cv::Mat dst_roi; + cv::Mat dst1_roi; //bak + //ocl dst mat for testing + cv::ocl::oclMat gdst_whole; + cv::ocl::oclMat gdst1_whole; //bak + //ocl mat with roi + cv::ocl::oclMat gmat1; + cv::ocl::oclMat gmat2; + cv::ocl::oclMat gdst; + cv::ocl::oclMat gdst1; //bak + virtual void SetUp() + { + type = GET_PARAM(0); + + cv::RNG &rng = TS::ptr()->get_rng(); + + cv::Size size(MWIDTH, MHEIGHT); + + mat1 = randomMat(rng, size, type, 5, 16, false); + mat2 = randomMat(rng, size, type, 5, 16, false); + dst = randomMat(rng, size, type, 5, 16, false); + dst1 = randomMat(rng, size, type, 5, 16, false); + } + void random_roi() + { + cv::RNG &rng = TS::ptr()->get_rng(); + +#ifdef RANDOMROI + //randomize ROI + roicols = rng.uniform(1, mat1.cols); + roirows = rng.uniform(1, mat1.rows); + src1x = rng.uniform(0, mat1.cols - roicols); + src1y = rng.uniform(0, mat1.rows - roirows); + dstx = rng.uniform(0, dst.cols - roicols); + dsty = rng.uniform(0, dst.rows - roirows); +#else + roicols = mat1.cols; + roirows = mat1.rows; + src1x = 0; + src1y = 0; + dstx = 0; + dsty = 0; +#endif + src2x = rng.uniform(0, mat2.cols - roicols); + src2y = rng.uniform(0, mat2.rows - roirows); + mat1_roi = mat1(Rect(src1x, src1y, roicols, roirows)); + mat2_roi = mat2(Rect(src2x, src2y, roicols, roirows)); + dst_roi = dst(Rect(dstx, dsty, roicols, roirows)); + dst1_roi = dst1(Rect(dstx, dsty, roicols, roirows)); + + gdst_whole = dst; + gdst = gdst_whole(Rect(dstx, dsty, roicols, roirows)); + + gdst1_whole = dst1; + gdst1 = gdst1_whole(Rect(dstx, dsty, roicols, roirows)); + + gmat1 = mat1_roi; + gmat2 = mat2_roi; + //end + } + +}; +struct Convolve : ConvolveTestBase {}; + +void conv2( cv::Mat x, cv::Mat y, cv::Mat z) +{ + int N1 = x.rows; + int M1 = x.cols; + int N2 = y.rows; + int M2 = y.cols; + + int i,j; + int m,n; + + + float *kerneldata = (float *)(x.data); + float *srcdata = (float *)(y.data); + float *dstdata = (float *)(z.data); + + for(i=0;i>2)+n]*srcdata[r*(y.step>>2)+c]; + } + dstdata[i*(z.step >> 2)+j]=temp; + } +} +TEST_P(Convolve, Mat) +{ + if(mat1.type()!=CV_32FC1) + { + cout<<"\tUnsupported type\t\n"; + } + for(int j=0;j