Chiebot-Mirror
/
opencv
mirror of https://github.com/opencv/opencv.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

fixed

Browse Source
pull/2149/head
Elena Gvozdeva 11 years ago
parent da4d33ec26
commit 47b572f99f
2 changed files with 78 additions and 58 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 134
      modules/imgproc/src/templmatch.cpp
  2. 2
      modules/imgproc/test/ocl/test_match_template.cpp

134
modules/imgproc/src/templmatch.cpp
Unescape View File

@ -45,17 +45,17 @@
//////////////////////////////////////////////////matchTemplate//////////////////////////////////////////////////////////
namespace cv
{
static bool matchTemplate_CCORR(const UMat &image, const UMat &templ, UMat &result);
static bool matchTemplate_CCORR_NORMED(const UMat &image, const UMat &templ, UMat &result);
static bool matchTemplate_CCORR(InputArray _image, InputArray _templ, OutputArray _result);
static bool matchTemplate_CCORR_NORMED(InputArray _image, InputArray _templ, OutputArray _result);
static bool matchTemplate_SQDIFF(const UMat &image, const UMat &templ, UMat &result);
static bool matchTemplate_SQDIFF_NORMED (const UMat &image, const UMat &templ, UMat &result);
static bool matchTemplate_SQDIFF(InputArray _image, InputArray _templ, OutputArray _result);
static bool matchTemplate_SQDIFF_NORMED (InputArray _image, InputArray _templ, OutputArray _result);
static bool matchTemplate_CCOEFF(const UMat &image, const UMat &templ, UMat &result);
static bool matchTemplate_CCOEFF_NORMED(const UMat &image, const UMat &templ, UMat &result);
static bool matchTemplate_CCOEFF(InputArray _image, InputArray _templ, OutputArray _result);
static bool matchTemplate_CCOEFF_NORMED(InputArray _image, InputArray _templ, OutputArray _result);
static bool matchTemplateNaive_CCORR (const UMat &image, const UMat &templ, UMat &result, int cn);
static bool matchTemplateNaive_SQDIFF(const UMat &image, const UMat &templ, UMat &result, int cn);
static bool matchTemplateNaive_CCORR (InputArray _image, InputArray _templ, OutputArray _result, int cn);
static bool matchTemplateNaive_SQDIFF(InputArray _image, InputArray _templ, OutputArray _result, int cn);
static bool useNaive(int method, int depth, Size size)
{
@ -76,39 +76,41 @@ namespace cv
///////////////////////////////////////////////////CCORR//////////////////////////////////////////////////////////////
static bool matchTemplate_CCORR(const UMat &image, const UMat &templ, UMat &result)
static bool matchTemplate_CCORR(InputArray _image, InputArray _templ, OutputArray _result)
{
if (useNaive(TM_CCORR, image.depth(), templ.size()) )
return matchTemplateNaive_CCORR(image, templ, result, image.channels());
if (useNaive(TM_CCORR, _image.depth(), _templ.size()) )
return matchTemplateNaive_CCORR(_image, _templ, _result, _image.channels());
else
return false;
}
static bool matchTemplateNaive_CCORR (const UMat &image, const UMat &templ, UMat &result, int cn)
static bool matchTemplateNaive_CCORR (InputArray _image, InputArray _templ, OutputArray _result, int cn)
{
int type = image.type();
int type = _image.type();
int depth = CV_MAT_DEPTH(type);
CV_Assert(result.channels() == 1);
const char * kernelName = "matchTemplate_Naive_CCORR";
ocl::Kernel k (kernelName, ocl::imgproc::match_template_oclsrc, format("-D type=%s -D elem_type=%s -D cn=%d",ocl::typeToStr(type), ocl::typeToStr(depth), cn));
if (k.empty())
return false;
UMat image = _image.getUMat();
UMat templ = _templ.getUMat(), result;
_result.create(image.rows - templ.rows + 1, image.cols - templ.cols + 1, CV_32F);
result = _result.getUMat();
size_t globalsize[2] = {result.cols, result.rows};
size_t localsize[2] = {16, 16};
return k.args(ocl::KernelArg::ReadOnlyNoSize(image), ocl::KernelArg::ReadOnly(templ), ocl::KernelArg::WriteOnly(result)).run(2,globalsize,localsize,true);
return k.args(ocl::KernelArg::ReadOnlyNoSize(image), ocl::KernelArg::ReadOnly(templ), ocl::KernelArg::WriteOnly(result)).run(2,globalsize,localsize,false);
}
static bool matchTemplate_CCORR_NORMED(const UMat &image, const UMat &templ, UMat &result)
static bool matchTemplate_CCORR_NORMED(InputArray _image, InputArray _templ, OutputArray _result)
{
if (!matchTemplate_CCORR(image, templ, result))
return false;
matchTemplate(_image, _templ, _result, CV_TM_CCORR);
int type = image.type();
int type = _image.type();
int depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
const char * kernelName = "matchTemplate_CCORR_NORMED";
@ -117,6 +119,11 @@ namespace cv
if (k.empty())
return false;
UMat image = _image.getUMat();
UMat templ = _templ.getUMat(), result;
_result.create(image.rows - templ.rows + 1, image.cols - templ.cols + 1, CV_32F);
result = _result.getUMat();
UMat temp, image_sums, image_sqsums;
integral(image.reshape(1), image_sums, temp);
@ -134,46 +141,48 @@ namespace cv
size_t globalsize[2] = {result.cols, result.rows};
size_t localsize[2] = {16, 16};
return k.args(ocl::KernelArg::ReadOnlyNoSize(image_sqsums), ocl::KernelArg::WriteOnly(result), templ.rows, templ.cols, templ_sqsum).run(2,globalsize,localsize,true);
return k.args(ocl::KernelArg::ReadOnlyNoSize(image_sqsums), ocl::KernelArg::WriteOnly(result), templ.rows, templ.cols, templ_sqsum).run(2,globalsize,localsize,false);
}
//////////////////////////////////////SQDIFF//////////////////////////////////////////////////////////////
static bool matchTemplate_SQDIFF(const UMat &image, const UMat &templ, UMat &result)
static bool matchTemplate_SQDIFF(InputArray _image, InputArray _templ, OutputArray _result)
{
if (useNaive(TM_SQDIFF, image.depth(), templ.size()))
if (useNaive(TM_SQDIFF, _image.depth(), _templ.size()))
{
return matchTemplateNaive_SQDIFF(image, templ, result, image.channels());;
return matchTemplateNaive_SQDIFF(_image, _templ, _result, _image.channels());;
}
else
return false;
}
static bool matchTemplateNaive_SQDIFF(const UMat &image, const UMat &templ, UMat &result, int cn)
static bool matchTemplateNaive_SQDIFF(InputArray _image, InputArray _templ, OutputArray _result, int cn)
{
int type = image.type();
int type = _image.type();
int depth = CV_MAT_DEPTH(type);
CV_Assert(result.channels() == 1);
const char * kernelName = "matchTemplate_Naive_SQDIFF";
ocl::Kernel k (kernelName, ocl::imgproc::match_template_oclsrc, format("-D type=%s -D elem_type=%s -D cn=%d",ocl::typeToStr(type), ocl::typeToStr(depth), cn));
if (k.empty())
return false;
UMat image = _image.getUMat();
UMat templ = _templ.getUMat(), result;
_result.create(image.rows - templ.rows + 1, image.cols - templ.cols + 1, CV_32F);
result = _result.getUMat();
size_t globalsize[2] = {result.cols, result.rows};
size_t localsize[2] = {16, 16};
return k.args(ocl::KernelArg::ReadOnlyNoSize(image), ocl::KernelArg::ReadOnly(templ), ocl::KernelArg::WriteOnly(result)).run(2,globalsize,localsize,true);
return k.args(ocl::KernelArg::ReadOnlyNoSize(image), ocl::KernelArg::ReadOnly(templ), ocl::KernelArg::WriteOnly(result)).run(2,globalsize,localsize,false);
}
static bool matchTemplate_SQDIFF_NORMED (const UMat &image, const UMat &templ, UMat &result)
static bool matchTemplate_SQDIFF_NORMED (InputArray _image, InputArray _templ, OutputArray _result)
{
if (!matchTemplate_CCORR(image, templ, result))
return false;
matchTemplate(_image, _templ, _result, CV_TM_CCORR);
int type = image.type();
int type = _image.type();
int depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
const char * kernelName = "matchTemplate_SQDIFF_NORMED";
@ -182,6 +191,11 @@ namespace cv
if (k.empty())
return false;
UMat image = _image.getUMat();
UMat templ = _templ.getUMat(), result;
_result.create(image.rows - templ.rows + 1, image.cols - templ.cols + 1, CV_32F);
result = _result.getUMat();
UMat temp, image_sums, image_sqsums;
integral(image.reshape(1), image_sums, temp);
@ -199,18 +213,17 @@ namespace cv
size_t globalsize[2] = {result.cols, result.rows};
size_t localsize[2] = {16, 16};
return k.args(ocl::KernelArg::ReadOnlyNoSize(image_sqsums), ocl::KernelArg::WriteOnly(result), templ.rows, templ.cols, templ_sqsum).run(2,globalsize,localsize,true);
return k.args(ocl::KernelArg::ReadOnlyNoSize(image_sqsums), ocl::KernelArg::WriteOnly(result), templ.rows, templ.cols, templ_sqsum).run(2,globalsize,localsize,false);
}
/////////////////////////////////////CCOEFF/////////////////////////////////////////////////////////////////
static bool matchTemplate_CCOEFF(const UMat &image, const UMat &templ, UMat &result)
static bool matchTemplate_CCOEFF(InputArray _image, InputArray _templ, OutputArray _result)
{
if (!matchTemplate_CCORR(image, templ, result))
return false;
matchTemplate(_image, _templ, _result, CV_TM_CCORR);
UMat image_sums;
integral(image, image_sums);
integral(_image, image_sums);
int type = image_sums.type();
int depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
@ -228,13 +241,18 @@ namespace cv
if (k.empty())
return false;
UMat templ = _templ.getUMat(), result;
int image_rows = _image.size().height, image_cols = _image.size().width;
_result.create(image_rows - templ.rows + 1, image_cols - templ.cols + 1, CV_32F);
result = _result.getUMat();
size_t globalsize[2] = {result.cols, result.rows};
size_t localsize[2] = {16, 16};
if (cn==1)
{
float templ_sum = (float)sum(templ)[0]/ templ.size().area();
return k.args(ocl::KernelArg::ReadOnlyNoSize(image_sums), ocl::KernelArg::WriteOnly(result), templ.rows, templ.cols, templ_sum).run(2,globalsize,localsize,true);
float templ_sum = (float)sum(_templ)[0]/ _templ.size().area();
return k.args(ocl::KernelArg::ReadOnlyNoSize(image_sums), ocl::KernelArg::WriteOnly(result), templ.rows, templ.cols, templ_sum).run(2,globalsize,localsize,false);
}
else
{
@ -242,26 +260,26 @@ namespace cv
templ_sum = sum(templ)/ templ.size().area();
if (cn==2)
return k.args(ocl::KernelArg::ReadOnlyNoSize(image_sums), ocl::KernelArg::WriteOnly(result), templ.rows, templ.cols,
templ_sum[0],templ_sum[1]).run(2,globalsize,localsize,true);
templ_sum[0],templ_sum[1]).run(2,globalsize,localsize,false);
return k.args(ocl::KernelArg::ReadOnlyNoSize(image_sums), ocl::KernelArg::WriteOnly(result), templ.rows, templ.cols,
templ_sum[0],templ_sum[1],templ_sum[2],templ_sum[3]).run(2,globalsize,localsize,true);
templ_sum[0],templ_sum[1],templ_sum[2],templ_sum[3]).run(2,globalsize,localsize,false);
}
}
static bool matchTemplate_CCOEFF_NORMED(const UMat &image, const UMat &templ, UMat &result)
static bool matchTemplate_CCOEFF_NORMED(InputArray _image, InputArray _templ, OutputArray _result)
{
UMat imagef, templf;
image.convertTo(imagef, CV_32F);
templ.convertTo(templf, CV_32F);
if(!matchTemplate_CCORR(imagef, templf, result))
return false;
_image.getUMat().convertTo(imagef, CV_32F);
_templ.getUMat().convertTo(templf, CV_32F);
matchTemplate(imagef, templf, _result, CV_TM_CCORR);
const char * kernelName;
UMat temp, image_sums, image_sqsums;
integral(image,image_sums, temp);
integral(_image,image_sums, temp);
int type = image_sums.type();
int depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
@ -278,6 +296,12 @@ namespace cv
if (k.empty())
return false;
UMat image = _image.getUMat();
UMat templ = _templ.getUMat(), result;
int image_rows = _image.size().height, image_cols = _image.size().width;
_result.create(image_rows - templ.rows + 1, image_cols - templ.cols + 1, CV_32F);
result = _result.getUMat();
if(temp.depth() == CV_64F)
temp.convertTo(image_sqsums, CV_32F);
else
@ -306,7 +330,7 @@ namespace cv
return k.args(ocl::KernelArg::ReadOnlyNoSize(image_sums),ocl::KernelArg::ReadOnlyNoSize(image_sqsums),
ocl::KernelArg::WriteOnly(result), templ.rows, templ.cols, scale, templ_sum, templ_sqsum)
.run(2,globalsize,localsize,true);
.run(2,globalsize,localsize,false);
}
else
{
@ -336,12 +360,12 @@ namespace cv
return k.args(ocl::KernelArg::ReadOnlyNoSize(image_sums), ocl::KernelArg::ReadOnlyNoSize(image_sqsums),
ocl::KernelArg::WriteOnly(result), templ.rows, templ.cols, scale,
templ_sum[0],templ_sum[1], templ_sqsum_sum)
.run(2,globalsize,localsize,true);
.run(2,globalsize,localsize,false);
return k.args(ocl::KernelArg::ReadOnlyNoSize(image_sums), ocl::KernelArg::ReadOnlyNoSize(image_sqsums),
ocl::KernelArg::WriteOnly(result), templ.rows, templ.cols, scale,
templ_sum[0],templ_sum[1],templ_sum[2],templ_sum[3], templ_sqsum_sum)
.run(2,globalsize,localsize,true);
.run(2,globalsize,localsize,false);
}
}
@ -355,7 +379,7 @@ namespace cv
CV_Assert( cn == _templ.channels() && cn!=3 && cn<=4);
typedef bool (*Caller)(const UMat &, const UMat &, UMat &);
typedef bool (*Caller)(InputArray _img, InputArray _templ, OutputArray _result);
const Caller callers[] =
{
@ -365,11 +389,7 @@ namespace cv
Caller caller = callers[method];
UMat image = _img.getUMat();
UMat templ = _templ.getUMat(), result;
_result.create(image.rows - templ.rows + 1, image.cols - templ.cols + 1, CV_32F);
result = _result.getUMat();
return caller(image, templ, result);
return caller(_img, _templ, _result);
}
}

2
modules/imgproc/test/ocl/test_match_template.cpp
Unescape View File

@ -74,7 +74,7 @@ PARAM_TEST_CASE(MatchTemplate, MatDepth, Channels, int, bool)
virtual void generateTestData()
{
Size image_roiSize = randomSize(2, 20);
Size image_roiSize = randomSize(2, 100);
Size templ_roiSize = Size(randomInt(1,image_roiSize.width), randomInt(1,image_roiSize.height));
Size result_roiSize = Size(image_roiSize.width - templ_roiSize.width + 1,
image_roiSize.height - templ_roiSize.height + 1);

Write Preview
Loading…
Cancel
Save