static bool ocl_fastNlMeansDenoising(InputArray _src, OutputArray _dst, float h,
int templateWindowSize, int searchWindowSize)
{
int type = _src.type(), cn = CV_MAT_CN(type);
Size size = _src.size();
if ( type != CV_8UC1 || type != CV_8UC2 || type != CV_8UC4 )
return false;
int templateWindowHalfWize = templateWindowSize / 2;
int searchWindowHalfSize = searchWindowSize / 2;
templateWindowSize = templateWindowHalfWize * 2 + 1;
searchWindowSize = searchWindowHalfSize * 2 + 1;
int nblocksx = divUp(size.width, BLOCK_COLS), nblocksy = divUp(size.height, BLOCK_ROWS);
int almostTemplateWindowSizeSqBinShift = -1;
char cvt[2][40];
String opts = format("-D OP_CALC_FASTNLMEANS -D TEMPLATE_SIZE=%d -D SEARCH_SIZE=%d"
" -D uchar_t=%s -D int_t=%s -D BLOCK_COLS=%d -D BLOCK_ROWS=%d"
" -D CTA_SIZE=%d -D TEMPLATE_SIZE2=%d -D SEARCH_SIZE2=%d"
" -D convert_int_t=%s -D cn=%d -D CTA_SIZE2=%d -D convert_uchar_t=%s",
templateWindowSize, searchWindowSize, ocl::typeToStr(type),
ocl::typeToStr(CV_32SC(cn)), BLOCK_COLS, BLOCK_ROWS, CTA_SIZE,
templateWindowHalfWize, searchWindowHalfSize,
ocl::convertTypeStr(CV_8U, CV_32S, cn, cvt[0]), cn,
CTA_SIZE >> 1, ocl::convertTypeStr(CV_32S, CV_8U, cn, cvt[1]));
ocl::Kernel k("fastNlMeansDenoising", ocl::photo::nlmeans_oclsrc, opts);
if (k.empty())
return false;
UMat almostDist2Weight;
if (!ocl_calcAlmostDist2Weight<float>(almostDist2Weight, searchWindowSize, templateWindowSize, h, cn,
almostTemplateWindowSizeSqBinShift))
return false;
CV_Assert(almostTemplateWindowSizeSqBinShift >= 0);
UMat srcex;
int borderSize = searchWindowHalfSize + templateWindowHalfWize;
copyMakeBorder(_src, srcex, borderSize, borderSize, borderSize, borderSize, BORDER_DEFAULT);
_dst.create(size, type);
UMat dst = _dst.getUMat();
int searchWindowSizeSq = searchWindowSize * searchWindowSize;
Size upColSumSize(size.width, searchWindowSizeSq * nblocksy);
Size colSumSize(nblocksx * templateWindowSize, searchWindowSizeSq * nblocksy);
UMat buffer(upColSumSize + colSumSize, CV_32SC(cn));
srcex = srcex(Rect(Point(borderSize, borderSize), size));
k.args(ocl::KernelArg::ReadOnlyNoSize(srcex), ocl::KernelArg::WriteOnly(dst),
ocl::KernelArg::PtrReadOnly(almostDist2Weight),
ocl::KernelArg::PtrReadOnly(buffer), almostTemplateWindowSizeSqBinShift);
size_t globalsize[2] = { nblocksx * CTA_SIZE, nblocksy }, localsize[2] = { CTA_SIZE, 1 };
return k.run(2, globalsize, localsize, false);
}
/**
* Convert gdal type to opencv type
*/
int KGDAL2CV::gdal2opencv(const GDALDataType& gdalType, const int& channels){
switch (gdalType){
/// UInt8
case GDT_Byte:
if (channels == 1){ return CV_8UC1; }
if (channels == 3){ return CV_8UC3; }
if (channels == 4){ return CV_8UC4; }
else { return CV_8UC(channels); }
return -1;
/// UInt16
case GDT_UInt16:
if (channels == 1){ return CV_16UC1; }
if (channels == 3){ return CV_16UC3; }
if (channels == 4){ return CV_16UC4; }
else { return CV_16UC(channels); }
return -1;
/// Int16
case GDT_Int16:
if (channels == 1){ return CV_16SC1; }
if (channels == 3){ return CV_16SC3; }
if (channels == 4){ return CV_16SC4; }
else { return CV_16SC(channels); }
return -1;
/// UInt32
case GDT_UInt32:
case GDT_Int32:
if (channels == 1){ return CV_32SC1; }
if (channels == 3){ return CV_32SC3; }
if (channels == 4){ return CV_32SC4; }
else { return CV_32SC(channels); }
return -1;
case GDT_Float32:
if (channels == 1){ return CV_32FC1; }
if (channels == 3){ return CV_32FC3; }
if (channels == 4){ return CV_32FC4; }
else { return CV_32FC(channels); }
return -1;
case GDT_Float64:
if (channels == 1){ return CV_64FC1; }
if (channels == 3){ return CV_64FC3; }
if (channels == 4){ return CV_64FC4; }
else { return CV_64FC(channels); }
return -1;
default:
std::cout << "Unknown GDAL Data Type" << std::endl;
std::cout << "Type: " << GDALGetDataTypeName(gdalType) << std::endl;
return -1;
}
return -1;
}
bool SurfFaceDetection::CalculateSurfSumImg(const Mat &_grayImg)
{
CV_Assert(_grayImg.type() == CV_8U && !_grayImg.empty());
imgOrg = _grayImg;
Mat img;
if(_grayImg.size().width > maxImgSize.width || _grayImg.size().height > maxImgSize.height)
{
double scale = cv::min( (double)maxImgSize.height / _grayImg.size().height, (double)maxImgSize.width / _grayImg.size().width);
srcScale = scale;
Size reSize((int)(_grayImg.size().width * scale + 0.5), (int)(_grayImg.size().height * scale + 0.5));
resize(_grayImg, img, reSize);
}else
{
img = _grayImg;
srcScale = 1.0;
}
imgSize = img.size();
cv::Mat rowImg(img.size(), CV_16SC1);
cv::Mat colImg(img.size(), CV_16SC1);
rowFilter->apply(img, rowImg);
colFilter->apply(img, colImg);
std::vector<cv::Mat> splitImg(8);
cv::Mat mergeImg(img.size(), CV_32SC(8));
//Mat sumImg(img.size() + Size(1,1), CV_64FC(8), sumCache.ptr(0,0));
Mat sumImg(sumCache,Rect(0,0,imgSize.width+1, imgSize.height+1));
cv::Mat dyM = cv::Mat_<short>((colImg < 0) / 255);
cv::Mat dxM = cv::Mat_<short>((rowImg < 0) / 255);
splitImg[0] = rowImg.mul(dyM); //dx when dy<0
splitImg[1] = rowImg.mul(1 - dyM); //dx when dy>=0
splitImg[2] = cv::abs(rowImg).mul(dyM); //abs(dx) when dy<0
splitImg[3] = cv::abs(rowImg).mul(1-dyM); //abs(dx) when dy>=0
splitImg[4] = colImg.mul(dxM); //dy when dx<0
splitImg[5] = colImg.mul(1 - dxM); //dy when dx>=0
splitImg[6] = cv::abs(colImg).mul(dxM); //abs(dy) when dx<0
splitImg[7] = cv::abs(colImg).mul(1 - dxM); //abs(dy) when dx>=0
cv::merge(splitImg, mergeImg);
mergeImg = cv::Mat_<cv::Vec<float,8>>(mergeImg);
cv::integral(mergeImg, sumImg);
return true;
}
void BagOfWordsSlic::ComputeVisualWordHistograms(int half_window_height, int half_window_width, const Mat& visual_word_map) {
Mat accumulated_arrays(visual_word_map.size(),CV_32SC(KCENTERS));
const unsigned short* visual_word_map_row;
Vec50s* this_row;
Vec50s* prev_row;
int upper_val, left_val, upper_left_val;
for(int i = 0; i < visual_word_map.rows; ++i) {
visual_word_map_row = visual_word_map.ptr<unsigned short>(i);
this_row = accumulated_arrays.ptr<Vec50s>(i);
if(i > 0) prev_row = accumulated_arrays.ptr<Vec50s>(i - 1);
for(int j = 0; j < visual_word_map.cols; ++j)
for(int k = 0; k < KCENTERS; ++k) {
upper_val = i > 0 ? prev_row[j][k] : 0;
left_val = j > 0 ? this_row[j-1][k] : 0;
upper_left_val = (i > 0 && j > 0) ? prev_row[j-1][k] : 0;
this_row[j][k] = upper_val + left_val - upper_left_val + (k == visual_word_map_row[j]);
}
}
visual_word_histogram_matrix_.create(visual_word_map.size(),CV_64FC(KCENTERS));
Vec50d* visual_word_histogram_row;
Vec50s* window_bottom;
Vec50s* window_top;
int top_ind, bottom_ind, left_ind, right_ind;
double window_area;
for(int i = 0; i < visual_word_histogram_matrix_.rows; ++i) {
top_ind = max(i - half_window_height - 1, 0);
window_top = accumulated_arrays.ptr<Vec50s>(top_ind);
bottom_ind = min(i + half_window_height, im_height_ - 1);
window_bottom = accumulated_arrays.ptr<Vec50s>(bottom_ind);
visual_word_histogram_row = visual_word_histogram_matrix_.ptr<Vec50d>(i);
for(int j = 0; j < visual_word_histogram_matrix_.cols; ++j) {
left_ind = max(0, j - half_window_width - 1);
right_ind = min(im_width_-1, j + half_window_width);
visual_word_histogram_row[j] = window_bottom[right_ind] + window_top[left_ind] - (window_top[right_ind] + window_bottom[left_ind]);
window_area = (right_ind - left_ind) * (bottom_ind - top_ind);
visual_word_histogram_row[j] /= window_area;
}
}
}
CV_IMPL void cvFindStereoCorrespondenceGC(const CvArr* _left, const CvArr* _right,
CvArr* _dispLeft, CvArr* _dispRight, CvStereoGCState* state, int useDisparityGuess) {
CvStereoGCState2 state2;
state2.orphans = 0;
state2.maxOrphans = 0;
CvMat lstub, *left = cvGetMat(_left, &lstub);
CvMat rstub, *right = cvGetMat(_right, &rstub);
CvMat dlstub, *dispLeft = cvGetMat(_dispLeft, &dlstub);
CvMat drstub, *dispRight = cvGetMat(_dispRight, &drstub);
CvSize size;
int iter, i, nZeroExpansions = 0;
CvRNG rng = cvRNG(-1);
int* disp;
CvMat _disp;
int64 E;
CV_Assert(state != 0);
CV_Assert(CV_ARE_SIZES_EQ(left, right) && CV_ARE_TYPES_EQ(left, right) &&
CV_MAT_TYPE(left->type) == CV_8UC1);
CV_Assert(!dispLeft ||
(CV_ARE_SIZES_EQ(dispLeft, left) && CV_MAT_CN(dispLeft->type) == 1));
CV_Assert(!dispRight ||
(CV_ARE_SIZES_EQ(dispRight, left) && CV_MAT_CN(dispRight->type) == 1));
size = cvGetSize(left);
if (!state->left || state->left->width != size.width || state->left->height != size.height) {
int pcn = (int)(sizeof(GCVtx*) / sizeof(int));
int vcn = (int)(sizeof(GCVtx) / sizeof(int));
int ecn = (int)(sizeof(GCEdge) / sizeof(int));
cvReleaseMat(&state->left);
cvReleaseMat(&state->right);
cvReleaseMat(&state->ptrLeft);
cvReleaseMat(&state->ptrRight);
cvReleaseMat(&state->dispLeft);
cvReleaseMat(&state->dispRight);
state->left = cvCreateMat(size.height, size.width, CV_8UC3);
state->right = cvCreateMat(size.height, size.width, CV_8UC3);
state->dispLeft = cvCreateMat(size.height, size.width, CV_16SC1);
state->dispRight = cvCreateMat(size.height, size.width, CV_16SC1);
state->ptrLeft = cvCreateMat(size.height, size.width, CV_32SC(pcn));
state->ptrRight = cvCreateMat(size.height, size.width, CV_32SC(pcn));
state->vtxBuf = cvCreateMat(1, size.height * size.width * 2, CV_32SC(vcn));
state->edgeBuf = cvCreateMat(1, size.height * size.width * 12 + 16, CV_32SC(ecn));
}
if (!useDisparityGuess) {
cvSet(state->dispLeft, cvScalarAll(OCCLUDED));
cvSet(state->dispRight, cvScalarAll(OCCLUDED));
} else {
CV_Assert(dispLeft && dispRight);
cvConvert(dispLeft, state->dispLeft);
cvConvert(dispRight, state->dispRight);
}
state2.Ithreshold = state->Ithreshold;
state2.interactionRadius = state->interactionRadius;
state2.lambda = cvRound(state->lambda * DENOMINATOR);
state2.lambda1 = cvRound(state->lambda1 * DENOMINATOR);
state2.lambda2 = cvRound(state->lambda2 * DENOMINATOR);
state2.K = cvRound(state->K * DENOMINATOR);
icvInitStereoConstTabs();
icvInitGraySubpix(left, right, state->left, state->right);
disp = (int*)cvStackAlloc(state->numberOfDisparities * sizeof(disp[0]));
_disp = cvMat(1, state->numberOfDisparities, CV_32S, disp);
cvRange(&_disp, state->minDisparity, state->minDisparity + state->numberOfDisparities);
cvRandShuffle(&_disp, &rng);
if (state2.lambda < 0 && (state2.K < 0 || state2.lambda1 < 0 || state2.lambda2 < 0)) {
float L = icvComputeK(state) * 0.2f;
state2.lambda = cvRound(L * DENOMINATOR);
}
if (state2.K < 0) {
state2.K = state2.lambda * 5;
}
if (state2.lambda1 < 0) {
state2.lambda1 = state2.lambda * 3;
}
if (state2.lambda2 < 0) {
state2.lambda2 = state2.lambda;
}
icvInitStereoTabs(&state2);
E = icvComputeEnergy(state, &state2, !useDisparityGuess);
for (iter = 0; iter < state->maxIters; iter++) {
for (i = 0; i < state->numberOfDisparities; i++) {
int alpha = disp[i];
int64 Enew = icvAlphaExpand(E, -alpha, state, &state2);
if (Enew < E) {
nZeroExpansions = 0;
E = Enew;
} else if (++nZeroExpansions >= state->numberOfDisparities) {
break;
}
}
}
if (dispLeft) {
cvConvert(state->dispLeft, dispLeft);
}
if (dispRight) {
cvConvert(state->dispRight, dispRight);
}
cvFree(&state2.orphans);
}
