Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
Greenplum
Opencv
提交
66df8ef0
O
Opencv
项目概览
Greenplum
/
Opencv
11 个月 前同步成功
通知
7
Star
0
Fork
0
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
0
列表
看板
标记
里程碑
合并请求
0
DevOps
流水线
流水线任务
计划
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
O
Opencv
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
0
Issue
0
列表
看板
标记
里程碑
合并请求
0
合并请求
0
Pages
DevOps
DevOps
流水线
流水线任务
计划
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
流水线任务
提交
Issue看板
体验新版 GitCode,发现更多精彩内容 >>
提交
66df8ef0
编写于
10月 06, 2010
作者:
V
Vladislav Vinogradov
浏览文件
操作
浏览文件
下载
电子邮件补丁
差异文件
added Filter Engine to gpu module.
disabled gpu::sum, gpu::minMax, gpu:Canny until fix crash.
上级
7a3b0785
变更
7
展开全部
隐藏空白更改
内联
并排
Showing
7 changed file
with
1127 addition
and
401 deletion
+1127
-401
modules/gpu/include/opencv2/gpu/gpu.hpp
modules/gpu/include/opencv2/gpu/gpu.hpp
+151
-12
modules/gpu/src/arithm.cpp
modules/gpu/src/arithm.cpp
+2
-0
modules/gpu/src/filtering_npp.cpp
modules/gpu/src/filtering_npp.cpp
+576
-212
modules/gpu/src/imgproc_gpu.cpp
modules/gpu/src/imgproc_gpu.cpp
+1
-0
tests/gpu/src/filters.cpp
tests/gpu/src/filters.cpp
+383
-0
tests/gpu/src/gputest_main.cpp
tests/gpu/src/gputest_main.cpp
+14
-12
tests/gpu/src/imgproc_gpu.cpp
tests/gpu/src/imgproc_gpu.cpp
+0
-165
未找到文件。
modules/gpu/include/opencv2/gpu/gpu.hpp
浏览文件 @
66df8ef0
...
...
@@ -407,10 +407,12 @@ namespace cv
//! computes sum of array elements
//! supports CV_8UC1, CV_8UC4 types
//! disabled until fix crash
CV_EXPORTS
Scalar
sum
(
const
GpuMat
&
m
);
//! finds global minimum and maximum array elements and returns their values
//! supports only CV_8UC1 type
//! disabled until fix npp bug
CV_EXPORTS
void
minMax
(
const
GpuMat
&
src
,
double
*
minVal
,
double
*
maxVal
=
0
);
//! transforms 8-bit unsigned integers using lookup table: dst(i)=lut(src(i))
...
...
@@ -451,8 +453,10 @@ namespace cv
CV_EXPORTS
void
log
(
const
GpuMat
&
a
,
GpuMat
&
b
);
//! computes magnitude (magnitude(i)) of each (x(i), y(i)) vector
//! supports only CV_32FC1 type
CV_EXPORTS
void
magnitude
(
const
GpuMat
&
x
,
const
GpuMat
&
y
,
GpuMat
&
magnitude
);
//! computes magnitude (magnitude(i)) of complex (x(i).re, x(i).im) vector
//! supports only CV_32FC2 type
CV_EXPORTS
void
magnitude
(
const
GpuMat
&
x
,
GpuMat
&
magnitude
);
////////////////////////////// Image processing //////////////////////////////
...
...
@@ -517,34 +521,169 @@ namespace cv
//! supports only CV_32FC1 source type
CV_EXPORTS
void
integral
(
GpuMat
&
src
,
GpuMat
&
sum
,
GpuMat
&
sqsum
);
//! applies Canny edge detector and produces the edge map
//! supprots only CV_8UC1 source type
//! disabled until fix crash
CV_EXPORTS
void
Canny
(
const
GpuMat
&
image
,
GpuMat
&
edges
,
double
threshold1
,
double
threshold2
,
int
apertureSize
=
3
);
//////////////////////////////// Filter Engine ////////////////////////////////
/*!
The Base Class for 1D or Row-wise Filters
This is the base class for linear or non-linear filters that process 1D data.
In particular, such filters are used for the "horizontal" filtering parts in separable filters.
*/
class
CV_EXPORTS
BaseRowFilter_GPU
{
public:
BaseRowFilter_GPU
(
int
ksize_
,
int
anchor_
)
:
ksize
(
ksize_
),
anchor
(
anchor_
)
{}
virtual
~
BaseRowFilter_GPU
()
{}
virtual
void
operator
()(
const
GpuMat
&
src
,
GpuMat
&
dst
)
=
0
;
int
ksize
,
anchor
;
};
/*!
The Base Class for Column-wise Filters
This is the base class for linear or non-linear filters that process columns of 2D arrays.
Such filters are used for the "vertical" filtering parts in separable filters.
*/
class
CV_EXPORTS
BaseColumnFilter_GPU
{
public:
BaseColumnFilter_GPU
(
int
ksize_
,
int
anchor_
)
:
ksize
(
ksize_
),
anchor
(
anchor_
)
{}
virtual
~
BaseColumnFilter_GPU
()
{}
virtual
void
operator
()(
const
GpuMat
&
src
,
GpuMat
&
dst
)
=
0
;
int
ksize
,
anchor
;
};
/*!
The Base Class for Non-Separable 2D Filters.
This is the base class for linear or non-linear 2D filters.
*/
class
CV_EXPORTS
BaseFilter_GPU
{
public:
BaseFilter_GPU
(
const
Size
&
ksize_
,
const
Point
&
anchor_
)
:
ksize
(
ksize_
),
anchor
(
anchor_
)
{}
virtual
~
BaseFilter_GPU
()
{}
virtual
void
operator
()(
const
GpuMat
&
src
,
GpuMat
&
dst
)
=
0
;
Size
ksize
;
Point
anchor
;
};
/*!
The Base Class for Filter Engine.
The class can be used to apply an arbitrary filtering operation to an image.
It contains all the necessary intermediate buffers.
*/
class
CV_EXPORTS
FilterEngine_GPU
{
public:
virtual
~
FilterEngine_GPU
()
{}
virtual
void
apply
(
const
GpuMat
&
src
,
GpuMat
&
dst
,
Rect
roi
=
Rect
(
0
,
0
,
-
1
,
-
1
))
=
0
;
};
//! returns the non-separable filter engine with the specified filter
CV_EXPORTS
Ptr
<
FilterEngine_GPU
>
createFilter2D_GPU
(
const
Ptr
<
BaseFilter_GPU
>
filter2D
);
//! returns the separable filter engine with the specified filters
CV_EXPORTS
Ptr
<
FilterEngine_GPU
>
createSeparableFilter_GPU
(
const
Ptr
<
BaseRowFilter_GPU
>&
rowFilter
,
const
Ptr
<
BaseColumnFilter_GPU
>&
columnFilter
);
//! returns horizontal 1D box filter
//! supports only CV_8UC1 source type and CV_32FC1 sum type
CV_EXPORTS
Ptr
<
BaseRowFilter_GPU
>
getRowSumFilter_GPU
(
int
srcType
,
int
sumType
,
int
ksize
,
int
anchor
=
-
1
);
//! returns vertical 1D box filter
//! supports only CV_8UC1 sum type and CV_32FC1 dst type
CV_EXPORTS
Ptr
<
BaseColumnFilter_GPU
>
getColumnSumFilter_GPU
(
int
sumType
,
int
dstType
,
int
ksize
,
int
anchor
=
-
1
);
//! returns 2D box filter
//! supports CV_8UC1 and CV_8UC4 source type, dst type must be the same as source type
CV_EXPORTS
Ptr
<
BaseFilter_GPU
>
getBoxFilter_GPU
(
int
srcType
,
int
dstType
,
const
Size
&
ksize
,
Point
anchor
=
Point
(
-
1
,
-
1
));
//! returns box filter engine
CV_EXPORTS
Ptr
<
FilterEngine_GPU
>
createBoxFilter_GPU
(
int
srcType
,
int
dstType
,
const
Size
&
ksize
,
const
Point
&
anchor
=
Point
(
-
1
,
-
1
));
//! returns 2D morphological filter
//! only MORPH_ERODE and MORPH_DILATE are supported
//! supports CV_8UC1 and CV_8UC4 types
//! kernel must have CV_8UC1 type, one rows and cols == ksize.width * ksize.height
CV_EXPORTS
Ptr
<
BaseFilter_GPU
>
getMorphologyFilter_GPU
(
int
op
,
int
type
,
const
GpuMat
&
kernel
,
const
Size
&
ksize
,
Point
anchor
=
Point
(
-
1
,
-
1
));
//! returns morphological filter engine. Only MORPH_ERODE and MORPH_DILATE are supported.
CV_EXPORTS
Ptr
<
FilterEngine_GPU
>
createMorphologyFilter_GPU
(
int
op
,
int
type
,
const
Mat
&
kernel
,
const
Point
&
anchor
=
Point
(
-
1
,
-
1
),
int
iterations
=
1
);
//! returns 2D filter with the specified kernel
//! supports CV_8UC1 and CV_8UC4 types
//! kernel must have CV_8UC1 type, one rows and cols == ksize.width * ksize.height
CV_EXPORTS
Ptr
<
BaseFilter_GPU
>
getLinearFilter_GPU
(
int
srcType
,
int
dstType
,
const
GpuMat
&
kernel
,
const
Size
&
ksize
,
Point
anchor
=
Point
(
-
1
,
-
1
),
int
nDivisor
=
1
);
//! returns the non-separable linear filter engine
CV_EXPORTS
Ptr
<
FilterEngine_GPU
>
createLinearFilter_GPU
(
int
srcType
,
int
dstType
,
const
Mat
&
kernel
,
const
Point
&
anchor
=
Point
(
-
1
,
-
1
));
//! returns the primitive row filter with the specified kernel
CV_EXPORTS
Ptr
<
BaseRowFilter_GPU
>
getLinearRowFilter_GPU
(
int
srcType
,
int
bufType
,
const
GpuMat
&
rowKernel
,
int
anchor
=
-
1
,
int
nDivisor
=
1
);
//! returns the primitive column filter with the specified kernel
CV_EXPORTS
Ptr
<
BaseColumnFilter_GPU
>
getLinearColumnFilter_GPU
(
int
bufType
,
int
dstType
,
const
GpuMat
&
columnKernel
,
int
anchor
=
-
1
,
int
nDivisor
=
1
);
//! returns the separable linear filter engine
CV_EXPORTS
Ptr
<
FilterEngine_GPU
>
createSeparableLinearFilter_GPU
(
int
srcType
,
int
dstType
,
const
Mat
&
rowKernel
,
const
Mat
&
columnKernel
,
const
Point
&
anchor
=
Point
(
-
1
,
-
1
));
//! returns filter engine for the generalized Sobel operator
CV_EXPORTS
Ptr
<
FilterEngine_GPU
>
createDerivFilter_GPU
(
int
srcType
,
int
dstType
,
int
dx
,
int
dy
,
int
ksize
);
//! returns the Gaussian filter engine
CV_EXPORTS
Ptr
<
FilterEngine_GPU
>
createGaussianFilter_GPU
(
int
type
,
Size
ksize
,
double
sigma1
,
double
sigma2
=
0
);
//! smooths the image using the normalized box filter
//! supports CV_8UC1, CV_8UC4 types
and kernel size 3, 5, 7
CV_EXPORTS
void
boxFilter
(
const
GpuMat
&
src
,
GpuMat
&
dst
,
Size
ksize
,
Point
anchor
=
Point
(
-
1
,
-
1
));
//! supports CV_8UC1, CV_8UC4 types
CV_EXPORTS
void
boxFilter
(
const
GpuMat
&
src
,
GpuMat
&
dst
,
int
ddepth
,
Size
ksize
,
Point
anchor
=
Point
(
-
1
,
-
1
));
//! a synonym for normalized box filter
static
inline
void
blur
(
const
GpuMat
&
src
,
GpuMat
&
dst
,
Size
ksize
,
Point
anchor
=
Point
(
-
1
,
-
1
))
{
boxFilter
(
src
,
dst
,
ksize
,
anchor
);
}
static
inline
void
blur
(
const
GpuMat
&
src
,
GpuMat
&
dst
,
Size
ksize
,
Point
anchor
=
Point
(
-
1
,
-
1
))
{
boxFilter
(
src
,
dst
,
-
1
,
ksize
,
anchor
);
}
//! erodes the image (applies the local minimum operator)
CV_EXPORTS
void
erode
(
const
GpuMat
&
src
,
GpuMat
&
dst
,
const
Mat
&
kernel
,
Point
anchor
,
int
iterations
);
CV_EXPORTS
void
erode
(
const
GpuMat
&
src
,
GpuMat
&
dst
,
const
Mat
&
kernel
,
Point
anchor
=
Point
(
-
1
,
-
1
),
int
iterations
=
1
);
//! dilates the image (applies the local maximum operator)
CV_EXPORTS
void
dilate
(
const
GpuMat
&
src
,
GpuMat
&
dst
,
const
Mat
&
kernel
,
Point
anchor
,
int
iterations
);
CV_EXPORTS
void
dilate
(
const
GpuMat
&
src
,
GpuMat
&
dst
,
const
Mat
&
kernel
,
Point
anchor
=
Point
(
-
1
,
-
1
),
int
iterations
=
1
);
//! applies an advanced morphological operation to the image
CV_EXPORTS
void
morphologyEx
(
const
GpuMat
&
src
,
GpuMat
&
dst
,
int
op
,
const
Mat
&
kernel
,
Point
anchor
,
int
iterations
);
CV_EXPORTS
void
morphologyEx
(
const
GpuMat
&
src
,
GpuMat
&
dst
,
int
op
,
const
Mat
&
kernel
,
Point
anchor
=
Point
(
-
1
,
-
1
),
int
iterations
=
1
);
//! applies non-separable 2D linear filter to the image
CV_EXPORTS
void
filter2D
(
const
GpuMat
&
src
,
GpuMat
&
dst
,
int
ddepth
,
const
Mat
&
kernel
,
Point
anchor
=
Point
(
-
1
,
-
1
));
//!
1D mask Window Sum for 8 bit images
CV_EXPORTS
void
s
umWindowColumn
(
const
GpuMat
&
src
,
GpuMat
&
dst
,
int
ksize
,
int
anchor
=
-
1
);
CV_EXPORTS
void
sumWindowRow
(
const
GpuMat
&
src
,
GpuMat
&
dst
,
int
ksize
,
int
anchor
=
-
1
);
//!
applies separable 2D linear filter to the image
CV_EXPORTS
void
s
epFilter2D
(
const
GpuMat
&
src
,
GpuMat
&
dst
,
int
ddepth
,
const
Mat
&
kernelX
,
const
Mat
&
kernelY
,
Point
anchor
=
Point
(
-
1
,
-
1
)
);
//! applies generalized Sobel operator to the image
CV_EXPORTS
void
Sobel
(
const
GpuMat
&
src
,
GpuMat
&
dst
,
int
ddepth
,
int
dx
,
int
dy
,
int
ksize
=
3
,
double
scale
=
1
);
//! applies the vertical or horizontal Scharr operator to the image
CV_EXPORTS
void
Scharr
(
const
GpuMat
&
src
,
GpuMat
&
dst
,
int
ddepth
,
int
dx
,
int
dy
,
double
scale
=
1
);
//! smooths the image using Gaussian filter.
CV_EXPORTS
void
GaussianBlur
(
const
GpuMat
&
src
,
GpuMat
&
dst
,
Size
ksize
,
double
sigma1
,
double
sigma2
=
0
);
//! applies Canny edge detector and produces the edge map.
CV_EXPORTS
void
Canny
(
const
GpuMat
&
image
,
GpuMat
&
edges
,
double
threshold1
,
double
threshold2
,
int
apertureSize
=
3
);
//! applies Laplacian operator to the image
//! supports only ksize = 1 and ksize = 3
CV_EXPORTS
void
Laplacian
(
const
GpuMat
&
src
,
GpuMat
&
dst
,
int
ddepth
,
int
ksize
=
1
,
double
scale
=
1
);
//////////////////////////////// Image Labeling ////////////////////////////////
...
...
modules/gpu/src/arithm.cpp
浏览文件 @
66df8ef0
...
...
@@ -387,6 +387,7 @@ void cv::gpu::flip(const GpuMat& src, GpuMat& dst, int flipCode)
Scalar
cv
::
gpu
::
sum
(
const
GpuMat
&
src
)
{
CV_Assert
(
!
"disabled until fix crash"
);
CV_Assert
(
src
.
type
()
==
CV_8UC1
||
src
.
type
()
==
CV_8UC4
);
NppiSize
sz
;
...
...
@@ -420,6 +421,7 @@ Scalar cv::gpu::sum(const GpuMat& src)
void
cv
::
gpu
::
minMax
(
const
GpuMat
&
src
,
double
*
minVal
,
double
*
maxVal
)
{
CV_Assert
(
!
"disabled until fix npp bug"
);
CV_Assert
(
src
.
type
()
==
CV_8UC1
);
NppiSize
sz
;
...
...
modules/gpu/src/filtering_npp.cpp
浏览文件 @
66df8ef0
此差异已折叠。
点击以展开。
modules/gpu/src/imgproc_gpu.cpp
浏览文件 @
66df8ef0
...
...
@@ -992,6 +992,7 @@ void cv::gpu::integral(GpuMat& src, GpuMat& sum, GpuMat& sqsum)
void
cv
::
gpu
::
Canny
(
const
GpuMat
&
image
,
GpuMat
&
edges
,
double
threshold1
,
double
threshold2
,
int
apertureSize
)
{
CV_Assert
(
!
"disabled until fix crash"
);
CV_Assert
(
image
.
type
()
==
CV_8UC1
);
GpuMat
srcDx
,
srcDy
;
...
...
tests/gpu/src/
morf_
filters.cpp
→
tests/gpu/src/filters.cpp
浏览文件 @
66df8ef0
/*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) 2000, Intel Corporation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// 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 <iostream>
#include <cmath>
#include <limits>
#include "gputest.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/highgui/highgui.hpp"
using
namespace
cv
;
using
namespace
std
;
using
namespace
gpu
;
class
CV_GpuNppMorphogyTest
:
public
CvTest
{
public:
CV_GpuNppMorphogyTest
(
const
char
*
test_name
,
const
char
*
test_funcs
)
:
CvTest
(
test_name
,
test_funcs
)
{}
virtual
~
CV_GpuNppMorphogyTest
()
{}
protected:
void
run
(
int
);
virtual
int
test
(
const
Mat
&
img
)
=
0
;
int
test8UC1
(
const
Mat
&
img
)
{
cv
::
Mat
img_C1
;
cvtColor
(
img
,
img_C1
,
CV_BGR2GRAY
);
return
test
(
img_C1
);
}
int
test8UC4
(
const
Mat
&
img
)
{
cv
::
Mat
img_C4
;
cvtColor
(
img
,
img_C4
,
CV_BGR2BGRA
);
return
test
(
img_C4
);
}
int
CheckNorm
(
const
Mat
&
m1
,
const
Mat
&
m2
)
{
double
res
=
norm
(
m1
,
m2
,
NORM_INF
);
if
(
res
<
std
::
numeric_limits
<
double
>::
epsilon
())
return
CvTS
::
OK
;
ts
->
printf
(
CvTS
::
LOG
,
"
\n
Norm: %f
\n
"
,
res
);
return
CvTS
::
FAIL_GENERIC
;
}
};
void
CV_GpuNppMorphogyTest
::
run
(
int
)
{
cv
::
Mat
img
=
cv
::
imread
(
std
::
string
(
ts
->
get_data_path
())
+
"stereobp/aloe-L.png"
);
if
(
img
.
empty
())
{
ts
->
set_failed_test_info
(
CvTS
::
FAIL_MISSING_TEST_DATA
);
return
;
}
try
{
//run tests
int
testResult
=
test8UC1
(
img
);
if
(
testResult
!=
CvTS
::
OK
)
{
ts
->
set_failed_test_info
(
testResult
);
return
;
}
testResult
=
test8UC4
(
img
);
if
(
testResult
!=
CvTS
::
OK
)
{
ts
->
set_failed_test_info
(
testResult
);
return
;
}
}
catch
(
const
cv
::
Exception
&
e
)
{
if
(
!
check_and_treat_gpu_exception
(
e
,
ts
))
throw
;
return
;
}
ts
->
set_failed_test_info
(
CvTS
::
OK
);
}
////////////////////////////////////////////////////////////////////////////////
// Erode
class
CV_GpuErodeTest
:
public
CV_GpuNppMorphogyTest
{
public:
CV_GpuErodeTest
()
:
CV_GpuNppMorphogyTest
(
"GPU-NppErode"
,
"erode"
)
{}
protected:
virtual
int
test
(
const
Mat
&
img
)
{
GpuMat
kernel
(
Mat
::
ones
(
3
,
3
,
CV_8U
));
Point
anchor
(
0
,
0
);
int
iters
=
1
;
cv
::
Mat
cpuRes
,
cpuRes1
;
cv
::
erode
(
img
,
cpuRes
,
kernel
,
anchor
,
iters
);
GpuMat
gpuRes
;
cv
::
gpu
::
erode
(
GpuMat
(
img
),
gpuRes
,
kernel
,
anchor
,
iters
);
return
CheckNorm
(
cpuRes
,
gpuRes
);
}
};
////////////////////////////////////////////////////////////////////////////////
// Dilate
class
CV_GpuDilateTest
:
public
CV_GpuNppMorphogyTest
{
public:
CV_GpuDilateTest
()
:
CV_GpuNppMorphogyTest
(
"GPU-NppDilate"
,
"dilate"
)
{}
protected:
virtual
int
test
(
const
Mat
&
img
)
{
GpuMat
kernel
(
Mat
::
ones
(
3
,
3
,
CV_8U
));
Point
anchor
(
0
,
0
);
int
iters
=
1
;
cv
::
Mat
cpuRes
,
cpuRes1
;
cv
::
dilate
(
img
,
cpuRes
,
kernel
,
anchor
,
iters
);
GpuMat
gpuRes
,
gpuRes1
;
cv
::
gpu
::
dilate
(
GpuMat
(
img
),
gpuRes
,
kernel
,
anchor
,
iters
);
return
CheckNorm
(
cpuRes
,
gpuRes
);
}
};
////////////////////////////////////////////////////////////////////////////////
// Dilate
class
CV_GpuMorphExTest
:
public
CV_GpuNppMorphogyTest
{
public:
CV_GpuMorphExTest
()
:
CV_GpuNppMorphogyTest
(
"GPU-NppMorphologyEx"
,
"dmorphologyExilate"
)
{}
protected:
virtual
int
test
(
const
Mat
&
img
)
{
static
int
ops
[]
=
{
MORPH_OPEN
,
CV_MOP_CLOSE
,
CV_MOP_GRADIENT
,
CV_MOP_TOPHAT
,
CV_MOP_BLACKHAT
};
const
char
*
names
[]
=
{
"MORPH_OPEN"
,
"CV_MOP_CLOSE"
,
"CV_MOP_GRADIENT"
,
"CV_MOP_TOPHAT"
,
"CV_MOP_BLACKHAT"
};
int
num
=
sizeof
(
ops
)
/
sizeof
(
ops
[
0
]);
GpuMat
kernel
(
Mat
::
ones
(
3
,
3
,
CV_8U
));
Point
anchor
(
0
,
0
);
int
iters
=
1
;
for
(
int
i
=
0
;
i
<
num
;
++
i
)
{
ts
->
printf
(
CvTS
::
LOG
,
"Tesing %s
\n
"
,
names
[
i
]);
cv
::
Mat
cpuRes
;
cv
::
morphologyEx
(
img
,
cpuRes
,
ops
[
i
],
kernel
,
anchor
,
iters
);
GpuMat
gpuRes
;
cv
::
gpu
::
morphologyEx
(
GpuMat
(
img
),
gpuRes
,
ops
[
i
],
kernel
,
anchor
,
iters
);
int
res
=
CheckNorm
(
cpuRes
,
gpuRes
);
if
(
CvTS
::
OK
!=
res
)
return
res
;
}
return
CvTS
::
OK
;
}
};
/////////////////////////////////////////////////////////////////////////////
/////////////////// tests registration /////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
CV_GpuErodeTest
CV_GpuErode_test
;
CV_GpuDilateTest
CV_GpuDilate_test
;
/*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) 2000, Intel Corporation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// 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 <iostream>
#include <cmath>
#include <limits>
#include "gputest.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/highgui/highgui.hpp"
using
namespace
cv
;
using
namespace
std
;
using
namespace
gpu
;
class
CV_GpuNppFilterTest
:
public
CvTest
{
public:
CV_GpuNppFilterTest
(
const
char
*
test_name
,
const
char
*
test_funcs
)
:
CvTest
(
test_name
,
test_funcs
)
{}
virtual
~
CV_GpuNppFilterTest
()
{}
protected:
void
run
(
int
);
virtual
int
test
(
const
Mat
&
img
)
=
0
;
int
test8UC1
(
const
Mat
&
img
)
{
cv
::
Mat
img_C1
;
cvtColor
(
img
,
img_C1
,
CV_BGR2GRAY
);
return
test
(
img_C1
);
}
int
test8UC4
(
const
Mat
&
img
)
{
cv
::
Mat
img_C4
;
cvtColor
(
img
,
img_C4
,
CV_BGR2BGRA
);
return
test
(
img_C4
);
}
int
CheckNorm
(
const
Mat
&
m1
,
const
Mat
&
m2
,
const
Size
&
ksize
)
{
Rect
roi
=
Rect
(
ksize
.
width
,
ksize
.
height
,
m1
.
cols
-
2
*
ksize
.
width
,
m1
.
rows
-
2
*
ksize
.
height
);
Mat
m1ROI
=
m1
(
roi
);
Mat
m2ROI
=
m2
(
roi
);
double
res
=
norm
(
m1ROI
,
m2ROI
,
NORM_INF
);
if
(
res
<=
1
)
return
CvTS
::
OK
;
ts
->
printf
(
CvTS
::
LOG
,
"
\n
Norm: %f
\n
"
,
res
);
return
CvTS
::
FAIL_GENERIC
;
}
};
void
CV_GpuNppFilterTest
::
run
(
int
)
{
cv
::
Mat
img
=
cv
::
imread
(
std
::
string
(
ts
->
get_data_path
())
+
"stereobp/aloe-L.png"
);
if
(
img
.
empty
())
{
ts
->
set_failed_test_info
(
CvTS
::
FAIL_MISSING_TEST_DATA
);
return
;
}
try
{
//run tests
int
testResult
=
CvTS
::
OK
;
if
(
test8UC1
(
img
)
!=
CvTS
::
OK
)
testResult
=
CvTS
::
FAIL_GENERIC
;
if
(
test8UC4
(
img
)
!=
CvTS
::
OK
)
testResult
=
CvTS
::
FAIL_GENERIC
;
ts
->
set_failed_test_info
(
testResult
);
}
catch
(
const
cv
::
Exception
&
e
)
{
if
(
!
check_and_treat_gpu_exception
(
e
,
ts
))
throw
;
return
;
}
ts
->
set_failed_test_info
(
CvTS
::
OK
);
}
////////////////////////////////////////////////////////////////////////////////
// blur
struct
CV_GpuNppImageBlurTest
:
public
CV_GpuNppFilterTest
{
CV_GpuNppImageBlurTest
()
:
CV_GpuNppFilterTest
(
"GPU-NppImageBlur"
,
"blur"
)
{}
int
test
(
const
Mat
&
img
)
{
int
ksizes
[]
=
{
3
,
5
,
7
};
int
ksizes_num
=
sizeof
(
ksizes
)
/
sizeof
(
int
);
int
test_res
=
CvTS
::
OK
;
for
(
int
i
=
0
;
i
<
ksizes_num
;
++
i
)
{
for
(
int
j
=
0
;
j
<
ksizes_num
;
++
j
)
{
Size
ksize
(
ksizes
[
i
],
ksizes
[
j
]);
ts
->
printf
(
CvTS
::
LOG
,
"
\n
ksize = (%dx%d)
\n
"
,
ksizes
[
i
],
ksizes
[
j
]);
Mat
cpudst
;
cv
::
blur
(
img
,
cpudst
,
ksize
);
GpuMat
gpu1
(
img
);
GpuMat
gpudst
;
cv
::
gpu
::
blur
(
gpu1
,
gpudst
,
ksize
);
if
(
CheckNorm
(
cpudst
,
gpudst
,
ksize
)
!=
CvTS
::
OK
)
test_res
=
CvTS
::
FAIL_GENERIC
;
}
}
return
test_res
;
}
};
////////////////////////////////////////////////////////////////////////////////
// Sobel
struct
CV_GpuNppImageSobelTest
:
public
CV_GpuNppFilterTest
{
CV_GpuNppImageSobelTest
()
:
CV_GpuNppFilterTest
(
"GPU-NppImageSobel"
,
"Sobel"
)
{}
int
test
(
const
Mat
&
img
)
{
int
ksizes
[]
=
{
3
,
5
,
7
};
int
ksizes_num
=
sizeof
(
ksizes
)
/
sizeof
(
int
);
int
dx
=
1
,
dy
=
0
;
int
test_res
=
CvTS
::
OK
;
for
(
int
i
=
0
;
i
<
ksizes_num
;
++
i
)
{
ts
->
printf
(
CvTS
::
LOG
,
"
\n
ksize = %d
\n
"
,
ksizes
[
i
]);
Mat
cpudst
;
cv
::
Sobel
(
img
,
cpudst
,
-
1
,
dx
,
dy
,
ksizes
[
i
]);
GpuMat
gpu1
(
img
);
GpuMat
gpudst
;
cv
::
gpu
::
Sobel
(
gpu1
,
gpudst
,
-
1
,
dx
,
dy
,
ksizes
[
i
]);
if
(
CheckNorm
(
cpudst
,
gpudst
,
Size
(
ksizes
[
i
],
ksizes
[
i
]))
!=
CvTS
::
OK
)
test_res
=
CvTS
::
FAIL_GENERIC
;
}
return
test_res
;
}
};
////////////////////////////////////////////////////////////////////////////////
// Scharr
struct
CV_GpuNppImageScharrTest
:
public
CV_GpuNppFilterTest
{
CV_GpuNppImageScharrTest
()
:
CV_GpuNppFilterTest
(
"GPU-NppImageScharr"
,
"Scharr"
)
{}
int
test
(
const
Mat
&
img
)
{
int
dx
=
1
,
dy
=
0
;
Mat
cpudst
;
cv
::
Scharr
(
img
,
cpudst
,
-
1
,
dx
,
dy
);
GpuMat
gpu1
(
img
);
GpuMat
gpudst
;
cv
::
gpu
::
Scharr
(
gpu1
,
gpudst
,
-
1
,
dx
,
dy
);
return
CheckNorm
(
cpudst
,
gpudst
,
Size
(
3
,
3
));
}
};
////////////////////////////////////////////////////////////////////////////////
// GaussianBlur
struct
CV_GpuNppImageGaussianBlurTest
:
public
CV_GpuNppFilterTest
{
CV_GpuNppImageGaussianBlurTest
()
:
CV_GpuNppFilterTest
(
"GPU-NppImageGaussianBlur"
,
"GaussianBlur"
)
{}
int
test
(
const
Mat
&
img
)
{
int
ksizes
[]
=
{
3
,
5
,
7
};
int
ksizes_num
=
sizeof
(
ksizes
)
/
sizeof
(
int
);
int
test_res
=
CvTS
::
OK
;
const
double
sigma1
=
3.0
;
for
(
int
i
=
0
;
i
<
ksizes_num
;
++
i
)
{
for
(
int
j
=
0
;
j
<
ksizes_num
;
++
j
)
{
cv
::
Size
ksize
(
ksizes
[
i
],
ksizes
[
j
]);
ts
->
printf
(
CvTS
::
LOG
,
"
\n
ksize = (%dx%d)
\n
"
,
ksizes
[
i
],
ksizes
[
j
]);
Mat
cpudst
;
cv
::
GaussianBlur
(
img
,
cpudst
,
ksize
,
sigma1
);
GpuMat
gpu1
(
img
);
GpuMat
gpudst
;
cv
::
gpu
::
GaussianBlur
(
gpu1
,
gpudst
,
ksize
,
sigma1
);
if
(
CheckNorm
(
cpudst
,
gpudst
,
ksize
)
!=
CvTS
::
OK
)
test_res
=
CvTS
::
FAIL_GENERIC
;
}
}
return
test_res
;
}
};
////////////////////////////////////////////////////////////////////////////////
// Laplacian
struct
CV_GpuNppImageLaplacianTest
:
public
CV_GpuNppFilterTest
{
CV_GpuNppImageLaplacianTest
()
:
CV_GpuNppFilterTest
(
"GPU-NppImageLaplacian"
,
"Laplacian"
)
{}
int
test
(
const
Mat
&
img
)
{
int
ksizes
[]
=
{
1
,
3
};
int
ksizes_num
=
sizeof
(
ksizes
)
/
sizeof
(
int
);
int
test_res
=
CvTS
::
OK
;
for
(
int
i
=
0
;
i
<
ksizes_num
;
++
i
)
{
ts
->
printf
(
CvTS
::
LOG
,
"
\n
ksize = %d
\n
"
,
ksizes
[
i
]);
Mat
cpudst
;
cv
::
Laplacian
(
img
,
cpudst
,
-
1
,
ksizes
[
i
]);
GpuMat
gpu1
(
img
);
GpuMat
gpudst
;
cv
::
gpu
::
Laplacian
(
gpu1
,
gpudst
,
-
1
,
ksizes
[
i
]);
if
(
CheckNorm
(
cpudst
,
gpudst
,
Size
(
3
,
3
))
!=
CvTS
::
OK
)
test_res
=
CvTS
::
FAIL_GENERIC
;
}
return
test_res
;
}
};
////////////////////////////////////////////////////////////////////////////////
// Erode
class
CV_GpuErodeTest
:
public
CV_GpuNppFilterTest
{
public:
CV_GpuErodeTest
()
:
CV_GpuNppFilterTest
(
"GPU-NppErode"
,
"erode"
)
{}
protected:
virtual
int
test
(
const
Mat
&
img
)
{
Mat
kernel
(
Mat
::
ones
(
3
,
3
,
CV_8U
));
cv
::
Mat
cpuRes
;
cv
::
erode
(
img
,
cpuRes
,
kernel
);
GpuMat
gpuRes
;
cv
::
gpu
::
erode
(
GpuMat
(
img
),
gpuRes
,
kernel
);
return
CheckNorm
(
cpuRes
,
gpuRes
,
Size
(
3
,
3
));
}
};
////////////////////////////////////////////////////////////////////////////////
// Dilate
class
CV_GpuDilateTest
:
public
CV_GpuNppFilterTest
{
public:
CV_GpuDilateTest
()
:
CV_GpuNppFilterTest
(
"GPU-NppDilate"
,
"dilate"
)
{}
protected:
virtual
int
test
(
const
Mat
&
img
)
{
Mat
kernel
(
Mat
::
ones
(
3
,
3
,
CV_8U
));
cv
::
Mat
cpuRes
;
cv
::
dilate
(
img
,
cpuRes
,
kernel
);
GpuMat
gpuRes
;
cv
::
gpu
::
dilate
(
GpuMat
(
img
),
gpuRes
,
kernel
);
return
CheckNorm
(
cpuRes
,
gpuRes
,
Size
(
3
,
3
));
}
};
////////////////////////////////////////////////////////////////////////////////
// MorphologyEx
class
CV_GpuMorphExTest
:
public
CV_GpuNppFilterTest
{
public:
CV_GpuMorphExTest
()
:
CV_GpuNppFilterTest
(
"GPU-NppMorphologyEx"
,
"morphologyEx"
)
{}
protected:
virtual
int
test
(
const
Mat
&
img
)
{
static
int
ops
[]
=
{
MORPH_OPEN
,
CV_MOP_CLOSE
,
CV_MOP_GRADIENT
,
CV_MOP_TOPHAT
,
CV_MOP_BLACKHAT
};
const
char
*
names
[]
=
{
"MORPH_OPEN"
,
"CV_MOP_CLOSE"
,
"CV_MOP_GRADIENT"
,
"CV_MOP_TOPHAT"
,
"CV_MOP_BLACKHAT"
};
int
num
=
sizeof
(
ops
)
/
sizeof
(
ops
[
0
]);
GpuMat
kernel
(
Mat
::
ones
(
3
,
3
,
CV_8U
));
int
res
=
CvTS
::
OK
;
for
(
int
i
=
0
;
i
<
num
;
++
i
)
{
ts
->
printf
(
CvTS
::
LOG
,
"Tesing %s
\n
"
,
names
[
i
]);
cv
::
Mat
cpuRes
;
cv
::
morphologyEx
(
img
,
cpuRes
,
ops
[
i
],
kernel
);
GpuMat
gpuRes
;
cv
::
gpu
::
morphologyEx
(
GpuMat
(
img
),
gpuRes
,
ops
[
i
],
kernel
);
if
(
CvTS
::
OK
!=
CheckNorm
(
cpuRes
,
gpuRes
,
Size
(
3
,
3
)))
res
=
CvTS
::
FAIL_GENERIC
;
}
return
res
;
}
};
/////////////////////////////////////////////////////////////////////////////
/////////////////// tests registration /////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
CV_GpuNppImageBlurTest
CV_GpuNppImageBlur_test
;
CV_GpuNppImageSobelTest
CV_GpuNppImageSobel_test
;
CV_GpuNppImageScharrTest
CV_GpuNppImageScharr_test
;
CV_GpuNppImageGaussianBlurTest
CV_GpuNppImageGaussianBlur_test
;
CV_GpuNppImageLaplacianTest
CV_GpuNppImageLaplacian_test
;
CV_GpuErodeTest
CV_GpuErode_test
;
CV_GpuDilateTest
CV_GpuDilate_test
;
CV_GpuMorphExTest
CV_GpuMorphEx_test
;
\ No newline at end of file
tests/gpu/src/gputest_main.cpp
浏览文件 @
66df8ef0
...
...
@@ -45,25 +45,27 @@ CvTS test_system;
const
char
*
blacklist
[]
=
{
"GPU-NppImageSum"
,
// crash
"GPU-MatOperatorAsyncCall"
,
// crash
//"GPU-NppErode", // different border interpolation
//"GPU-NppMorphologyEx", // different border interpolation
"GPU-NppImageSum"
,
// crash, probably npp bug
"GPU-NppImageMinNax"
,
// npp bug - don't find min/max near right border
//"GPU-NppImageDivide", // different round mode
//"GPU-NppImageMeanStdDev", // different precision
//"GPU-NppImageMinNax", // npp bug - don't find min/max near right border
//"GPU-NppImageResize", // different precision in interpolation
//"GPU-NppImageWarpAffine", // different precision in interpolation
//"GPU-NppImageWarpPerspective", // different precision in interpolation
//"GPU-NppImageIntegral", // different precision
//"GPU-NppImageBlur", // different precision
//"GPU-NppImageExp", // different precision
//"GPU-NppImageLog", // different precision
//"GPU-NppImageMagnitude", // different precision
//"GPU-NppImageSumWindow", // different border interpolation
//"GPU-NppImageSobel", // ???
//"GPU-NppImageGaussianBlur", // different border interpolation
"GPU-NppImageCanny"
,
// NPP_TEXTURE_BIND_ERROR
//"GPU-NppImageResize", // different precision
//"GPU-NppImageWarpAffine", // different precision
//"GPU-NppImageWarpPerspective", // different precision
//"GPU-NppImageIntegral", // different precision
//"GPU-NppImageSobel", // ???
//"GPU-NppImageScharr", // ???
//"GPU-NppImageGaussianBlur", // different precision
//"GPU-NppMorphologyEx", // different precision?
0
};
...
...
tests/gpu/src/imgproc_gpu.cpp
浏览文件 @
66df8ef0
...
...
@@ -413,167 +413,6 @@ struct CV_GpuNppImageIntegralTest : public CV_GpuImageProcTest
}
};
////////////////////////////////////////////////////////////////////////////////
// blur
struct
CV_GpuNppImageBlurTest
:
public
CV_GpuImageProcTest
{
CV_GpuNppImageBlurTest
()
:
CV_GpuImageProcTest
(
"GPU-NppImageBlur"
,
"blur"
)
{}
int
test
(
const
Mat
&
img
)
{
if
(
img
.
type
()
!=
CV_8UC1
&&
img
.
type
()
!=
CV_8UC4
)
{
ts
->
printf
(
CvTS
::
LOG
,
"
\n
Unsupported type
\n
"
);
return
CvTS
::
OK
;
}
int
ksizes
[]
=
{
3
,
5
,
7
};
int
ksizes_num
=
sizeof
(
ksizes
)
/
sizeof
(
int
);
int
test_res
=
CvTS
::
OK
;
for
(
int
i
=
0
;
i
<
ksizes_num
;
++
i
)
{
ts
->
printf
(
CvTS
::
LOG
,
"
\n
ksize = %d
\n
"
,
ksizes
[
i
]);
Mat
cpudst
;
cv
::
blur
(
img
,
cpudst
,
Size
(
ksizes
[
i
],
ksizes
[
i
]));
GpuMat
gpu1
(
img
);
GpuMat
gpudst
;
cv
::
gpu
::
blur
(
gpu1
,
gpudst
,
Size
(
ksizes
[
i
],
ksizes
[
i
]));
if
(
CheckNorm
(
cpudst
,
gpudst
)
!=
CvTS
::
OK
)
test_res
=
CvTS
::
FAIL_GENERIC
;
}
return
test_res
;
}
};
////////////////////////////////////////////////////////////////////////////////
// sumWindow
struct
CV_GpuNppImageSumWindowTest
:
public
CV_GpuImageProcTest
{
CV_GpuNppImageSumWindowTest
()
:
CV_GpuImageProcTest
(
"GPU-NppImageSumWindow"
,
"sumWindow"
)
{}
int
test
(
const
Mat
&
img
)
{
if
(
img
.
type
()
!=
CV_8UC1
)
{
ts
->
printf
(
CvTS
::
LOG
,
"
\n
Unsupported type
\n
"
);
return
CvTS
::
OK
;
}
int
ksizes
[]
=
{
3
,
5
,
7
};
int
ksizes_num
=
sizeof
(
ksizes
)
/
sizeof
(
int
);
int
test_res
=
CvTS
::
OK
;
for
(
int
i
=
0
;
i
<
ksizes_num
;
++
i
)
{
ts
->
printf
(
CvTS
::
LOG
,
"
\n
ksize = %d
\n
"
,
ksizes
[
i
]);
Mat
cpudst
(
img
.
size
(),
CV_64FC1
,
Scalar
());
cv
::
Ptr
<
cv
::
BaseRowFilter
>
ft
=
cv
::
getRowSumFilter
(
CV_8UC1
,
CV_64FC1
,
ksizes
[
i
],
0
);
for
(
int
y
=
0
;
y
<
img
.
rows
;
++
y
)
(
*
ft
)(
img
.
ptr
(
y
),
cpudst
.
ptr
(
y
),
img
.
cols
,
1
);
cpudst
.
convertTo
(
cpudst
,
CV_32F
);
GpuMat
gpu1
(
img
);
GpuMat
gpudst
;
cv
::
gpu
::
sumWindowRow
(
gpu1
,
gpudst
,
ksizes
[
i
],
0
);
if
(
CheckNorm
(
cpudst
,
gpudst
)
!=
CvTS
::
OK
)
test_res
=
CvTS
::
FAIL_GENERIC
;
}
return
test_res
;
}
};
////////////////////////////////////////////////////////////////////////////////
// Sobel
struct
CV_GpuNppImageSobelTest
:
public
CV_GpuImageProcTest
{
CV_GpuNppImageSobelTest
()
:
CV_GpuImageProcTest
(
"GPU-NppImageSobel"
,
"Sobel"
)
{}
int
test
(
const
Mat
&
img
)
{
if
(
img
.
type
()
!=
CV_8UC1
&&
img
.
type
()
!=
CV_8UC4
)
{
ts
->
printf
(
CvTS
::
LOG
,
"
\n
Unsupported type
\n
"
);
return
CvTS
::
OK
;
}
int
ksizes
[]
=
{
3
,
5
,
7
};
int
ksizes_num
=
sizeof
(
ksizes
)
/
sizeof
(
int
);
int
dx
=
1
,
dy
=
0
;
int
test_res
=
CvTS
::
OK
;
for
(
int
i
=
0
;
i
<
ksizes_num
;
++
i
)
{
ts
->
printf
(
CvTS
::
LOG
,
"
\n
ksize = %d
\n
"
,
ksizes
[
i
]);
Mat
cpudst
;
cv
::
Sobel
(
img
,
cpudst
,
-
1
,
dx
,
dy
,
ksizes
[
i
]);
GpuMat
gpu1
(
img
);
GpuMat
gpudst
;
cv
::
gpu
::
Sobel
(
gpu1
,
gpudst
,
-
1
,
dx
,
dy
,
ksizes
[
i
]);
if
(
CheckNorm
(
cpudst
,
gpudst
)
!=
CvTS
::
OK
)
test_res
=
CvTS
::
FAIL_GENERIC
;
}
return
test_res
;
}
};
////////////////////////////////////////////////////////////////////////////////
// GaussianBlur
struct
CV_GpuNppImageGaussianBlurTest
:
public
CV_GpuImageProcTest
{
CV_GpuNppImageGaussianBlurTest
()
:
CV_GpuImageProcTest
(
"GPU-NppImageGaussianBlur"
,
"GaussianBlur"
)
{}
int
test
(
const
Mat
&
img
)
{
if
(
img
.
type
()
!=
CV_8UC1
&&
img
.
type
()
!=
CV_8UC4
)
{
ts
->
printf
(
CvTS
::
LOG
,
"
\n
Unsupported type
\n
"
);
return
CvTS
::
OK
;
}
int
ksizes
[]
=
{
3
,
5
,
7
};
int
ksizes_num
=
sizeof
(
ksizes
)
/
sizeof
(
int
);
int
test_res
=
CvTS
::
OK
;
const
double
sigma1
=
3.0
;
for
(
int
i
=
0
;
i
<
ksizes_num
;
++
i
)
{
for
(
int
j
=
0
;
j
<
ksizes_num
;
++
j
)
{
ts
->
printf
(
CvTS
::
LOG
,
"
\n
ksize = (%dx%d)
\n
"
,
ksizes
[
i
],
ksizes
[
j
]);
Mat
cpudst
;
cv
::
GaussianBlur
(
img
,
cpudst
,
cv
::
Size
(
ksizes
[
i
],
ksizes
[
j
]),
sigma1
);
GpuMat
gpu1
(
img
);
GpuMat
gpudst
;
cv
::
gpu
::
GaussianBlur
(
gpu1
,
gpudst
,
cv
::
Size
(
ksizes
[
i
],
ksizes
[
j
]),
sigma1
);
if
(
CheckNorm
(
cpudst
,
gpudst
)
!=
CvTS
::
OK
)
test_res
=
CvTS
::
FAIL_GENERIC
;
}
}
return
test_res
;
}
};
////////////////////////////////////////////////////////////////////////////////
// Canny
struct
CV_GpuNppImageCannyTest
:
public
CV_GpuImageProcTest
...
...
@@ -705,9 +544,5 @@ CV_GpuNppImageCopyMakeBorderTest CV_GpuNppImageCopyMakeBorder_test;
CV_GpuNppImageWarpAffineTest
CV_GpuNppImageWarpAffine_test
;
CV_GpuNppImageWarpPerspectiveTest
CV_GpuNppImageWarpPerspective_test
;
CV_GpuNppImageIntegralTest
CV_GpuNppImageIntegral_test
;
CV_GpuNppImageBlurTest
CV_GpuNppImageBlur_test
;
CV_GpuNppImageSumWindowTest
CV_GpuNppImageSumWindow_test
;
CV_GpuNppImageSobelTest
CV_GpuNppImageSobel_test
;
CV_GpuNppImageGaussianBlurTest
CV_GpuNppImageGaussianBlur_test
;
CV_GpuNppImageCannyTest
CV_GpuNppImageCanny_test
;
CV_GpuCvtColorTest
CV_GpuCvtColor_test
;
\ No newline at end of file
编辑
预览
Markdown
is supported
0%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录