static bool ocl_fastNlMeansDenoisingColored( InputArray _src, OutputArray _dst,
float h, float hForColorComponents,
int templateWindowSize, int searchWindowSize)
{
UMat src = _src.getUMat();
_dst.create(src.size(), src.type());
UMat dst = _dst.getUMat();
UMat src_lab;
cvtColor(src, src_lab, COLOR_LBGR2Lab);
UMat l(src.size(), CV_8U);
UMat ab(src.size(), CV_8UC2);
std::vector<UMat> l_ab(2), l_ab_denoised(2);
l_ab[0] = l;
l_ab[1] = ab;
l_ab_denoised[0].create(src.size(), CV_8U);
l_ab_denoised[1].create(src.size(), CV_8UC2);
int from_to[] = { 0,0, 1,1, 2,2 };
mixChannels(std::vector<UMat>(1, src_lab), l_ab, from_to, 3);
fastNlMeansDenoising(l_ab[0], l_ab_denoised[0], h, templateWindowSize, searchWindowSize);
fastNlMeansDenoising(l_ab[1], l_ab_denoised[1], hForColorComponents, templateWindowSize, searchWindowSize);
UMat dst_lab(src.size(), CV_8UC3);
mixChannels(l_ab_denoised, std::vector<UMat>(1, dst_lab), from_to, 3);
cvtColor(dst_lab, dst, COLOR_Lab2LBGR, src.channels());
return true;
}
UMat cv::superres::convertToType(const UMat& src, int type, UMat& buf0, UMat& buf1)
{
CV_INSTRUMENT_REGION();
if (src.type() == type)
return src;
const int depth = CV_MAT_DEPTH(type);
const int cn = CV_MAT_CN(type);
if (src.depth() == depth)
{
convertToCn(src, buf0, cn);
return buf0;
}
if (src.channels() == cn)
{
convertToDepth(src, buf1, depth);
return buf1;
}
convertToCn(src, buf0, cn);
convertToDepth(buf0, buf1, depth);
return buf1;
}
static bool convolve_32F(InputArray _image, InputArray _templ, OutputArray _result)
{
_result.create(_image.rows() - _templ.rows() + 1, _image.cols() - _templ.cols() + 1, CV_32F);
if (_image.channels() == 1)
return(convolve_dft(_image, _templ, _result));
else
{
UMat image = _image.getUMat();
UMat templ = _templ.getUMat();
UMat result_(image.rows-templ.rows+1,(image.cols-templ.cols+1)*image.channels(), CV_32F);
bool ok = convolve_dft(image.reshape(1), templ.reshape(1), result_);
if (ok==false)
return false;
UMat result = _result.getUMat();
return (extractFirstChannel_32F(result_, _result, _image.channels()));
}
}
int main(int argc, const char** argv)
{
// declare capture engine that can read images from camera or file
VideoCapture cap;
// if no cmd-line arguments other than the app name then camera flag is raised
bool camera = (1==argc);
if(camera)
// call open(int) method to init capture engine to read from camera
// In case of many cameras the index of camera can be passed as argument.
cap.open(0);
else
// call open(char*) method to init capture engine to read images from file
// the argument is file name that will be opened for reading
// it can be name of video file or still image
cap.open(argv[1]);
// check that capture engine open source (camera or file) successfully
if (!cap.isOpened())
{
printf("can not open %s\n",camera?"camera":argv[1]);
printf("trying to open test.jpg\n");
// in case of fail try to open simple test file to be able check pipeline working
cap.open("test.jpg");
if (!cap.isOpened())
{
printf("can not open test.jpg\n");
return EXIT_FAILURE;
}
}
// prepare for processing images
// declare mat objects to store input, intermediate and output images
// this is main loop over all input frames
for (;;)
{
// get next frame from input stream
//cap >> imgInp;
imgInp = imread(cap, CV_LOAD_IMAGE_ANYDEPTH);
// check read result
// in case of reading from file the loop will be break after last frame is read and processed
// in case of camera this condition is always false until something wrong with camera
if (imgInp.empty())
{
// wait until user press any key and the break the loop
// we need to wait to ge
waitKey(0);
break;
}
// show the input image on the screen using opencv function
// this call creates window named "Input" and draws imgInp inside the window
imshow("Input", imgInp);
// convert input image into intermediate grayscale image
if (imgInp.channels() > 1)
{
printf("Preceding with blanks: %10d \n", imgInp.channels());
cvtColor(imgInp, imgGray, COLOR_BGR2GRAY);
Mat spl;
split(imgInp, spl);
imshow("spl1", spl[0]);//b
imshow("spl2", spl[1]);//g
imshow("spl3", spl[2]);//r
}
else{ imgGray = imgInp; }
/// Initialize values
alpha_slider = 0;
p2_slider = 0;
// run canny processing on grayscale image
//Canny(imgGray, imgOut, 50, 150);
// show the result on the screen using opencv function
// this call creates window named "Canny" and draw imgOut inside the window
//imshow("Canny", imgOut);
/// Create Windows
namedWindow("Linear Blend",WINDOW_NORMAL);
/// Create Trackbars
char TrackbarName[50];
char TrackbarName2[50];
sprintf(TrackbarName, "Thresh#1 /n x %d", alpha_slider_max);
sprintf(TrackbarName2, "Thresh#2 /n 2 x %d", alpha_slider_max);
//createTrackbar(TrackbarName, "Linear Blend", &alpha_slider, alpha_slider_max, on_trackbar);
createTrackbar(TrackbarName, "Linear Blend", &alpha_slider, alpha_slider_max, on_trackbar_Canny);
createTrackbar(TrackbarName2, "Linear Blend", &p2_slider, p2_slider_max, on_trackbar_Canny);
ps_array[0] = alpha_slider;
ps_array[1] = p2_slider;
/// Show some stuff
on_trackbar_Canny(0,0);
//on_trackbar(alpha_slider, 0);
// the waitKey function is called for 2 reasons
// 1. detect when ESC key is pressed
// 2. to allow "Input" and "Canny" windows to plumb messages. It allows user to manipulate with "Input" and "Canny" windows
// 10ms param is passed to spend only 10ms inside the waitKey function and then go to further processing
int key = waitKey(100);
//exit if ESC is pressed
if (key == 27)
break;
}
return EXIT_SUCCESS;
}
int cv::meanShift( InputArray _probImage, Rect& window, TermCriteria criteria )
{
CV_INSTRUMENT_REGION()
Size size;
int cn;
Mat mat;
UMat umat;
bool isUMat = _probImage.isUMat();
if (isUMat)
umat = _probImage.getUMat(), cn = umat.channels(), size = umat.size();
else
mat = _probImage.getMat(), cn = mat.channels(), size = mat.size();
Rect cur_rect = window;
CV_Assert( cn == 1 );
if( window.height <= 0 || window.width <= 0 )
CV_Error( Error::StsBadArg, "Input window has non-positive sizes" );
window = window & Rect(0, 0, size.width, size.height);
double eps = (criteria.type & TermCriteria::EPS) ? std::max(criteria.epsilon, 0.) : 1.;
eps = cvRound(eps*eps);
int i, niters = (criteria.type & TermCriteria::MAX_ITER) ? std::max(criteria.maxCount, 1) : 100;
for( i = 0; i < niters; i++ )
{
cur_rect = cur_rect & Rect(0, 0, size.width, size.height);
if( cur_rect == Rect() )
{
cur_rect.x = size.width/2;
cur_rect.y = size.height/2;
}
cur_rect.width = std::max(cur_rect.width, 1);
cur_rect.height = std::max(cur_rect.height, 1);
Moments m = isUMat ? moments(umat(cur_rect)) : moments(mat(cur_rect));
// Calculating center of mass
if( fabs(m.m00) < DBL_EPSILON )
break;
int dx = cvRound( m.m10/m.m00 - window.width*0.5 );
int dy = cvRound( m.m01/m.m00 - window.height*0.5 );
int nx = std::min(std::max(cur_rect.x + dx, 0), size.width - cur_rect.width);
int ny = std::min(std::max(cur_rect.y + dy, 0), size.height - cur_rect.height);
dx = nx - cur_rect.x;
dy = ny - cur_rect.y;
cur_rect.x = nx;
cur_rect.y = ny;
// Check for coverage centers mass & window
if( dx*dx + dy*dy < eps )
break;
}
window = cur_rect;
return i;
}
int main(int argc, const char** argv)
{
// get next frame from input stream
//cap >> imgInp;
src = imread(argv[1], CV_LOAD_IMAGE_ANYDEPTH);
src.convertTo(imgInp, CV_8UC1, 0.00390625);
//src.copyTo(imgInp);
std::istringstream iss(argv[1]);
std::vector<std::string> tokens;
std::string token;
while (std::getline(iss, token, '.')) {
if (!token.empty())
tokens.push_back(token);
}
// check read result
// in case of reading from file the loop will be break after last frame is read and processed
// in case of camera this condition is always false until something wrong with camera
// show the input image on the screen using opencv function
// this call creates window named "Input" and draws imgInp inside the window
imshow("Input", imgInp);
// convert input image into intermediate grayscale image
if (imgInp.channels() > 1)
{
printf("Preceding with blanks: %10d \n", imgInp.channels());
cvtColor(imgInp, imgGray, COLOR_BGR2GRAY);
Mat spl;
split(imgInp, spl);
//imshow("spl1", spl[0]);//b
//imshow("spl2", spl[1]);//g
// imshow("spl3", spl[2]);//r
}
else
{
printf("Preceding with blanks: %10d \n", imgInp.channels());
imgGray = imgInp;
}
/// Initialize values
alpha_slider = 0;
p2_slider = 0;
// run canny processing on grayscale image
//Canny(imgGray, imgOut, 50, 150);
// show the result on the screen using opencv function
// this call creates window named "Canny" and draw imgOut inside the window
//imshow("Canny", imgOut);
/// Create Windows
namedWindow("Linear Blend",WINDOW_NORMAL);
/// Create Trackbars
char TrackbarName[50];
char TrackbarName2[50];
sprintf(TrackbarName, "Thresh#1 /n x %d", alpha_slider_max);
sprintf(TrackbarName2, "Thresh#2 /n 2 x %d", alpha_slider_max);
//createTrackbar(TrackbarName, "Linear Blend", &alpha_slider, alpha_slider_max, on_trackbar);
createTrackbar(TrackbarName, "Linear Blend", &alpha_slider, alpha_slider_max, on_trackbar_Canny);
createTrackbar(TrackbarName2, "Linear Blend", &p2_slider, p2_slider_max, on_trackbar_Canny);
ps_array[0] = alpha_slider;
ps_array[1] = p2_slider;
for (;;)
{
/// Show some stuff
on_trackbar_Canny(0, 0);
//on_trackbar(alpha_slider, 0);
// the waitKey function is called for 2 reasons
// 1. detect when ESC key is pressed
// 2. to allow "Input" and "Canny" windows to plumb messages. It allows user to manipulate with "Input" and "Canny" windows
// 10ms param is passed to spend only 10ms inside the waitKey function and then go to further processing
int key = waitKey(100);
//exit if ESC is pressed
if (key == 27)
break;
}
return EXIT_SUCCESS;
}
