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;
}
Exemple #2
0
void cv::fastNlMeansDenoisingColored( InputArray _src, OutputArray _dst,
                                      float h, float hForColorComponents,
                                      int templateWindowSize, int searchWindowSize)
{
    Mat src = _src.getMat();
    _dst.create(src.size(), src.type());
    Mat dst = _dst.getMat();

    if (src.type() != CV_8UC3) {
        CV_Error(CV_StsBadArg, "Type of input image should be CV_8UC3!");
        return;
    }

    Mat src_lab;
    cvtColor(src, src_lab, CV_LBGR2Lab);

    Mat l(src.size(), CV_8U);
    Mat ab(src.size(), CV_8UC2);
    Mat l_ab[] = { l, ab };
    int from_to[] = { 0,0, 1,1, 2,2 };
    mixChannels(&src_lab, 1, l_ab, 2, from_to, 3);

    fastNlMeansDenoising(l, l, h, templateWindowSize, searchWindowSize);
    fastNlMeansDenoising(ab, ab, hForColorComponents, templateWindowSize, searchWindowSize);

    Mat l_ab_denoised[] = { l, ab };
    Mat dst_lab(src.size(), src.type());
    mixChannels(l_ab_denoised, 2, &dst_lab, 1, from_to, 3);

    cvtColor(dst_lab, dst, CV_Lab2LBGR);
}
Exemple #3
0
void cv::fastNlMeansDenoisingColored( InputArray _src, OutputArray _dst,
                                      float h, float hForColorComponents,
                                      int templateWindowSize, int searchWindowSize)
{
    int type = _src.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);

    if (type != CV_8UC3 && type != CV_8UC4)
    {
        CV_Error(Error::StsBadArg, "Type of input image should be CV_8UC3!");
        return;
    }

    CV_OCL_RUN(_src.dims() <= 2 && (_dst.isUMat() || _src.isUMat()),
                ocl_fastNlMeansDenoisingColored(_src, _dst, h, hForColorComponents,
                                                templateWindowSize, searchWindowSize))

    Mat src = _src.getMat();
    _dst.create(src.size(), type);
    Mat dst = _dst.getMat();

    Mat src_lab;
    cvtColor(src, src_lab, COLOR_LBGR2Lab);

    Mat l(src.size(), CV_8U);
    Mat ab(src.size(), CV_8UC2);
    Mat l_ab[] = { l, ab };
    int from_to[] = { 0,0, 1,1, 2,2 };
    mixChannels(&src_lab, 1, l_ab, 2, from_to, 3);

    fastNlMeansDenoising(l, l, h, templateWindowSize, searchWindowSize);
    fastNlMeansDenoising(ab, ab, hForColorComponents, templateWindowSize, searchWindowSize);

    Mat l_ab_denoised[] = { l, ab };
    Mat dst_lab(src.size(), CV_MAKE_TYPE(depth, 3));
    mixChannels(l_ab_denoised, 2, &dst_lab, 1, from_to, 3);

    cvtColor(dst_lab, dst, COLOR_Lab2LBGR, cn);
}
Exemple #4
0
void test8uc1(bool show=false)
{
	Mat src = imread("image.png",0);
	Mat noise;
	Mat dest;
	int64 pre;

	float sigma = 15;
	cout<<"gray"<<endl;
	cout<<"sigma: "<<sigma<<endl;

	cout<<"RAW: "<<endl;
	addNoise(src,noise,sigma);
	cout<<PSNR(src,noise)<<"dB"<<endl;
	cout<<endl;

	cout<<"NML opencv: "<<endl;
	pre = getTickCount();
	fastNlMeansDenoising(noise,dest,sigma,3,7);
	cout<<(getTickCount()-pre)/(getTickFrequency())*1000<<"ms"<<endl;
	cout<<PSNR(src,dest)<<"dB"<<endl;
	cout<<endl;

	cout<<"NML base: "<<endl;
	pre = getTickCount();
	nonLocalMeansFilterBase(noise,dest,3,7,sigma);
	cout<<(getTickCount()-pre)/(getTickFrequency())*1000<<"ms"<<endl;
	cout<<PSNR(src,dest)<<"dB"<<endl;
	cout<<endl;

	cout<<"NML sse4: "<<endl;
	pre = getTickCount();
	nonLocalMeansFilter(noise,dest,3,7,sigma);
	cout<<(getTickCount()-pre)/(getTickFrequency())*1000<<"ms"<<endl;
	cout<<PSNR(src,dest)<<"dB"<<endl;
	cout<<endl;

	if(show)
	{
		imshow("noise",noise);
		imshow("NLM",dest);
		waitKey();
	}
}
Exemple #5
0
/**
 * Main processing function.
 * Read input image and create vector of images for each digit.
 */
void ImageProcessor::process() {
    _digits.clear();
    // convert to gray
    cvtColor(_img, _imgGray, CV_BGR2GRAY);
    fastNlMeansDenoising(_imgGray, _imgGray, 10);
    cv::imshow("Denoising", _imgGray);	
    _imgCalque = imread("./images/calque.png");
    cvtColor(_imgCalque, _imgCalqueGray, CV_BGR2GRAY);
    addWeighted( _imgGray, 0.65, _imgCalqueGray, 0.35, 0.0, _imgGray);
    cv::imshow("ImageProcessor1", _imgGray);
    threshold(_imgGray, _imgGray, 135, 255, 3);	 
     cv::imshow("ImageProcessor2", _imgGray);
    // find and isolate counter digits
    findCounterDigits();

    if (_debugWindow) {
        showImage();
    }
}