replaced GPU -> CUDA
This commit is contained in:
Vladislav Vinogradov
parent
3c34b24f1f
commit
fd88654b45
@ -41,8 +41,8 @@
|
|||||||
//
|
//
|
||||||
//M*/
|
//M*/
|
||||||
|
|
||||||
#ifndef __OPENCV_CORE_GPU_HPP__
|
#ifndef __OPENCV_CORE_CUDA_HPP__
|
||||||
#define __OPENCV_CORE_GPU_HPP__
|
#define __OPENCV_CORE_CUDA_HPP__
|
||||||
|
|
||||||
#ifndef __cplusplus
|
#ifndef __cplusplus
|
||||||
# error cuda.hpp header must be compiled as C++
|
# error cuda.hpp header must be compiled as C++
|
||||||
@ -453,7 +453,7 @@ enum FeatureSet
|
|||||||
//! checks whether current device supports the given feature
|
//! checks whether current device supports the given feature
|
||||||
CV_EXPORTS bool deviceSupports(FeatureSet feature_set);
|
CV_EXPORTS bool deviceSupports(FeatureSet feature_set);
|
||||||
|
|
||||||
//! information about what GPU archs this OpenCV GPU module was compiled for
|
//! information about what GPU archs this OpenCV CUDA module was compiled for
|
||||||
class CV_EXPORTS TargetArchs
|
class CV_EXPORTS TargetArchs
|
||||||
{
|
{
|
||||||
public:
|
public:
|
||||||
@ -654,7 +654,7 @@ public:
|
|||||||
//! checks whether device supports the given feature
|
//! checks whether device supports the given feature
|
||||||
bool supports(FeatureSet feature_set) const;
|
bool supports(FeatureSet feature_set) const;
|
||||||
|
|
||||||
//! checks whether the GPU module can be run on the given device
|
//! checks whether the CUDA module can be run on the given device
|
||||||
bool isCompatible() const;
|
bool isCompatible() const;
|
||||||
|
|
||||||
private:
|
private:
|
||||||
@ -675,4 +675,4 @@ template <> CV_EXPORTS void Ptr<cv::cuda::Event::Impl>::delete_obj();
|
|||||||
|
|
||||||
#include "opencv2/core/cuda.inl.hpp"
|
#include "opencv2/core/cuda.inl.hpp"
|
||||||
|
|
||||||
#endif /* __OPENCV_CORE_GPU_HPP__ */
|
#endif /* __OPENCV_CORE_CUDA_HPP__ */
|
||||||
|
|||||||
@ -41,8 +41,8 @@
|
|||||||
//
|
//
|
||||||
//M*/
|
//M*/
|
||||||
|
|
||||||
#ifndef __OPENCV_CORE_GPUINL_HPP__
|
#ifndef __OPENCV_CORE_CUDAINL_HPP__
|
||||||
#define __OPENCV_CORE_GPUINL_HPP__
|
#define __OPENCV_CORE_CUDAINL_HPP__
|
||||||
|
|
||||||
#include "opencv2/core/cuda.hpp"
|
#include "opencv2/core/cuda.hpp"
|
||||||
|
|
||||||
@ -602,4 +602,4 @@ Mat::Mat(const cuda::GpuMat& m)
|
|||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
#endif // __OPENCV_CORE_GPUINL_HPP__
|
#endif // __OPENCV_CORE_CUDAINL_HPP__
|
||||||
|
|||||||
@ -40,8 +40,8 @@
|
|||||||
//
|
//
|
||||||
//M*/
|
//M*/
|
||||||
|
|
||||||
#ifndef __OPENCV_GPU_DEVICE_BLOCK_HPP__
|
#ifndef __OPENCV_CUDA_DEVICE_BLOCK_HPP__
|
||||||
#define __OPENCV_GPU_DEVICE_BLOCK_HPP__
|
#define __OPENCV_CUDA_DEVICE_BLOCK_HPP__
|
||||||
|
|
||||||
namespace cv { namespace cuda { namespace device
|
namespace cv { namespace cuda { namespace device
|
||||||
{
|
{
|
||||||
@ -200,4 +200,4 @@ namespace cv { namespace cuda { namespace device
|
|||||||
};
|
};
|
||||||
}}}
|
}}}
|
||||||
|
|
||||||
#endif /* __OPENCV_GPU_DEVICE_BLOCK_HPP__ */
|
#endif /* __OPENCV_CUDA_DEVICE_BLOCK_HPP__ */
|
||||||
|
|||||||
@ -40,8 +40,8 @@
|
|||||||
//
|
//
|
||||||
//M*/
|
//M*/
|
||||||
|
|
||||||
#ifndef __OPENCV_GPU_BORDER_INTERPOLATE_HPP__
|
#ifndef __OPENCV_CUDA_BORDER_INTERPOLATE_HPP__
|
||||||
#define __OPENCV_GPU_BORDER_INTERPOLATE_HPP__
|
#define __OPENCV_CUDA_BORDER_INTERPOLATE_HPP__
|
||||||
|
|
||||||
#include "saturate_cast.hpp"
|
#include "saturate_cast.hpp"
|
||||||
#include "vec_traits.hpp"
|
#include "vec_traits.hpp"
|
||||||
@ -711,4 +711,4 @@ namespace cv { namespace cuda { namespace device
|
|||||||
};
|
};
|
||||||
}}} // namespace cv { namespace cuda { namespace cudev
|
}}} // namespace cv { namespace cuda { namespace cudev
|
||||||
|
|
||||||
#endif // __OPENCV_GPU_BORDER_INTERPOLATE_HPP__
|
#endif // __OPENCV_CUDA_BORDER_INTERPOLATE_HPP__
|
||||||
|
|||||||
@ -40,262 +40,262 @@
|
|||||||
//
|
//
|
||||||
//M*/
|
//M*/
|
||||||
|
|
||||||
#ifndef __OPENCV_GPU_COLOR_HPP__
|
#ifndef __OPENCV_CUDA_COLOR_HPP__
|
||||||
#define __OPENCV_GPU_COLOR_HPP__
|
#define __OPENCV_CUDA_COLOR_HPP__
|
||||||
|
|
||||||
#include "detail/color_detail.hpp"
|
#include "detail/color_detail.hpp"
|
||||||
|
|
||||||
namespace cv { namespace cuda { namespace device
|
namespace cv { namespace cuda { namespace device
|
||||||
{
|
{
|
||||||
// All OPENCV_GPU_IMPLEMENT_*_TRAITS(ColorSpace1_to_ColorSpace2, ...) macros implements
|
// All OPENCV_CUDA_IMPLEMENT_*_TRAITS(ColorSpace1_to_ColorSpace2, ...) macros implements
|
||||||
// template <typename T> class ColorSpace1_to_ColorSpace2_traits
|
// template <typename T> class ColorSpace1_to_ColorSpace2_traits
|
||||||
// {
|
// {
|
||||||
// typedef ... functor_type;
|
// typedef ... functor_type;
|
||||||
// static __host__ __device__ functor_type create_functor();
|
// static __host__ __device__ functor_type create_functor();
|
||||||
// };
|
// };
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2RGB_TRAITS(bgr_to_rgb, 3, 3, 2)
|
OPENCV_CUDA_IMPLEMENT_RGB2RGB_TRAITS(bgr_to_rgb, 3, 3, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2RGB_TRAITS(bgr_to_bgra, 3, 4, 0)
|
OPENCV_CUDA_IMPLEMENT_RGB2RGB_TRAITS(bgr_to_bgra, 3, 4, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2RGB_TRAITS(bgr_to_rgba, 3, 4, 2)
|
OPENCV_CUDA_IMPLEMENT_RGB2RGB_TRAITS(bgr_to_rgba, 3, 4, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2RGB_TRAITS(bgra_to_bgr, 4, 3, 0)
|
OPENCV_CUDA_IMPLEMENT_RGB2RGB_TRAITS(bgra_to_bgr, 4, 3, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2RGB_TRAITS(bgra_to_rgb, 4, 3, 2)
|
OPENCV_CUDA_IMPLEMENT_RGB2RGB_TRAITS(bgra_to_rgb, 4, 3, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2RGB_TRAITS(bgra_to_rgba, 4, 4, 2)
|
OPENCV_CUDA_IMPLEMENT_RGB2RGB_TRAITS(bgra_to_rgba, 4, 4, 2)
|
||||||
|
|
||||||
#undef OPENCV_GPU_IMPLEMENT_RGB2RGB_TRAITS
|
#undef OPENCV_CUDA_IMPLEMENT_RGB2RGB_TRAITS
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2RGB5x5_TRAITS(bgr_to_bgr555, 3, 0, 5)
|
OPENCV_CUDA_IMPLEMENT_RGB2RGB5x5_TRAITS(bgr_to_bgr555, 3, 0, 5)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2RGB5x5_TRAITS(bgr_to_bgr565, 3, 0, 6)
|
OPENCV_CUDA_IMPLEMENT_RGB2RGB5x5_TRAITS(bgr_to_bgr565, 3, 0, 6)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2RGB5x5_TRAITS(rgb_to_bgr555, 3, 2, 5)
|
OPENCV_CUDA_IMPLEMENT_RGB2RGB5x5_TRAITS(rgb_to_bgr555, 3, 2, 5)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2RGB5x5_TRAITS(rgb_to_bgr565, 3, 2, 6)
|
OPENCV_CUDA_IMPLEMENT_RGB2RGB5x5_TRAITS(rgb_to_bgr565, 3, 2, 6)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2RGB5x5_TRAITS(bgra_to_bgr555, 4, 0, 5)
|
OPENCV_CUDA_IMPLEMENT_RGB2RGB5x5_TRAITS(bgra_to_bgr555, 4, 0, 5)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2RGB5x5_TRAITS(bgra_to_bgr565, 4, 0, 6)
|
OPENCV_CUDA_IMPLEMENT_RGB2RGB5x5_TRAITS(bgra_to_bgr565, 4, 0, 6)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2RGB5x5_TRAITS(rgba_to_bgr555, 4, 2, 5)
|
OPENCV_CUDA_IMPLEMENT_RGB2RGB5x5_TRAITS(rgba_to_bgr555, 4, 2, 5)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2RGB5x5_TRAITS(rgba_to_bgr565, 4, 2, 6)
|
OPENCV_CUDA_IMPLEMENT_RGB2RGB5x5_TRAITS(rgba_to_bgr565, 4, 2, 6)
|
||||||
|
|
||||||
#undef OPENCV_GPU_IMPLEMENT_RGB2RGB5x5_TRAITS
|
#undef OPENCV_CUDA_IMPLEMENT_RGB2RGB5x5_TRAITS
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_RGB5x52RGB_TRAITS(bgr555_to_rgb, 3, 2, 5)
|
OPENCV_CUDA_IMPLEMENT_RGB5x52RGB_TRAITS(bgr555_to_rgb, 3, 2, 5)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB5x52RGB_TRAITS(bgr565_to_rgb, 3, 2, 6)
|
OPENCV_CUDA_IMPLEMENT_RGB5x52RGB_TRAITS(bgr565_to_rgb, 3, 2, 6)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB5x52RGB_TRAITS(bgr555_to_bgr, 3, 0, 5)
|
OPENCV_CUDA_IMPLEMENT_RGB5x52RGB_TRAITS(bgr555_to_bgr, 3, 0, 5)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB5x52RGB_TRAITS(bgr565_to_bgr, 3, 0, 6)
|
OPENCV_CUDA_IMPLEMENT_RGB5x52RGB_TRAITS(bgr565_to_bgr, 3, 0, 6)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB5x52RGB_TRAITS(bgr555_to_rgba, 4, 2, 5)
|
OPENCV_CUDA_IMPLEMENT_RGB5x52RGB_TRAITS(bgr555_to_rgba, 4, 2, 5)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB5x52RGB_TRAITS(bgr565_to_rgba, 4, 2, 6)
|
OPENCV_CUDA_IMPLEMENT_RGB5x52RGB_TRAITS(bgr565_to_rgba, 4, 2, 6)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB5x52RGB_TRAITS(bgr555_to_bgra, 4, 0, 5)
|
OPENCV_CUDA_IMPLEMENT_RGB5x52RGB_TRAITS(bgr555_to_bgra, 4, 0, 5)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB5x52RGB_TRAITS(bgr565_to_bgra, 4, 0, 6)
|
OPENCV_CUDA_IMPLEMENT_RGB5x52RGB_TRAITS(bgr565_to_bgra, 4, 0, 6)
|
||||||
|
|
||||||
#undef OPENCV_GPU_IMPLEMENT_RGB5x52RGB_TRAITS
|
#undef OPENCV_CUDA_IMPLEMENT_RGB5x52RGB_TRAITS
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_GRAY2RGB_TRAITS(gray_to_bgr, 3)
|
OPENCV_CUDA_IMPLEMENT_GRAY2RGB_TRAITS(gray_to_bgr, 3)
|
||||||
OPENCV_GPU_IMPLEMENT_GRAY2RGB_TRAITS(gray_to_bgra, 4)
|
OPENCV_CUDA_IMPLEMENT_GRAY2RGB_TRAITS(gray_to_bgra, 4)
|
||||||
|
|
||||||
#undef OPENCV_GPU_IMPLEMENT_GRAY2RGB_TRAITS
|
#undef OPENCV_CUDA_IMPLEMENT_GRAY2RGB_TRAITS
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_GRAY2RGB5x5_TRAITS(gray_to_bgr555, 5)
|
OPENCV_CUDA_IMPLEMENT_GRAY2RGB5x5_TRAITS(gray_to_bgr555, 5)
|
||||||
OPENCV_GPU_IMPLEMENT_GRAY2RGB5x5_TRAITS(gray_to_bgr565, 6)
|
OPENCV_CUDA_IMPLEMENT_GRAY2RGB5x5_TRAITS(gray_to_bgr565, 6)
|
||||||
|
|
||||||
#undef OPENCV_GPU_IMPLEMENT_GRAY2RGB5x5_TRAITS
|
#undef OPENCV_CUDA_IMPLEMENT_GRAY2RGB5x5_TRAITS
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_RGB5x52GRAY_TRAITS(bgr555_to_gray, 5)
|
OPENCV_CUDA_IMPLEMENT_RGB5x52GRAY_TRAITS(bgr555_to_gray, 5)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB5x52GRAY_TRAITS(bgr565_to_gray, 6)
|
OPENCV_CUDA_IMPLEMENT_RGB5x52GRAY_TRAITS(bgr565_to_gray, 6)
|
||||||
|
|
||||||
#undef OPENCV_GPU_IMPLEMENT_RGB5x52GRAY_TRAITS
|
#undef OPENCV_CUDA_IMPLEMENT_RGB5x52GRAY_TRAITS
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2GRAY_TRAITS(rgb_to_gray, 3, 2)
|
OPENCV_CUDA_IMPLEMENT_RGB2GRAY_TRAITS(rgb_to_gray, 3, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2GRAY_TRAITS(bgr_to_gray, 3, 0)
|
OPENCV_CUDA_IMPLEMENT_RGB2GRAY_TRAITS(bgr_to_gray, 3, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2GRAY_TRAITS(rgba_to_gray, 4, 2)
|
OPENCV_CUDA_IMPLEMENT_RGB2GRAY_TRAITS(rgba_to_gray, 4, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2GRAY_TRAITS(bgra_to_gray, 4, 0)
|
OPENCV_CUDA_IMPLEMENT_RGB2GRAY_TRAITS(bgra_to_gray, 4, 0)
|
||||||
|
|
||||||
#undef OPENCV_GPU_IMPLEMENT_RGB2GRAY_TRAITS
|
#undef OPENCV_CUDA_IMPLEMENT_RGB2GRAY_TRAITS
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2YUV_TRAITS(rgb_to_yuv, 3, 3, 2)
|
OPENCV_CUDA_IMPLEMENT_RGB2YUV_TRAITS(rgb_to_yuv, 3, 3, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2YUV_TRAITS(rgba_to_yuv, 4, 3, 2)
|
OPENCV_CUDA_IMPLEMENT_RGB2YUV_TRAITS(rgba_to_yuv, 4, 3, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2YUV_TRAITS(rgb_to_yuv4, 3, 4, 2)
|
OPENCV_CUDA_IMPLEMENT_RGB2YUV_TRAITS(rgb_to_yuv4, 3, 4, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2YUV_TRAITS(rgba_to_yuv4, 4, 4, 2)
|
OPENCV_CUDA_IMPLEMENT_RGB2YUV_TRAITS(rgba_to_yuv4, 4, 4, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2YUV_TRAITS(bgr_to_yuv, 3, 3, 0)
|
OPENCV_CUDA_IMPLEMENT_RGB2YUV_TRAITS(bgr_to_yuv, 3, 3, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2YUV_TRAITS(bgra_to_yuv, 4, 3, 0)
|
OPENCV_CUDA_IMPLEMENT_RGB2YUV_TRAITS(bgra_to_yuv, 4, 3, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2YUV_TRAITS(bgr_to_yuv4, 3, 4, 0)
|
OPENCV_CUDA_IMPLEMENT_RGB2YUV_TRAITS(bgr_to_yuv4, 3, 4, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2YUV_TRAITS(bgra_to_yuv4, 4, 4, 0)
|
OPENCV_CUDA_IMPLEMENT_RGB2YUV_TRAITS(bgra_to_yuv4, 4, 4, 0)
|
||||||
|
|
||||||
#undef OPENCV_GPU_IMPLEMENT_RGB2YUV_TRAITS
|
#undef OPENCV_CUDA_IMPLEMENT_RGB2YUV_TRAITS
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_YUV2RGB_TRAITS(yuv_to_rgb, 3, 3, 2)
|
OPENCV_CUDA_IMPLEMENT_YUV2RGB_TRAITS(yuv_to_rgb, 3, 3, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_YUV2RGB_TRAITS(yuv_to_rgba, 3, 4, 2)
|
OPENCV_CUDA_IMPLEMENT_YUV2RGB_TRAITS(yuv_to_rgba, 3, 4, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_YUV2RGB_TRAITS(yuv4_to_rgb, 4, 3, 2)
|
OPENCV_CUDA_IMPLEMENT_YUV2RGB_TRAITS(yuv4_to_rgb, 4, 3, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_YUV2RGB_TRAITS(yuv4_to_rgba, 4, 4, 2)
|
OPENCV_CUDA_IMPLEMENT_YUV2RGB_TRAITS(yuv4_to_rgba, 4, 4, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_YUV2RGB_TRAITS(yuv_to_bgr, 3, 3, 0)
|
OPENCV_CUDA_IMPLEMENT_YUV2RGB_TRAITS(yuv_to_bgr, 3, 3, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_YUV2RGB_TRAITS(yuv_to_bgra, 3, 4, 0)
|
OPENCV_CUDA_IMPLEMENT_YUV2RGB_TRAITS(yuv_to_bgra, 3, 4, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_YUV2RGB_TRAITS(yuv4_to_bgr, 4, 3, 0)
|
OPENCV_CUDA_IMPLEMENT_YUV2RGB_TRAITS(yuv4_to_bgr, 4, 3, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_YUV2RGB_TRAITS(yuv4_to_bgra, 4, 4, 0)
|
OPENCV_CUDA_IMPLEMENT_YUV2RGB_TRAITS(yuv4_to_bgra, 4, 4, 0)
|
||||||
|
|
||||||
#undef OPENCV_GPU_IMPLEMENT_YUV2RGB_TRAITS
|
#undef OPENCV_CUDA_IMPLEMENT_YUV2RGB_TRAITS
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2YCrCb_TRAITS(rgb_to_YCrCb, 3, 3, 2)
|
OPENCV_CUDA_IMPLEMENT_RGB2YCrCb_TRAITS(rgb_to_YCrCb, 3, 3, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2YCrCb_TRAITS(rgba_to_YCrCb, 4, 3, 2)
|
OPENCV_CUDA_IMPLEMENT_RGB2YCrCb_TRAITS(rgba_to_YCrCb, 4, 3, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2YCrCb_TRAITS(rgb_to_YCrCb4, 3, 4, 2)
|
OPENCV_CUDA_IMPLEMENT_RGB2YCrCb_TRAITS(rgb_to_YCrCb4, 3, 4, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2YCrCb_TRAITS(rgba_to_YCrCb4, 4, 4, 2)
|
OPENCV_CUDA_IMPLEMENT_RGB2YCrCb_TRAITS(rgba_to_YCrCb4, 4, 4, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2YCrCb_TRAITS(bgr_to_YCrCb, 3, 3, 0)
|
OPENCV_CUDA_IMPLEMENT_RGB2YCrCb_TRAITS(bgr_to_YCrCb, 3, 3, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2YCrCb_TRAITS(bgra_to_YCrCb, 4, 3, 0)
|
OPENCV_CUDA_IMPLEMENT_RGB2YCrCb_TRAITS(bgra_to_YCrCb, 4, 3, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2YCrCb_TRAITS(bgr_to_YCrCb4, 3, 4, 0)
|
OPENCV_CUDA_IMPLEMENT_RGB2YCrCb_TRAITS(bgr_to_YCrCb4, 3, 4, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2YCrCb_TRAITS(bgra_to_YCrCb4, 4, 4, 0)
|
OPENCV_CUDA_IMPLEMENT_RGB2YCrCb_TRAITS(bgra_to_YCrCb4, 4, 4, 0)
|
||||||
|
|
||||||
#undef OPENCV_GPU_IMPLEMENT_RGB2YCrCb_TRAITS
|
#undef OPENCV_CUDA_IMPLEMENT_RGB2YCrCb_TRAITS
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_YCrCb2RGB_TRAITS(YCrCb_to_rgb, 3, 3, 2)
|
OPENCV_CUDA_IMPLEMENT_YCrCb2RGB_TRAITS(YCrCb_to_rgb, 3, 3, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_YCrCb2RGB_TRAITS(YCrCb_to_rgba, 3, 4, 2)
|
OPENCV_CUDA_IMPLEMENT_YCrCb2RGB_TRAITS(YCrCb_to_rgba, 3, 4, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_YCrCb2RGB_TRAITS(YCrCb4_to_rgb, 4, 3, 2)
|
OPENCV_CUDA_IMPLEMENT_YCrCb2RGB_TRAITS(YCrCb4_to_rgb, 4, 3, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_YCrCb2RGB_TRAITS(YCrCb4_to_rgba, 4, 4, 2)
|
OPENCV_CUDA_IMPLEMENT_YCrCb2RGB_TRAITS(YCrCb4_to_rgba, 4, 4, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_YCrCb2RGB_TRAITS(YCrCb_to_bgr, 3, 3, 0)
|
OPENCV_CUDA_IMPLEMENT_YCrCb2RGB_TRAITS(YCrCb_to_bgr, 3, 3, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_YCrCb2RGB_TRAITS(YCrCb_to_bgra, 3, 4, 0)
|
OPENCV_CUDA_IMPLEMENT_YCrCb2RGB_TRAITS(YCrCb_to_bgra, 3, 4, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_YCrCb2RGB_TRAITS(YCrCb4_to_bgr, 4, 3, 0)
|
OPENCV_CUDA_IMPLEMENT_YCrCb2RGB_TRAITS(YCrCb4_to_bgr, 4, 3, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_YCrCb2RGB_TRAITS(YCrCb4_to_bgra, 4, 4, 0)
|
OPENCV_CUDA_IMPLEMENT_YCrCb2RGB_TRAITS(YCrCb4_to_bgra, 4, 4, 0)
|
||||||
|
|
||||||
#undef OPENCV_GPU_IMPLEMENT_YCrCb2RGB_TRAITS
|
#undef OPENCV_CUDA_IMPLEMENT_YCrCb2RGB_TRAITS
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2XYZ_TRAITS(rgb_to_xyz, 3, 3, 2)
|
OPENCV_CUDA_IMPLEMENT_RGB2XYZ_TRAITS(rgb_to_xyz, 3, 3, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2XYZ_TRAITS(rgba_to_xyz, 4, 3, 2)
|
OPENCV_CUDA_IMPLEMENT_RGB2XYZ_TRAITS(rgba_to_xyz, 4, 3, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2XYZ_TRAITS(rgb_to_xyz4, 3, 4, 2)
|
OPENCV_CUDA_IMPLEMENT_RGB2XYZ_TRAITS(rgb_to_xyz4, 3, 4, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2XYZ_TRAITS(rgba_to_xyz4, 4, 4, 2)
|
OPENCV_CUDA_IMPLEMENT_RGB2XYZ_TRAITS(rgba_to_xyz4, 4, 4, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2XYZ_TRAITS(bgr_to_xyz, 3, 3, 0)
|
OPENCV_CUDA_IMPLEMENT_RGB2XYZ_TRAITS(bgr_to_xyz, 3, 3, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2XYZ_TRAITS(bgra_to_xyz, 4, 3, 0)
|
OPENCV_CUDA_IMPLEMENT_RGB2XYZ_TRAITS(bgra_to_xyz, 4, 3, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2XYZ_TRAITS(bgr_to_xyz4, 3, 4, 0)
|
OPENCV_CUDA_IMPLEMENT_RGB2XYZ_TRAITS(bgr_to_xyz4, 3, 4, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2XYZ_TRAITS(bgra_to_xyz4, 4, 4, 0)
|
OPENCV_CUDA_IMPLEMENT_RGB2XYZ_TRAITS(bgra_to_xyz4, 4, 4, 0)
|
||||||
|
|
||||||
#undef OPENCV_GPU_IMPLEMENT_RGB2XYZ_TRAITS
|
#undef OPENCV_CUDA_IMPLEMENT_RGB2XYZ_TRAITS
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_XYZ2RGB_TRAITS(xyz_to_rgb, 3, 3, 2)
|
OPENCV_CUDA_IMPLEMENT_XYZ2RGB_TRAITS(xyz_to_rgb, 3, 3, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_XYZ2RGB_TRAITS(xyz4_to_rgb, 4, 3, 2)
|
OPENCV_CUDA_IMPLEMENT_XYZ2RGB_TRAITS(xyz4_to_rgb, 4, 3, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_XYZ2RGB_TRAITS(xyz_to_rgba, 3, 4, 2)
|
OPENCV_CUDA_IMPLEMENT_XYZ2RGB_TRAITS(xyz_to_rgba, 3, 4, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_XYZ2RGB_TRAITS(xyz4_to_rgba, 4, 4, 2)
|
OPENCV_CUDA_IMPLEMENT_XYZ2RGB_TRAITS(xyz4_to_rgba, 4, 4, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_XYZ2RGB_TRAITS(xyz_to_bgr, 3, 3, 0)
|
OPENCV_CUDA_IMPLEMENT_XYZ2RGB_TRAITS(xyz_to_bgr, 3, 3, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_XYZ2RGB_TRAITS(xyz4_to_bgr, 4, 3, 0)
|
OPENCV_CUDA_IMPLEMENT_XYZ2RGB_TRAITS(xyz4_to_bgr, 4, 3, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_XYZ2RGB_TRAITS(xyz_to_bgra, 3, 4, 0)
|
OPENCV_CUDA_IMPLEMENT_XYZ2RGB_TRAITS(xyz_to_bgra, 3, 4, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_XYZ2RGB_TRAITS(xyz4_to_bgra, 4, 4, 0)
|
OPENCV_CUDA_IMPLEMENT_XYZ2RGB_TRAITS(xyz4_to_bgra, 4, 4, 0)
|
||||||
|
|
||||||
#undef OPENCV_GPU_IMPLEMENT_XYZ2RGB_TRAITS
|
#undef OPENCV_CUDA_IMPLEMENT_XYZ2RGB_TRAITS
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2HSV_TRAITS(rgb_to_hsv, 3, 3, 2)
|
OPENCV_CUDA_IMPLEMENT_RGB2HSV_TRAITS(rgb_to_hsv, 3, 3, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2HSV_TRAITS(rgba_to_hsv, 4, 3, 2)
|
OPENCV_CUDA_IMPLEMENT_RGB2HSV_TRAITS(rgba_to_hsv, 4, 3, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2HSV_TRAITS(rgb_to_hsv4, 3, 4, 2)
|
OPENCV_CUDA_IMPLEMENT_RGB2HSV_TRAITS(rgb_to_hsv4, 3, 4, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2HSV_TRAITS(rgba_to_hsv4, 4, 4, 2)
|
OPENCV_CUDA_IMPLEMENT_RGB2HSV_TRAITS(rgba_to_hsv4, 4, 4, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2HSV_TRAITS(bgr_to_hsv, 3, 3, 0)
|
OPENCV_CUDA_IMPLEMENT_RGB2HSV_TRAITS(bgr_to_hsv, 3, 3, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2HSV_TRAITS(bgra_to_hsv, 4, 3, 0)
|
OPENCV_CUDA_IMPLEMENT_RGB2HSV_TRAITS(bgra_to_hsv, 4, 3, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2HSV_TRAITS(bgr_to_hsv4, 3, 4, 0)
|
OPENCV_CUDA_IMPLEMENT_RGB2HSV_TRAITS(bgr_to_hsv4, 3, 4, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2HSV_TRAITS(bgra_to_hsv4, 4, 4, 0)
|
OPENCV_CUDA_IMPLEMENT_RGB2HSV_TRAITS(bgra_to_hsv4, 4, 4, 0)
|
||||||
|
|
||||||
#undef OPENCV_GPU_IMPLEMENT_RGB2HSV_TRAITS
|
#undef OPENCV_CUDA_IMPLEMENT_RGB2HSV_TRAITS
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_HSV2RGB_TRAITS(hsv_to_rgb, 3, 3, 2)
|
OPENCV_CUDA_IMPLEMENT_HSV2RGB_TRAITS(hsv_to_rgb, 3, 3, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_HSV2RGB_TRAITS(hsv_to_rgba, 3, 4, 2)
|
OPENCV_CUDA_IMPLEMENT_HSV2RGB_TRAITS(hsv_to_rgba, 3, 4, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_HSV2RGB_TRAITS(hsv4_to_rgb, 4, 3, 2)
|
OPENCV_CUDA_IMPLEMENT_HSV2RGB_TRAITS(hsv4_to_rgb, 4, 3, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_HSV2RGB_TRAITS(hsv4_to_rgba, 4, 4, 2)
|
OPENCV_CUDA_IMPLEMENT_HSV2RGB_TRAITS(hsv4_to_rgba, 4, 4, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_HSV2RGB_TRAITS(hsv_to_bgr, 3, 3, 0)
|
OPENCV_CUDA_IMPLEMENT_HSV2RGB_TRAITS(hsv_to_bgr, 3, 3, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_HSV2RGB_TRAITS(hsv_to_bgra, 3, 4, 0)
|
OPENCV_CUDA_IMPLEMENT_HSV2RGB_TRAITS(hsv_to_bgra, 3, 4, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_HSV2RGB_TRAITS(hsv4_to_bgr, 4, 3, 0)
|
OPENCV_CUDA_IMPLEMENT_HSV2RGB_TRAITS(hsv4_to_bgr, 4, 3, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_HSV2RGB_TRAITS(hsv4_to_bgra, 4, 4, 0)
|
OPENCV_CUDA_IMPLEMENT_HSV2RGB_TRAITS(hsv4_to_bgra, 4, 4, 0)
|
||||||
|
|
||||||
#undef OPENCV_GPU_IMPLEMENT_HSV2RGB_TRAITS
|
#undef OPENCV_CUDA_IMPLEMENT_HSV2RGB_TRAITS
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2HLS_TRAITS(rgb_to_hls, 3, 3, 2)
|
OPENCV_CUDA_IMPLEMENT_RGB2HLS_TRAITS(rgb_to_hls, 3, 3, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2HLS_TRAITS(rgba_to_hls, 4, 3, 2)
|
OPENCV_CUDA_IMPLEMENT_RGB2HLS_TRAITS(rgba_to_hls, 4, 3, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2HLS_TRAITS(rgb_to_hls4, 3, 4, 2)
|
OPENCV_CUDA_IMPLEMENT_RGB2HLS_TRAITS(rgb_to_hls4, 3, 4, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2HLS_TRAITS(rgba_to_hls4, 4, 4, 2)
|
OPENCV_CUDA_IMPLEMENT_RGB2HLS_TRAITS(rgba_to_hls4, 4, 4, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2HLS_TRAITS(bgr_to_hls, 3, 3, 0)
|
OPENCV_CUDA_IMPLEMENT_RGB2HLS_TRAITS(bgr_to_hls, 3, 3, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2HLS_TRAITS(bgra_to_hls, 4, 3, 0)
|
OPENCV_CUDA_IMPLEMENT_RGB2HLS_TRAITS(bgra_to_hls, 4, 3, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2HLS_TRAITS(bgr_to_hls4, 3, 4, 0)
|
OPENCV_CUDA_IMPLEMENT_RGB2HLS_TRAITS(bgr_to_hls4, 3, 4, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2HLS_TRAITS(bgra_to_hls4, 4, 4, 0)
|
OPENCV_CUDA_IMPLEMENT_RGB2HLS_TRAITS(bgra_to_hls4, 4, 4, 0)
|
||||||
|
|
||||||
#undef OPENCV_GPU_IMPLEMENT_RGB2HLS_TRAITS
|
#undef OPENCV_CUDA_IMPLEMENT_RGB2HLS_TRAITS
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_HLS2RGB_TRAITS(hls_to_rgb, 3, 3, 2)
|
OPENCV_CUDA_IMPLEMENT_HLS2RGB_TRAITS(hls_to_rgb, 3, 3, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_HLS2RGB_TRAITS(hls_to_rgba, 3, 4, 2)
|
OPENCV_CUDA_IMPLEMENT_HLS2RGB_TRAITS(hls_to_rgba, 3, 4, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_HLS2RGB_TRAITS(hls4_to_rgb, 4, 3, 2)
|
OPENCV_CUDA_IMPLEMENT_HLS2RGB_TRAITS(hls4_to_rgb, 4, 3, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_HLS2RGB_TRAITS(hls4_to_rgba, 4, 4, 2)
|
OPENCV_CUDA_IMPLEMENT_HLS2RGB_TRAITS(hls4_to_rgba, 4, 4, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_HLS2RGB_TRAITS(hls_to_bgr, 3, 3, 0)
|
OPENCV_CUDA_IMPLEMENT_HLS2RGB_TRAITS(hls_to_bgr, 3, 3, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_HLS2RGB_TRAITS(hls_to_bgra, 3, 4, 0)
|
OPENCV_CUDA_IMPLEMENT_HLS2RGB_TRAITS(hls_to_bgra, 3, 4, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_HLS2RGB_TRAITS(hls4_to_bgr, 4, 3, 0)
|
OPENCV_CUDA_IMPLEMENT_HLS2RGB_TRAITS(hls4_to_bgr, 4, 3, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_HLS2RGB_TRAITS(hls4_to_bgra, 4, 4, 0)
|
OPENCV_CUDA_IMPLEMENT_HLS2RGB_TRAITS(hls4_to_bgra, 4, 4, 0)
|
||||||
|
|
||||||
#undef OPENCV_GPU_IMPLEMENT_HLS2RGB_TRAITS
|
#undef OPENCV_CUDA_IMPLEMENT_HLS2RGB_TRAITS
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2Lab_TRAITS(rgb_to_lab, 3, 3, true, 2)
|
OPENCV_CUDA_IMPLEMENT_RGB2Lab_TRAITS(rgb_to_lab, 3, 3, true, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2Lab_TRAITS(rgba_to_lab, 4, 3, true, 2)
|
OPENCV_CUDA_IMPLEMENT_RGB2Lab_TRAITS(rgba_to_lab, 4, 3, true, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2Lab_TRAITS(rgb_to_lab4, 3, 4, true, 2)
|
OPENCV_CUDA_IMPLEMENT_RGB2Lab_TRAITS(rgb_to_lab4, 3, 4, true, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2Lab_TRAITS(rgba_to_lab4, 4, 4, true, 2)
|
OPENCV_CUDA_IMPLEMENT_RGB2Lab_TRAITS(rgba_to_lab4, 4, 4, true, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2Lab_TRAITS(bgr_to_lab, 3, 3, true, 0)
|
OPENCV_CUDA_IMPLEMENT_RGB2Lab_TRAITS(bgr_to_lab, 3, 3, true, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2Lab_TRAITS(bgra_to_lab, 4, 3, true, 0)
|
OPENCV_CUDA_IMPLEMENT_RGB2Lab_TRAITS(bgra_to_lab, 4, 3, true, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2Lab_TRAITS(bgr_to_lab4, 3, 4, true, 0)
|
OPENCV_CUDA_IMPLEMENT_RGB2Lab_TRAITS(bgr_to_lab4, 3, 4, true, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2Lab_TRAITS(bgra_to_lab4, 4, 4, true, 0)
|
OPENCV_CUDA_IMPLEMENT_RGB2Lab_TRAITS(bgra_to_lab4, 4, 4, true, 0)
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2Lab_TRAITS(lrgb_to_lab, 3, 3, false, 2)
|
OPENCV_CUDA_IMPLEMENT_RGB2Lab_TRAITS(lrgb_to_lab, 3, 3, false, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2Lab_TRAITS(lrgba_to_lab, 4, 3, false, 2)
|
OPENCV_CUDA_IMPLEMENT_RGB2Lab_TRAITS(lrgba_to_lab, 4, 3, false, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2Lab_TRAITS(lrgb_to_lab4, 3, 4, false, 2)
|
OPENCV_CUDA_IMPLEMENT_RGB2Lab_TRAITS(lrgb_to_lab4, 3, 4, false, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2Lab_TRAITS(lrgba_to_lab4, 4, 4, false, 2)
|
OPENCV_CUDA_IMPLEMENT_RGB2Lab_TRAITS(lrgba_to_lab4, 4, 4, false, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2Lab_TRAITS(lbgr_to_lab, 3, 3, false, 0)
|
OPENCV_CUDA_IMPLEMENT_RGB2Lab_TRAITS(lbgr_to_lab, 3, 3, false, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2Lab_TRAITS(lbgra_to_lab, 4, 3, false, 0)
|
OPENCV_CUDA_IMPLEMENT_RGB2Lab_TRAITS(lbgra_to_lab, 4, 3, false, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2Lab_TRAITS(lbgr_to_lab4, 3, 4, false, 0)
|
OPENCV_CUDA_IMPLEMENT_RGB2Lab_TRAITS(lbgr_to_lab4, 3, 4, false, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2Lab_TRAITS(lbgra_to_lab4, 4, 4, false, 0)
|
OPENCV_CUDA_IMPLEMENT_RGB2Lab_TRAITS(lbgra_to_lab4, 4, 4, false, 0)
|
||||||
|
|
||||||
#undef OPENCV_GPU_IMPLEMENT_RGB2Lab_TRAITS
|
#undef OPENCV_CUDA_IMPLEMENT_RGB2Lab_TRAITS
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_Lab2RGB_TRAITS(lab_to_rgb, 3, 3, true, 2)
|
OPENCV_CUDA_IMPLEMENT_Lab2RGB_TRAITS(lab_to_rgb, 3, 3, true, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_Lab2RGB_TRAITS(lab4_to_rgb, 4, 3, true, 2)
|
OPENCV_CUDA_IMPLEMENT_Lab2RGB_TRAITS(lab4_to_rgb, 4, 3, true, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_Lab2RGB_TRAITS(lab_to_rgba, 3, 4, true, 2)
|
OPENCV_CUDA_IMPLEMENT_Lab2RGB_TRAITS(lab_to_rgba, 3, 4, true, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_Lab2RGB_TRAITS(lab4_to_rgba, 4, 4, true, 2)
|
OPENCV_CUDA_IMPLEMENT_Lab2RGB_TRAITS(lab4_to_rgba, 4, 4, true, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_Lab2RGB_TRAITS(lab_to_bgr, 3, 3, true, 0)
|
OPENCV_CUDA_IMPLEMENT_Lab2RGB_TRAITS(lab_to_bgr, 3, 3, true, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_Lab2RGB_TRAITS(lab4_to_bgr, 4, 3, true, 0)
|
OPENCV_CUDA_IMPLEMENT_Lab2RGB_TRAITS(lab4_to_bgr, 4, 3, true, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_Lab2RGB_TRAITS(lab_to_bgra, 3, 4, true, 0)
|
OPENCV_CUDA_IMPLEMENT_Lab2RGB_TRAITS(lab_to_bgra, 3, 4, true, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_Lab2RGB_TRAITS(lab4_to_bgra, 4, 4, true, 0)
|
OPENCV_CUDA_IMPLEMENT_Lab2RGB_TRAITS(lab4_to_bgra, 4, 4, true, 0)
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_Lab2RGB_TRAITS(lab_to_lrgb, 3, 3, false, 2)
|
OPENCV_CUDA_IMPLEMENT_Lab2RGB_TRAITS(lab_to_lrgb, 3, 3, false, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_Lab2RGB_TRAITS(lab4_to_lrgb, 4, 3, false, 2)
|
OPENCV_CUDA_IMPLEMENT_Lab2RGB_TRAITS(lab4_to_lrgb, 4, 3, false, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_Lab2RGB_TRAITS(lab_to_lrgba, 3, 4, false, 2)
|
OPENCV_CUDA_IMPLEMENT_Lab2RGB_TRAITS(lab_to_lrgba, 3, 4, false, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_Lab2RGB_TRAITS(lab4_to_lrgba, 4, 4, false, 2)
|
OPENCV_CUDA_IMPLEMENT_Lab2RGB_TRAITS(lab4_to_lrgba, 4, 4, false, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_Lab2RGB_TRAITS(lab_to_lbgr, 3, 3, false, 0)
|
OPENCV_CUDA_IMPLEMENT_Lab2RGB_TRAITS(lab_to_lbgr, 3, 3, false, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_Lab2RGB_TRAITS(lab4_to_lbgr, 4, 3, false, 0)
|
OPENCV_CUDA_IMPLEMENT_Lab2RGB_TRAITS(lab4_to_lbgr, 4, 3, false, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_Lab2RGB_TRAITS(lab_to_lbgra, 3, 4, false, 0)
|
OPENCV_CUDA_IMPLEMENT_Lab2RGB_TRAITS(lab_to_lbgra, 3, 4, false, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_Lab2RGB_TRAITS(lab4_to_lbgra, 4, 4, false, 0)
|
OPENCV_CUDA_IMPLEMENT_Lab2RGB_TRAITS(lab4_to_lbgra, 4, 4, false, 0)
|
||||||
|
|
||||||
#undef OPENCV_GPU_IMPLEMENT_Lab2RGB_TRAITS
|
#undef OPENCV_CUDA_IMPLEMENT_Lab2RGB_TRAITS
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2Luv_TRAITS(rgb_to_luv, 3, 3, true, 2)
|
OPENCV_CUDA_IMPLEMENT_RGB2Luv_TRAITS(rgb_to_luv, 3, 3, true, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2Luv_TRAITS(rgba_to_luv, 4, 3, true, 2)
|
OPENCV_CUDA_IMPLEMENT_RGB2Luv_TRAITS(rgba_to_luv, 4, 3, true, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2Luv_TRAITS(rgb_to_luv4, 3, 4, true, 2)
|
OPENCV_CUDA_IMPLEMENT_RGB2Luv_TRAITS(rgb_to_luv4, 3, 4, true, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2Luv_TRAITS(rgba_to_luv4, 4, 4, true, 2)
|
OPENCV_CUDA_IMPLEMENT_RGB2Luv_TRAITS(rgba_to_luv4, 4, 4, true, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2Luv_TRAITS(bgr_to_luv, 3, 3, true, 0)
|
OPENCV_CUDA_IMPLEMENT_RGB2Luv_TRAITS(bgr_to_luv, 3, 3, true, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2Luv_TRAITS(bgra_to_luv, 4, 3, true, 0)
|
OPENCV_CUDA_IMPLEMENT_RGB2Luv_TRAITS(bgra_to_luv, 4, 3, true, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2Luv_TRAITS(bgr_to_luv4, 3, 4, true, 0)
|
OPENCV_CUDA_IMPLEMENT_RGB2Luv_TRAITS(bgr_to_luv4, 3, 4, true, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2Luv_TRAITS(bgra_to_luv4, 4, 4, true, 0)
|
OPENCV_CUDA_IMPLEMENT_RGB2Luv_TRAITS(bgra_to_luv4, 4, 4, true, 0)
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2Luv_TRAITS(lrgb_to_luv, 3, 3, false, 2)
|
OPENCV_CUDA_IMPLEMENT_RGB2Luv_TRAITS(lrgb_to_luv, 3, 3, false, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2Luv_TRAITS(lrgba_to_luv, 4, 3, false, 2)
|
OPENCV_CUDA_IMPLEMENT_RGB2Luv_TRAITS(lrgba_to_luv, 4, 3, false, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2Luv_TRAITS(lrgb_to_luv4, 3, 4, false, 2)
|
OPENCV_CUDA_IMPLEMENT_RGB2Luv_TRAITS(lrgb_to_luv4, 3, 4, false, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2Luv_TRAITS(lrgba_to_luv4, 4, 4, false, 2)
|
OPENCV_CUDA_IMPLEMENT_RGB2Luv_TRAITS(lrgba_to_luv4, 4, 4, false, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2Luv_TRAITS(lbgr_to_luv, 3, 3, false, 0)
|
OPENCV_CUDA_IMPLEMENT_RGB2Luv_TRAITS(lbgr_to_luv, 3, 3, false, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2Luv_TRAITS(lbgra_to_luv, 4, 3, false, 0)
|
OPENCV_CUDA_IMPLEMENT_RGB2Luv_TRAITS(lbgra_to_luv, 4, 3, false, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2Luv_TRAITS(lbgr_to_luv4, 3, 4, false, 0)
|
OPENCV_CUDA_IMPLEMENT_RGB2Luv_TRAITS(lbgr_to_luv4, 3, 4, false, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_RGB2Luv_TRAITS(lbgra_to_luv4, 4, 4, false, 0)
|
OPENCV_CUDA_IMPLEMENT_RGB2Luv_TRAITS(lbgra_to_luv4, 4, 4, false, 0)
|
||||||
|
|
||||||
#undef OPENCV_GPU_IMPLEMENT_RGB2Luv_TRAITS
|
#undef OPENCV_CUDA_IMPLEMENT_RGB2Luv_TRAITS
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_Luv2RGB_TRAITS(luv_to_rgb, 3, 3, true, 2)
|
OPENCV_CUDA_IMPLEMENT_Luv2RGB_TRAITS(luv_to_rgb, 3, 3, true, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_Luv2RGB_TRAITS(luv4_to_rgb, 4, 3, true, 2)
|
OPENCV_CUDA_IMPLEMENT_Luv2RGB_TRAITS(luv4_to_rgb, 4, 3, true, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_Luv2RGB_TRAITS(luv_to_rgba, 3, 4, true, 2)
|
OPENCV_CUDA_IMPLEMENT_Luv2RGB_TRAITS(luv_to_rgba, 3, 4, true, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_Luv2RGB_TRAITS(luv4_to_rgba, 4, 4, true, 2)
|
OPENCV_CUDA_IMPLEMENT_Luv2RGB_TRAITS(luv4_to_rgba, 4, 4, true, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_Luv2RGB_TRAITS(luv_to_bgr, 3, 3, true, 0)
|
OPENCV_CUDA_IMPLEMENT_Luv2RGB_TRAITS(luv_to_bgr, 3, 3, true, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_Luv2RGB_TRAITS(luv4_to_bgr, 4, 3, true, 0)
|
OPENCV_CUDA_IMPLEMENT_Luv2RGB_TRAITS(luv4_to_bgr, 4, 3, true, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_Luv2RGB_TRAITS(luv_to_bgra, 3, 4, true, 0)
|
OPENCV_CUDA_IMPLEMENT_Luv2RGB_TRAITS(luv_to_bgra, 3, 4, true, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_Luv2RGB_TRAITS(luv4_to_bgra, 4, 4, true, 0)
|
OPENCV_CUDA_IMPLEMENT_Luv2RGB_TRAITS(luv4_to_bgra, 4, 4, true, 0)
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_Luv2RGB_TRAITS(luv_to_lrgb, 3, 3, false, 2)
|
OPENCV_CUDA_IMPLEMENT_Luv2RGB_TRAITS(luv_to_lrgb, 3, 3, false, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_Luv2RGB_TRAITS(luv4_to_lrgb, 4, 3, false, 2)
|
OPENCV_CUDA_IMPLEMENT_Luv2RGB_TRAITS(luv4_to_lrgb, 4, 3, false, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_Luv2RGB_TRAITS(luv_to_lrgba, 3, 4, false, 2)
|
OPENCV_CUDA_IMPLEMENT_Luv2RGB_TRAITS(luv_to_lrgba, 3, 4, false, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_Luv2RGB_TRAITS(luv4_to_lrgba, 4, 4, false, 2)
|
OPENCV_CUDA_IMPLEMENT_Luv2RGB_TRAITS(luv4_to_lrgba, 4, 4, false, 2)
|
||||||
OPENCV_GPU_IMPLEMENT_Luv2RGB_TRAITS(luv_to_lbgr, 3, 3, false, 0)
|
OPENCV_CUDA_IMPLEMENT_Luv2RGB_TRAITS(luv_to_lbgr, 3, 3, false, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_Luv2RGB_TRAITS(luv4_to_lbgr, 4, 3, false, 0)
|
OPENCV_CUDA_IMPLEMENT_Luv2RGB_TRAITS(luv4_to_lbgr, 4, 3, false, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_Luv2RGB_TRAITS(luv_to_lbgra, 3, 4, false, 0)
|
OPENCV_CUDA_IMPLEMENT_Luv2RGB_TRAITS(luv_to_lbgra, 3, 4, false, 0)
|
||||||
OPENCV_GPU_IMPLEMENT_Luv2RGB_TRAITS(luv4_to_lbgra, 4, 4, false, 0)
|
OPENCV_CUDA_IMPLEMENT_Luv2RGB_TRAITS(luv4_to_lbgra, 4, 4, false, 0)
|
||||||
|
|
||||||
#undef OPENCV_GPU_IMPLEMENT_Luv2RGB_TRAITS
|
#undef OPENCV_CUDA_IMPLEMENT_Luv2RGB_TRAITS
|
||||||
}}} // namespace cv { namespace cuda { namespace cudev
|
}}} // namespace cv { namespace cuda { namespace cudev
|
||||||
|
|
||||||
#endif // __OPENCV_GPU_BORDER_INTERPOLATE_HPP__
|
#endif // __OPENCV_CUDA_BORDER_INTERPOLATE_HPP__
|
||||||
|
|||||||
@ -40,8 +40,8 @@
|
|||||||
//
|
//
|
||||||
//M*/
|
//M*/
|
||||||
|
|
||||||
#ifndef __OPENCV_GPU_COMMON_HPP__
|
#ifndef __OPENCV_CUDA_COMMON_HPP__
|
||||||
#define __OPENCV_GPU_COMMON_HPP__
|
#define __OPENCV_CUDA_COMMON_HPP__
|
||||||
|
|
||||||
#include <cuda_runtime.h>
|
#include <cuda_runtime.h>
|
||||||
#include "opencv2/core/cuda_types.hpp"
|
#include "opencv2/core/cuda_types.hpp"
|
||||||
@ -104,4 +104,4 @@ namespace cv { namespace cuda
|
|||||||
|
|
||||||
|
|
||||||
|
|
||||||
#endif // __OPENCV_GPU_COMMON_HPP__
|
#endif // __OPENCV_CUDA_COMMON_HPP__
|
||||||
|
|||||||
@ -40,8 +40,8 @@
|
|||||||
//
|
//
|
||||||
//M*/
|
//M*/
|
||||||
|
|
||||||
#ifndef __OPENCV_GPU_DATAMOV_UTILS_HPP__
|
#ifndef __OPENCV_CUDA_DATAMOV_UTILS_HPP__
|
||||||
#define __OPENCV_GPU_DATAMOV_UTILS_HPP__
|
#define __OPENCV_CUDA_DATAMOV_UTILS_HPP__
|
||||||
|
|
||||||
#include "common.hpp"
|
#include "common.hpp"
|
||||||
|
|
||||||
@ -59,47 +59,47 @@ namespace cv { namespace cuda { namespace device
|
|||||||
|
|
||||||
#if defined(_WIN64) || defined(__LP64__)
|
#if defined(_WIN64) || defined(__LP64__)
|
||||||
// 64-bit register modifier for inlined asm
|
// 64-bit register modifier for inlined asm
|
||||||
#define OPENCV_GPU_ASM_PTR "l"
|
#define OPENCV_CUDA_ASM_PTR "l"
|
||||||
#else
|
#else
|
||||||
// 32-bit register modifier for inlined asm
|
// 32-bit register modifier for inlined asm
|
||||||
#define OPENCV_GPU_ASM_PTR "r"
|
#define OPENCV_CUDA_ASM_PTR "r"
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
template<class T> struct ForceGlob;
|
template<class T> struct ForceGlob;
|
||||||
|
|
||||||
#define OPENCV_GPU_DEFINE_FORCE_GLOB(base_type, ptx_type, reg_mod) \
|
#define OPENCV_CUDA_DEFINE_FORCE_GLOB(base_type, ptx_type, reg_mod) \
|
||||||
template <> struct ForceGlob<base_type> \
|
template <> struct ForceGlob<base_type> \
|
||||||
{ \
|
{ \
|
||||||
__device__ __forceinline__ static void Load(const base_type* ptr, int offset, base_type& val) \
|
__device__ __forceinline__ static void Load(const base_type* ptr, int offset, base_type& val) \
|
||||||
{ \
|
{ \
|
||||||
asm("ld.global."#ptx_type" %0, [%1];" : "="#reg_mod(val) : OPENCV_GPU_ASM_PTR(ptr + offset)); \
|
asm("ld.global."#ptx_type" %0, [%1];" : "="#reg_mod(val) : OPENCV_CUDA_ASM_PTR(ptr + offset)); \
|
||||||
} \
|
} \
|
||||||
};
|
};
|
||||||
|
|
||||||
#define OPENCV_GPU_DEFINE_FORCE_GLOB_B(base_type, ptx_type) \
|
#define OPENCV_CUDA_DEFINE_FORCE_GLOB_B(base_type, ptx_type) \
|
||||||
template <> struct ForceGlob<base_type> \
|
template <> struct ForceGlob<base_type> \
|
||||||
{ \
|
{ \
|
||||||
__device__ __forceinline__ static void Load(const base_type* ptr, int offset, base_type& val) \
|
__device__ __forceinline__ static void Load(const base_type* ptr, int offset, base_type& val) \
|
||||||
{ \
|
{ \
|
||||||
asm("ld.global."#ptx_type" %0, [%1];" : "=r"(*reinterpret_cast<uint*>(&val)) : OPENCV_GPU_ASM_PTR(ptr + offset)); \
|
asm("ld.global."#ptx_type" %0, [%1];" : "=r"(*reinterpret_cast<uint*>(&val)) : OPENCV_CUDA_ASM_PTR(ptr + offset)); \
|
||||||
} \
|
} \
|
||||||
};
|
};
|
||||||
|
|
||||||
OPENCV_GPU_DEFINE_FORCE_GLOB_B(uchar, u8)
|
OPENCV_CUDA_DEFINE_FORCE_GLOB_B(uchar, u8)
|
||||||
OPENCV_GPU_DEFINE_FORCE_GLOB_B(schar, s8)
|
OPENCV_CUDA_DEFINE_FORCE_GLOB_B(schar, s8)
|
||||||
OPENCV_GPU_DEFINE_FORCE_GLOB_B(char, b8)
|
OPENCV_CUDA_DEFINE_FORCE_GLOB_B(char, b8)
|
||||||
OPENCV_GPU_DEFINE_FORCE_GLOB (ushort, u16, h)
|
OPENCV_CUDA_DEFINE_FORCE_GLOB (ushort, u16, h)
|
||||||
OPENCV_GPU_DEFINE_FORCE_GLOB (short, s16, h)
|
OPENCV_CUDA_DEFINE_FORCE_GLOB (short, s16, h)
|
||||||
OPENCV_GPU_DEFINE_FORCE_GLOB (uint, u32, r)
|
OPENCV_CUDA_DEFINE_FORCE_GLOB (uint, u32, r)
|
||||||
OPENCV_GPU_DEFINE_FORCE_GLOB (int, s32, r)
|
OPENCV_CUDA_DEFINE_FORCE_GLOB (int, s32, r)
|
||||||
OPENCV_GPU_DEFINE_FORCE_GLOB (float, f32, f)
|
OPENCV_CUDA_DEFINE_FORCE_GLOB (float, f32, f)
|
||||||
OPENCV_GPU_DEFINE_FORCE_GLOB (double, f64, d)
|
OPENCV_CUDA_DEFINE_FORCE_GLOB (double, f64, d)
|
||||||
|
|
||||||
#undef OPENCV_GPU_DEFINE_FORCE_GLOB
|
#undef OPENCV_CUDA_DEFINE_FORCE_GLOB
|
||||||
#undef OPENCV_GPU_DEFINE_FORCE_GLOB_B
|
#undef OPENCV_CUDA_DEFINE_FORCE_GLOB_B
|
||||||
#undef OPENCV_GPU_ASM_PTR
|
#undef OPENCV_CUDA_ASM_PTR
|
||||||
|
|
||||||
#endif // __CUDA_ARCH__ >= 200
|
#endif // __CUDA_ARCH__ >= 200
|
||||||
}}} // namespace cv { namespace cuda { namespace cudev
|
}}} // namespace cv { namespace cuda { namespace cudev
|
||||||
|
|
||||||
#endif // __OPENCV_GPU_DATAMOV_UTILS_HPP__
|
#endif // __OPENCV_CUDA_DATAMOV_UTILS_HPP__
|
||||||
|
|||||||
@ -40,8 +40,8 @@
|
|||||||
//
|
//
|
||||||
//M*/
|
//M*/
|
||||||
|
|
||||||
#ifndef __OPENCV_GPU_COLOR_DETAIL_HPP__
|
#ifndef __OPENCV_CUDA_COLOR_DETAIL_HPP__
|
||||||
#define __OPENCV_GPU_COLOR_DETAIL_HPP__
|
#define __OPENCV_CUDA_COLOR_DETAIL_HPP__
|
||||||
|
|
||||||
#include "../common.hpp"
|
#include "../common.hpp"
|
||||||
#include "../vec_traits.hpp"
|
#include "../vec_traits.hpp"
|
||||||
@ -143,7 +143,7 @@ namespace cv { namespace cuda { namespace device
|
|||||||
};
|
};
|
||||||
}
|
}
|
||||||
|
|
||||||
#define OPENCV_GPU_IMPLEMENT_RGB2RGB_TRAITS(name, scn, dcn, bidx) \
|
#define OPENCV_CUDA_IMPLEMENT_RGB2RGB_TRAITS(name, scn, dcn, bidx) \
|
||||||
template <typename T> struct name ## _traits \
|
template <typename T> struct name ## _traits \
|
||||||
{ \
|
{ \
|
||||||
typedef ::cv::cuda::device::color_detail::RGB2RGB<T, scn, dcn, bidx> functor_type; \
|
typedef ::cv::cuda::device::color_detail::RGB2RGB<T, scn, dcn, bidx> functor_type; \
|
||||||
@ -216,7 +216,7 @@ namespace cv { namespace cuda { namespace device
|
|||||||
};
|
};
|
||||||
}
|
}
|
||||||
|
|
||||||
#define OPENCV_GPU_IMPLEMENT_RGB2RGB5x5_TRAITS(name, scn, bidx, green_bits) \
|
#define OPENCV_CUDA_IMPLEMENT_RGB2RGB5x5_TRAITS(name, scn, bidx, green_bits) \
|
||||||
struct name ## _traits \
|
struct name ## _traits \
|
||||||
{ \
|
{ \
|
||||||
typedef ::cv::cuda::device::color_detail::RGB2RGB5x5<scn, bidx, green_bits> functor_type; \
|
typedef ::cv::cuda::device::color_detail::RGB2RGB5x5<scn, bidx, green_bits> functor_type; \
|
||||||
@ -297,7 +297,7 @@ namespace cv { namespace cuda { namespace device
|
|||||||
};
|
};
|
||||||
}
|
}
|
||||||
|
|
||||||
#define OPENCV_GPU_IMPLEMENT_RGB5x52RGB_TRAITS(name, dcn, bidx, green_bits) \
|
#define OPENCV_CUDA_IMPLEMENT_RGB5x52RGB_TRAITS(name, dcn, bidx, green_bits) \
|
||||||
struct name ## _traits \
|
struct name ## _traits \
|
||||||
{ \
|
{ \
|
||||||
typedef ::cv::cuda::device::color_detail::RGB5x52RGB<dcn, bidx, green_bits> functor_type; \
|
typedef ::cv::cuda::device::color_detail::RGB5x52RGB<dcn, bidx, green_bits> functor_type; \
|
||||||
@ -343,7 +343,7 @@ namespace cv { namespace cuda { namespace device
|
|||||||
};
|
};
|
||||||
}
|
}
|
||||||
|
|
||||||
#define OPENCV_GPU_IMPLEMENT_GRAY2RGB_TRAITS(name, dcn) \
|
#define OPENCV_CUDA_IMPLEMENT_GRAY2RGB_TRAITS(name, dcn) \
|
||||||
template <typename T> struct name ## _traits \
|
template <typename T> struct name ## _traits \
|
||||||
{ \
|
{ \
|
||||||
typedef ::cv::cuda::device::color_detail::Gray2RGB<T, dcn> functor_type; \
|
typedef ::cv::cuda::device::color_detail::Gray2RGB<T, dcn> functor_type; \
|
||||||
@ -385,7 +385,7 @@ namespace cv { namespace cuda { namespace device
|
|||||||
};
|
};
|
||||||
}
|
}
|
||||||
|
|
||||||
#define OPENCV_GPU_IMPLEMENT_GRAY2RGB5x5_TRAITS(name, green_bits) \
|
#define OPENCV_CUDA_IMPLEMENT_GRAY2RGB5x5_TRAITS(name, green_bits) \
|
||||||
struct name ## _traits \
|
struct name ## _traits \
|
||||||
{ \
|
{ \
|
||||||
typedef ::cv::cuda::device::color_detail::Gray2RGB5x5<green_bits> functor_type; \
|
typedef ::cv::cuda::device::color_detail::Gray2RGB5x5<green_bits> functor_type; \
|
||||||
@ -427,7 +427,7 @@ namespace cv { namespace cuda { namespace device
|
|||||||
};
|
};
|
||||||
}
|
}
|
||||||
|
|
||||||
#define OPENCV_GPU_IMPLEMENT_RGB5x52GRAY_TRAITS(name, green_bits) \
|
#define OPENCV_CUDA_IMPLEMENT_RGB5x52GRAY_TRAITS(name, green_bits) \
|
||||||
struct name ## _traits \
|
struct name ## _traits \
|
||||||
{ \
|
{ \
|
||||||
typedef ::cv::cuda::device::color_detail::RGB5x52Gray<green_bits> functor_type; \
|
typedef ::cv::cuda::device::color_detail::RGB5x52Gray<green_bits> functor_type; \
|
||||||
@ -478,7 +478,7 @@ namespace cv { namespace cuda { namespace device
|
|||||||
};
|
};
|
||||||
}
|
}
|
||||||
|
|
||||||
#define OPENCV_GPU_IMPLEMENT_RGB2GRAY_TRAITS(name, scn, bidx) \
|
#define OPENCV_CUDA_IMPLEMENT_RGB2GRAY_TRAITS(name, scn, bidx) \
|
||||||
template <typename T> struct name ## _traits \
|
template <typename T> struct name ## _traits \
|
||||||
{ \
|
{ \
|
||||||
typedef ::cv::cuda::device::color_detail::RGB2Gray<T, scn, bidx> functor_type; \
|
typedef ::cv::cuda::device::color_detail::RGB2Gray<T, scn, bidx> functor_type; \
|
||||||
@ -529,7 +529,7 @@ namespace cv { namespace cuda { namespace device
|
|||||||
};
|
};
|
||||||
}
|
}
|
||||||
|
|
||||||
#define OPENCV_GPU_IMPLEMENT_RGB2YUV_TRAITS(name, scn, dcn, bidx) \
|
#define OPENCV_CUDA_IMPLEMENT_RGB2YUV_TRAITS(name, scn, dcn, bidx) \
|
||||||
template <typename T> struct name ## _traits \
|
template <typename T> struct name ## _traits \
|
||||||
{ \
|
{ \
|
||||||
typedef ::cv::cuda::device::color_detail::RGB2YUV<T, scn, dcn, bidx> functor_type; \
|
typedef ::cv::cuda::device::color_detail::RGB2YUV<T, scn, dcn, bidx> functor_type; \
|
||||||
@ -617,7 +617,7 @@ namespace cv { namespace cuda { namespace device
|
|||||||
};
|
};
|
||||||
}
|
}
|
||||||
|
|
||||||
#define OPENCV_GPU_IMPLEMENT_YUV2RGB_TRAITS(name, scn, dcn, bidx) \
|
#define OPENCV_CUDA_IMPLEMENT_YUV2RGB_TRAITS(name, scn, dcn, bidx) \
|
||||||
template <typename T> struct name ## _traits \
|
template <typename T> struct name ## _traits \
|
||||||
{ \
|
{ \
|
||||||
typedef ::cv::cuda::device::color_detail::YUV2RGB<T, scn, dcn, bidx> functor_type; \
|
typedef ::cv::cuda::device::color_detail::YUV2RGB<T, scn, dcn, bidx> functor_type; \
|
||||||
@ -696,7 +696,7 @@ namespace cv { namespace cuda { namespace device
|
|||||||
};
|
};
|
||||||
}
|
}
|
||||||
|
|
||||||
#define OPENCV_GPU_IMPLEMENT_RGB2YCrCb_TRAITS(name, scn, dcn, bidx) \
|
#define OPENCV_CUDA_IMPLEMENT_RGB2YCrCb_TRAITS(name, scn, dcn, bidx) \
|
||||||
template <typename T> struct name ## _traits \
|
template <typename T> struct name ## _traits \
|
||||||
{ \
|
{ \
|
||||||
typedef ::cv::cuda::device::color_detail::RGB2YCrCb<T, scn, dcn, bidx> functor_type; \
|
typedef ::cv::cuda::device::color_detail::RGB2YCrCb<T, scn, dcn, bidx> functor_type; \
|
||||||
@ -775,7 +775,7 @@ namespace cv { namespace cuda { namespace device
|
|||||||
};
|
};
|
||||||
}
|
}
|
||||||
|
|
||||||
#define OPENCV_GPU_IMPLEMENT_YCrCb2RGB_TRAITS(name, scn, dcn, bidx) \
|
#define OPENCV_CUDA_IMPLEMENT_YCrCb2RGB_TRAITS(name, scn, dcn, bidx) \
|
||||||
template <typename T> struct name ## _traits \
|
template <typename T> struct name ## _traits \
|
||||||
{ \
|
{ \
|
||||||
typedef ::cv::cuda::device::color_detail::YCrCb2RGB<T, scn, dcn, bidx> functor_type; \
|
typedef ::cv::cuda::device::color_detail::YCrCb2RGB<T, scn, dcn, bidx> functor_type; \
|
||||||
@ -851,7 +851,7 @@ namespace cv { namespace cuda { namespace device
|
|||||||
};
|
};
|
||||||
}
|
}
|
||||||
|
|
||||||
#define OPENCV_GPU_IMPLEMENT_RGB2XYZ_TRAITS(name, scn, dcn, bidx) \
|
#define OPENCV_CUDA_IMPLEMENT_RGB2XYZ_TRAITS(name, scn, dcn, bidx) \
|
||||||
template <typename T> struct name ## _traits \
|
template <typename T> struct name ## _traits \
|
||||||
{ \
|
{ \
|
||||||
typedef ::cv::cuda::device::color_detail::RGB2XYZ<T, scn, dcn, bidx> functor_type; \
|
typedef ::cv::cuda::device::color_detail::RGB2XYZ<T, scn, dcn, bidx> functor_type; \
|
||||||
@ -926,7 +926,7 @@ namespace cv { namespace cuda { namespace device
|
|||||||
};
|
};
|
||||||
}
|
}
|
||||||
|
|
||||||
#define OPENCV_GPU_IMPLEMENT_XYZ2RGB_TRAITS(name, scn, dcn, bidx) \
|
#define OPENCV_CUDA_IMPLEMENT_XYZ2RGB_TRAITS(name, scn, dcn, bidx) \
|
||||||
template <typename T> struct name ## _traits \
|
template <typename T> struct name ## _traits \
|
||||||
{ \
|
{ \
|
||||||
typedef ::cv::cuda::device::color_detail::XYZ2RGB<T, scn, dcn, bidx> functor_type; \
|
typedef ::cv::cuda::device::color_detail::XYZ2RGB<T, scn, dcn, bidx> functor_type; \
|
||||||
@ -1064,7 +1064,7 @@ namespace cv { namespace cuda { namespace device
|
|||||||
};
|
};
|
||||||
}
|
}
|
||||||
|
|
||||||
#define OPENCV_GPU_IMPLEMENT_RGB2HSV_TRAITS(name, scn, dcn, bidx) \
|
#define OPENCV_CUDA_IMPLEMENT_RGB2HSV_TRAITS(name, scn, dcn, bidx) \
|
||||||
template <typename T> struct name ## _traits \
|
template <typename T> struct name ## _traits \
|
||||||
{ \
|
{ \
|
||||||
typedef ::cv::cuda::device::color_detail::RGB2HSV<T, scn, dcn, bidx, 180> functor_type; \
|
typedef ::cv::cuda::device::color_detail::RGB2HSV<T, scn, dcn, bidx, 180> functor_type; \
|
||||||
@ -1204,7 +1204,7 @@ namespace cv { namespace cuda { namespace device
|
|||||||
};
|
};
|
||||||
}
|
}
|
||||||
|
|
||||||
#define OPENCV_GPU_IMPLEMENT_HSV2RGB_TRAITS(name, scn, dcn, bidx) \
|
#define OPENCV_CUDA_IMPLEMENT_HSV2RGB_TRAITS(name, scn, dcn, bidx) \
|
||||||
template <typename T> struct name ## _traits \
|
template <typename T> struct name ## _traits \
|
||||||
{ \
|
{ \
|
||||||
typedef ::cv::cuda::device::color_detail::HSV2RGB<T, scn, dcn, bidx, 180> functor_type; \
|
typedef ::cv::cuda::device::color_detail::HSV2RGB<T, scn, dcn, bidx, 180> functor_type; \
|
||||||
@ -1337,7 +1337,7 @@ namespace cv { namespace cuda { namespace device
|
|||||||
};
|
};
|
||||||
}
|
}
|
||||||
|
|
||||||
#define OPENCV_GPU_IMPLEMENT_RGB2HLS_TRAITS(name, scn, dcn, bidx) \
|
#define OPENCV_CUDA_IMPLEMENT_RGB2HLS_TRAITS(name, scn, dcn, bidx) \
|
||||||
template <typename T> struct name ## _traits \
|
template <typename T> struct name ## _traits \
|
||||||
{ \
|
{ \
|
||||||
typedef ::cv::cuda::device::color_detail::RGB2HLS<T, scn, dcn, bidx, 180> functor_type; \
|
typedef ::cv::cuda::device::color_detail::RGB2HLS<T, scn, dcn, bidx, 180> functor_type; \
|
||||||
@ -1477,7 +1477,7 @@ namespace cv { namespace cuda { namespace device
|
|||||||
};
|
};
|
||||||
}
|
}
|
||||||
|
|
||||||
#define OPENCV_GPU_IMPLEMENT_HLS2RGB_TRAITS(name, scn, dcn, bidx) \
|
#define OPENCV_CUDA_IMPLEMENT_HLS2RGB_TRAITS(name, scn, dcn, bidx) \
|
||||||
template <typename T> struct name ## _traits \
|
template <typename T> struct name ## _traits \
|
||||||
{ \
|
{ \
|
||||||
typedef ::cv::cuda::device::color_detail::HLS2RGB<T, scn, dcn, bidx, 180> functor_type; \
|
typedef ::cv::cuda::device::color_detail::HLS2RGB<T, scn, dcn, bidx, 180> functor_type; \
|
||||||
@ -1646,7 +1646,7 @@ namespace cv { namespace cuda { namespace device
|
|||||||
};
|
};
|
||||||
}
|
}
|
||||||
|
|
||||||
#define OPENCV_GPU_IMPLEMENT_RGB2Lab_TRAITS(name, scn, dcn, srgb, blueIdx) \
|
#define OPENCV_CUDA_IMPLEMENT_RGB2Lab_TRAITS(name, scn, dcn, srgb, blueIdx) \
|
||||||
template <typename T> struct name ## _traits \
|
template <typename T> struct name ## _traits \
|
||||||
{ \
|
{ \
|
||||||
typedef ::cv::cuda::device::color_detail::RGB2Lab<T, scn, dcn, srgb, blueIdx> functor_type; \
|
typedef ::cv::cuda::device::color_detail::RGB2Lab<T, scn, dcn, srgb, blueIdx> functor_type; \
|
||||||
@ -1759,7 +1759,7 @@ namespace cv { namespace cuda { namespace device
|
|||||||
};
|
};
|
||||||
}
|
}
|
||||||
|
|
||||||
#define OPENCV_GPU_IMPLEMENT_Lab2RGB_TRAITS(name, scn, dcn, srgb, blueIdx) \
|
#define OPENCV_CUDA_IMPLEMENT_Lab2RGB_TRAITS(name, scn, dcn, srgb, blueIdx) \
|
||||||
template <typename T> struct name ## _traits \
|
template <typename T> struct name ## _traits \
|
||||||
{ \
|
{ \
|
||||||
typedef ::cv::cuda::device::color_detail::Lab2RGB<T, scn, dcn, srgb, blueIdx> functor_type; \
|
typedef ::cv::cuda::device::color_detail::Lab2RGB<T, scn, dcn, srgb, blueIdx> functor_type; \
|
||||||
@ -1858,7 +1858,7 @@ namespace cv { namespace cuda { namespace device
|
|||||||
};
|
};
|
||||||
}
|
}
|
||||||
|
|
||||||
#define OPENCV_GPU_IMPLEMENT_RGB2Luv_TRAITS(name, scn, dcn, srgb, blueIdx) \
|
#define OPENCV_CUDA_IMPLEMENT_RGB2Luv_TRAITS(name, scn, dcn, srgb, blueIdx) \
|
||||||
template <typename T> struct name ## _traits \
|
template <typename T> struct name ## _traits \
|
||||||
{ \
|
{ \
|
||||||
typedef ::cv::cuda::device::color_detail::RGB2Luv<T, scn, dcn, srgb, blueIdx> functor_type; \
|
typedef ::cv::cuda::device::color_detail::RGB2Luv<T, scn, dcn, srgb, blueIdx> functor_type; \
|
||||||
@ -1959,7 +1959,7 @@ namespace cv { namespace cuda { namespace device
|
|||||||
};
|
};
|
||||||
}
|
}
|
||||||
|
|
||||||
#define OPENCV_GPU_IMPLEMENT_Luv2RGB_TRAITS(name, scn, dcn, srgb, blueIdx) \
|
#define OPENCV_CUDA_IMPLEMENT_Luv2RGB_TRAITS(name, scn, dcn, srgb, blueIdx) \
|
||||||
template <typename T> struct name ## _traits \
|
template <typename T> struct name ## _traits \
|
||||||
{ \
|
{ \
|
||||||
typedef ::cv::cuda::device::color_detail::Luv2RGB<T, scn, dcn, srgb, blueIdx> functor_type; \
|
typedef ::cv::cuda::device::color_detail::Luv2RGB<T, scn, dcn, srgb, blueIdx> functor_type; \
|
||||||
@ -1973,4 +1973,4 @@ namespace cv { namespace cuda { namespace device
|
|||||||
|
|
||||||
}}} // namespace cv { namespace cuda { namespace cudev
|
}}} // namespace cv { namespace cuda { namespace cudev
|
||||||
|
|
||||||
#endif // __OPENCV_GPU_COLOR_DETAIL_HPP__
|
#endif // __OPENCV_CUDA_COLOR_DETAIL_HPP__
|
||||||
|
|||||||
@ -40,8 +40,8 @@
|
|||||||
//
|
//
|
||||||
//M*/
|
//M*/
|
||||||
|
|
||||||
#ifndef __OPENCV_GPU_REDUCE_DETAIL_HPP__
|
#ifndef __OPENCV_CUDA_REDUCE_DETAIL_HPP__
|
||||||
#define __OPENCV_GPU_REDUCE_DETAIL_HPP__
|
#define __OPENCV_CUDA_REDUCE_DETAIL_HPP__
|
||||||
|
|
||||||
#include <thrust/tuple.h>
|
#include <thrust/tuple.h>
|
||||||
#include "../warp.hpp"
|
#include "../warp.hpp"
|
||||||
@ -358,4 +358,4 @@ namespace cv { namespace cuda { namespace device
|
|||||||
}
|
}
|
||||||
}}}
|
}}}
|
||||||
|
|
||||||
#endif // __OPENCV_GPU_REDUCE_DETAIL_HPP__
|
#endif // __OPENCV_CUDA_REDUCE_DETAIL_HPP__
|
||||||
|
|||||||
@ -40,8 +40,8 @@
|
|||||||
//
|
//
|
||||||
//M*/
|
//M*/
|
||||||
|
|
||||||
#ifndef __OPENCV_GPU_PRED_VAL_REDUCE_DETAIL_HPP__
|
#ifndef __OPENCV_CUDA_PRED_VAL_REDUCE_DETAIL_HPP__
|
||||||
#define __OPENCV_GPU_PRED_VAL_REDUCE_DETAIL_HPP__
|
#define __OPENCV_CUDA_PRED_VAL_REDUCE_DETAIL_HPP__
|
||||||
|
|
||||||
#include <thrust/tuple.h>
|
#include <thrust/tuple.h>
|
||||||
#include "../warp.hpp"
|
#include "../warp.hpp"
|
||||||
@ -495,4 +495,4 @@ namespace cv { namespace cuda { namespace device
|
|||||||
}
|
}
|
||||||
}}}
|
}}}
|
||||||
|
|
||||||
#endif // __OPENCV_GPU_PRED_VAL_REDUCE_DETAIL_HPP__
|
#endif // __OPENCV_CUDA_PRED_VAL_REDUCE_DETAIL_HPP__
|
||||||
|
|||||||
@ -40,8 +40,8 @@
|
|||||||
//
|
//
|
||||||
//M*/
|
//M*/
|
||||||
|
|
||||||
#ifndef __OPENCV_GPU_TRANSFORM_DETAIL_HPP__
|
#ifndef __OPENCV_CUDA_TRANSFORM_DETAIL_HPP__
|
||||||
#define __OPENCV_GPU_TRANSFORM_DETAIL_HPP__
|
#define __OPENCV_CUDA_TRANSFORM_DETAIL_HPP__
|
||||||
|
|
||||||
#include "../common.hpp"
|
#include "../common.hpp"
|
||||||
#include "../vec_traits.hpp"
|
#include "../vec_traits.hpp"
|
||||||
@ -392,4 +392,4 @@ namespace cv { namespace cuda { namespace device
|
|||||||
} // namespace transform_detail
|
} // namespace transform_detail
|
||||||
}}} // namespace cv { namespace cuda { namespace cudev
|
}}} // namespace cv { namespace cuda { namespace cudev
|
||||||
|
|
||||||
#endif // __OPENCV_GPU_TRANSFORM_DETAIL_HPP__
|
#endif // __OPENCV_CUDA_TRANSFORM_DETAIL_HPP__
|
||||||
|
|||||||
@ -40,8 +40,8 @@
|
|||||||
//
|
//
|
||||||
//M*/
|
//M*/
|
||||||
|
|
||||||
#ifndef __OPENCV_GPU_TYPE_TRAITS_DETAIL_HPP__
|
#ifndef __OPENCV_CUDA_TYPE_TRAITS_DETAIL_HPP__
|
||||||
#define __OPENCV_GPU_TYPE_TRAITS_DETAIL_HPP__
|
#define __OPENCV_CUDA_TYPE_TRAITS_DETAIL_HPP__
|
||||||
|
|
||||||
#include "../common.hpp"
|
#include "../common.hpp"
|
||||||
#include "../vec_traits.hpp"
|
#include "../vec_traits.hpp"
|
||||||
@ -184,4 +184,4 @@ namespace cv { namespace cuda { namespace device
|
|||||||
} // namespace type_traits_detail
|
} // namespace type_traits_detail
|
||||||
}}} // namespace cv { namespace cuda { namespace cudev
|
}}} // namespace cv { namespace cuda { namespace cudev
|
||||||
|
|
||||||
#endif // __OPENCV_GPU_TYPE_TRAITS_DETAIL_HPP__
|
#endif // __OPENCV_CUDA_TYPE_TRAITS_DETAIL_HPP__
|
||||||
|
|||||||
@ -40,8 +40,8 @@
|
|||||||
//
|
//
|
||||||
//M*/
|
//M*/
|
||||||
|
|
||||||
#ifndef __OPENCV_GPU_VEC_DISTANCE_DETAIL_HPP__
|
#ifndef __OPENCV_CUDA_VEC_DISTANCE_DETAIL_HPP__
|
||||||
#define __OPENCV_GPU_VEC_DISTANCE_DETAIL_HPP__
|
#define __OPENCV_CUDA_VEC_DISTANCE_DETAIL_HPP__
|
||||||
|
|
||||||
#include "../datamov_utils.hpp"
|
#include "../datamov_utils.hpp"
|
||||||
|
|
||||||
@ -114,4 +114,4 @@ namespace cv { namespace cuda { namespace device
|
|||||||
} // namespace vec_distance_detail
|
} // namespace vec_distance_detail
|
||||||
}}} // namespace cv { namespace cuda { namespace cudev
|
}}} // namespace cv { namespace cuda { namespace cudev
|
||||||
|
|
||||||
#endif // __OPENCV_GPU_VEC_DISTANCE_DETAIL_HPP__
|
#endif // __OPENCV_CUDA_VEC_DISTANCE_DETAIL_HPP__
|
||||||
|
|||||||
@ -40,8 +40,8 @@
|
|||||||
//
|
//
|
||||||
//M*/
|
//M*/
|
||||||
|
|
||||||
#ifndef __OPENCV_GPU_DYNAMIC_SMEM_HPP__
|
#ifndef __OPENCV_CUDA_DYNAMIC_SMEM_HPP__
|
||||||
#define __OPENCV_GPU_DYNAMIC_SMEM_HPP__
|
#define __OPENCV_CUDA_DYNAMIC_SMEM_HPP__
|
||||||
|
|
||||||
namespace cv { namespace cuda { namespace device
|
namespace cv { namespace cuda { namespace device
|
||||||
{
|
{
|
||||||
@ -77,4 +77,4 @@ namespace cv { namespace cuda { namespace device
|
|||||||
};
|
};
|
||||||
}}}
|
}}}
|
||||||
|
|
||||||
#endif // __OPENCV_GPU_DYNAMIC_SMEM_HPP__
|
#endif // __OPENCV_CUDA_DYNAMIC_SMEM_HPP__
|
||||||
|
|||||||
@ -40,8 +40,8 @@
|
|||||||
//
|
//
|
||||||
//M*/
|
//M*/
|
||||||
|
|
||||||
#ifndef OPENCV_GPU_EMULATION_HPP_
|
#ifndef OPENCV_CUDA_EMULATION_HPP_
|
||||||
#define OPENCV_GPU_EMULATION_HPP_
|
#define OPENCV_CUDA_EMULATION_HPP_
|
||||||
|
|
||||||
#include "common.hpp"
|
#include "common.hpp"
|
||||||
#include "warp_reduce.hpp"
|
#include "warp_reduce.hpp"
|
||||||
@ -258,4 +258,4 @@ namespace cv { namespace cuda { namespace device
|
|||||||
}; //struct Emulation
|
}; //struct Emulation
|
||||||
}}} // namespace cv { namespace cuda { namespace cudev
|
}}} // namespace cv { namespace cuda { namespace cudev
|
||||||
|
|
||||||
#endif /* OPENCV_GPU_EMULATION_HPP_ */
|
#endif /* OPENCV_CUDA_EMULATION_HPP_ */
|
||||||
|
|||||||
@ -40,8 +40,8 @@
|
|||||||
//
|
//
|
||||||
//M*/
|
//M*/
|
||||||
|
|
||||||
#ifndef __OPENCV_GPU_FILTERS_HPP__
|
#ifndef __OPENCV_CUDA_FILTERS_HPP__
|
||||||
#define __OPENCV_GPU_FILTERS_HPP__
|
#define __OPENCV_CUDA_FILTERS_HPP__
|
||||||
|
|
||||||
#include "saturate_cast.hpp"
|
#include "saturate_cast.hpp"
|
||||||
#include "vec_traits.hpp"
|
#include "vec_traits.hpp"
|
||||||
@ -275,4 +275,4 @@ namespace cv { namespace cuda { namespace device
|
|||||||
};
|
};
|
||||||
}}} // namespace cv { namespace cuda { namespace cudev
|
}}} // namespace cv { namespace cuda { namespace cudev
|
||||||
|
|
||||||
#endif // __OPENCV_GPU_FILTERS_HPP__
|
#endif // __OPENCV_CUDA_FILTERS_HPP__
|
||||||
|
|||||||
@ -40,8 +40,8 @@
|
|||||||
//
|
//
|
||||||
//M*/
|
//M*/
|
||||||
|
|
||||||
#ifndef __OPENCV_GPU_DEVICE_FUNCATTRIB_HPP_
|
#ifndef __OPENCV_CUDA_DEVICE_FUNCATTRIB_HPP_
|
||||||
#define __OPENCV_GPU_DEVICE_FUNCATTRIB_HPP_
|
#define __OPENCV_CUDA_DEVICE_FUNCATTRIB_HPP_
|
||||||
|
|
||||||
#include <cstdio>
|
#include <cstdio>
|
||||||
|
|
||||||
@ -68,4 +68,4 @@ namespace cv { namespace cuda { namespace device
|
|||||||
}
|
}
|
||||||
}}} // namespace cv { namespace cuda { namespace cudev
|
}}} // namespace cv { namespace cuda { namespace cudev
|
||||||
|
|
||||||
#endif /* __OPENCV_GPU_DEVICE_FUNCATTRIB_HPP_ */
|
#endif /* __OPENCV_CUDA_DEVICE_FUNCATTRIB_HPP_ */
|
||||||
|
|||||||
@ -40,8 +40,8 @@
|
|||||||
//
|
//
|
||||||
//M*/
|
//M*/
|
||||||
|
|
||||||
#ifndef __OPENCV_GPU_FUNCTIONAL_HPP__
|
#ifndef __OPENCV_CUDA_FUNCTIONAL_HPP__
|
||||||
#define __OPENCV_GPU_FUNCTIONAL_HPP__
|
#define __OPENCV_CUDA_FUNCTIONAL_HPP__
|
||||||
|
|
||||||
#include <functional>
|
#include <functional>
|
||||||
#include "saturate_cast.hpp"
|
#include "saturate_cast.hpp"
|
||||||
@ -298,7 +298,7 @@ namespace cv { namespace cuda { namespace device
|
|||||||
|
|
||||||
// Min/Max Operations
|
// Min/Max Operations
|
||||||
|
|
||||||
#define OPENCV_GPU_IMPLEMENT_MINMAX(name, type, op) \
|
#define OPENCV_CUDA_IMPLEMENT_MINMAX(name, type, op) \
|
||||||
template <> struct name<type> : binary_function<type, type, type> \
|
template <> struct name<type> : binary_function<type, type, type> \
|
||||||
{ \
|
{ \
|
||||||
__device__ __forceinline__ type operator()(type lhs, type rhs) const {return op(lhs, rhs);} \
|
__device__ __forceinline__ type operator()(type lhs, type rhs) const {return op(lhs, rhs);} \
|
||||||
@ -316,15 +316,15 @@ namespace cv { namespace cuda { namespace device
|
|||||||
__host__ __device__ __forceinline__ maximum(const maximum&) {}
|
__host__ __device__ __forceinline__ maximum(const maximum&) {}
|
||||||
};
|
};
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_MINMAX(maximum, uchar, ::max)
|
OPENCV_CUDA_IMPLEMENT_MINMAX(maximum, uchar, ::max)
|
||||||
OPENCV_GPU_IMPLEMENT_MINMAX(maximum, schar, ::max)
|
OPENCV_CUDA_IMPLEMENT_MINMAX(maximum, schar, ::max)
|
||||||
OPENCV_GPU_IMPLEMENT_MINMAX(maximum, char, ::max)
|
OPENCV_CUDA_IMPLEMENT_MINMAX(maximum, char, ::max)
|
||||||
OPENCV_GPU_IMPLEMENT_MINMAX(maximum, ushort, ::max)
|
OPENCV_CUDA_IMPLEMENT_MINMAX(maximum, ushort, ::max)
|
||||||
OPENCV_GPU_IMPLEMENT_MINMAX(maximum, short, ::max)
|
OPENCV_CUDA_IMPLEMENT_MINMAX(maximum, short, ::max)
|
||||||
OPENCV_GPU_IMPLEMENT_MINMAX(maximum, int, ::max)
|
OPENCV_CUDA_IMPLEMENT_MINMAX(maximum, int, ::max)
|
||||||
OPENCV_GPU_IMPLEMENT_MINMAX(maximum, uint, ::max)
|
OPENCV_CUDA_IMPLEMENT_MINMAX(maximum, uint, ::max)
|
||||||
OPENCV_GPU_IMPLEMENT_MINMAX(maximum, float, ::fmax)
|
OPENCV_CUDA_IMPLEMENT_MINMAX(maximum, float, ::fmax)
|
||||||
OPENCV_GPU_IMPLEMENT_MINMAX(maximum, double, ::fmax)
|
OPENCV_CUDA_IMPLEMENT_MINMAX(maximum, double, ::fmax)
|
||||||
|
|
||||||
template <typename T> struct minimum : binary_function<T, T, T>
|
template <typename T> struct minimum : binary_function<T, T, T>
|
||||||
{
|
{
|
||||||
@ -336,17 +336,17 @@ namespace cv { namespace cuda { namespace device
|
|||||||
__host__ __device__ __forceinline__ minimum(const minimum&) {}
|
__host__ __device__ __forceinline__ minimum(const minimum&) {}
|
||||||
};
|
};
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_MINMAX(minimum, uchar, ::min)
|
OPENCV_CUDA_IMPLEMENT_MINMAX(minimum, uchar, ::min)
|
||||||
OPENCV_GPU_IMPLEMENT_MINMAX(minimum, schar, ::min)
|
OPENCV_CUDA_IMPLEMENT_MINMAX(minimum, schar, ::min)
|
||||||
OPENCV_GPU_IMPLEMENT_MINMAX(minimum, char, ::min)
|
OPENCV_CUDA_IMPLEMENT_MINMAX(minimum, char, ::min)
|
||||||
OPENCV_GPU_IMPLEMENT_MINMAX(minimum, ushort, ::min)
|
OPENCV_CUDA_IMPLEMENT_MINMAX(minimum, ushort, ::min)
|
||||||
OPENCV_GPU_IMPLEMENT_MINMAX(minimum, short, ::min)
|
OPENCV_CUDA_IMPLEMENT_MINMAX(minimum, short, ::min)
|
||||||
OPENCV_GPU_IMPLEMENT_MINMAX(minimum, int, ::min)
|
OPENCV_CUDA_IMPLEMENT_MINMAX(minimum, int, ::min)
|
||||||
OPENCV_GPU_IMPLEMENT_MINMAX(minimum, uint, ::min)
|
OPENCV_CUDA_IMPLEMENT_MINMAX(minimum, uint, ::min)
|
||||||
OPENCV_GPU_IMPLEMENT_MINMAX(minimum, float, ::fmin)
|
OPENCV_CUDA_IMPLEMENT_MINMAX(minimum, float, ::fmin)
|
||||||
OPENCV_GPU_IMPLEMENT_MINMAX(minimum, double, ::fmin)
|
OPENCV_CUDA_IMPLEMENT_MINMAX(minimum, double, ::fmin)
|
||||||
|
|
||||||
#undef OPENCV_GPU_IMPLEMENT_MINMAX
|
#undef OPENCV_CUDA_IMPLEMENT_MINMAX
|
||||||
|
|
||||||
// Math functions
|
// Math functions
|
||||||
|
|
||||||
@ -451,7 +451,7 @@ namespace cv { namespace cuda { namespace device
|
|||||||
__host__ __device__ __forceinline__ abs_func(const abs_func&) {}
|
__host__ __device__ __forceinline__ abs_func(const abs_func&) {}
|
||||||
};
|
};
|
||||||
|
|
||||||
#define OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(name, func) \
|
#define OPENCV_CUDA_IMPLEMENT_UN_FUNCTOR(name, func) \
|
||||||
template <typename T> struct name ## _func : unary_function<T, float> \
|
template <typename T> struct name ## _func : unary_function<T, float> \
|
||||||
{ \
|
{ \
|
||||||
__device__ __forceinline__ float operator ()(typename TypeTraits<T>::ParameterType v) const \
|
__device__ __forceinline__ float operator ()(typename TypeTraits<T>::ParameterType v) const \
|
||||||
@ -471,7 +471,7 @@ namespace cv { namespace cuda { namespace device
|
|||||||
__host__ __device__ __forceinline__ name ## _func(const name ## _func&) {} \
|
__host__ __device__ __forceinline__ name ## _func(const name ## _func&) {} \
|
||||||
};
|
};
|
||||||
|
|
||||||
#define OPENCV_GPU_IMPLEMENT_BIN_FUNCTOR(name, func) \
|
#define OPENCV_CUDA_IMPLEMENT_BIN_FUNCTOR(name, func) \
|
||||||
template <typename T> struct name ## _func : binary_function<T, T, float> \
|
template <typename T> struct name ## _func : binary_function<T, T, float> \
|
||||||
{ \
|
{ \
|
||||||
__device__ __forceinline__ float operator ()(typename TypeTraits<T>::ParameterType v1, typename TypeTraits<T>::ParameterType v2) const \
|
__device__ __forceinline__ float operator ()(typename TypeTraits<T>::ParameterType v1, typename TypeTraits<T>::ParameterType v2) const \
|
||||||
@ -491,33 +491,33 @@ namespace cv { namespace cuda { namespace device
|
|||||||
__host__ __device__ __forceinline__ name ## _func(const name ## _func&) {} \
|
__host__ __device__ __forceinline__ name ## _func(const name ## _func&) {} \
|
||||||
};
|
};
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(sqrt, ::sqrt)
|
OPENCV_CUDA_IMPLEMENT_UN_FUNCTOR(sqrt, ::sqrt)
|
||||||
OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(exp, ::exp)
|
OPENCV_CUDA_IMPLEMENT_UN_FUNCTOR(exp, ::exp)
|
||||||
OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(exp2, ::exp2)
|
OPENCV_CUDA_IMPLEMENT_UN_FUNCTOR(exp2, ::exp2)
|
||||||
OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(exp10, ::exp10)
|
OPENCV_CUDA_IMPLEMENT_UN_FUNCTOR(exp10, ::exp10)
|
||||||
OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(log, ::log)
|
OPENCV_CUDA_IMPLEMENT_UN_FUNCTOR(log, ::log)
|
||||||
OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(log2, ::log2)
|
OPENCV_CUDA_IMPLEMENT_UN_FUNCTOR(log2, ::log2)
|
||||||
OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(log10, ::log10)
|
OPENCV_CUDA_IMPLEMENT_UN_FUNCTOR(log10, ::log10)
|
||||||
OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(sin, ::sin)
|
OPENCV_CUDA_IMPLEMENT_UN_FUNCTOR(sin, ::sin)
|
||||||
OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(cos, ::cos)
|
OPENCV_CUDA_IMPLEMENT_UN_FUNCTOR(cos, ::cos)
|
||||||
OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(tan, ::tan)
|
OPENCV_CUDA_IMPLEMENT_UN_FUNCTOR(tan, ::tan)
|
||||||
OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(asin, ::asin)
|
OPENCV_CUDA_IMPLEMENT_UN_FUNCTOR(asin, ::asin)
|
||||||
OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(acos, ::acos)
|
OPENCV_CUDA_IMPLEMENT_UN_FUNCTOR(acos, ::acos)
|
||||||
OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(atan, ::atan)
|
OPENCV_CUDA_IMPLEMENT_UN_FUNCTOR(atan, ::atan)
|
||||||
OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(sinh, ::sinh)
|
OPENCV_CUDA_IMPLEMENT_UN_FUNCTOR(sinh, ::sinh)
|
||||||
OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(cosh, ::cosh)
|
OPENCV_CUDA_IMPLEMENT_UN_FUNCTOR(cosh, ::cosh)
|
||||||
OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(tanh, ::tanh)
|
OPENCV_CUDA_IMPLEMENT_UN_FUNCTOR(tanh, ::tanh)
|
||||||
OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(asinh, ::asinh)
|
OPENCV_CUDA_IMPLEMENT_UN_FUNCTOR(asinh, ::asinh)
|
||||||
OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(acosh, ::acosh)
|
OPENCV_CUDA_IMPLEMENT_UN_FUNCTOR(acosh, ::acosh)
|
||||||
OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(atanh, ::atanh)
|
OPENCV_CUDA_IMPLEMENT_UN_FUNCTOR(atanh, ::atanh)
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_BIN_FUNCTOR(hypot, ::hypot)
|
OPENCV_CUDA_IMPLEMENT_BIN_FUNCTOR(hypot, ::hypot)
|
||||||
OPENCV_GPU_IMPLEMENT_BIN_FUNCTOR(atan2, ::atan2)
|
OPENCV_CUDA_IMPLEMENT_BIN_FUNCTOR(atan2, ::atan2)
|
||||||
OPENCV_GPU_IMPLEMENT_BIN_FUNCTOR(pow, ::pow)
|
OPENCV_CUDA_IMPLEMENT_BIN_FUNCTOR(pow, ::pow)
|
||||||
|
|
||||||
#undef OPENCV_GPU_IMPLEMENT_UN_FUNCTOR
|
#undef OPENCV_CUDA_IMPLEMENT_UN_FUNCTOR
|
||||||
#undef OPENCV_GPU_IMPLEMENT_UN_FUNCTOR_NO_DOUBLE
|
#undef OPENCV_CUDA_IMPLEMENT_UN_FUNCTOR_NO_DOUBLE
|
||||||
#undef OPENCV_GPU_IMPLEMENT_BIN_FUNCTOR
|
#undef OPENCV_CUDA_IMPLEMENT_BIN_FUNCTOR
|
||||||
|
|
||||||
template<typename T> struct hypot_sqr_func : binary_function<T, T, float>
|
template<typename T> struct hypot_sqr_func : binary_function<T, T, float>
|
||||||
{
|
{
|
||||||
@ -782,8 +782,8 @@ namespace cv { namespace cuda { namespace device
|
|||||||
|
|
||||||
template <typename Func> struct TransformFunctorTraits : DefaultTransformFunctorTraits<Func> {};
|
template <typename Func> struct TransformFunctorTraits : DefaultTransformFunctorTraits<Func> {};
|
||||||
|
|
||||||
#define OPENCV_GPU_TRANSFORM_FUNCTOR_TRAITS(type) \
|
#define OPENCV_CUDA_TRANSFORM_FUNCTOR_TRAITS(type) \
|
||||||
template <> struct TransformFunctorTraits< type > : DefaultTransformFunctorTraits< type >
|
template <> struct TransformFunctorTraits< type > : DefaultTransformFunctorTraits< type >
|
||||||
}}} // namespace cv { namespace cuda { namespace cudev
|
}}} // namespace cv { namespace cuda { namespace cudev
|
||||||
|
|
||||||
#endif // __OPENCV_GPU_FUNCTIONAL_HPP__
|
#endif // __OPENCV_CUDA_FUNCTIONAL_HPP__
|
||||||
|
|||||||
@ -40,8 +40,8 @@
|
|||||||
//
|
//
|
||||||
//M*/
|
//M*/
|
||||||
|
|
||||||
#ifndef __OPENCV_GPU_LIMITS_GPU_HPP__
|
#ifndef __OPENCV_CUDA_LIMITS_HPP__
|
||||||
#define __OPENCV_GPU_LIMITS_GPU_HPP__
|
#define __OPENCV_CUDA_LIMITS_HPP__
|
||||||
|
|
||||||
#include <limits.h>
|
#include <limits.h>
|
||||||
#include <float.h>
|
#include <float.h>
|
||||||
@ -119,4 +119,4 @@ template <> struct numeric_limits<double>
|
|||||||
|
|
||||||
}}} // namespace cv { namespace cuda { namespace cudev {
|
}}} // namespace cv { namespace cuda { namespace cudev {
|
||||||
|
|
||||||
#endif // __OPENCV_GPU_LIMITS_GPU_HPP__
|
#endif // __OPENCV_CUDA_LIMITS_HPP__
|
||||||
|
|||||||
@ -40,8 +40,8 @@
|
|||||||
//
|
//
|
||||||
//M*/
|
//M*/
|
||||||
|
|
||||||
#ifndef __OPENCV_GPU_REDUCE_HPP__
|
#ifndef __OPENCV_CUDA_REDUCE_HPP__
|
||||||
#define __OPENCV_GPU_REDUCE_HPP__
|
#define __OPENCV_CUDA_REDUCE_HPP__
|
||||||
|
|
||||||
#include <thrust/tuple.h>
|
#include <thrust/tuple.h>
|
||||||
#include "detail/reduce.hpp"
|
#include "detail/reduce.hpp"
|
||||||
@ -194,4 +194,4 @@ namespace cv { namespace cuda { namespace device
|
|||||||
}
|
}
|
||||||
}}}
|
}}}
|
||||||
|
|
||||||
#endif // __OPENCV_GPU_UTILITY_HPP__
|
#endif // __OPENCV_CUDA_UTILITY_HPP__
|
||||||
|
|||||||
@ -40,8 +40,8 @@
|
|||||||
//
|
//
|
||||||
//M*/
|
//M*/
|
||||||
|
|
||||||
#ifndef __OPENCV_GPU_SATURATE_CAST_HPP__
|
#ifndef __OPENCV_CUDA_SATURATE_CAST_HPP__
|
||||||
#define __OPENCV_GPU_SATURATE_CAST_HPP__
|
#define __OPENCV_CUDA_SATURATE_CAST_HPP__
|
||||||
|
|
||||||
#include "common.hpp"
|
#include "common.hpp"
|
||||||
|
|
||||||
@ -281,4 +281,4 @@ namespace cv { namespace cuda { namespace device
|
|||||||
}
|
}
|
||||||
}}}
|
}}}
|
||||||
|
|
||||||
#endif /* __OPENCV_GPU_SATURATE_CAST_HPP__ */
|
#endif /* __OPENCV_CUDA_SATURATE_CAST_HPP__ */
|
||||||
|
|||||||
@ -40,8 +40,8 @@
|
|||||||
//
|
//
|
||||||
//M*/
|
//M*/
|
||||||
|
|
||||||
#ifndef __OPENCV_GPU_SCAN_HPP__
|
#ifndef __OPENCV_CUDA_SCAN_HPP__
|
||||||
#define __OPENCV_GPU_SCAN_HPP__
|
#define __OPENCV_CUDA_SCAN_HPP__
|
||||||
|
|
||||||
#include "opencv2/core/cuda/common.hpp"
|
#include "opencv2/core/cuda/common.hpp"
|
||||||
#include "opencv2/core/cuda/utility.hpp"
|
#include "opencv2/core/cuda/utility.hpp"
|
||||||
@ -178,7 +178,7 @@ namespace cv { namespace cuda { namespace device
|
|||||||
|
|
||||||
// scan on shuffl functions
|
// scan on shuffl functions
|
||||||
#pragma unroll
|
#pragma unroll
|
||||||
for (int i = 1; i <= (OPENCV_GPU_WARP_SIZE / 2); i *= 2)
|
for (int i = 1; i <= (OPENCV_CUDA_WARP_SIZE / 2); i *= 2)
|
||||||
{
|
{
|
||||||
const T n = cv::cuda::device::shfl_up(idata, i);
|
const T n = cv::cuda::device::shfl_up(idata, i);
|
||||||
if (laneId >= i)
|
if (laneId >= i)
|
||||||
@ -187,9 +187,9 @@ namespace cv { namespace cuda { namespace device
|
|||||||
|
|
||||||
return idata;
|
return idata;
|
||||||
#else
|
#else
|
||||||
unsigned int pos = 2 * tid - (tid & (OPENCV_GPU_WARP_SIZE - 1));
|
unsigned int pos = 2 * tid - (tid & (OPENCV_CUDA_WARP_SIZE - 1));
|
||||||
s_Data[pos] = 0;
|
s_Data[pos] = 0;
|
||||||
pos += OPENCV_GPU_WARP_SIZE;
|
pos += OPENCV_CUDA_WARP_SIZE;
|
||||||
s_Data[pos] = idata;
|
s_Data[pos] = idata;
|
||||||
|
|
||||||
s_Data[pos] += s_Data[pos - 1];
|
s_Data[pos] += s_Data[pos - 1];
|
||||||
@ -211,7 +211,7 @@ namespace cv { namespace cuda { namespace device
|
|||||||
template <int tiNumScanThreads, typename T>
|
template <int tiNumScanThreads, typename T>
|
||||||
__device__ T blockScanInclusive(T idata, volatile T* s_Data, unsigned int tid)
|
__device__ T blockScanInclusive(T idata, volatile T* s_Data, unsigned int tid)
|
||||||
{
|
{
|
||||||
if (tiNumScanThreads > OPENCV_GPU_WARP_SIZE)
|
if (tiNumScanThreads > OPENCV_CUDA_WARP_SIZE)
|
||||||
{
|
{
|
||||||
//Bottom-level inclusive warp scan
|
//Bottom-level inclusive warp scan
|
||||||
T warpResult = warpScanInclusive(idata, s_Data, tid);
|
T warpResult = warpScanInclusive(idata, s_Data, tid);
|
||||||
@ -219,15 +219,15 @@ namespace cv { namespace cuda { namespace device
|
|||||||
//Save top elements of each warp for exclusive warp scan
|
//Save top elements of each warp for exclusive warp scan
|
||||||
//sync to wait for warp scans to complete (because s_Data is being overwritten)
|
//sync to wait for warp scans to complete (because s_Data is being overwritten)
|
||||||
__syncthreads();
|
__syncthreads();
|
||||||
if ((tid & (OPENCV_GPU_WARP_SIZE - 1)) == (OPENCV_GPU_WARP_SIZE - 1))
|
if ((tid & (OPENCV_CUDA_WARP_SIZE - 1)) == (OPENCV_CUDA_WARP_SIZE - 1))
|
||||||
{
|
{
|
||||||
s_Data[tid >> OPENCV_GPU_LOG_WARP_SIZE] = warpResult;
|
s_Data[tid >> OPENCV_CUDA_LOG_WARP_SIZE] = warpResult;
|
||||||
}
|
}
|
||||||
|
|
||||||
//wait for warp scans to complete
|
//wait for warp scans to complete
|
||||||
__syncthreads();
|
__syncthreads();
|
||||||
|
|
||||||
if (tid < (tiNumScanThreads / OPENCV_GPU_WARP_SIZE) )
|
if (tid < (tiNumScanThreads / OPENCV_CUDA_WARP_SIZE) )
|
||||||
{
|
{
|
||||||
//grab top warp elements
|
//grab top warp elements
|
||||||
T val = s_Data[tid];
|
T val = s_Data[tid];
|
||||||
@ -238,7 +238,7 @@ namespace cv { namespace cuda { namespace device
|
|||||||
//return updated warp scans with exclusive scan results
|
//return updated warp scans with exclusive scan results
|
||||||
__syncthreads();
|
__syncthreads();
|
||||||
|
|
||||||
return warpResult + s_Data[tid >> OPENCV_GPU_LOG_WARP_SIZE];
|
return warpResult + s_Data[tid >> OPENCV_CUDA_LOG_WARP_SIZE];
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
@ -247,4 +247,4 @@ namespace cv { namespace cuda { namespace device
|
|||||||
}
|
}
|
||||||
}}}
|
}}}
|
||||||
|
|
||||||
#endif // __OPENCV_GPU_SCAN_HPP__
|
#endif // __OPENCV_CUDA_SCAN_HPP__
|
||||||
|
|||||||
@ -70,16 +70,16 @@
|
|||||||
* POSSIBILITY OF SUCH DAMAGE.
|
* POSSIBILITY OF SUCH DAMAGE.
|
||||||
*/
|
*/
|
||||||
|
|
||||||
#ifndef __OPENCV_GPU_SIMD_FUNCTIONS_HPP__
|
#ifndef __OPENCV_CUDA_SIMD_FUNCTIONS_HPP__
|
||||||
#define __OPENCV_GPU_SIMD_FUNCTIONS_HPP__
|
#define __OPENCV_CUDA_SIMD_FUNCTIONS_HPP__
|
||||||
|
|
||||||
#include "common.hpp"
|
#include "common.hpp"
|
||||||
|
|
||||||
/*
|
/*
|
||||||
This header file contains inline functions that implement intra-word SIMD
|
This header file contains inline functions that implement intra-word SIMD
|
||||||
operations, that are hardware accelerated on sm_3x (Kepler) GPUs. Efficient
|
operations, that are hardware accelerated on sm_3x (Kepler) CUDAs. Efficient
|
||||||
emulation code paths are provided for earlier architectures (sm_1x, sm_2x)
|
emulation code paths are provided for earlier architectures (sm_1x, sm_2x)
|
||||||
to make the code portable across all GPUs supported by CUDA. The following
|
to make the code portable across all CUDAs supported by CUDA. The following
|
||||||
functions are currently implemented:
|
functions are currently implemented:
|
||||||
|
|
||||||
vadd2(a,b) per-halfword unsigned addition, with wrap-around: a + b
|
vadd2(a,b) per-halfword unsigned addition, with wrap-around: a + b
|
||||||
@ -906,4 +906,4 @@ namespace cv { namespace cuda { namespace device
|
|||||||
}
|
}
|
||||||
}}}
|
}}}
|
||||||
|
|
||||||
#endif // __OPENCV_GPU_SIMD_FUNCTIONS_HPP__
|
#endif // __OPENCV_CUDA_SIMD_FUNCTIONS_HPP__
|
||||||
|
|||||||
@ -40,8 +40,8 @@
|
|||||||
//
|
//
|
||||||
//M*/
|
//M*/
|
||||||
|
|
||||||
#ifndef __OPENCV_GPU_TRANSFORM_HPP__
|
#ifndef __OPENCV_CUDA_TRANSFORM_HPP__
|
||||||
#define __OPENCV_GPU_TRANSFORM_HPP__
|
#define __OPENCV_CUDA_TRANSFORM_HPP__
|
||||||
|
|
||||||
#include "common.hpp"
|
#include "common.hpp"
|
||||||
#include "utility.hpp"
|
#include "utility.hpp"
|
||||||
@ -64,4 +64,4 @@ namespace cv { namespace cuda { namespace device
|
|||||||
}
|
}
|
||||||
}}}
|
}}}
|
||||||
|
|
||||||
#endif // __OPENCV_GPU_TRANSFORM_HPP__
|
#endif // __OPENCV_CUDA_TRANSFORM_HPP__
|
||||||
|
|||||||
@ -40,8 +40,8 @@
|
|||||||
//
|
//
|
||||||
//M*/
|
//M*/
|
||||||
|
|
||||||
#ifndef __OPENCV_GPU_TYPE_TRAITS_HPP__
|
#ifndef __OPENCV_CUDA_TYPE_TRAITS_HPP__
|
||||||
#define __OPENCV_GPU_TYPE_TRAITS_HPP__
|
#define __OPENCV_CUDA_TYPE_TRAITS_HPP__
|
||||||
|
|
||||||
#include "detail/type_traits_detail.hpp"
|
#include "detail/type_traits_detail.hpp"
|
||||||
|
|
||||||
@ -79,4 +79,4 @@ namespace cv { namespace cuda { namespace device
|
|||||||
};
|
};
|
||||||
}}}
|
}}}
|
||||||
|
|
||||||
#endif // __OPENCV_GPU_TYPE_TRAITS_HPP__
|
#endif // __OPENCV_CUDA_TYPE_TRAITS_HPP__
|
||||||
|
|||||||
@ -40,18 +40,18 @@
|
|||||||
//
|
//
|
||||||
//M*/
|
//M*/
|
||||||
|
|
||||||
#ifndef __OPENCV_GPU_UTILITY_HPP__
|
#ifndef __OPENCV_CUDA_UTILITY_HPP__
|
||||||
#define __OPENCV_GPU_UTILITY_HPP__
|
#define __OPENCV_CUDA_UTILITY_HPP__
|
||||||
|
|
||||||
#include "saturate_cast.hpp"
|
#include "saturate_cast.hpp"
|
||||||
#include "datamov_utils.hpp"
|
#include "datamov_utils.hpp"
|
||||||
|
|
||||||
namespace cv { namespace cuda { namespace device
|
namespace cv { namespace cuda { namespace device
|
||||||
{
|
{
|
||||||
#define OPENCV_GPU_LOG_WARP_SIZE (5)
|
#define OPENCV_CUDA_LOG_WARP_SIZE (5)
|
||||||
#define OPENCV_GPU_WARP_SIZE (1 << OPENCV_GPU_LOG_WARP_SIZE)
|
#define OPENCV_CUDA_WARP_SIZE (1 << OPENCV_CUDA_LOG_WARP_SIZE)
|
||||||
#define OPENCV_GPU_LOG_MEM_BANKS ((__CUDA_ARCH__ >= 200) ? 5 : 4) // 32 banks on fermi, 16 on tesla
|
#define OPENCV_CUDA_LOG_MEM_BANKS ((__CUDA_ARCH__ >= 200) ? 5 : 4) // 32 banks on fermi, 16 on tesla
|
||||||
#define OPENCV_GPU_MEM_BANKS (1 << OPENCV_GPU_LOG_MEM_BANKS)
|
#define OPENCV_CUDA_MEM_BANKS (1 << OPENCV_CUDA_LOG_MEM_BANKS)
|
||||||
|
|
||||||
///////////////////////////////////////////////////////////////////////////////
|
///////////////////////////////////////////////////////////////////////////////
|
||||||
// swap
|
// swap
|
||||||
@ -210,4 +210,4 @@ namespace cv { namespace cuda { namespace device
|
|||||||
}
|
}
|
||||||
}}} // namespace cv { namespace cuda { namespace cudev
|
}}} // namespace cv { namespace cuda { namespace cudev
|
||||||
|
|
||||||
#endif // __OPENCV_GPU_UTILITY_HPP__
|
#endif // __OPENCV_CUDA_UTILITY_HPP__
|
||||||
|
|||||||
@ -40,8 +40,8 @@
|
|||||||
//
|
//
|
||||||
//M*/
|
//M*/
|
||||||
|
|
||||||
#ifndef __OPENCV_GPU_VEC_DISTANCE_HPP__
|
#ifndef __OPENCV_CUDA_VEC_DISTANCE_HPP__
|
||||||
#define __OPENCV_GPU_VEC_DISTANCE_HPP__
|
#define __OPENCV_CUDA_VEC_DISTANCE_HPP__
|
||||||
|
|
||||||
#include "reduce.hpp"
|
#include "reduce.hpp"
|
||||||
#include "functional.hpp"
|
#include "functional.hpp"
|
||||||
@ -221,4 +221,4 @@ namespace cv { namespace cuda { namespace device
|
|||||||
};
|
};
|
||||||
}}} // namespace cv { namespace cuda { namespace cudev
|
}}} // namespace cv { namespace cuda { namespace cudev
|
||||||
|
|
||||||
#endif // __OPENCV_GPU_VEC_DISTANCE_HPP__
|
#endif // __OPENCV_CUDA_VEC_DISTANCE_HPP__
|
||||||
|
|||||||
@ -40,8 +40,8 @@
|
|||||||
//
|
//
|
||||||
//M*/
|
//M*/
|
||||||
|
|
||||||
#ifndef __OPENCV_GPU_VECMATH_HPP__
|
#ifndef __OPENCV_CUDA_VECMATH_HPP__
|
||||||
#define __OPENCV_GPU_VECMATH_HPP__
|
#define __OPENCV_CUDA_VECMATH_HPP__
|
||||||
|
|
||||||
#include "vec_traits.hpp"
|
#include "vec_traits.hpp"
|
||||||
#include "saturate_cast.hpp"
|
#include "saturate_cast.hpp"
|
||||||
@ -919,4 +919,4 @@ CV_CUDEV_IMPLEMENT_SCALAR_BINARY_FUNC(atan2, ::atan2, double, double, double)
|
|||||||
|
|
||||||
}}} // namespace cv { namespace cuda { namespace device
|
}}} // namespace cv { namespace cuda { namespace device
|
||||||
|
|
||||||
#endif // __OPENCV_GPU_VECMATH_HPP__
|
#endif // __OPENCV_CUDA_VECMATH_HPP__
|
||||||
|
|||||||
@ -40,8 +40,8 @@
|
|||||||
//
|
//
|
||||||
//M*/
|
//M*/
|
||||||
|
|
||||||
#ifndef __OPENCV_GPU_VEC_TRAITS_HPP__
|
#ifndef __OPENCV_CUDA_VEC_TRAITS_HPP__
|
||||||
#define __OPENCV_GPU_VEC_TRAITS_HPP__
|
#define __OPENCV_CUDA_VEC_TRAITS_HPP__
|
||||||
|
|
||||||
#include "common.hpp"
|
#include "common.hpp"
|
||||||
|
|
||||||
@ -122,7 +122,7 @@ namespace cv { namespace cuda { namespace device
|
|||||||
return val;
|
return val;
|
||||||
}
|
}
|
||||||
|
|
||||||
#define OPENCV_GPU_IMPLEMENT_TYPE_VEC(type) \
|
#define OPENCV_CUDA_IMPLEMENT_TYPE_VEC(type) \
|
||||||
template<> struct TypeVec<type, 1> { typedef type vec_type; }; \
|
template<> struct TypeVec<type, 1> { typedef type vec_type; }; \
|
||||||
template<> struct TypeVec<type ## 1, 1> { typedef type ## 1 vec_type; }; \
|
template<> struct TypeVec<type ## 1, 1> { typedef type ## 1 vec_type; }; \
|
||||||
template<> struct TypeVec<type, 2> { typedef type ## 2 vec_type; }; \
|
template<> struct TypeVec<type, 2> { typedef type ## 2 vec_type; }; \
|
||||||
@ -134,16 +134,16 @@ namespace cv { namespace cuda { namespace device
|
|||||||
template<> struct TypeVec<type, 8> { typedef type ## 8 vec_type; }; \
|
template<> struct TypeVec<type, 8> { typedef type ## 8 vec_type; }; \
|
||||||
template<> struct TypeVec<type ## 8, 8> { typedef type ## 8 vec_type; };
|
template<> struct TypeVec<type ## 8, 8> { typedef type ## 8 vec_type; };
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_TYPE_VEC(uchar)
|
OPENCV_CUDA_IMPLEMENT_TYPE_VEC(uchar)
|
||||||
OPENCV_GPU_IMPLEMENT_TYPE_VEC(char)
|
OPENCV_CUDA_IMPLEMENT_TYPE_VEC(char)
|
||||||
OPENCV_GPU_IMPLEMENT_TYPE_VEC(ushort)
|
OPENCV_CUDA_IMPLEMENT_TYPE_VEC(ushort)
|
||||||
OPENCV_GPU_IMPLEMENT_TYPE_VEC(short)
|
OPENCV_CUDA_IMPLEMENT_TYPE_VEC(short)
|
||||||
OPENCV_GPU_IMPLEMENT_TYPE_VEC(int)
|
OPENCV_CUDA_IMPLEMENT_TYPE_VEC(int)
|
||||||
OPENCV_GPU_IMPLEMENT_TYPE_VEC(uint)
|
OPENCV_CUDA_IMPLEMENT_TYPE_VEC(uint)
|
||||||
OPENCV_GPU_IMPLEMENT_TYPE_VEC(float)
|
OPENCV_CUDA_IMPLEMENT_TYPE_VEC(float)
|
||||||
OPENCV_GPU_IMPLEMENT_TYPE_VEC(double)
|
OPENCV_CUDA_IMPLEMENT_TYPE_VEC(double)
|
||||||
|
|
||||||
#undef OPENCV_GPU_IMPLEMENT_TYPE_VEC
|
#undef OPENCV_CUDA_IMPLEMENT_TYPE_VEC
|
||||||
|
|
||||||
template<> struct TypeVec<schar, 1> { typedef schar vec_type; };
|
template<> struct TypeVec<schar, 1> { typedef schar vec_type; };
|
||||||
template<> struct TypeVec<schar, 2> { typedef char2 vec_type; };
|
template<> struct TypeVec<schar, 2> { typedef char2 vec_type; };
|
||||||
@ -159,7 +159,7 @@ namespace cv { namespace cuda { namespace device
|
|||||||
|
|
||||||
template<typename T> struct VecTraits;
|
template<typename T> struct VecTraits;
|
||||||
|
|
||||||
#define OPENCV_GPU_IMPLEMENT_VEC_TRAITS(type) \
|
#define OPENCV_CUDA_IMPLEMENT_VEC_TRAITS(type) \
|
||||||
template<> struct VecTraits<type> \
|
template<> struct VecTraits<type> \
|
||||||
{ \
|
{ \
|
||||||
typedef type elem_type; \
|
typedef type elem_type; \
|
||||||
@ -209,15 +209,15 @@ namespace cv { namespace cuda { namespace device
|
|||||||
static __device__ __host__ __forceinline__ type ## 8 make(const type* v) {return make_ ## type ## 8(v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7]);} \
|
static __device__ __host__ __forceinline__ type ## 8 make(const type* v) {return make_ ## type ## 8(v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7]);} \
|
||||||
};
|
};
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_VEC_TRAITS(uchar)
|
OPENCV_CUDA_IMPLEMENT_VEC_TRAITS(uchar)
|
||||||
OPENCV_GPU_IMPLEMENT_VEC_TRAITS(ushort)
|
OPENCV_CUDA_IMPLEMENT_VEC_TRAITS(ushort)
|
||||||
OPENCV_GPU_IMPLEMENT_VEC_TRAITS(short)
|
OPENCV_CUDA_IMPLEMENT_VEC_TRAITS(short)
|
||||||
OPENCV_GPU_IMPLEMENT_VEC_TRAITS(int)
|
OPENCV_CUDA_IMPLEMENT_VEC_TRAITS(int)
|
||||||
OPENCV_GPU_IMPLEMENT_VEC_TRAITS(uint)
|
OPENCV_CUDA_IMPLEMENT_VEC_TRAITS(uint)
|
||||||
OPENCV_GPU_IMPLEMENT_VEC_TRAITS(float)
|
OPENCV_CUDA_IMPLEMENT_VEC_TRAITS(float)
|
||||||
OPENCV_GPU_IMPLEMENT_VEC_TRAITS(double)
|
OPENCV_CUDA_IMPLEMENT_VEC_TRAITS(double)
|
||||||
|
|
||||||
#undef OPENCV_GPU_IMPLEMENT_VEC_TRAITS
|
#undef OPENCV_CUDA_IMPLEMENT_VEC_TRAITS
|
||||||
|
|
||||||
template<> struct VecTraits<char>
|
template<> struct VecTraits<char>
|
||||||
{
|
{
|
||||||
@ -277,4 +277,4 @@ namespace cv { namespace cuda { namespace device
|
|||||||
};
|
};
|
||||||
}}} // namespace cv { namespace cuda { namespace cudev
|
}}} // namespace cv { namespace cuda { namespace cudev
|
||||||
|
|
||||||
#endif // __OPENCV_GPU_VEC_TRAITS_HPP__
|
#endif // __OPENCV_CUDA_VEC_TRAITS_HPP__
|
||||||
|
|||||||
@ -40,8 +40,8 @@
|
|||||||
//
|
//
|
||||||
//M*/
|
//M*/
|
||||||
|
|
||||||
#ifndef __OPENCV_GPU_DEVICE_WARP_HPP__
|
#ifndef __OPENCV_CUDA_DEVICE_WARP_HPP__
|
||||||
#define __OPENCV_GPU_DEVICE_WARP_HPP__
|
#define __OPENCV_CUDA_DEVICE_WARP_HPP__
|
||||||
|
|
||||||
namespace cv { namespace cuda { namespace device
|
namespace cv { namespace cuda { namespace device
|
||||||
{
|
{
|
||||||
@ -128,4 +128,4 @@ namespace cv { namespace cuda { namespace device
|
|||||||
};
|
};
|
||||||
}}} // namespace cv { namespace cuda { namespace cudev
|
}}} // namespace cv { namespace cuda { namespace cudev
|
||||||
|
|
||||||
#endif /* __OPENCV_GPU_DEVICE_WARP_HPP__ */
|
#endif /* __OPENCV_CUDA_DEVICE_WARP_HPP__ */
|
||||||
|
|||||||
@ -40,8 +40,8 @@
|
|||||||
//
|
//
|
||||||
//M*/
|
//M*/
|
||||||
|
|
||||||
#ifndef OPENCV_GPU_WARP_REDUCE_HPP__
|
#ifndef OPENCV_CUDA_WARP_REDUCE_HPP__
|
||||||
#define OPENCV_GPU_WARP_REDUCE_HPP__
|
#define OPENCV_CUDA_WARP_REDUCE_HPP__
|
||||||
|
|
||||||
namespace cv { namespace cuda { namespace device
|
namespace cv { namespace cuda { namespace device
|
||||||
{
|
{
|
||||||
@ -65,4 +65,4 @@ namespace cv { namespace cuda { namespace device
|
|||||||
}
|
}
|
||||||
}}} // namespace cv { namespace cuda { namespace cudev {
|
}}} // namespace cv { namespace cuda { namespace cudev {
|
||||||
|
|
||||||
#endif /* OPENCV_GPU_WARP_REDUCE_HPP__ */
|
#endif /* OPENCV_CUDA_WARP_REDUCE_HPP__ */
|
||||||
|
|||||||
@ -40,8 +40,8 @@
|
|||||||
//
|
//
|
||||||
//M*/
|
//M*/
|
||||||
|
|
||||||
#ifndef __OPENCV_GPU_WARP_SHUFFLE_HPP__
|
#ifndef __OPENCV_CUDA_WARP_SHUFFLE_HPP__
|
||||||
#define __OPENCV_GPU_WARP_SHUFFLE_HPP__
|
#define __OPENCV_CUDA_WARP_SHUFFLE_HPP__
|
||||||
|
|
||||||
namespace cv { namespace cuda { namespace device
|
namespace cv { namespace cuda { namespace device
|
||||||
{
|
{
|
||||||
@ -142,4 +142,4 @@ namespace cv { namespace cuda { namespace device
|
|||||||
}
|
}
|
||||||
}}}
|
}}}
|
||||||
|
|
||||||
#endif // __OPENCV_GPU_WARP_SHUFFLE_HPP__
|
#endif // __OPENCV_CUDA_WARP_SHUFFLE_HPP__
|
||||||
|
|||||||
@ -40,8 +40,8 @@
|
|||||||
//
|
//
|
||||||
//M*/
|
//M*/
|
||||||
|
|
||||||
#ifndef __OPENCV_CORE_GPU_STREAM_ACCESSOR_HPP__
|
#ifndef __OPENCV_CORE_CUDA_STREAM_ACCESSOR_HPP__
|
||||||
#define __OPENCV_CORE_GPU_STREAM_ACCESSOR_HPP__
|
#define __OPENCV_CORE_CUDA_STREAM_ACCESSOR_HPP__
|
||||||
|
|
||||||
#ifndef __cplusplus
|
#ifndef __cplusplus
|
||||||
# error cuda_stream_accessor.hpp header must be compiled as C++
|
# error cuda_stream_accessor.hpp header must be compiled as C++
|
||||||
@ -49,7 +49,7 @@
|
|||||||
|
|
||||||
// This is only header file that depends on Cuda. All other headers are independent.
|
// This is only header file that depends on Cuda. All other headers are independent.
|
||||||
// So if you use OpenCV binaries you do noot need to install Cuda Toolkit.
|
// So if you use OpenCV binaries you do noot need to install Cuda Toolkit.
|
||||||
// But of you wanna use GPU by yourself, may get cuda stream instance using the class below.
|
// But of you wanna use CUDA by yourself, may get cuda stream instance using the class below.
|
||||||
// In this case you have to install Cuda Toolkit.
|
// In this case you have to install Cuda Toolkit.
|
||||||
|
|
||||||
#include <cuda_runtime.h>
|
#include <cuda_runtime.h>
|
||||||
@ -74,4 +74,4 @@ namespace cv
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
#endif /* __OPENCV_CORE_GPU_STREAM_ACCESSOR_HPP__ */
|
#endif /* __OPENCV_CORE_CUDA_STREAM_ACCESSOR_HPP__ */
|
||||||
|
|||||||
@ -40,17 +40,17 @@
|
|||||||
//
|
//
|
||||||
//M*/
|
//M*/
|
||||||
|
|
||||||
#ifndef __OPENCV_CORE_GPU_TYPES_HPP__
|
#ifndef __OPENCV_CORE_CUDA_TYPES_HPP__
|
||||||
#define __OPENCV_CORE_GPU_TYPES_HPP__
|
#define __OPENCV_CORE_CUDA_TYPES_HPP__
|
||||||
|
|
||||||
#ifndef __cplusplus
|
#ifndef __cplusplus
|
||||||
# error cuda_types.hpp header must be compiled as C++
|
# error cuda_types.hpp header must be compiled as C++
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#ifdef __CUDACC__
|
#ifdef __CUDACC__
|
||||||
#define __CV_GPU_HOST_DEVICE__ __host__ __device__ __forceinline__
|
#define __CV_CUDA_HOST_DEVICE__ __host__ __device__ __forceinline__
|
||||||
#else
|
#else
|
||||||
#define __CV_GPU_HOST_DEVICE__
|
#define __CV_CUDA_HOST_DEVICE__
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
namespace cv
|
namespace cv
|
||||||
@ -69,41 +69,41 @@ namespace cv
|
|||||||
|
|
||||||
T* data;
|
T* data;
|
||||||
|
|
||||||
__CV_GPU_HOST_DEVICE__ DevPtr() : data(0) {}
|
__CV_CUDA_HOST_DEVICE__ DevPtr() : data(0) {}
|
||||||
__CV_GPU_HOST_DEVICE__ DevPtr(T* data_) : data(data_) {}
|
__CV_CUDA_HOST_DEVICE__ DevPtr(T* data_) : data(data_) {}
|
||||||
|
|
||||||
__CV_GPU_HOST_DEVICE__ size_t elemSize() const { return elem_size; }
|
__CV_CUDA_HOST_DEVICE__ size_t elemSize() const { return elem_size; }
|
||||||
__CV_GPU_HOST_DEVICE__ operator T*() { return data; }
|
__CV_CUDA_HOST_DEVICE__ operator T*() { return data; }
|
||||||
__CV_GPU_HOST_DEVICE__ operator const T*() const { return data; }
|
__CV_CUDA_HOST_DEVICE__ operator const T*() const { return data; }
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename T> struct PtrSz : public DevPtr<T>
|
template <typename T> struct PtrSz : public DevPtr<T>
|
||||||
{
|
{
|
||||||
__CV_GPU_HOST_DEVICE__ PtrSz() : size(0) {}
|
__CV_CUDA_HOST_DEVICE__ PtrSz() : size(0) {}
|
||||||
__CV_GPU_HOST_DEVICE__ PtrSz(T* data_, size_t size_) : DevPtr<T>(data_), size(size_) {}
|
__CV_CUDA_HOST_DEVICE__ PtrSz(T* data_, size_t size_) : DevPtr<T>(data_), size(size_) {}
|
||||||
|
|
||||||
size_t size;
|
size_t size;
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename T> struct PtrStep : public DevPtr<T>
|
template <typename T> struct PtrStep : public DevPtr<T>
|
||||||
{
|
{
|
||||||
__CV_GPU_HOST_DEVICE__ PtrStep() : step(0) {}
|
__CV_CUDA_HOST_DEVICE__ PtrStep() : step(0) {}
|
||||||
__CV_GPU_HOST_DEVICE__ PtrStep(T* data_, size_t step_) : DevPtr<T>(data_), step(step_) {}
|
__CV_CUDA_HOST_DEVICE__ PtrStep(T* data_, size_t step_) : DevPtr<T>(data_), step(step_) {}
|
||||||
|
|
||||||
//! stride between two consecutive rows in bytes. Step is stored always and everywhere in bytes!!!
|
//! stride between two consecutive rows in bytes. Step is stored always and everywhere in bytes!!!
|
||||||
size_t step;
|
size_t step;
|
||||||
|
|
||||||
__CV_GPU_HOST_DEVICE__ T* ptr(int y = 0) { return ( T*)( ( char*)DevPtr<T>::data + y * step); }
|
__CV_CUDA_HOST_DEVICE__ T* ptr(int y = 0) { return ( T*)( ( char*)DevPtr<T>::data + y * step); }
|
||||||
__CV_GPU_HOST_DEVICE__ const T* ptr(int y = 0) const { return (const T*)( (const char*)DevPtr<T>::data + y * step); }
|
__CV_CUDA_HOST_DEVICE__ const T* ptr(int y = 0) const { return (const T*)( (const char*)DevPtr<T>::data + y * step); }
|
||||||
|
|
||||||
__CV_GPU_HOST_DEVICE__ T& operator ()(int y, int x) { return ptr(y)[x]; }
|
__CV_CUDA_HOST_DEVICE__ T& operator ()(int y, int x) { return ptr(y)[x]; }
|
||||||
__CV_GPU_HOST_DEVICE__ const T& operator ()(int y, int x) const { return ptr(y)[x]; }
|
__CV_CUDA_HOST_DEVICE__ const T& operator ()(int y, int x) const { return ptr(y)[x]; }
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename T> struct PtrStepSz : public PtrStep<T>
|
template <typename T> struct PtrStepSz : public PtrStep<T>
|
||||||
{
|
{
|
||||||
__CV_GPU_HOST_DEVICE__ PtrStepSz() : cols(0), rows(0) {}
|
__CV_CUDA_HOST_DEVICE__ PtrStepSz() : cols(0), rows(0) {}
|
||||||
__CV_GPU_HOST_DEVICE__ PtrStepSz(int rows_, int cols_, T* data_, size_t step_)
|
__CV_CUDA_HOST_DEVICE__ PtrStepSz(int rows_, int cols_, T* data_, size_t step_)
|
||||||
: PtrStep<T>(data_, step_), cols(cols_), rows(rows_) {}
|
: PtrStep<T>(data_, step_), cols(cols_), rows(rows_) {}
|
||||||
|
|
||||||
template <typename U>
|
template <typename U>
|
||||||
@ -123,4 +123,4 @@ namespace cv
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
#endif /* __OPENCV_CORE_GPU_TYPES_HPP__ */
|
#endif /* __OPENCV_CORE_CUDA_TYPES_HPP__ */
|
||||||
|
|||||||
@ -41,8 +41,8 @@
|
|||||||
//
|
//
|
||||||
//M*/
|
//M*/
|
||||||
|
|
||||||
#ifndef __OPENCV_CORE_PRIVATE_GPU_HPP__
|
#ifndef __OPENCV_CORE_PRIVATE_CUDA_HPP__
|
||||||
#define __OPENCV_CORE_PRIVATE_GPU_HPP__
|
#define __OPENCV_CORE_PRIVATE_CUDA_HPP__
|
||||||
|
|
||||||
#ifndef __OPENCV_BUILD
|
#ifndef __OPENCV_BUILD
|
||||||
# error this is a private header which should not be used from outside of the OpenCV library
|
# error this is a private header which should not be used from outside of the OpenCV library
|
||||||
@ -71,7 +71,7 @@
|
|||||||
# endif
|
# endif
|
||||||
|
|
||||||
# if defined(CUDA_ARCH_BIN_OR_PTX_10)
|
# if defined(CUDA_ARCH_BIN_OR_PTX_10)
|
||||||
# error "OpenCV GPU module doesn't support NVIDIA compute capability 1.0"
|
# error "OpenCV CUDA module doesn't support NVIDIA compute capability 1.0"
|
||||||
# endif
|
# endif
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
@ -82,7 +82,7 @@ namespace cv { namespace cuda {
|
|||||||
|
|
||||||
#ifndef HAVE_CUDA
|
#ifndef HAVE_CUDA
|
||||||
|
|
||||||
static inline void throw_no_cuda() { CV_Error(cv::Error::GpuNotSupported, "The library is compiled without GPU support"); }
|
static inline void throw_no_cuda() { CV_Error(cv::Error::GpuNotSupported, "The library is compiled without CUDA support"); }
|
||||||
|
|
||||||
#else // HAVE_CUDA
|
#else // HAVE_CUDA
|
||||||
|
|
||||||
@ -140,4 +140,4 @@ namespace cv { namespace cuda
|
|||||||
|
|
||||||
#endif // HAVE_CUDA
|
#endif // HAVE_CUDA
|
||||||
|
|
||||||
#endif // __OPENCV_CORE_GPU_PRIVATE_HPP__
|
#endif // __OPENCV_CORE_CUDA_PRIVATE_HPP__
|
||||||
|
|||||||
@ -634,7 +634,7 @@ CV_IMPL const char* cvErrorStr( int status )
|
|||||||
case CV_StsNotImplemented : return "The function/feature is not implemented";
|
case CV_StsNotImplemented : return "The function/feature is not implemented";
|
||||||
case CV_StsBadMemBlock : return "Memory block has been corrupted";
|
case CV_StsBadMemBlock : return "Memory block has been corrupted";
|
||||||
case CV_StsAssert : return "Assertion failed";
|
case CV_StsAssert : return "Assertion failed";
|
||||||
case CV_GpuNotSupported : return "No GPU support";
|
case CV_GpuNotSupported : return "No CUDA support";
|
||||||
case CV_GpuApiCallError : return "Gpu API call";
|
case CV_GpuApiCallError : return "Gpu API call";
|
||||||
case CV_OpenGlNotSupported : return "No OpenGL support";
|
case CV_OpenGlNotSupported : return "No OpenGL support";
|
||||||
case CV_OpenGlApiCallError : return "OpenGL API call";
|
case CV_OpenGlApiCallError : return "OpenGL API call";
|
||||||
|
|||||||
@ -146,12 +146,12 @@ protected:
|
|||||||
//////////////////////////// CascadeClassifier ////////////////////////////
|
//////////////////////////// CascadeClassifier ////////////////////////////
|
||||||
|
|
||||||
// The cascade classifier class for object detection: supports old haar and new lbp xlm formats and nvbin for haar cascades olny.
|
// The cascade classifier class for object detection: supports old haar and new lbp xlm formats and nvbin for haar cascades olny.
|
||||||
class CV_EXPORTS CascadeClassifier_GPU
|
class CV_EXPORTS CascadeClassifier_CUDA
|
||||||
{
|
{
|
||||||
public:
|
public:
|
||||||
CascadeClassifier_GPU();
|
CascadeClassifier_CUDA();
|
||||||
CascadeClassifier_GPU(const String& filename);
|
CascadeClassifier_CUDA(const String& filename);
|
||||||
~CascadeClassifier_GPU();
|
~CascadeClassifier_CUDA();
|
||||||
|
|
||||||
bool empty() const;
|
bool empty() const;
|
||||||
bool load(const String& filename);
|
bool load(const String& filename);
|
||||||
@ -171,7 +171,7 @@ private:
|
|||||||
CascadeClassifierImpl* impl;
|
CascadeClassifierImpl* impl;
|
||||||
struct HaarCascade;
|
struct HaarCascade;
|
||||||
struct LbpCascade;
|
struct LbpCascade;
|
||||||
friend class CascadeClassifier_GPU_LBP;
|
friend class CascadeClassifier_CUDA_LBP;
|
||||||
};
|
};
|
||||||
|
|
||||||
//////////////////////////// Labeling ////////////////////////////
|
//////////////////////////// Labeling ////////////////////////////
|
||||||
|
|||||||
@ -63,14 +63,14 @@ PERF_TEST_P(Count, Calib3D_ProjectPoints,
|
|||||||
const cv::Mat tvec = cv::Mat::ones(1, 3, CV_32FC1);
|
const cv::Mat tvec = cv::Mat::ones(1, 3, CV_32FC1);
|
||||||
const cv::Mat camera_mat = cv::Mat::ones(3, 3, CV_32FC1);
|
const cv::Mat camera_mat = cv::Mat::ones(3, 3, CV_32FC1);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_src(src);
|
const cv::cuda::GpuMat d_src(src);
|
||||||
cv::cuda::GpuMat dst;
|
cv::cuda::GpuMat dst;
|
||||||
|
|
||||||
TEST_CYCLE() cv::cuda::projectPoints(d_src, rvec, tvec, camera_mat, cv::Mat(), dst);
|
TEST_CYCLE() cv::cuda::projectPoints(d_src, rvec, tvec, camera_mat, cv::Mat(), dst);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst);
|
CUDA_SANITY_CHECK(dst);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
@ -118,12 +118,12 @@ PERF_TEST_P(Count, Calib3D_SolvePnPRansac,
|
|||||||
cv::Mat rvec;
|
cv::Mat rvec;
|
||||||
cv::Mat tvec;
|
cv::Mat tvec;
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
TEST_CYCLE() cv::cuda::solvePnPRansac(object, image, camera_mat, dist_coef, rvec, tvec);
|
TEST_CYCLE() cv::cuda::solvePnPRansac(object, image, camera_mat, dist_coef, rvec, tvec);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(rvec, 1e-3);
|
CUDA_SANITY_CHECK(rvec, 1e-3);
|
||||||
GPU_SANITY_CHECK(tvec, 1e-3);
|
CUDA_SANITY_CHECK(tvec, 1e-3);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
|
|||||||
@ -149,14 +149,14 @@ PERF_TEST_P(Image, DISABLED_Labeling_ConnectivityMask,
|
|||||||
const cv::Mat image = readImage(GetParam(), cv::IMREAD_GRAYSCALE);
|
const cv::Mat image = readImage(GetParam(), cv::IMREAD_GRAYSCALE);
|
||||||
ASSERT_FALSE(image.empty());
|
ASSERT_FALSE(image.empty());
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
cv::cuda::GpuMat d_image(image);
|
cv::cuda::GpuMat d_image(image);
|
||||||
cv::cuda::GpuMat mask;
|
cv::cuda::GpuMat mask;
|
||||||
|
|
||||||
TEST_CYCLE() cv::cuda::connectivityMask(d_image, mask, cv::Scalar::all(0), cv::Scalar::all(2));
|
TEST_CYCLE() cv::cuda::connectivityMask(d_image, mask, cv::Scalar::all(0), cv::Scalar::all(2));
|
||||||
|
|
||||||
GPU_SANITY_CHECK(mask);
|
CUDA_SANITY_CHECK(mask);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
@ -172,7 +172,7 @@ PERF_TEST_P(Image, DISABLED_Labeling_ConnectedComponents,
|
|||||||
const cv::Mat image = readImage(GetParam(), cv::IMREAD_GRAYSCALE);
|
const cv::Mat image = readImage(GetParam(), cv::IMREAD_GRAYSCALE);
|
||||||
ASSERT_FALSE(image.empty());
|
ASSERT_FALSE(image.empty());
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
cv::cuda::GpuMat d_mask;
|
cv::cuda::GpuMat d_mask;
|
||||||
cv::cuda::connectivityMask(cv::cuda::GpuMat(image), d_mask, cv::Scalar::all(0), cv::Scalar::all(2));
|
cv::cuda::connectivityMask(cv::cuda::GpuMat(image), d_mask, cv::Scalar::all(0), cv::Scalar::all(2));
|
||||||
@ -181,7 +181,7 @@ PERF_TEST_P(Image, DISABLED_Labeling_ConnectedComponents,
|
|||||||
|
|
||||||
TEST_CYCLE() cv::cuda::labelComponents(d_mask, components);
|
TEST_CYCLE() cv::cuda::labelComponents(d_mask, components);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(components);
|
CUDA_SANITY_CHECK(components);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
|
|||||||
@ -50,9 +50,9 @@ using namespace perf;
|
|||||||
// SetTo
|
// SetTo
|
||||||
|
|
||||||
PERF_TEST_P(Sz_Depth_Cn, MatOp_SetTo,
|
PERF_TEST_P(Sz_Depth_Cn, MatOp_SetTo,
|
||||||
Combine(GPU_TYPICAL_MAT_SIZES,
|
Combine(CUDA_TYPICAL_MAT_SIZES,
|
||||||
Values(CV_8U, CV_16U, CV_32F, CV_64F),
|
Values(CV_8U, CV_16U, CV_32F, CV_64F),
|
||||||
GPU_CHANNELS_1_3_4))
|
CUDA_CHANNELS_1_3_4))
|
||||||
{
|
{
|
||||||
const cv::Size size = GET_PARAM(0);
|
const cv::Size size = GET_PARAM(0);
|
||||||
const int depth = GET_PARAM(1);
|
const int depth = GET_PARAM(1);
|
||||||
@ -62,13 +62,13 @@ PERF_TEST_P(Sz_Depth_Cn, MatOp_SetTo,
|
|||||||
|
|
||||||
const cv::Scalar val(1, 2, 3, 4);
|
const cv::Scalar val(1, 2, 3, 4);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
cv::cuda::GpuMat dst(size, type);
|
cv::cuda::GpuMat dst(size, type);
|
||||||
|
|
||||||
TEST_CYCLE() dst.setTo(val);
|
TEST_CYCLE() dst.setTo(val);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst);
|
CUDA_SANITY_CHECK(dst);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
@ -84,9 +84,9 @@ PERF_TEST_P(Sz_Depth_Cn, MatOp_SetTo,
|
|||||||
// SetToMasked
|
// SetToMasked
|
||||||
|
|
||||||
PERF_TEST_P(Sz_Depth_Cn, MatOp_SetToMasked,
|
PERF_TEST_P(Sz_Depth_Cn, MatOp_SetToMasked,
|
||||||
Combine(GPU_TYPICAL_MAT_SIZES,
|
Combine(CUDA_TYPICAL_MAT_SIZES,
|
||||||
Values(CV_8U, CV_16U, CV_32F, CV_64F),
|
Values(CV_8U, CV_16U, CV_32F, CV_64F),
|
||||||
GPU_CHANNELS_1_3_4))
|
CUDA_CHANNELS_1_3_4))
|
||||||
{
|
{
|
||||||
const cv::Size size = GET_PARAM(0);
|
const cv::Size size = GET_PARAM(0);
|
||||||
const int depth = GET_PARAM(1);
|
const int depth = GET_PARAM(1);
|
||||||
@ -100,14 +100,14 @@ PERF_TEST_P(Sz_Depth_Cn, MatOp_SetToMasked,
|
|||||||
|
|
||||||
const cv::Scalar val(1, 2, 3, 4);
|
const cv::Scalar val(1, 2, 3, 4);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
cv::cuda::GpuMat dst(src);
|
cv::cuda::GpuMat dst(src);
|
||||||
const cv::cuda::GpuMat d_mask(mask);
|
const cv::cuda::GpuMat d_mask(mask);
|
||||||
|
|
||||||
TEST_CYCLE() dst.setTo(val, d_mask);
|
TEST_CYCLE() dst.setTo(val, d_mask);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst, 1e-10);
|
CUDA_SANITY_CHECK(dst, 1e-10);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
@ -123,9 +123,9 @@ PERF_TEST_P(Sz_Depth_Cn, MatOp_SetToMasked,
|
|||||||
// CopyToMasked
|
// CopyToMasked
|
||||||
|
|
||||||
PERF_TEST_P(Sz_Depth_Cn, MatOp_CopyToMasked,
|
PERF_TEST_P(Sz_Depth_Cn, MatOp_CopyToMasked,
|
||||||
Combine(GPU_TYPICAL_MAT_SIZES,
|
Combine(CUDA_TYPICAL_MAT_SIZES,
|
||||||
Values(CV_8U, CV_16U, CV_32F, CV_64F),
|
Values(CV_8U, CV_16U, CV_32F, CV_64F),
|
||||||
GPU_CHANNELS_1_3_4))
|
CUDA_CHANNELS_1_3_4))
|
||||||
{
|
{
|
||||||
const cv::Size size = GET_PARAM(0);
|
const cv::Size size = GET_PARAM(0);
|
||||||
const int depth = GET_PARAM(1);
|
const int depth = GET_PARAM(1);
|
||||||
@ -137,7 +137,7 @@ PERF_TEST_P(Sz_Depth_Cn, MatOp_CopyToMasked,
|
|||||||
cv::Mat mask(size, CV_8UC1);
|
cv::Mat mask(size, CV_8UC1);
|
||||||
declare.in(src, mask, WARMUP_RNG);
|
declare.in(src, mask, WARMUP_RNG);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_src(src);
|
const cv::cuda::GpuMat d_src(src);
|
||||||
const cv::cuda::GpuMat d_mask(mask);
|
const cv::cuda::GpuMat d_mask(mask);
|
||||||
@ -145,7 +145,7 @@ PERF_TEST_P(Sz_Depth_Cn, MatOp_CopyToMasked,
|
|||||||
|
|
||||||
TEST_CYCLE() d_src.copyTo(dst, d_mask);
|
TEST_CYCLE() d_src.copyTo(dst, d_mask);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst, 1e-10);
|
CUDA_SANITY_CHECK(dst, 1e-10);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
@ -163,7 +163,7 @@ PERF_TEST_P(Sz_Depth_Cn, MatOp_CopyToMasked,
|
|||||||
DEF_PARAM_TEST(Sz_2Depth, cv::Size, MatDepth, MatDepth);
|
DEF_PARAM_TEST(Sz_2Depth, cv::Size, MatDepth, MatDepth);
|
||||||
|
|
||||||
PERF_TEST_P(Sz_2Depth, MatOp_ConvertTo,
|
PERF_TEST_P(Sz_2Depth, MatOp_ConvertTo,
|
||||||
Combine(GPU_TYPICAL_MAT_SIZES,
|
Combine(CUDA_TYPICAL_MAT_SIZES,
|
||||||
Values(CV_8U, CV_16U, CV_32F, CV_64F),
|
Values(CV_8U, CV_16U, CV_32F, CV_64F),
|
||||||
Values(CV_8U, CV_16U, CV_32F, CV_64F)))
|
Values(CV_8U, CV_16U, CV_32F, CV_64F)))
|
||||||
{
|
{
|
||||||
@ -177,14 +177,14 @@ PERF_TEST_P(Sz_2Depth, MatOp_ConvertTo,
|
|||||||
const double a = 0.5;
|
const double a = 0.5;
|
||||||
const double b = 1.0;
|
const double b = 1.0;
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_src(src);
|
const cv::cuda::GpuMat d_src(src);
|
||||||
cv::cuda::GpuMat dst;
|
cv::cuda::GpuMat dst;
|
||||||
|
|
||||||
TEST_CYCLE() d_src.convertTo(dst, depth2, a, b);
|
TEST_CYCLE() d_src.convertTo(dst, depth2, a, b);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst, 1e-10);
|
CUDA_SANITY_CHECK(dst, 1e-10);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
|
|||||||
@ -66,7 +66,7 @@ PERF_TEST_P(Image, ObjDetect_HOG,
|
|||||||
const cv::Mat img = readImage(GetParam(), cv::IMREAD_GRAYSCALE);
|
const cv::Mat img = readImage(GetParam(), cv::IMREAD_GRAYSCALE);
|
||||||
ASSERT_FALSE(img.empty());
|
ASSERT_FALSE(img.empty());
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_img(img);
|
const cv::cuda::GpuMat d_img(img);
|
||||||
std::vector<cv::Rect> gpu_found_locations;
|
std::vector<cv::Rect> gpu_found_locations;
|
||||||
@ -103,9 +103,9 @@ PERF_TEST_P(ImageAndCascade, ObjDetect_HaarClassifier,
|
|||||||
const cv::Mat img = readImage(GetParam().first, cv::IMREAD_GRAYSCALE);
|
const cv::Mat img = readImage(GetParam().first, cv::IMREAD_GRAYSCALE);
|
||||||
ASSERT_FALSE(img.empty());
|
ASSERT_FALSE(img.empty());
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
cv::cuda::CascadeClassifier_GPU d_cascade;
|
cv::cuda::CascadeClassifier_CUDA d_cascade;
|
||||||
ASSERT_TRUE(d_cascade.load(perf::TestBase::getDataPath(GetParam().second)));
|
ASSERT_TRUE(d_cascade.load(perf::TestBase::getDataPath(GetParam().second)));
|
||||||
|
|
||||||
const cv::cuda::GpuMat d_img(img);
|
const cv::cuda::GpuMat d_img(img);
|
||||||
@ -142,9 +142,9 @@ PERF_TEST_P(ImageAndCascade, ObjDetect_LBPClassifier,
|
|||||||
const cv::Mat img = readImage(GetParam().first, cv::IMREAD_GRAYSCALE);
|
const cv::Mat img = readImage(GetParam().first, cv::IMREAD_GRAYSCALE);
|
||||||
ASSERT_FALSE(img.empty());
|
ASSERT_FALSE(img.empty());
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
cv::cuda::CascadeClassifier_GPU d_cascade;
|
cv::cuda::CascadeClassifier_CUDA d_cascade;
|
||||||
ASSERT_TRUE(d_cascade.load(perf::TestBase::getDataPath(GetParam().second)));
|
ASSERT_TRUE(d_cascade.load(perf::TestBase::getDataPath(GetParam().second)));
|
||||||
|
|
||||||
const cv::cuda::GpuMat d_img(img);
|
const cv::cuda::GpuMat d_img(img);
|
||||||
|
|||||||
@ -48,19 +48,19 @@ using namespace cv::cuda;
|
|||||||
|
|
||||||
#if !defined (HAVE_CUDA) || defined (CUDA_DISABLER)
|
#if !defined (HAVE_CUDA) || defined (CUDA_DISABLER)
|
||||||
|
|
||||||
cv::cuda::CascadeClassifier_GPU::CascadeClassifier_GPU() { throw_no_cuda(); }
|
cv::cuda::CascadeClassifier_CUDA::CascadeClassifier_CUDA() { throw_no_cuda(); }
|
||||||
cv::cuda::CascadeClassifier_GPU::CascadeClassifier_GPU(const String&) { throw_no_cuda(); }
|
cv::cuda::CascadeClassifier_CUDA::CascadeClassifier_CUDA(const String&) { throw_no_cuda(); }
|
||||||
cv::cuda::CascadeClassifier_GPU::~CascadeClassifier_GPU() { throw_no_cuda(); }
|
cv::cuda::CascadeClassifier_CUDA::~CascadeClassifier_CUDA() { throw_no_cuda(); }
|
||||||
bool cv::cuda::CascadeClassifier_GPU::empty() const { throw_no_cuda(); return true; }
|
bool cv::cuda::CascadeClassifier_CUDA::empty() const { throw_no_cuda(); return true; }
|
||||||
bool cv::cuda::CascadeClassifier_GPU::load(const String&) { throw_no_cuda(); return true; }
|
bool cv::cuda::CascadeClassifier_CUDA::load(const String&) { throw_no_cuda(); return true; }
|
||||||
Size cv::cuda::CascadeClassifier_GPU::getClassifierSize() const { throw_no_cuda(); return Size();}
|
Size cv::cuda::CascadeClassifier_CUDA::getClassifierSize() const { throw_no_cuda(); return Size();}
|
||||||
void cv::cuda::CascadeClassifier_GPU::release() { throw_no_cuda(); }
|
void cv::cuda::CascadeClassifier_CUDA::release() { throw_no_cuda(); }
|
||||||
int cv::cuda::CascadeClassifier_GPU::detectMultiScale( const GpuMat&, GpuMat&, double, int, Size) {throw_no_cuda(); return -1;}
|
int cv::cuda::CascadeClassifier_CUDA::detectMultiScale( const GpuMat&, GpuMat&, double, int, Size) {throw_no_cuda(); return -1;}
|
||||||
int cv::cuda::CascadeClassifier_GPU::detectMultiScale( const GpuMat&, GpuMat&, Size, Size, double, int) {throw_no_cuda(); return -1;}
|
int cv::cuda::CascadeClassifier_CUDA::detectMultiScale( const GpuMat&, GpuMat&, Size, Size, double, int) {throw_no_cuda(); return -1;}
|
||||||
|
|
||||||
#else
|
#else
|
||||||
|
|
||||||
struct cv::cuda::CascadeClassifier_GPU::CascadeClassifierImpl
|
struct cv::cuda::CascadeClassifier_CUDA::CascadeClassifierImpl
|
||||||
{
|
{
|
||||||
public:
|
public:
|
||||||
CascadeClassifierImpl(){}
|
CascadeClassifierImpl(){}
|
||||||
@ -75,7 +75,7 @@ public:
|
|||||||
|
|
||||||
#ifndef HAVE_OPENCV_CUDALEGACY
|
#ifndef HAVE_OPENCV_CUDALEGACY
|
||||||
|
|
||||||
struct cv::cuda::CascadeClassifier_GPU::HaarCascade : cv::cuda::CascadeClassifier_GPU::CascadeClassifierImpl
|
struct cv::cuda::CascadeClassifier_CUDA::HaarCascade : cv::cuda::CascadeClassifier_CUDA::CascadeClassifierImpl
|
||||||
{
|
{
|
||||||
public:
|
public:
|
||||||
HaarCascade()
|
HaarCascade()
|
||||||
@ -104,7 +104,7 @@ public:
|
|||||||
|
|
||||||
#else
|
#else
|
||||||
|
|
||||||
struct cv::cuda::CascadeClassifier_GPU::HaarCascade : cv::cuda::CascadeClassifier_GPU::CascadeClassifierImpl
|
struct cv::cuda::CascadeClassifier_CUDA::HaarCascade : cv::cuda::CascadeClassifier_CUDA::CascadeClassifierImpl
|
||||||
{
|
{
|
||||||
public:
|
public:
|
||||||
HaarCascade() : lastAllocatedFrameSize(-1, -1)
|
HaarCascade() : lastAllocatedFrameSize(-1, -1)
|
||||||
@ -398,7 +398,7 @@ namespace cv { namespace cuda { namespace device
|
|||||||
}
|
}
|
||||||
}}}
|
}}}
|
||||||
|
|
||||||
struct cv::cuda::CascadeClassifier_GPU::LbpCascade : cv::cuda::CascadeClassifier_GPU::CascadeClassifierImpl
|
struct cv::cuda::CascadeClassifier_CUDA::LbpCascade : cv::cuda::CascadeClassifier_CUDA::CascadeClassifierImpl
|
||||||
{
|
{
|
||||||
public:
|
public:
|
||||||
struct Stage
|
struct Stage
|
||||||
@ -528,48 +528,48 @@ private:
|
|||||||
|
|
||||||
bool read(const FileNode &root)
|
bool read(const FileNode &root)
|
||||||
{
|
{
|
||||||
const char *GPU_CC_STAGE_TYPE = "stageType";
|
const char *CUDA_CC_STAGE_TYPE = "stageType";
|
||||||
const char *GPU_CC_FEATURE_TYPE = "featureType";
|
const char *CUDA_CC_FEATURE_TYPE = "featureType";
|
||||||
const char *GPU_CC_BOOST = "BOOST";
|
const char *CUDA_CC_BOOST = "BOOST";
|
||||||
const char *GPU_CC_LBP = "LBP";
|
const char *CUDA_CC_LBP = "LBP";
|
||||||
const char *GPU_CC_MAX_CAT_COUNT = "maxCatCount";
|
const char *CUDA_CC_MAX_CAT_COUNT = "maxCatCount";
|
||||||
const char *GPU_CC_HEIGHT = "height";
|
const char *CUDA_CC_HEIGHT = "height";
|
||||||
const char *GPU_CC_WIDTH = "width";
|
const char *CUDA_CC_WIDTH = "width";
|
||||||
const char *GPU_CC_STAGE_PARAMS = "stageParams";
|
const char *CUDA_CC_STAGE_PARAMS = "stageParams";
|
||||||
const char *GPU_CC_MAX_DEPTH = "maxDepth";
|
const char *CUDA_CC_MAX_DEPTH = "maxDepth";
|
||||||
const char *GPU_CC_FEATURE_PARAMS = "featureParams";
|
const char *CUDA_CC_FEATURE_PARAMS = "featureParams";
|
||||||
const char *GPU_CC_STAGES = "stages";
|
const char *CUDA_CC_STAGES = "stages";
|
||||||
const char *GPU_CC_STAGE_THRESHOLD = "stageThreshold";
|
const char *CUDA_CC_STAGE_THRESHOLD = "stageThreshold";
|
||||||
const float GPU_THRESHOLD_EPS = 1e-5f;
|
const float CUDA_THRESHOLD_EPS = 1e-5f;
|
||||||
const char *GPU_CC_WEAK_CLASSIFIERS = "weakClassifiers";
|
const char *CUDA_CC_WEAK_CLASSIFIERS = "weakClassifiers";
|
||||||
const char *GPU_CC_INTERNAL_NODES = "internalNodes";
|
const char *CUDA_CC_INTERNAL_NODES = "internalNodes";
|
||||||
const char *GPU_CC_LEAF_VALUES = "leafValues";
|
const char *CUDA_CC_LEAF_VALUES = "leafValues";
|
||||||
const char *GPU_CC_FEATURES = "features";
|
const char *CUDA_CC_FEATURES = "features";
|
||||||
const char *GPU_CC_RECT = "rect";
|
const char *CUDA_CC_RECT = "rect";
|
||||||
|
|
||||||
String stageTypeStr = (String)root[GPU_CC_STAGE_TYPE];
|
String stageTypeStr = (String)root[CUDA_CC_STAGE_TYPE];
|
||||||
CV_Assert(stageTypeStr == GPU_CC_BOOST);
|
CV_Assert(stageTypeStr == CUDA_CC_BOOST);
|
||||||
|
|
||||||
String featureTypeStr = (String)root[GPU_CC_FEATURE_TYPE];
|
String featureTypeStr = (String)root[CUDA_CC_FEATURE_TYPE];
|
||||||
CV_Assert(featureTypeStr == GPU_CC_LBP);
|
CV_Assert(featureTypeStr == CUDA_CC_LBP);
|
||||||
|
|
||||||
NxM.width = (int)root[GPU_CC_WIDTH];
|
NxM.width = (int)root[CUDA_CC_WIDTH];
|
||||||
NxM.height = (int)root[GPU_CC_HEIGHT];
|
NxM.height = (int)root[CUDA_CC_HEIGHT];
|
||||||
CV_Assert( NxM.height > 0 && NxM.width > 0 );
|
CV_Assert( NxM.height > 0 && NxM.width > 0 );
|
||||||
|
|
||||||
isStumps = ((int)(root[GPU_CC_STAGE_PARAMS][GPU_CC_MAX_DEPTH]) == 1) ? true : false;
|
isStumps = ((int)(root[CUDA_CC_STAGE_PARAMS][CUDA_CC_MAX_DEPTH]) == 1) ? true : false;
|
||||||
CV_Assert(isStumps);
|
CV_Assert(isStumps);
|
||||||
|
|
||||||
FileNode fn = root[GPU_CC_FEATURE_PARAMS];
|
FileNode fn = root[CUDA_CC_FEATURE_PARAMS];
|
||||||
if (fn.empty())
|
if (fn.empty())
|
||||||
return false;
|
return false;
|
||||||
|
|
||||||
ncategories = fn[GPU_CC_MAX_CAT_COUNT];
|
ncategories = fn[CUDA_CC_MAX_CAT_COUNT];
|
||||||
|
|
||||||
subsetSize = (ncategories + 31) / 32;
|
subsetSize = (ncategories + 31) / 32;
|
||||||
nodeStep = 3 + ( ncategories > 0 ? subsetSize : 1 );
|
nodeStep = 3 + ( ncategories > 0 ? subsetSize : 1 );
|
||||||
|
|
||||||
fn = root[GPU_CC_STAGES];
|
fn = root[CUDA_CC_STAGES];
|
||||||
if (fn.empty())
|
if (fn.empty())
|
||||||
return false;
|
return false;
|
||||||
|
|
||||||
@ -586,9 +586,9 @@ private:
|
|||||||
{
|
{
|
||||||
FileNode fns = *it;
|
FileNode fns = *it;
|
||||||
Stage st;
|
Stage st;
|
||||||
st.threshold = (float)fns[GPU_CC_STAGE_THRESHOLD] - GPU_THRESHOLD_EPS;
|
st.threshold = (float)fns[CUDA_CC_STAGE_THRESHOLD] - CUDA_THRESHOLD_EPS;
|
||||||
|
|
||||||
fns = fns[GPU_CC_WEAK_CLASSIFIERS];
|
fns = fns[CUDA_CC_WEAK_CLASSIFIERS];
|
||||||
if (fns.empty())
|
if (fns.empty())
|
||||||
return false;
|
return false;
|
||||||
|
|
||||||
@ -605,8 +605,8 @@ private:
|
|||||||
{
|
{
|
||||||
FileNode fnw = *it1;
|
FileNode fnw = *it1;
|
||||||
|
|
||||||
FileNode internalNodes = fnw[GPU_CC_INTERNAL_NODES];
|
FileNode internalNodes = fnw[CUDA_CC_INTERNAL_NODES];
|
||||||
FileNode leafValues = fnw[GPU_CC_LEAF_VALUES];
|
FileNode leafValues = fnw[CUDA_CC_LEAF_VALUES];
|
||||||
if ( internalNodes.empty() || leafValues.empty() )
|
if ( internalNodes.empty() || leafValues.empty() )
|
||||||
return false;
|
return false;
|
||||||
|
|
||||||
@ -640,7 +640,7 @@ private:
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn = root[GPU_CC_FEATURES];
|
fn = root[CUDA_CC_FEATURES];
|
||||||
if( fn.empty() )
|
if( fn.empty() )
|
||||||
return false;
|
return false;
|
||||||
std::vector<uchar> features;
|
std::vector<uchar> features;
|
||||||
@ -648,7 +648,7 @@ private:
|
|||||||
FileNodeIterator f_it = fn.begin(), f_end = fn.end();
|
FileNodeIterator f_it = fn.begin(), f_end = fn.end();
|
||||||
for (; f_it != f_end; ++f_it)
|
for (; f_it != f_end; ++f_it)
|
||||||
{
|
{
|
||||||
FileNode rect = (*f_it)[GPU_CC_RECT];
|
FileNode rect = (*f_it)[CUDA_CC_RECT];
|
||||||
FileNodeIterator r_it = rect.begin();
|
FileNodeIterator r_it = rect.begin();
|
||||||
features.push_back(saturate_cast<uchar>((int)*(r_it++)));
|
features.push_back(saturate_cast<uchar>((int)*(r_it++)));
|
||||||
features.push_back(saturate_cast<uchar>((int)*(r_it++)));
|
features.push_back(saturate_cast<uchar>((int)*(r_it++)));
|
||||||
@ -694,36 +694,36 @@ private:
|
|||||||
static const int integralFactor = 4;
|
static const int integralFactor = 4;
|
||||||
};
|
};
|
||||||
|
|
||||||
cv::cuda::CascadeClassifier_GPU::CascadeClassifier_GPU()
|
cv::cuda::CascadeClassifier_CUDA::CascadeClassifier_CUDA()
|
||||||
: findLargestObject(false), visualizeInPlace(false), impl(0) {}
|
: findLargestObject(false), visualizeInPlace(false), impl(0) {}
|
||||||
|
|
||||||
cv::cuda::CascadeClassifier_GPU::CascadeClassifier_GPU(const String& filename)
|
cv::cuda::CascadeClassifier_CUDA::CascadeClassifier_CUDA(const String& filename)
|
||||||
: findLargestObject(false), visualizeInPlace(false), impl(0) { load(filename); }
|
: findLargestObject(false), visualizeInPlace(false), impl(0) { load(filename); }
|
||||||
|
|
||||||
cv::cuda::CascadeClassifier_GPU::~CascadeClassifier_GPU() { release(); }
|
cv::cuda::CascadeClassifier_CUDA::~CascadeClassifier_CUDA() { release(); }
|
||||||
|
|
||||||
void cv::cuda::CascadeClassifier_GPU::release() { if (impl) { delete impl; impl = 0; } }
|
void cv::cuda::CascadeClassifier_CUDA::release() { if (impl) { delete impl; impl = 0; } }
|
||||||
|
|
||||||
bool cv::cuda::CascadeClassifier_GPU::empty() const { return impl == 0; }
|
bool cv::cuda::CascadeClassifier_CUDA::empty() const { return impl == 0; }
|
||||||
|
|
||||||
Size cv::cuda::CascadeClassifier_GPU::getClassifierSize() const
|
Size cv::cuda::CascadeClassifier_CUDA::getClassifierSize() const
|
||||||
{
|
{
|
||||||
return this->empty() ? Size() : impl->getClassifierCvSize();
|
return this->empty() ? Size() : impl->getClassifierCvSize();
|
||||||
}
|
}
|
||||||
|
|
||||||
int cv::cuda::CascadeClassifier_GPU::detectMultiScale( const GpuMat& image, GpuMat& objectsBuf, double scaleFactor, int minNeighbors, Size minSize)
|
int cv::cuda::CascadeClassifier_CUDA::detectMultiScale( const GpuMat& image, GpuMat& objectsBuf, double scaleFactor, int minNeighbors, Size minSize)
|
||||||
{
|
{
|
||||||
CV_Assert( !this->empty());
|
CV_Assert( !this->empty());
|
||||||
return impl->process(image, objectsBuf, (float)scaleFactor, minNeighbors, findLargestObject, visualizeInPlace, minSize, cv::Size());
|
return impl->process(image, objectsBuf, (float)scaleFactor, minNeighbors, findLargestObject, visualizeInPlace, minSize, cv::Size());
|
||||||
}
|
}
|
||||||
|
|
||||||
int cv::cuda::CascadeClassifier_GPU::detectMultiScale(const GpuMat& image, GpuMat& objectsBuf, Size maxObjectSize, Size minSize, double scaleFactor, int minNeighbors)
|
int cv::cuda::CascadeClassifier_CUDA::detectMultiScale(const GpuMat& image, GpuMat& objectsBuf, Size maxObjectSize, Size minSize, double scaleFactor, int minNeighbors)
|
||||||
{
|
{
|
||||||
CV_Assert( !this->empty());
|
CV_Assert( !this->empty());
|
||||||
return impl->process(image, objectsBuf, (float)scaleFactor, minNeighbors, findLargestObject, visualizeInPlace, minSize, maxObjectSize);
|
return impl->process(image, objectsBuf, (float)scaleFactor, minNeighbors, findLargestObject, visualizeInPlace, minSize, maxObjectSize);
|
||||||
}
|
}
|
||||||
|
|
||||||
bool cv::cuda::CascadeClassifier_GPU::load(const String& filename)
|
bool cv::cuda::CascadeClassifier_CUDA::load(const String& filename)
|
||||||
{
|
{
|
||||||
release();
|
release();
|
||||||
|
|
||||||
@ -744,9 +744,9 @@ bool cv::cuda::CascadeClassifier_GPU::load(const String& filename)
|
|||||||
return impl->read(filename);
|
return impl->read(filename);
|
||||||
}
|
}
|
||||||
|
|
||||||
const char *GPU_CC_LBP = "LBP";
|
const char *CUDA_CC_LBP = "LBP";
|
||||||
String featureTypeStr = (String)fs.getFirstTopLevelNode()["featureType"];
|
String featureTypeStr = (String)fs.getFirstTopLevelNode()["featureType"];
|
||||||
if (featureTypeStr == GPU_CC_LBP)
|
if (featureTypeStr == CUDA_CC_LBP)
|
||||||
impl = new LbpCascade();
|
impl = new LbpCascade();
|
||||||
else
|
else
|
||||||
impl = new HaarCascade();
|
impl = new HaarCascade();
|
||||||
|
|||||||
@ -40,8 +40,8 @@
|
|||||||
//
|
//
|
||||||
//M*/
|
//M*/
|
||||||
|
|
||||||
#ifndef __OPENCV_GPU_DEVICE_LBP_HPP_
|
#ifndef __OPENCV_CUDA_DEVICE_LBP_HPP_
|
||||||
#define __OPENCV_GPU_DEVICE_LBP_HPP_
|
#define __OPENCV_CUDA_DEVICE_LBP_HPP_
|
||||||
|
|
||||||
#include "opencv2/core/cuda/common.hpp"
|
#include "opencv2/core/cuda/common.hpp"
|
||||||
#include "opencv2/core/cuda/emulation.hpp"
|
#include "opencv2/core/cuda/emulation.hpp"
|
||||||
|
|||||||
@ -61,7 +61,7 @@ struct TransformPoints : testing::TestWithParam<cv::cuda::DeviceInfo>
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(TransformPoints, Accuracy)
|
CUDA_TEST_P(TransformPoints, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(cv::Size(1000, 1), CV_32FC3, 0, 10);
|
cv::Mat src = randomMat(cv::Size(1000, 1), CV_32FC3, 0, 10);
|
||||||
cv::Mat rvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
|
cv::Mat rvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
|
||||||
@ -92,7 +92,7 @@ GPU_TEST_P(TransformPoints, Accuracy)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Calib3D, TransformPoints, ALL_DEVICES);
|
INSTANTIATE_TEST_CASE_P(CUDA_Calib3D, TransformPoints, ALL_DEVICES);
|
||||||
|
|
||||||
///////////////////////////////////////////////////////////////////////////////////////////////////////
|
///////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||||
// ProjectPoints
|
// ProjectPoints
|
||||||
@ -109,7 +109,7 @@ struct ProjectPoints : testing::TestWithParam<cv::cuda::DeviceInfo>
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(ProjectPoints, Accuracy)
|
CUDA_TEST_P(ProjectPoints, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(cv::Size(1000, 1), CV_32FC3, 0, 10);
|
cv::Mat src = randomMat(cv::Size(1000, 1), CV_32FC3, 0, 10);
|
||||||
cv::Mat rvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
|
cv::Mat rvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
|
||||||
@ -142,7 +142,7 @@ GPU_TEST_P(ProjectPoints, Accuracy)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Calib3D, ProjectPoints, ALL_DEVICES);
|
INSTANTIATE_TEST_CASE_P(CUDA_Calib3D, ProjectPoints, ALL_DEVICES);
|
||||||
|
|
||||||
///////////////////////////////////////////////////////////////////////////////////////////////////////
|
///////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||||
// SolvePnPRansac
|
// SolvePnPRansac
|
||||||
@ -159,7 +159,7 @@ struct SolvePnPRansac : testing::TestWithParam<cv::cuda::DeviceInfo>
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(SolvePnPRansac, Accuracy)
|
CUDA_TEST_P(SolvePnPRansac, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat object = randomMat(cv::Size(5000, 1), CV_32FC3, 0, 100);
|
cv::Mat object = randomMat(cv::Size(5000, 1), CV_32FC3, 0, 100);
|
||||||
cv::Mat camera_mat = randomMat(cv::Size(3, 3), CV_32F, 0.5, 1);
|
cv::Mat camera_mat = randomMat(cv::Size(3, 3), CV_32F, 0.5, 1);
|
||||||
@ -185,6 +185,6 @@ GPU_TEST_P(SolvePnPRansac, Accuracy)
|
|||||||
ASSERT_LE(cv::norm(tvec - tvec_gold), 1e-3);
|
ASSERT_LE(cv::norm(tvec - tvec_gold), 1e-3);
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Calib3D, SolvePnPRansac, ALL_DEVICES);
|
INSTANTIATE_TEST_CASE_P(CUDA_Calib3D, SolvePnPRansac, ALL_DEVICES);
|
||||||
|
|
||||||
#endif // HAVE_CUDA
|
#endif // HAVE_CUDA
|
||||||
|
|||||||
@ -52,7 +52,7 @@ struct CompactPoints : testing::TestWithParam<cuda::DeviceInfo>
|
|||||||
virtual void SetUp() { cuda::setDevice(GetParam().deviceID()); }
|
virtual void SetUp() { cuda::setDevice(GetParam().deviceID()); }
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(CompactPoints, CanCompactizeSmallInput)
|
CUDA_TEST_P(CompactPoints, CanCompactizeSmallInput)
|
||||||
{
|
{
|
||||||
Mat src0(1, 3, CV_32FC2);
|
Mat src0(1, 3, CV_32FC2);
|
||||||
src0.at<Point2f>(0,0) = Point2f(0,0);
|
src0.at<Point2f>(0,0) = Point2f(0,0);
|
||||||
@ -85,6 +85,6 @@ GPU_TEST_P(CompactPoints, CanCompactizeSmallInput)
|
|||||||
ASSERT_TRUE(src1.at<Point2f>(0,1) == Point2f(1,2));
|
ASSERT_TRUE(src1.at<Point2f>(0,1) == Point2f(1,2));
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_GlobalMotion, CompactPoints, ALL_DEVICES);
|
INSTANTIATE_TEST_CASE_P(CUDA_GlobalMotion, CompactPoints, ALL_DEVICES);
|
||||||
|
|
||||||
#endif // HAVE_CUDA
|
#endif // HAVE_CUDA
|
||||||
|
|||||||
@ -67,7 +67,7 @@ PARAM_TEST_CASE(SetTo, cv::cuda::DeviceInfo, cv::Size, MatType, UseRoi)
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(SetTo, Zero)
|
CUDA_TEST_P(SetTo, Zero)
|
||||||
{
|
{
|
||||||
cv::Scalar zero = cv::Scalar::all(0);
|
cv::Scalar zero = cv::Scalar::all(0);
|
||||||
|
|
||||||
@ -77,7 +77,7 @@ GPU_TEST_P(SetTo, Zero)
|
|||||||
EXPECT_MAT_NEAR(cv::Mat::zeros(size, type), mat, 0.0);
|
EXPECT_MAT_NEAR(cv::Mat::zeros(size, type), mat, 0.0);
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(SetTo, SameVal)
|
CUDA_TEST_P(SetTo, SameVal)
|
||||||
{
|
{
|
||||||
cv::Scalar val = cv::Scalar::all(randomDouble(0.0, 255.0));
|
cv::Scalar val = cv::Scalar::all(randomDouble(0.0, 255.0));
|
||||||
|
|
||||||
@ -102,7 +102,7 @@ GPU_TEST_P(SetTo, SameVal)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(SetTo, DifferentVal)
|
CUDA_TEST_P(SetTo, DifferentVal)
|
||||||
{
|
{
|
||||||
cv::Scalar val = randomScalar(0.0, 255.0);
|
cv::Scalar val = randomScalar(0.0, 255.0);
|
||||||
|
|
||||||
@ -127,7 +127,7 @@ GPU_TEST_P(SetTo, DifferentVal)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(SetTo, Masked)
|
CUDA_TEST_P(SetTo, Masked)
|
||||||
{
|
{
|
||||||
cv::Scalar val = randomScalar(0.0, 255.0);
|
cv::Scalar val = randomScalar(0.0, 255.0);
|
||||||
cv::Mat mat_gold = randomMat(size, type);
|
cv::Mat mat_gold = randomMat(size, type);
|
||||||
@ -156,7 +156,7 @@ GPU_TEST_P(SetTo, Masked)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_GpuMat, SetTo, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_GpuMat, SetTo, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
ALL_TYPES,
|
ALL_TYPES,
|
||||||
@ -184,7 +184,7 @@ PARAM_TEST_CASE(CopyTo, cv::cuda::DeviceInfo, cv::Size, MatType, UseRoi)
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(CopyTo, WithOutMask)
|
CUDA_TEST_P(CopyTo, WithOutMask)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, type);
|
cv::Mat src = randomMat(size, type);
|
||||||
|
|
||||||
@ -195,7 +195,7 @@ GPU_TEST_P(CopyTo, WithOutMask)
|
|||||||
EXPECT_MAT_NEAR(src, dst, 0.0);
|
EXPECT_MAT_NEAR(src, dst, 0.0);
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(CopyTo, Masked)
|
CUDA_TEST_P(CopyTo, Masked)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, type);
|
cv::Mat src = randomMat(size, type);
|
||||||
cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
|
cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
|
||||||
@ -226,7 +226,7 @@ GPU_TEST_P(CopyTo, Masked)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_GpuMat, CopyTo, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_GpuMat, CopyTo, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
ALL_TYPES,
|
ALL_TYPES,
|
||||||
@ -255,7 +255,7 @@ PARAM_TEST_CASE(ConvertTo, cv::cuda::DeviceInfo, cv::Size, MatDepth, MatDepth, U
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(ConvertTo, WithOutScaling)
|
CUDA_TEST_P(ConvertTo, WithOutScaling)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, depth1);
|
cv::Mat src = randomMat(size, depth1);
|
||||||
|
|
||||||
@ -285,7 +285,7 @@ GPU_TEST_P(ConvertTo, WithOutScaling)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(ConvertTo, WithScaling)
|
CUDA_TEST_P(ConvertTo, WithScaling)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, depth1);
|
cv::Mat src = randomMat(size, depth1);
|
||||||
double a = randomDouble(0.0, 1.0);
|
double a = randomDouble(0.0, 1.0);
|
||||||
@ -317,7 +317,7 @@ GPU_TEST_P(ConvertTo, WithScaling)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_GpuMat, ConvertTo, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_GpuMat, ConvertTo, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
ALL_DEPTH,
|
ALL_DEPTH,
|
||||||
@ -336,7 +336,7 @@ struct EnsureSizeIsEnough : testing::TestWithParam<cv::cuda::DeviceInfo>
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(EnsureSizeIsEnough, BufferReuse)
|
CUDA_TEST_P(EnsureSizeIsEnough, BufferReuse)
|
||||||
{
|
{
|
||||||
cv::cuda::GpuMat buffer(100, 100, CV_8U);
|
cv::cuda::GpuMat buffer(100, 100, CV_8U);
|
||||||
cv::cuda::GpuMat old = buffer;
|
cv::cuda::GpuMat old = buffer;
|
||||||
@ -356,6 +356,6 @@ GPU_TEST_P(EnsureSizeIsEnough, BufferReuse)
|
|||||||
EXPECT_EQ(reinterpret_cast<intptr_t>(old.data), reinterpret_cast<intptr_t>(buffer.data));
|
EXPECT_EQ(reinterpret_cast<intptr_t>(old.data), reinterpret_cast<intptr_t>(buffer.data));
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_GpuMat, EnsureSizeIsEnough, ALL_DEVICES);
|
INSTANTIATE_TEST_CASE_P(CUDA_GpuMat, EnsureSizeIsEnough, ALL_DEVICES);
|
||||||
|
|
||||||
#endif // HAVE_CUDA
|
#endif // HAVE_CUDA
|
||||||
|
|||||||
@ -167,7 +167,7 @@ struct Labeling : testing::TestWithParam<cv::cuda::DeviceInfo>
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Labeling, DISABLED_ConnectedComponents)
|
CUDA_TEST_P(Labeling, DISABLED_ConnectedComponents)
|
||||||
{
|
{
|
||||||
cv::Mat image;
|
cv::Mat image;
|
||||||
cvtColor(loat_image(), image, cv::COLOR_BGR2GRAY);
|
cvtColor(loat_image(), image, cv::COLOR_BGR2GRAY);
|
||||||
@ -192,6 +192,6 @@ GPU_TEST_P(Labeling, DISABLED_ConnectedComponents)
|
|||||||
host.checkCorrectness(cv::Mat(components));
|
host.checkCorrectness(cv::Mat(components));
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_ConnectedComponents, Labeling, ALL_DEVICES);
|
INSTANTIATE_TEST_CASE_P(CUDA_ConnectedComponents, Labeling, ALL_DEVICES);
|
||||||
|
|
||||||
#endif // HAVE_CUDA
|
#endif // HAVE_CUDA
|
||||||
|
|||||||
@ -42,4 +42,4 @@
|
|||||||
|
|
||||||
#include "test_precomp.hpp"
|
#include "test_precomp.hpp"
|
||||||
|
|
||||||
CV_GPU_TEST_MAIN("gpu")
|
CV_CUDA_TEST_MAIN("gpu")
|
||||||
|
|||||||
@ -177,7 +177,7 @@ struct HOG : testing::TestWithParam<cv::cuda::DeviceInfo>, cv::cuda::HOGDescript
|
|||||||
};
|
};
|
||||||
|
|
||||||
// desabled while resize does not fixed
|
// desabled while resize does not fixed
|
||||||
GPU_TEST_P(HOG, Detect)
|
CUDA_TEST_P(HOG, Detect)
|
||||||
{
|
{
|
||||||
cv::Mat img_rgb = readImage("hog/road.png");
|
cv::Mat img_rgb = readImage("hog/road.png");
|
||||||
ASSERT_FALSE(img_rgb.empty());
|
ASSERT_FALSE(img_rgb.empty());
|
||||||
@ -202,7 +202,7 @@ GPU_TEST_P(HOG, Detect)
|
|||||||
f.close();
|
f.close();
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(HOG, GetDescriptors)
|
CUDA_TEST_P(HOG, GetDescriptors)
|
||||||
{
|
{
|
||||||
// Load image (e.g. train data, composed from windows)
|
// Load image (e.g. train data, composed from windows)
|
||||||
cv::Mat img_rgb = readImage("hog/train_data.png");
|
cv::Mat img_rgb = readImage("hog/train_data.png");
|
||||||
@ -286,7 +286,7 @@ GPU_TEST_P(HOG, GetDescriptors)
|
|||||||
compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(5, 6)));
|
compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(5, 6)));
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_ObjDetect, HOG, ALL_DEVICES);
|
INSTANTIATE_TEST_CASE_P(CUDA_ObjDetect, HOG, ALL_DEVICES);
|
||||||
|
|
||||||
//============== caltech hog tests =====================//
|
//============== caltech hog tests =====================//
|
||||||
|
|
||||||
@ -305,7 +305,7 @@ struct CalTech : public ::testing::TestWithParam<std::tr1::tuple<cv::cuda::Devic
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(CalTech, HOG)
|
CUDA_TEST_P(CalTech, HOG)
|
||||||
{
|
{
|
||||||
cv::cuda::GpuMat d_img(img);
|
cv::cuda::GpuMat d_img(img);
|
||||||
cv::Mat markedImage(img.clone());
|
cv::Mat markedImage(img.clone());
|
||||||
@ -352,14 +352,14 @@ PARAM_TEST_CASE(LBP_Read_classifier, cv::cuda::DeviceInfo, int)
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(LBP_Read_classifier, Accuracy)
|
CUDA_TEST_P(LBP_Read_classifier, Accuracy)
|
||||||
{
|
{
|
||||||
cv::cuda::CascadeClassifier_GPU classifier;
|
cv::cuda::CascadeClassifier_CUDA classifier;
|
||||||
std::string classifierXmlPath = std::string(cvtest::TS::ptr()->get_data_path()) + "lbpcascade/lbpcascade_frontalface.xml";
|
std::string classifierXmlPath = std::string(cvtest::TS::ptr()->get_data_path()) + "lbpcascade/lbpcascade_frontalface.xml";
|
||||||
ASSERT_TRUE(classifier.load(classifierXmlPath));
|
ASSERT_TRUE(classifier.load(classifierXmlPath));
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_ObjDetect, LBP_Read_classifier,
|
INSTANTIATE_TEST_CASE_P(CUDA_ObjDetect, LBP_Read_classifier,
|
||||||
testing::Combine(ALL_DEVICES, testing::Values<int>(0)));
|
testing::Combine(ALL_DEVICES, testing::Values<int>(0)));
|
||||||
|
|
||||||
|
|
||||||
@ -374,7 +374,7 @@ PARAM_TEST_CASE(LBP_classify, cv::cuda::DeviceInfo, int)
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(LBP_classify, Accuracy)
|
CUDA_TEST_P(LBP_classify, Accuracy)
|
||||||
{
|
{
|
||||||
std::string classifierXmlPath = std::string(cvtest::TS::ptr()->get_data_path()) + "lbpcascade/lbpcascade_frontalface.xml";
|
std::string classifierXmlPath = std::string(cvtest::TS::ptr()->get_data_path()) + "lbpcascade/lbpcascade_frontalface.xml";
|
||||||
std::string imagePath = std::string(cvtest::TS::ptr()->get_data_path()) + "lbpcascade/er.png";
|
std::string imagePath = std::string(cvtest::TS::ptr()->get_data_path()) + "lbpcascade/er.png";
|
||||||
@ -396,7 +396,7 @@ GPU_TEST_P(LBP_classify, Accuracy)
|
|||||||
for (; it != rects.end(); ++it)
|
for (; it != rects.end(); ++it)
|
||||||
cv::rectangle(markedImage, *it, cv::Scalar(255, 0, 0));
|
cv::rectangle(markedImage, *it, cv::Scalar(255, 0, 0));
|
||||||
|
|
||||||
cv::cuda::CascadeClassifier_GPU gpuClassifier;
|
cv::cuda::CascadeClassifier_CUDA gpuClassifier;
|
||||||
ASSERT_TRUE(gpuClassifier.load(classifierXmlPath));
|
ASSERT_TRUE(gpuClassifier.load(classifierXmlPath));
|
||||||
|
|
||||||
cv::cuda::GpuMat gpu_rects;
|
cv::cuda::GpuMat gpu_rects;
|
||||||
@ -421,7 +421,7 @@ GPU_TEST_P(LBP_classify, Accuracy)
|
|||||||
(void)count;
|
(void)count;
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_ObjDetect, LBP_classify,
|
INSTANTIATE_TEST_CASE_P(CUDA_ObjDetect, LBP_classify,
|
||||||
testing::Combine(ALL_DEVICES, testing::Values<int>(0)));
|
testing::Combine(ALL_DEVICES, testing::Values<int>(0)));
|
||||||
|
|
||||||
#endif // HAVE_CUDA
|
#endif // HAVE_CUDA
|
||||||
|
|||||||
@ -71,7 +71,7 @@ PARAM_TEST_CASE(Buffer, cv::Size, MatType)
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Buffer, Constructor1)
|
CUDA_TEST_P(Buffer, Constructor1)
|
||||||
{
|
{
|
||||||
cv::ogl::Buffer buf(size.height, size.width, type, cv::ogl::Buffer::ARRAY_BUFFER, true);
|
cv::ogl::Buffer buf(size.height, size.width, type, cv::ogl::Buffer::ARRAY_BUFFER, true);
|
||||||
|
|
||||||
@ -80,7 +80,7 @@ GPU_TEST_P(Buffer, Constructor1)
|
|||||||
EXPECT_EQ(type, buf.type());
|
EXPECT_EQ(type, buf.type());
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Buffer, Constructor2)
|
CUDA_TEST_P(Buffer, Constructor2)
|
||||||
{
|
{
|
||||||
cv::ogl::Buffer buf(size, type, cv::ogl::Buffer::ARRAY_BUFFER, true);
|
cv::ogl::Buffer buf(size, type, cv::ogl::Buffer::ARRAY_BUFFER, true);
|
||||||
|
|
||||||
@ -89,7 +89,7 @@ GPU_TEST_P(Buffer, Constructor2)
|
|||||||
EXPECT_EQ(type, buf.type());
|
EXPECT_EQ(type, buf.type());
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Buffer, ConstructorFromMat)
|
CUDA_TEST_P(Buffer, ConstructorFromMat)
|
||||||
{
|
{
|
||||||
cv::Mat gold = randomMat(size, type);
|
cv::Mat gold = randomMat(size, type);
|
||||||
|
|
||||||
@ -101,7 +101,7 @@ GPU_TEST_P(Buffer, ConstructorFromMat)
|
|||||||
EXPECT_MAT_NEAR(gold, bufData, 0);
|
EXPECT_MAT_NEAR(gold, bufData, 0);
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Buffer, ConstructorFromGpuMat)
|
CUDA_TEST_P(Buffer, ConstructorFromGpuMat)
|
||||||
{
|
{
|
||||||
cv::Mat gold = randomMat(size, type);
|
cv::Mat gold = randomMat(size, type);
|
||||||
cv::cuda::GpuMat d_gold(gold);
|
cv::cuda::GpuMat d_gold(gold);
|
||||||
@ -114,7 +114,7 @@ GPU_TEST_P(Buffer, ConstructorFromGpuMat)
|
|||||||
EXPECT_MAT_NEAR(gold, bufData, 0);
|
EXPECT_MAT_NEAR(gold, bufData, 0);
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Buffer, ConstructorFromBuffer)
|
CUDA_TEST_P(Buffer, ConstructorFromBuffer)
|
||||||
{
|
{
|
||||||
cv::ogl::Buffer buf_gold(size, type, cv::ogl::Buffer::ARRAY_BUFFER, true);
|
cv::ogl::Buffer buf_gold(size, type, cv::ogl::Buffer::ARRAY_BUFFER, true);
|
||||||
|
|
||||||
@ -126,7 +126,7 @@ GPU_TEST_P(Buffer, ConstructorFromBuffer)
|
|||||||
EXPECT_EQ(buf_gold.type(), buf.type());
|
EXPECT_EQ(buf_gold.type(), buf.type());
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Buffer, Create)
|
CUDA_TEST_P(Buffer, Create)
|
||||||
{
|
{
|
||||||
cv::ogl::Buffer buf;
|
cv::ogl::Buffer buf;
|
||||||
buf.create(size.height, size.width, type, cv::ogl::Buffer::ARRAY_BUFFER, true);
|
buf.create(size.height, size.width, type, cv::ogl::Buffer::ARRAY_BUFFER, true);
|
||||||
@ -136,7 +136,7 @@ GPU_TEST_P(Buffer, Create)
|
|||||||
EXPECT_EQ(type, buf.type());
|
EXPECT_EQ(type, buf.type());
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Buffer, CopyFromMat)
|
CUDA_TEST_P(Buffer, CopyFromMat)
|
||||||
{
|
{
|
||||||
cv::Mat gold = randomMat(size, type);
|
cv::Mat gold = randomMat(size, type);
|
||||||
|
|
||||||
@ -149,7 +149,7 @@ GPU_TEST_P(Buffer, CopyFromMat)
|
|||||||
EXPECT_MAT_NEAR(gold, bufData, 0);
|
EXPECT_MAT_NEAR(gold, bufData, 0);
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Buffer, CopyFromGpuMat)
|
CUDA_TEST_P(Buffer, CopyFromGpuMat)
|
||||||
{
|
{
|
||||||
cv::Mat gold = randomMat(size, type);
|
cv::Mat gold = randomMat(size, type);
|
||||||
cv::cuda::GpuMat d_gold(gold);
|
cv::cuda::GpuMat d_gold(gold);
|
||||||
@ -163,7 +163,7 @@ GPU_TEST_P(Buffer, CopyFromGpuMat)
|
|||||||
EXPECT_MAT_NEAR(gold, bufData, 0);
|
EXPECT_MAT_NEAR(gold, bufData, 0);
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Buffer, CopyFromBuffer)
|
CUDA_TEST_P(Buffer, CopyFromBuffer)
|
||||||
{
|
{
|
||||||
cv::Mat gold = randomMat(size, type);
|
cv::Mat gold = randomMat(size, type);
|
||||||
cv::ogl::Buffer buf_gold(gold, cv::ogl::Buffer::ARRAY_BUFFER, true);
|
cv::ogl::Buffer buf_gold(gold, cv::ogl::Buffer::ARRAY_BUFFER, true);
|
||||||
@ -179,7 +179,7 @@ GPU_TEST_P(Buffer, CopyFromBuffer)
|
|||||||
EXPECT_MAT_NEAR(gold, bufData, 0);
|
EXPECT_MAT_NEAR(gold, bufData, 0);
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Buffer, CopyToGpuMat)
|
CUDA_TEST_P(Buffer, CopyToGpuMat)
|
||||||
{
|
{
|
||||||
cv::Mat gold = randomMat(size, type);
|
cv::Mat gold = randomMat(size, type);
|
||||||
|
|
||||||
@ -191,7 +191,7 @@ GPU_TEST_P(Buffer, CopyToGpuMat)
|
|||||||
EXPECT_MAT_NEAR(gold, dst, 0);
|
EXPECT_MAT_NEAR(gold, dst, 0);
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Buffer, CopyToBuffer)
|
CUDA_TEST_P(Buffer, CopyToBuffer)
|
||||||
{
|
{
|
||||||
cv::Mat gold = randomMat(size, type);
|
cv::Mat gold = randomMat(size, type);
|
||||||
|
|
||||||
@ -209,7 +209,7 @@ GPU_TEST_P(Buffer, CopyToBuffer)
|
|||||||
EXPECT_MAT_NEAR(gold, bufData, 0);
|
EXPECT_MAT_NEAR(gold, bufData, 0);
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Buffer, Clone)
|
CUDA_TEST_P(Buffer, Clone)
|
||||||
{
|
{
|
||||||
cv::Mat gold = randomMat(size, type);
|
cv::Mat gold = randomMat(size, type);
|
||||||
|
|
||||||
@ -225,7 +225,7 @@ GPU_TEST_P(Buffer, Clone)
|
|||||||
EXPECT_MAT_NEAR(gold, bufData, 0);
|
EXPECT_MAT_NEAR(gold, bufData, 0);
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Buffer, MapHostRead)
|
CUDA_TEST_P(Buffer, MapHostRead)
|
||||||
{
|
{
|
||||||
cv::Mat gold = randomMat(size, type);
|
cv::Mat gold = randomMat(size, type);
|
||||||
|
|
||||||
@ -238,7 +238,7 @@ GPU_TEST_P(Buffer, MapHostRead)
|
|||||||
buf.unmapHost();
|
buf.unmapHost();
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Buffer, MapHostWrite)
|
CUDA_TEST_P(Buffer, MapHostWrite)
|
||||||
{
|
{
|
||||||
cv::Mat gold = randomMat(size, type);
|
cv::Mat gold = randomMat(size, type);
|
||||||
|
|
||||||
@ -255,7 +255,7 @@ GPU_TEST_P(Buffer, MapHostWrite)
|
|||||||
EXPECT_MAT_NEAR(gold, bufData, 0);
|
EXPECT_MAT_NEAR(gold, bufData, 0);
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Buffer, MapDevice)
|
CUDA_TEST_P(Buffer, MapDevice)
|
||||||
{
|
{
|
||||||
cv::Mat gold = randomMat(size, type);
|
cv::Mat gold = randomMat(size, type);
|
||||||
|
|
||||||
@ -302,7 +302,7 @@ PARAM_TEST_CASE(Texture2D, cv::Size, MatType)
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Texture2D, Constructor1)
|
CUDA_TEST_P(Texture2D, Constructor1)
|
||||||
{
|
{
|
||||||
cv::ogl::Texture2D tex(size.height, size.width, format, true);
|
cv::ogl::Texture2D tex(size.height, size.width, format, true);
|
||||||
|
|
||||||
@ -311,7 +311,7 @@ GPU_TEST_P(Texture2D, Constructor1)
|
|||||||
EXPECT_EQ(format, tex.format());
|
EXPECT_EQ(format, tex.format());
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Texture2D, Constructor2)
|
CUDA_TEST_P(Texture2D, Constructor2)
|
||||||
{
|
{
|
||||||
cv::ogl::Texture2D tex(size, format, true);
|
cv::ogl::Texture2D tex(size, format, true);
|
||||||
|
|
||||||
@ -320,7 +320,7 @@ GPU_TEST_P(Texture2D, Constructor2)
|
|||||||
EXPECT_EQ(format, tex.format());
|
EXPECT_EQ(format, tex.format());
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Texture2D, ConstructorFromMat)
|
CUDA_TEST_P(Texture2D, ConstructorFromMat)
|
||||||
{
|
{
|
||||||
cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
|
cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
|
||||||
|
|
||||||
@ -332,7 +332,7 @@ GPU_TEST_P(Texture2D, ConstructorFromMat)
|
|||||||
EXPECT_MAT_NEAR(gold, texData, 1e-2);
|
EXPECT_MAT_NEAR(gold, texData, 1e-2);
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Texture2D, ConstructorFromGpuMat)
|
CUDA_TEST_P(Texture2D, ConstructorFromGpuMat)
|
||||||
{
|
{
|
||||||
cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
|
cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
|
||||||
cv::cuda::GpuMat d_gold(gold);
|
cv::cuda::GpuMat d_gold(gold);
|
||||||
@ -345,7 +345,7 @@ GPU_TEST_P(Texture2D, ConstructorFromGpuMat)
|
|||||||
EXPECT_MAT_NEAR(gold, texData, 1e-2);
|
EXPECT_MAT_NEAR(gold, texData, 1e-2);
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Texture2D, ConstructorFromBuffer)
|
CUDA_TEST_P(Texture2D, ConstructorFromBuffer)
|
||||||
{
|
{
|
||||||
cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
|
cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
|
||||||
cv::ogl::Buffer buf_gold(gold, cv::ogl::Buffer::PIXEL_UNPACK_BUFFER, true);
|
cv::ogl::Buffer buf_gold(gold, cv::ogl::Buffer::PIXEL_UNPACK_BUFFER, true);
|
||||||
@ -358,7 +358,7 @@ GPU_TEST_P(Texture2D, ConstructorFromBuffer)
|
|||||||
EXPECT_MAT_NEAR(gold, texData, 1e-2);
|
EXPECT_MAT_NEAR(gold, texData, 1e-2);
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Texture2D, ConstructorFromTexture2D)
|
CUDA_TEST_P(Texture2D, ConstructorFromTexture2D)
|
||||||
{
|
{
|
||||||
cv::ogl::Texture2D tex_gold(size, format, true);
|
cv::ogl::Texture2D tex_gold(size, format, true);
|
||||||
cv::ogl::Texture2D tex(tex_gold);
|
cv::ogl::Texture2D tex(tex_gold);
|
||||||
@ -369,7 +369,7 @@ GPU_TEST_P(Texture2D, ConstructorFromTexture2D)
|
|||||||
EXPECT_EQ(tex_gold.format(), tex.format());
|
EXPECT_EQ(tex_gold.format(), tex.format());
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Texture2D, Create)
|
CUDA_TEST_P(Texture2D, Create)
|
||||||
{
|
{
|
||||||
cv::ogl::Texture2D tex;
|
cv::ogl::Texture2D tex;
|
||||||
tex.create(size.height, size.width, format, true);
|
tex.create(size.height, size.width, format, true);
|
||||||
@ -379,7 +379,7 @@ GPU_TEST_P(Texture2D, Create)
|
|||||||
EXPECT_EQ(format, tex.format());
|
EXPECT_EQ(format, tex.format());
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Texture2D, CopyFromMat)
|
CUDA_TEST_P(Texture2D, CopyFromMat)
|
||||||
{
|
{
|
||||||
cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
|
cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
|
||||||
|
|
||||||
@ -392,7 +392,7 @@ GPU_TEST_P(Texture2D, CopyFromMat)
|
|||||||
EXPECT_MAT_NEAR(gold, texData, 1e-2);
|
EXPECT_MAT_NEAR(gold, texData, 1e-2);
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Texture2D, CopyFromGpuMat)
|
CUDA_TEST_P(Texture2D, CopyFromGpuMat)
|
||||||
{
|
{
|
||||||
cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
|
cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
|
||||||
cv::cuda::GpuMat d_gold(gold);
|
cv::cuda::GpuMat d_gold(gold);
|
||||||
@ -406,7 +406,7 @@ GPU_TEST_P(Texture2D, CopyFromGpuMat)
|
|||||||
EXPECT_MAT_NEAR(gold, texData, 1e-2);
|
EXPECT_MAT_NEAR(gold, texData, 1e-2);
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Texture2D, CopyFromBuffer)
|
CUDA_TEST_P(Texture2D, CopyFromBuffer)
|
||||||
{
|
{
|
||||||
cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
|
cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
|
||||||
cv::ogl::Buffer buf_gold(gold, cv::ogl::Buffer::PIXEL_UNPACK_BUFFER, true);
|
cv::ogl::Buffer buf_gold(gold, cv::ogl::Buffer::PIXEL_UNPACK_BUFFER, true);
|
||||||
@ -420,7 +420,7 @@ GPU_TEST_P(Texture2D, CopyFromBuffer)
|
|||||||
EXPECT_MAT_NEAR(gold, texData, 1e-2);
|
EXPECT_MAT_NEAR(gold, texData, 1e-2);
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Texture2D, CopyToGpuMat)
|
CUDA_TEST_P(Texture2D, CopyToGpuMat)
|
||||||
{
|
{
|
||||||
cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
|
cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
|
||||||
|
|
||||||
@ -432,7 +432,7 @@ GPU_TEST_P(Texture2D, CopyToGpuMat)
|
|||||||
EXPECT_MAT_NEAR(gold, dst, 1e-2);
|
EXPECT_MAT_NEAR(gold, dst, 1e-2);
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Texture2D, CopyToBuffer)
|
CUDA_TEST_P(Texture2D, CopyToBuffer)
|
||||||
{
|
{
|
||||||
cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
|
cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
|
||||||
|
|
||||||
|
|||||||
@ -84,7 +84,7 @@ void checkMemSet(int status, void* userData)
|
|||||||
ASSERT_MAT_NEAR(dst_gold, dst, 0);
|
ASSERT_MAT_NEAR(dst_gold, dst, 0);
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Async, MemSet)
|
CUDA_TEST_P(Async, MemSet)
|
||||||
{
|
{
|
||||||
cv::cuda::Stream stream;
|
cv::cuda::Stream stream;
|
||||||
|
|
||||||
@ -114,7 +114,7 @@ void checkConvert(int status, void* userData)
|
|||||||
ASSERT_MAT_NEAR(dst_gold, dst, 0);
|
ASSERT_MAT_NEAR(dst_gold, dst, 0);
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Async, Convert)
|
CUDA_TEST_P(Async, Convert)
|
||||||
{
|
{
|
||||||
cv::cuda::Stream stream;
|
cv::cuda::Stream stream;
|
||||||
|
|
||||||
@ -128,7 +128,7 @@ GPU_TEST_P(Async, Convert)
|
|||||||
stream.waitForCompletion();
|
stream.waitForCompletion();
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Stream, Async, ALL_DEVICES);
|
INSTANTIATE_TEST_CASE_P(CUDA_Stream, Async, ALL_DEVICES);
|
||||||
|
|
||||||
#endif // CUDART_VERSION >= 5000
|
#endif // CUDART_VERSION >= 5000
|
||||||
|
|
||||||
|
|||||||
@ -73,7 +73,7 @@ PERF_TEST_P(Sz_Type_Flags, GEMM,
|
|||||||
cv::Mat src3(size, type);
|
cv::Mat src3(size, type);
|
||||||
declare.in(src3, WARMUP_RNG);
|
declare.in(src3, WARMUP_RNG);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
declare.time(5.0);
|
declare.time(5.0);
|
||||||
|
|
||||||
@ -84,7 +84,7 @@ PERF_TEST_P(Sz_Type_Flags, GEMM,
|
|||||||
|
|
||||||
TEST_CYCLE() cv::cuda::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, dst, flags);
|
TEST_CYCLE() cv::cuda::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, dst, flags);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst, 1e-6, ERROR_RELATIVE);
|
CUDA_SANITY_CHECK(dst, 1e-6, ERROR_RELATIVE);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
@ -106,7 +106,7 @@ CV_FLAGS(DftFlags, 0, cv::DFT_INVERSE, cv::DFT_SCALE, cv::DFT_ROWS, cv::DFT_COMP
|
|||||||
DEF_PARAM_TEST(Sz_Flags, cv::Size, DftFlags);
|
DEF_PARAM_TEST(Sz_Flags, cv::Size, DftFlags);
|
||||||
|
|
||||||
PERF_TEST_P(Sz_Flags, MulSpectrums,
|
PERF_TEST_P(Sz_Flags, MulSpectrums,
|
||||||
Combine(GPU_TYPICAL_MAT_SIZES,
|
Combine(CUDA_TYPICAL_MAT_SIZES,
|
||||||
Values(0, DftFlags(cv::DFT_ROWS))))
|
Values(0, DftFlags(cv::DFT_ROWS))))
|
||||||
{
|
{
|
||||||
const cv::Size size = GET_PARAM(0);
|
const cv::Size size = GET_PARAM(0);
|
||||||
@ -116,7 +116,7 @@ PERF_TEST_P(Sz_Flags, MulSpectrums,
|
|||||||
cv::Mat b(size, CV_32FC2);
|
cv::Mat b(size, CV_32FC2);
|
||||||
declare.in(a, b, WARMUP_RNG);
|
declare.in(a, b, WARMUP_RNG);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_a(a);
|
const cv::cuda::GpuMat d_a(a);
|
||||||
const cv::cuda::GpuMat d_b(b);
|
const cv::cuda::GpuMat d_b(b);
|
||||||
@ -124,7 +124,7 @@ PERF_TEST_P(Sz_Flags, MulSpectrums,
|
|||||||
|
|
||||||
TEST_CYCLE() cv::cuda::mulSpectrums(d_a, d_b, dst, flag);
|
TEST_CYCLE() cv::cuda::mulSpectrums(d_a, d_b, dst, flag);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst);
|
CUDA_SANITY_CHECK(dst);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
@ -140,7 +140,7 @@ PERF_TEST_P(Sz_Flags, MulSpectrums,
|
|||||||
// MulAndScaleSpectrums
|
// MulAndScaleSpectrums
|
||||||
|
|
||||||
PERF_TEST_P(Sz, MulAndScaleSpectrums,
|
PERF_TEST_P(Sz, MulAndScaleSpectrums,
|
||||||
GPU_TYPICAL_MAT_SIZES)
|
CUDA_TYPICAL_MAT_SIZES)
|
||||||
{
|
{
|
||||||
const cv::Size size = GetParam();
|
const cv::Size size = GetParam();
|
||||||
|
|
||||||
@ -150,7 +150,7 @@ PERF_TEST_P(Sz, MulAndScaleSpectrums,
|
|||||||
cv::Mat src2(size, CV_32FC2);
|
cv::Mat src2(size, CV_32FC2);
|
||||||
declare.in(src1,src2, WARMUP_RNG);
|
declare.in(src1,src2, WARMUP_RNG);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_src1(src1);
|
const cv::cuda::GpuMat d_src1(src1);
|
||||||
const cv::cuda::GpuMat d_src2(src2);
|
const cv::cuda::GpuMat d_src2(src2);
|
||||||
@ -158,7 +158,7 @@ PERF_TEST_P(Sz, MulAndScaleSpectrums,
|
|||||||
|
|
||||||
TEST_CYCLE() cv::cuda::mulAndScaleSpectrums(d_src1, d_src2, dst, cv::DFT_ROWS, scale, false);
|
TEST_CYCLE() cv::cuda::mulAndScaleSpectrums(d_src1, d_src2, dst, cv::DFT_ROWS, scale, false);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst);
|
CUDA_SANITY_CHECK(dst);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
@ -170,7 +170,7 @@ PERF_TEST_P(Sz, MulAndScaleSpectrums,
|
|||||||
// Dft
|
// Dft
|
||||||
|
|
||||||
PERF_TEST_P(Sz_Flags, Dft,
|
PERF_TEST_P(Sz_Flags, Dft,
|
||||||
Combine(GPU_TYPICAL_MAT_SIZES,
|
Combine(CUDA_TYPICAL_MAT_SIZES,
|
||||||
Values(0, DftFlags(cv::DFT_ROWS), DftFlags(cv::DFT_INVERSE))))
|
Values(0, DftFlags(cv::DFT_ROWS), DftFlags(cv::DFT_INVERSE))))
|
||||||
{
|
{
|
||||||
declare.time(10.0);
|
declare.time(10.0);
|
||||||
@ -181,14 +181,14 @@ PERF_TEST_P(Sz_Flags, Dft,
|
|||||||
cv::Mat src(size, CV_32FC2);
|
cv::Mat src(size, CV_32FC2);
|
||||||
declare.in(src, WARMUP_RNG);
|
declare.in(src, WARMUP_RNG);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_src(src);
|
const cv::cuda::GpuMat d_src(src);
|
||||||
cv::cuda::GpuMat dst;
|
cv::cuda::GpuMat dst;
|
||||||
|
|
||||||
TEST_CYCLE() cv::cuda::dft(d_src, dst, size, flag);
|
TEST_CYCLE() cv::cuda::dft(d_src, dst, size, flag);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst, 1e-6, ERROR_RELATIVE);
|
CUDA_SANITY_CHECK(dst, 1e-6, ERROR_RELATIVE);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
@ -206,7 +206,7 @@ PERF_TEST_P(Sz_Flags, Dft,
|
|||||||
DEF_PARAM_TEST(Sz_KernelSz_Ccorr, cv::Size, int, bool);
|
DEF_PARAM_TEST(Sz_KernelSz_Ccorr, cv::Size, int, bool);
|
||||||
|
|
||||||
PERF_TEST_P(Sz_KernelSz_Ccorr, Convolve,
|
PERF_TEST_P(Sz_KernelSz_Ccorr, Convolve,
|
||||||
Combine(GPU_TYPICAL_MAT_SIZES,
|
Combine(CUDA_TYPICAL_MAT_SIZES,
|
||||||
Values(17, 27, 32, 64),
|
Values(17, 27, 32, 64),
|
||||||
Bool()))
|
Bool()))
|
||||||
{
|
{
|
||||||
@ -220,7 +220,7 @@ PERF_TEST_P(Sz_KernelSz_Ccorr, Convolve,
|
|||||||
const cv::Mat templ(templ_size, templ_size, CV_32FC1);
|
const cv::Mat templ(templ_size, templ_size, CV_32FC1);
|
||||||
declare.in(image, templ, WARMUP_RNG);
|
declare.in(image, templ, WARMUP_RNG);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
cv::cuda::GpuMat d_image = cv::cuda::createContinuous(size, CV_32FC1);
|
cv::cuda::GpuMat d_image = cv::cuda::createContinuous(size, CV_32FC1);
|
||||||
d_image.upload(image);
|
d_image.upload(image);
|
||||||
@ -234,7 +234,7 @@ PERF_TEST_P(Sz_KernelSz_Ccorr, Convolve,
|
|||||||
|
|
||||||
TEST_CYCLE() convolution->convolve(d_image, d_templ, dst, ccorr);
|
TEST_CYCLE() convolution->convolve(d_image, d_templ, dst, ccorr);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst, 1e-6, ERROR_RELATIVE);
|
CUDA_SANITY_CHECK(dst, 1e-6, ERROR_RELATIVE);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
@ -253,14 +253,14 @@ PERF_TEST_P(Sz_KernelSz_Ccorr, Convolve,
|
|||||||
// Integral
|
// Integral
|
||||||
|
|
||||||
PERF_TEST_P(Sz, Integral,
|
PERF_TEST_P(Sz, Integral,
|
||||||
GPU_TYPICAL_MAT_SIZES)
|
CUDA_TYPICAL_MAT_SIZES)
|
||||||
{
|
{
|
||||||
const cv::Size size = GetParam();
|
const cv::Size size = GetParam();
|
||||||
|
|
||||||
cv::Mat src(size, CV_8UC1);
|
cv::Mat src(size, CV_8UC1);
|
||||||
declare.in(src, WARMUP_RNG);
|
declare.in(src, WARMUP_RNG);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_src(src);
|
const cv::cuda::GpuMat d_src(src);
|
||||||
cv::cuda::GpuMat dst;
|
cv::cuda::GpuMat dst;
|
||||||
@ -268,7 +268,7 @@ PERF_TEST_P(Sz, Integral,
|
|||||||
|
|
||||||
TEST_CYCLE() cv::cuda::integral(d_src, dst, d_buf);
|
TEST_CYCLE() cv::cuda::integral(d_src, dst, d_buf);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst);
|
CUDA_SANITY_CHECK(dst);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
@ -284,21 +284,21 @@ PERF_TEST_P(Sz, Integral,
|
|||||||
// IntegralSqr
|
// IntegralSqr
|
||||||
|
|
||||||
PERF_TEST_P(Sz, IntegralSqr,
|
PERF_TEST_P(Sz, IntegralSqr,
|
||||||
GPU_TYPICAL_MAT_SIZES)
|
CUDA_TYPICAL_MAT_SIZES)
|
||||||
{
|
{
|
||||||
const cv::Size size = GetParam();
|
const cv::Size size = GetParam();
|
||||||
|
|
||||||
cv::Mat src(size, CV_8UC1);
|
cv::Mat src(size, CV_8UC1);
|
||||||
declare.in(src, WARMUP_RNG);
|
declare.in(src, WARMUP_RNG);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_src(src);
|
const cv::cuda::GpuMat d_src(src);
|
||||||
cv::cuda::GpuMat dst, buf;
|
cv::cuda::GpuMat dst, buf;
|
||||||
|
|
||||||
TEST_CYCLE() cv::cuda::sqrIntegral(d_src, dst, buf);
|
TEST_CYCLE() cv::cuda::sqrIntegral(d_src, dst, buf);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst);
|
CUDA_SANITY_CHECK(dst);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
|
|||||||
@ -52,7 +52,7 @@ using namespace perf;
|
|||||||
// Merge
|
// Merge
|
||||||
|
|
||||||
PERF_TEST_P(Sz_Depth_Cn, Merge,
|
PERF_TEST_P(Sz_Depth_Cn, Merge,
|
||||||
Combine(GPU_TYPICAL_MAT_SIZES,
|
Combine(CUDA_TYPICAL_MAT_SIZES,
|
||||||
ARITHM_MAT_DEPTH,
|
ARITHM_MAT_DEPTH,
|
||||||
Values(2, 3, 4)))
|
Values(2, 3, 4)))
|
||||||
{
|
{
|
||||||
@ -67,7 +67,7 @@ PERF_TEST_P(Sz_Depth_Cn, Merge,
|
|||||||
declare.in(src[i], WARMUP_RNG);
|
declare.in(src[i], WARMUP_RNG);
|
||||||
}
|
}
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
std::vector<cv::cuda::GpuMat> d_src(channels);
|
std::vector<cv::cuda::GpuMat> d_src(channels);
|
||||||
for (int i = 0; i < channels; ++i)
|
for (int i = 0; i < channels; ++i)
|
||||||
@ -77,7 +77,7 @@ PERF_TEST_P(Sz_Depth_Cn, Merge,
|
|||||||
|
|
||||||
TEST_CYCLE() cv::cuda::merge(d_src, dst);
|
TEST_CYCLE() cv::cuda::merge(d_src, dst);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst, 1e-10);
|
CUDA_SANITY_CHECK(dst, 1e-10);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
@ -93,7 +93,7 @@ PERF_TEST_P(Sz_Depth_Cn, Merge,
|
|||||||
// Split
|
// Split
|
||||||
|
|
||||||
PERF_TEST_P(Sz_Depth_Cn, Split,
|
PERF_TEST_P(Sz_Depth_Cn, Split,
|
||||||
Combine(GPU_TYPICAL_MAT_SIZES,
|
Combine(CUDA_TYPICAL_MAT_SIZES,
|
||||||
ARITHM_MAT_DEPTH,
|
ARITHM_MAT_DEPTH,
|
||||||
Values(2, 3, 4)))
|
Values(2, 3, 4)))
|
||||||
{
|
{
|
||||||
@ -104,7 +104,7 @@ PERF_TEST_P(Sz_Depth_Cn, Split,
|
|||||||
cv::Mat src(size, CV_MAKE_TYPE(depth, channels));
|
cv::Mat src(size, CV_MAKE_TYPE(depth, channels));
|
||||||
declare.in(src, WARMUP_RNG);
|
declare.in(src, WARMUP_RNG);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_src(src);
|
const cv::cuda::GpuMat d_src(src);
|
||||||
std::vector<cv::cuda::GpuMat> dst;
|
std::vector<cv::cuda::GpuMat> dst;
|
||||||
@ -114,8 +114,8 @@ PERF_TEST_P(Sz_Depth_Cn, Split,
|
|||||||
const cv::cuda::GpuMat& dst0 = dst[0];
|
const cv::cuda::GpuMat& dst0 = dst[0];
|
||||||
const cv::cuda::GpuMat& dst1 = dst[1];
|
const cv::cuda::GpuMat& dst1 = dst[1];
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst0, 1e-10);
|
CUDA_SANITY_CHECK(dst0, 1e-10);
|
||||||
GPU_SANITY_CHECK(dst1, 1e-10);
|
CUDA_SANITY_CHECK(dst1, 1e-10);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
@ -135,7 +135,7 @@ PERF_TEST_P(Sz_Depth_Cn, Split,
|
|||||||
// Transpose
|
// Transpose
|
||||||
|
|
||||||
PERF_TEST_P(Sz_Type, Transpose,
|
PERF_TEST_P(Sz_Type, Transpose,
|
||||||
Combine(GPU_TYPICAL_MAT_SIZES,
|
Combine(CUDA_TYPICAL_MAT_SIZES,
|
||||||
Values(CV_8UC1, CV_8UC4, CV_16UC2, CV_16SC2, CV_32SC1, CV_32SC2, CV_64FC1)))
|
Values(CV_8UC1, CV_8UC4, CV_16UC2, CV_16SC2, CV_32SC1, CV_32SC2, CV_64FC1)))
|
||||||
{
|
{
|
||||||
const cv::Size size = GET_PARAM(0);
|
const cv::Size size = GET_PARAM(0);
|
||||||
@ -144,14 +144,14 @@ PERF_TEST_P(Sz_Type, Transpose,
|
|||||||
cv::Mat src(size, type);
|
cv::Mat src(size, type);
|
||||||
declare.in(src, WARMUP_RNG);
|
declare.in(src, WARMUP_RNG);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_src(src);
|
const cv::cuda::GpuMat d_src(src);
|
||||||
cv::cuda::GpuMat dst;
|
cv::cuda::GpuMat dst;
|
||||||
|
|
||||||
TEST_CYCLE() cv::cuda::transpose(d_src, dst);
|
TEST_CYCLE() cv::cuda::transpose(d_src, dst);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst, 1e-10);
|
CUDA_SANITY_CHECK(dst, 1e-10);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
@ -172,9 +172,9 @@ CV_ENUM(FlipCode, FLIP_BOTH, FLIP_X, FLIP_Y)
|
|||||||
DEF_PARAM_TEST(Sz_Depth_Cn_Code, cv::Size, MatDepth, MatCn, FlipCode);
|
DEF_PARAM_TEST(Sz_Depth_Cn_Code, cv::Size, MatDepth, MatCn, FlipCode);
|
||||||
|
|
||||||
PERF_TEST_P(Sz_Depth_Cn_Code, Flip,
|
PERF_TEST_P(Sz_Depth_Cn_Code, Flip,
|
||||||
Combine(GPU_TYPICAL_MAT_SIZES,
|
Combine(CUDA_TYPICAL_MAT_SIZES,
|
||||||
Values(CV_8U, CV_16U, CV_32F),
|
Values(CV_8U, CV_16U, CV_32F),
|
||||||
GPU_CHANNELS_1_3_4,
|
CUDA_CHANNELS_1_3_4,
|
||||||
FlipCode::all()))
|
FlipCode::all()))
|
||||||
{
|
{
|
||||||
const cv::Size size = GET_PARAM(0);
|
const cv::Size size = GET_PARAM(0);
|
||||||
@ -187,14 +187,14 @@ PERF_TEST_P(Sz_Depth_Cn_Code, Flip,
|
|||||||
cv::Mat src(size, type);
|
cv::Mat src(size, type);
|
||||||
declare.in(src, WARMUP_RNG);
|
declare.in(src, WARMUP_RNG);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_src(src);
|
const cv::cuda::GpuMat d_src(src);
|
||||||
cv::cuda::GpuMat dst;
|
cv::cuda::GpuMat dst;
|
||||||
|
|
||||||
TEST_CYCLE() cv::cuda::flip(d_src, dst, flipCode);
|
TEST_CYCLE() cv::cuda::flip(d_src, dst, flipCode);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst);
|
CUDA_SANITY_CHECK(dst);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
@ -210,7 +210,7 @@ PERF_TEST_P(Sz_Depth_Cn_Code, Flip,
|
|||||||
// LutOneChannel
|
// LutOneChannel
|
||||||
|
|
||||||
PERF_TEST_P(Sz_Type, LutOneChannel,
|
PERF_TEST_P(Sz_Type, LutOneChannel,
|
||||||
Combine(GPU_TYPICAL_MAT_SIZES,
|
Combine(CUDA_TYPICAL_MAT_SIZES,
|
||||||
Values(CV_8UC1, CV_8UC3)))
|
Values(CV_8UC1, CV_8UC3)))
|
||||||
{
|
{
|
||||||
const cv::Size size = GET_PARAM(0);
|
const cv::Size size = GET_PARAM(0);
|
||||||
@ -222,7 +222,7 @@ PERF_TEST_P(Sz_Type, LutOneChannel,
|
|||||||
cv::Mat lut(1, 256, CV_8UC1);
|
cv::Mat lut(1, 256, CV_8UC1);
|
||||||
declare.in(lut, WARMUP_RNG);
|
declare.in(lut, WARMUP_RNG);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
cv::Ptr<cv::cuda::LookUpTable> lutAlg = cv::cuda::createLookUpTable(lut);
|
cv::Ptr<cv::cuda::LookUpTable> lutAlg = cv::cuda::createLookUpTable(lut);
|
||||||
|
|
||||||
@ -231,7 +231,7 @@ PERF_TEST_P(Sz_Type, LutOneChannel,
|
|||||||
|
|
||||||
TEST_CYCLE() lutAlg->transform(d_src, dst);
|
TEST_CYCLE() lutAlg->transform(d_src, dst);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst);
|
CUDA_SANITY_CHECK(dst);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
@ -247,7 +247,7 @@ PERF_TEST_P(Sz_Type, LutOneChannel,
|
|||||||
// LutMultiChannel
|
// LutMultiChannel
|
||||||
|
|
||||||
PERF_TEST_P(Sz_Type, LutMultiChannel,
|
PERF_TEST_P(Sz_Type, LutMultiChannel,
|
||||||
Combine(GPU_TYPICAL_MAT_SIZES,
|
Combine(CUDA_TYPICAL_MAT_SIZES,
|
||||||
Values<MatType>(CV_8UC3)))
|
Values<MatType>(CV_8UC3)))
|
||||||
{
|
{
|
||||||
const cv::Size size = GET_PARAM(0);
|
const cv::Size size = GET_PARAM(0);
|
||||||
@ -259,7 +259,7 @@ PERF_TEST_P(Sz_Type, LutMultiChannel,
|
|||||||
cv::Mat lut(1, 256, CV_MAKE_TYPE(CV_8U, src.channels()));
|
cv::Mat lut(1, 256, CV_MAKE_TYPE(CV_8U, src.channels()));
|
||||||
declare.in(lut, WARMUP_RNG);
|
declare.in(lut, WARMUP_RNG);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
cv::Ptr<cv::cuda::LookUpTable> lutAlg = cv::cuda::createLookUpTable(lut);
|
cv::Ptr<cv::cuda::LookUpTable> lutAlg = cv::cuda::createLookUpTable(lut);
|
||||||
|
|
||||||
@ -268,7 +268,7 @@ PERF_TEST_P(Sz_Type, LutMultiChannel,
|
|||||||
|
|
||||||
TEST_CYCLE() lutAlg->transform(d_src, dst);
|
TEST_CYCLE() lutAlg->transform(d_src, dst);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst);
|
CUDA_SANITY_CHECK(dst);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
@ -286,9 +286,9 @@ PERF_TEST_P(Sz_Type, LutMultiChannel,
|
|||||||
DEF_PARAM_TEST(Sz_Depth_Cn_Border, cv::Size, MatDepth, MatCn, BorderMode);
|
DEF_PARAM_TEST(Sz_Depth_Cn_Border, cv::Size, MatDepth, MatCn, BorderMode);
|
||||||
|
|
||||||
PERF_TEST_P(Sz_Depth_Cn_Border, CopyMakeBorder,
|
PERF_TEST_P(Sz_Depth_Cn_Border, CopyMakeBorder,
|
||||||
Combine(GPU_TYPICAL_MAT_SIZES,
|
Combine(CUDA_TYPICAL_MAT_SIZES,
|
||||||
Values(CV_8U, CV_16U, CV_32F),
|
Values(CV_8U, CV_16U, CV_32F),
|
||||||
GPU_CHANNELS_1_3_4,
|
CUDA_CHANNELS_1_3_4,
|
||||||
ALL_BORDER_MODES))
|
ALL_BORDER_MODES))
|
||||||
{
|
{
|
||||||
const cv::Size size = GET_PARAM(0);
|
const cv::Size size = GET_PARAM(0);
|
||||||
@ -301,14 +301,14 @@ PERF_TEST_P(Sz_Depth_Cn_Border, CopyMakeBorder,
|
|||||||
cv::Mat src(size, type);
|
cv::Mat src(size, type);
|
||||||
declare.in(src, WARMUP_RNG);
|
declare.in(src, WARMUP_RNG);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_src(src);
|
const cv::cuda::GpuMat d_src(src);
|
||||||
cv::cuda::GpuMat dst;
|
cv::cuda::GpuMat dst;
|
||||||
|
|
||||||
TEST_CYCLE() cv::cuda::copyMakeBorder(d_src, dst, 5, 5, 5, 5, borderMode);
|
TEST_CYCLE() cv::cuda::copyMakeBorder(d_src, dst, 5, 5, 5, 5, borderMode);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst);
|
CUDA_SANITY_CHECK(dst);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
|
|||||||
File diff suppressed because it is too large
Load Diff
@ -52,7 +52,7 @@ using namespace perf;
|
|||||||
DEF_PARAM_TEST(Sz_Depth_Norm, cv::Size, MatDepth, NormType);
|
DEF_PARAM_TEST(Sz_Depth_Norm, cv::Size, MatDepth, NormType);
|
||||||
|
|
||||||
PERF_TEST_P(Sz_Depth_Norm, Norm,
|
PERF_TEST_P(Sz_Depth_Norm, Norm,
|
||||||
Combine(GPU_TYPICAL_MAT_SIZES,
|
Combine(CUDA_TYPICAL_MAT_SIZES,
|
||||||
Values(CV_8U, CV_16U, CV_32S, CV_32F),
|
Values(CV_8U, CV_16U, CV_32S, CV_32F),
|
||||||
Values(NormType(cv::NORM_INF), NormType(cv::NORM_L1), NormType(cv::NORM_L2))))
|
Values(NormType(cv::NORM_INF), NormType(cv::NORM_L1), NormType(cv::NORM_L2))))
|
||||||
{
|
{
|
||||||
@ -66,7 +66,7 @@ PERF_TEST_P(Sz_Depth_Norm, Norm,
|
|||||||
else
|
else
|
||||||
declare.in(src, WARMUP_RNG);
|
declare.in(src, WARMUP_RNG);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_src(src);
|
const cv::cuda::GpuMat d_src(src);
|
||||||
cv::cuda::GpuMat d_buf;
|
cv::cuda::GpuMat d_buf;
|
||||||
@ -92,7 +92,7 @@ PERF_TEST_P(Sz_Depth_Norm, Norm,
|
|||||||
DEF_PARAM_TEST(Sz_Norm, cv::Size, NormType);
|
DEF_PARAM_TEST(Sz_Norm, cv::Size, NormType);
|
||||||
|
|
||||||
PERF_TEST_P(Sz_Norm, NormDiff,
|
PERF_TEST_P(Sz_Norm, NormDiff,
|
||||||
Combine(GPU_TYPICAL_MAT_SIZES,
|
Combine(CUDA_TYPICAL_MAT_SIZES,
|
||||||
Values(NormType(cv::NORM_INF), NormType(cv::NORM_L1), NormType(cv::NORM_L2))))
|
Values(NormType(cv::NORM_INF), NormType(cv::NORM_L1), NormType(cv::NORM_L2))))
|
||||||
{
|
{
|
||||||
const cv::Size size = GET_PARAM(0);
|
const cv::Size size = GET_PARAM(0);
|
||||||
@ -104,7 +104,7 @@ PERF_TEST_P(Sz_Norm, NormDiff,
|
|||||||
cv::Mat src2(size, CV_8UC1);
|
cv::Mat src2(size, CV_8UC1);
|
||||||
declare.in(src2, WARMUP_RNG);
|
declare.in(src2, WARMUP_RNG);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_src1(src1);
|
const cv::cuda::GpuMat d_src1(src1);
|
||||||
const cv::cuda::GpuMat d_src2(src2);
|
const cv::cuda::GpuMat d_src2(src2);
|
||||||
@ -130,9 +130,9 @@ PERF_TEST_P(Sz_Norm, NormDiff,
|
|||||||
// Sum
|
// Sum
|
||||||
|
|
||||||
PERF_TEST_P(Sz_Depth_Cn, Sum,
|
PERF_TEST_P(Sz_Depth_Cn, Sum,
|
||||||
Combine(GPU_TYPICAL_MAT_SIZES,
|
Combine(CUDA_TYPICAL_MAT_SIZES,
|
||||||
Values(CV_8U, CV_16U, CV_32F),
|
Values(CV_8U, CV_16U, CV_32F),
|
||||||
GPU_CHANNELS_1_3_4))
|
CUDA_CHANNELS_1_3_4))
|
||||||
{
|
{
|
||||||
const cv::Size size = GET_PARAM(0);
|
const cv::Size size = GET_PARAM(0);
|
||||||
const int depth = GET_PARAM(1);
|
const int depth = GET_PARAM(1);
|
||||||
@ -143,7 +143,7 @@ PERF_TEST_P(Sz_Depth_Cn, Sum,
|
|||||||
cv::Mat src(size, type);
|
cv::Mat src(size, type);
|
||||||
declare.in(src, WARMUP_RNG);
|
declare.in(src, WARMUP_RNG);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_src(src);
|
const cv::cuda::GpuMat d_src(src);
|
||||||
cv::cuda::GpuMat d_buf;
|
cv::cuda::GpuMat d_buf;
|
||||||
@ -167,9 +167,9 @@ PERF_TEST_P(Sz_Depth_Cn, Sum,
|
|||||||
// SumAbs
|
// SumAbs
|
||||||
|
|
||||||
PERF_TEST_P(Sz_Depth_Cn, SumAbs,
|
PERF_TEST_P(Sz_Depth_Cn, SumAbs,
|
||||||
Combine(GPU_TYPICAL_MAT_SIZES,
|
Combine(CUDA_TYPICAL_MAT_SIZES,
|
||||||
Values(CV_8U, CV_16U, CV_32F),
|
Values(CV_8U, CV_16U, CV_32F),
|
||||||
GPU_CHANNELS_1_3_4))
|
CUDA_CHANNELS_1_3_4))
|
||||||
{
|
{
|
||||||
const cv::Size size = GET_PARAM(0);
|
const cv::Size size = GET_PARAM(0);
|
||||||
const int depth = GET_PARAM(1);
|
const int depth = GET_PARAM(1);
|
||||||
@ -180,7 +180,7 @@ PERF_TEST_P(Sz_Depth_Cn, SumAbs,
|
|||||||
cv::Mat src(size, type);
|
cv::Mat src(size, type);
|
||||||
declare.in(src, WARMUP_RNG);
|
declare.in(src, WARMUP_RNG);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_src(src);
|
const cv::cuda::GpuMat d_src(src);
|
||||||
cv::cuda::GpuMat d_buf;
|
cv::cuda::GpuMat d_buf;
|
||||||
@ -200,9 +200,9 @@ PERF_TEST_P(Sz_Depth_Cn, SumAbs,
|
|||||||
// SumSqr
|
// SumSqr
|
||||||
|
|
||||||
PERF_TEST_P(Sz_Depth_Cn, SumSqr,
|
PERF_TEST_P(Sz_Depth_Cn, SumSqr,
|
||||||
Combine(GPU_TYPICAL_MAT_SIZES,
|
Combine(CUDA_TYPICAL_MAT_SIZES,
|
||||||
Values<MatDepth>(CV_8U, CV_16U, CV_32F),
|
Values<MatDepth>(CV_8U, CV_16U, CV_32F),
|
||||||
GPU_CHANNELS_1_3_4))
|
CUDA_CHANNELS_1_3_4))
|
||||||
{
|
{
|
||||||
const cv::Size size = GET_PARAM(0);
|
const cv::Size size = GET_PARAM(0);
|
||||||
const int depth = GET_PARAM(1);
|
const int depth = GET_PARAM(1);
|
||||||
@ -213,7 +213,7 @@ PERF_TEST_P(Sz_Depth_Cn, SumSqr,
|
|||||||
cv::Mat src(size, type);
|
cv::Mat src(size, type);
|
||||||
declare.in(src, WARMUP_RNG);
|
declare.in(src, WARMUP_RNG);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_src(src);
|
const cv::cuda::GpuMat d_src(src);
|
||||||
cv::cuda::GpuMat d_buf;
|
cv::cuda::GpuMat d_buf;
|
||||||
@ -233,7 +233,7 @@ PERF_TEST_P(Sz_Depth_Cn, SumSqr,
|
|||||||
// MinMax
|
// MinMax
|
||||||
|
|
||||||
PERF_TEST_P(Sz_Depth, MinMax,
|
PERF_TEST_P(Sz_Depth, MinMax,
|
||||||
Combine(GPU_TYPICAL_MAT_SIZES,
|
Combine(CUDA_TYPICAL_MAT_SIZES,
|
||||||
Values(CV_8U, CV_16U, CV_32F, CV_64F)))
|
Values(CV_8U, CV_16U, CV_32F, CV_64F)))
|
||||||
{
|
{
|
||||||
const cv::Size size = GET_PARAM(0);
|
const cv::Size size = GET_PARAM(0);
|
||||||
@ -245,7 +245,7 @@ PERF_TEST_P(Sz_Depth, MinMax,
|
|||||||
else
|
else
|
||||||
declare.in(src, WARMUP_RNG);
|
declare.in(src, WARMUP_RNG);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_src(src);
|
const cv::cuda::GpuMat d_src(src);
|
||||||
cv::cuda::GpuMat d_buf;
|
cv::cuda::GpuMat d_buf;
|
||||||
@ -271,7 +271,7 @@ PERF_TEST_P(Sz_Depth, MinMax,
|
|||||||
// MinMaxLoc
|
// MinMaxLoc
|
||||||
|
|
||||||
PERF_TEST_P(Sz_Depth, MinMaxLoc,
|
PERF_TEST_P(Sz_Depth, MinMaxLoc,
|
||||||
Combine(GPU_TYPICAL_MAT_SIZES,
|
Combine(CUDA_TYPICAL_MAT_SIZES,
|
||||||
Values(CV_8U, CV_16U, CV_32F, CV_64F)))
|
Values(CV_8U, CV_16U, CV_32F, CV_64F)))
|
||||||
{
|
{
|
||||||
const cv::Size size = GET_PARAM(0);
|
const cv::Size size = GET_PARAM(0);
|
||||||
@ -283,7 +283,7 @@ PERF_TEST_P(Sz_Depth, MinMaxLoc,
|
|||||||
else
|
else
|
||||||
declare.in(src, WARMUP_RNG);
|
declare.in(src, WARMUP_RNG);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_src(src);
|
const cv::cuda::GpuMat d_src(src);
|
||||||
cv::cuda::GpuMat d_valbuf, d_locbuf;
|
cv::cuda::GpuMat d_valbuf, d_locbuf;
|
||||||
@ -311,7 +311,7 @@ PERF_TEST_P(Sz_Depth, MinMaxLoc,
|
|||||||
// CountNonZero
|
// CountNonZero
|
||||||
|
|
||||||
PERF_TEST_P(Sz_Depth, CountNonZero,
|
PERF_TEST_P(Sz_Depth, CountNonZero,
|
||||||
Combine(GPU_TYPICAL_MAT_SIZES,
|
Combine(CUDA_TYPICAL_MAT_SIZES,
|
||||||
Values(CV_8U, CV_16U, CV_32F, CV_64F)))
|
Values(CV_8U, CV_16U, CV_32F, CV_64F)))
|
||||||
{
|
{
|
||||||
const cv::Size size = GET_PARAM(0);
|
const cv::Size size = GET_PARAM(0);
|
||||||
@ -320,7 +320,7 @@ PERF_TEST_P(Sz_Depth, CountNonZero,
|
|||||||
cv::Mat src(size, depth);
|
cv::Mat src(size, depth);
|
||||||
declare.in(src, WARMUP_RNG);
|
declare.in(src, WARMUP_RNG);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_src(src);
|
const cv::cuda::GpuMat d_src(src);
|
||||||
cv::cuda::GpuMat d_buf;
|
cv::cuda::GpuMat d_buf;
|
||||||
@ -351,7 +351,7 @@ CV_ENUM(ReduceDim, Rows, Cols)
|
|||||||
DEF_PARAM_TEST(Sz_Depth_Cn_Code_Dim, cv::Size, MatDepth, MatCn, ReduceCode, ReduceDim);
|
DEF_PARAM_TEST(Sz_Depth_Cn_Code_Dim, cv::Size, MatDepth, MatCn, ReduceCode, ReduceDim);
|
||||||
|
|
||||||
PERF_TEST_P(Sz_Depth_Cn_Code_Dim, Reduce,
|
PERF_TEST_P(Sz_Depth_Cn_Code_Dim, Reduce,
|
||||||
Combine(GPU_TYPICAL_MAT_SIZES,
|
Combine(CUDA_TYPICAL_MAT_SIZES,
|
||||||
Values(CV_8U, CV_16U, CV_16S, CV_32F),
|
Values(CV_8U, CV_16U, CV_16S, CV_32F),
|
||||||
Values(1, 2, 3, 4),
|
Values(1, 2, 3, 4),
|
||||||
ReduceCode::all(),
|
ReduceCode::all(),
|
||||||
@ -368,14 +368,14 @@ PERF_TEST_P(Sz_Depth_Cn_Code_Dim, Reduce,
|
|||||||
cv::Mat src(size, type);
|
cv::Mat src(size, type);
|
||||||
declare.in(src, WARMUP_RNG);
|
declare.in(src, WARMUP_RNG);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_src(src);
|
const cv::cuda::GpuMat d_src(src);
|
||||||
cv::cuda::GpuMat dst;
|
cv::cuda::GpuMat dst;
|
||||||
|
|
||||||
TEST_CYCLE() cv::cuda::reduce(d_src, dst, dim, reduceOp);
|
TEST_CYCLE() cv::cuda::reduce(d_src, dst, dim, reduceOp);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst);
|
CUDA_SANITY_CHECK(dst);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
@ -393,7 +393,7 @@ PERF_TEST_P(Sz_Depth_Cn_Code_Dim, Reduce,
|
|||||||
DEF_PARAM_TEST(Sz_Depth_NormType, cv::Size, MatDepth, NormType);
|
DEF_PARAM_TEST(Sz_Depth_NormType, cv::Size, MatDepth, NormType);
|
||||||
|
|
||||||
PERF_TEST_P(Sz_Depth_NormType, Normalize,
|
PERF_TEST_P(Sz_Depth_NormType, Normalize,
|
||||||
Combine(GPU_TYPICAL_MAT_SIZES,
|
Combine(CUDA_TYPICAL_MAT_SIZES,
|
||||||
Values(CV_8U, CV_16U, CV_32F, CV_64F),
|
Values(CV_8U, CV_16U, CV_32F, CV_64F),
|
||||||
Values(NormType(cv::NORM_INF),
|
Values(NormType(cv::NORM_INF),
|
||||||
NormType(cv::NORM_L1),
|
NormType(cv::NORM_L1),
|
||||||
@ -410,7 +410,7 @@ PERF_TEST_P(Sz_Depth_NormType, Normalize,
|
|||||||
cv::Mat src(size, type);
|
cv::Mat src(size, type);
|
||||||
declare.in(src, WARMUP_RNG);
|
declare.in(src, WARMUP_RNG);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_src(src);
|
const cv::cuda::GpuMat d_src(src);
|
||||||
cv::cuda::GpuMat dst;
|
cv::cuda::GpuMat dst;
|
||||||
@ -418,7 +418,7 @@ PERF_TEST_P(Sz_Depth_NormType, Normalize,
|
|||||||
|
|
||||||
TEST_CYCLE() cv::cuda::normalize(d_src, dst, alpha, beta, norm_type, type, cv::cuda::GpuMat(), d_norm_buf, d_cvt_buf);
|
TEST_CYCLE() cv::cuda::normalize(d_src, dst, alpha, beta, norm_type, type, cv::cuda::GpuMat(), d_norm_buf, d_cvt_buf);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst, 1e-6);
|
CUDA_SANITY_CHECK(dst, 1e-6);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
@ -434,7 +434,7 @@ PERF_TEST_P(Sz_Depth_NormType, Normalize,
|
|||||||
// MeanStdDev
|
// MeanStdDev
|
||||||
|
|
||||||
PERF_TEST_P(Sz, MeanStdDev,
|
PERF_TEST_P(Sz, MeanStdDev,
|
||||||
GPU_TYPICAL_MAT_SIZES)
|
CUDA_TYPICAL_MAT_SIZES)
|
||||||
{
|
{
|
||||||
const cv::Size size = GetParam();
|
const cv::Size size = GetParam();
|
||||||
|
|
||||||
@ -442,7 +442,7 @@ PERF_TEST_P(Sz, MeanStdDev,
|
|||||||
declare.in(src, WARMUP_RNG);
|
declare.in(src, WARMUP_RNG);
|
||||||
|
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_src(src);
|
const cv::cuda::GpuMat d_src(src);
|
||||||
cv::cuda::GpuMat d_buf;
|
cv::cuda::GpuMat d_buf;
|
||||||
|
|||||||
@ -74,7 +74,7 @@ PARAM_TEST_CASE(GEMM, cv::cuda::DeviceInfo, cv::Size, MatType, GemmFlags, UseRoi
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(GEMM, Accuracy)
|
CUDA_TEST_P(GEMM, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat src1 = randomMat(size, type, -10.0, 10.0);
|
cv::Mat src1 = randomMat(size, type, -10.0, 10.0);
|
||||||
cv::Mat src2 = randomMat(size, type, -10.0, 10.0);
|
cv::Mat src2 = randomMat(size, type, -10.0, 10.0);
|
||||||
@ -118,7 +118,7 @@ GPU_TEST_P(GEMM, Accuracy)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, GEMM, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, GEMM, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
testing::Values(MatType(CV_32FC1), MatType(CV_32FC2), MatType(CV_64FC1), MatType(CV_64FC2)),
|
testing::Values(MatType(CV_32FC1), MatType(CV_32FC2), MatType(CV_64FC1), MatType(CV_64FC2)),
|
||||||
@ -144,7 +144,7 @@ PARAM_TEST_CASE(Integral, cv::cuda::DeviceInfo, cv::Size, UseRoi)
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Integral, Accuracy)
|
CUDA_TEST_P(Integral, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, CV_8UC1);
|
cv::Mat src = randomMat(size, CV_8UC1);
|
||||||
|
|
||||||
@ -157,7 +157,7 @@ GPU_TEST_P(Integral, Accuracy)
|
|||||||
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
|
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Integral, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, Integral, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
WHOLE_SUBMAT));
|
WHOLE_SUBMAT));
|
||||||
@ -188,7 +188,7 @@ PARAM_TEST_CASE(MulSpectrums, cv::cuda::DeviceInfo, cv::Size, DftFlags)
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(MulSpectrums, Simple)
|
CUDA_TEST_P(MulSpectrums, Simple)
|
||||||
{
|
{
|
||||||
cv::cuda::GpuMat c;
|
cv::cuda::GpuMat c;
|
||||||
cv::cuda::mulSpectrums(loadMat(a), loadMat(b), c, flag, false);
|
cv::cuda::mulSpectrums(loadMat(a), loadMat(b), c, flag, false);
|
||||||
@ -199,7 +199,7 @@ GPU_TEST_P(MulSpectrums, Simple)
|
|||||||
EXPECT_MAT_NEAR(c_gold, c, 1e-2);
|
EXPECT_MAT_NEAR(c_gold, c, 1e-2);
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(MulSpectrums, Scaled)
|
CUDA_TEST_P(MulSpectrums, Scaled)
|
||||||
{
|
{
|
||||||
float scale = 1.f / size.area();
|
float scale = 1.f / size.area();
|
||||||
|
|
||||||
@ -213,7 +213,7 @@ GPU_TEST_P(MulSpectrums, Scaled)
|
|||||||
EXPECT_MAT_NEAR(c_gold, c, 1e-2);
|
EXPECT_MAT_NEAR(c_gold, c, 1e-2);
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, MulSpectrums, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, MulSpectrums, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
testing::Values(DftFlags(0), DftFlags(cv::DFT_ROWS))));
|
testing::Values(DftFlags(0), DftFlags(cv::DFT_ROWS))));
|
||||||
@ -260,7 +260,7 @@ namespace
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Dft, C2C)
|
CUDA_TEST_P(Dft, C2C)
|
||||||
{
|
{
|
||||||
int cols = randomInt(2, 100);
|
int cols = randomInt(2, 100);
|
||||||
int rows = randomInt(2, 100);
|
int rows = randomInt(2, 100);
|
||||||
@ -324,7 +324,7 @@ namespace
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Dft, R2CThenC2R)
|
CUDA_TEST_P(Dft, R2CThenC2R)
|
||||||
{
|
{
|
||||||
int cols = randomInt(2, 100);
|
int cols = randomInt(2, 100);
|
||||||
int rows = randomInt(2, 100);
|
int rows = randomInt(2, 100);
|
||||||
@ -346,7 +346,7 @@ GPU_TEST_P(Dft, R2CThenC2R)
|
|||||||
testR2CThenC2R("single row 1", cols + 1, 1, true);
|
testR2CThenC2R("single row 1", cols + 1, 1, true);
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Dft, ALL_DEVICES);
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, Dft, ALL_DEVICES);
|
||||||
|
|
||||||
////////////////////////////////////////////////////////
|
////////////////////////////////////////////////////////
|
||||||
// Convolve
|
// Convolve
|
||||||
@ -414,7 +414,7 @@ PARAM_TEST_CASE(Convolve, cv::cuda::DeviceInfo, cv::Size, KSize, Ccorr)
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Convolve, Accuracy)
|
CUDA_TEST_P(Convolve, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, CV_32FC1, 0.0, 100.0);
|
cv::Mat src = randomMat(size, CV_32FC1, 0.0, 100.0);
|
||||||
cv::Mat kernel = randomMat(cv::Size(ksize, ksize), CV_32FC1, 0.0, 1.0);
|
cv::Mat kernel = randomMat(cv::Size(ksize, ksize), CV_32FC1, 0.0, 1.0);
|
||||||
@ -430,7 +430,7 @@ GPU_TEST_P(Convolve, Accuracy)
|
|||||||
EXPECT_MAT_NEAR(dst, dst_gold, 1e-1);
|
EXPECT_MAT_NEAR(dst, dst_gold, 1e-1);
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Convolve, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, Convolve, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
testing::Values(KSize(3), KSize(7), KSize(11), KSize(17), KSize(19), KSize(23), KSize(45)),
|
testing::Values(KSize(3), KSize(7), KSize(11), KSize(17), KSize(19), KSize(23), KSize(45)),
|
||||||
|
|||||||
@ -69,7 +69,7 @@ PARAM_TEST_CASE(Merge, cv::cuda::DeviceInfo, cv::Size, MatDepth, Channels, UseRo
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Merge, Accuracy)
|
CUDA_TEST_P(Merge, Accuracy)
|
||||||
{
|
{
|
||||||
std::vector<cv::Mat> src;
|
std::vector<cv::Mat> src;
|
||||||
src.reserve(channels);
|
src.reserve(channels);
|
||||||
@ -104,7 +104,7 @@ GPU_TEST_P(Merge, Accuracy)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Merge, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, Merge, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
ALL_DEPTH,
|
ALL_DEPTH,
|
||||||
@ -138,7 +138,7 @@ PARAM_TEST_CASE(Split, cv::cuda::DeviceInfo, cv::Size, MatDepth, Channels, UseRo
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Split, Accuracy)
|
CUDA_TEST_P(Split, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, type);
|
cv::Mat src = randomMat(size, type);
|
||||||
|
|
||||||
@ -171,7 +171,7 @@ GPU_TEST_P(Split, Accuracy)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Split, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, Split, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
ALL_DEPTH,
|
ALL_DEPTH,
|
||||||
@ -199,7 +199,7 @@ PARAM_TEST_CASE(Transpose, cv::cuda::DeviceInfo, cv::Size, MatType, UseRoi)
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Transpose, Accuracy)
|
CUDA_TEST_P(Transpose, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, type);
|
cv::Mat src = randomMat(size, type);
|
||||||
|
|
||||||
@ -227,7 +227,7 @@ GPU_TEST_P(Transpose, Accuracy)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Transpose, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, Transpose, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
testing::Values(MatType(CV_8UC1),
|
testing::Values(MatType(CV_8UC1),
|
||||||
@ -266,7 +266,7 @@ PARAM_TEST_CASE(Flip, cv::cuda::DeviceInfo, cv::Size, MatType, FlipCode, UseRoi)
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Flip, Accuracy)
|
CUDA_TEST_P(Flip, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, type);
|
cv::Mat src = randomMat(size, type);
|
||||||
|
|
||||||
@ -279,7 +279,7 @@ GPU_TEST_P(Flip, Accuracy)
|
|||||||
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
|
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Flip, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, Flip, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
testing::Values(MatType(CV_8UC1),
|
testing::Values(MatType(CV_8UC1),
|
||||||
@ -318,7 +318,7 @@ PARAM_TEST_CASE(LUT, cv::cuda::DeviceInfo, cv::Size, MatType, UseRoi)
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(LUT, OneChannel)
|
CUDA_TEST_P(LUT, OneChannel)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, type);
|
cv::Mat src = randomMat(size, type);
|
||||||
cv::Mat lut = randomMat(cv::Size(256, 1), CV_8UC1);
|
cv::Mat lut = randomMat(cv::Size(256, 1), CV_8UC1);
|
||||||
@ -334,7 +334,7 @@ GPU_TEST_P(LUT, OneChannel)
|
|||||||
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
|
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(LUT, MultiChannel)
|
CUDA_TEST_P(LUT, MultiChannel)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, type);
|
cv::Mat src = randomMat(size, type);
|
||||||
cv::Mat lut = randomMat(cv::Size(256, 1), CV_MAKE_TYPE(CV_8U, src.channels()));
|
cv::Mat lut = randomMat(cv::Size(256, 1), CV_MAKE_TYPE(CV_8U, src.channels()));
|
||||||
@ -350,7 +350,7 @@ GPU_TEST_P(LUT, MultiChannel)
|
|||||||
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
|
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, LUT, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, LUT, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
testing::Values(MatType(CV_8UC1), MatType(CV_8UC3)),
|
testing::Values(MatType(CV_8UC1), MatType(CV_8UC3)),
|
||||||
@ -386,7 +386,7 @@ PARAM_TEST_CASE(CopyMakeBorder, cv::cuda::DeviceInfo, cv::Size, MatType, Border,
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(CopyMakeBorder, Accuracy)
|
CUDA_TEST_P(CopyMakeBorder, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, type);
|
cv::Mat src = randomMat(size, type);
|
||||||
cv::Scalar val = randomScalar(0, 255);
|
cv::Scalar val = randomScalar(0, 255);
|
||||||
@ -400,7 +400,7 @@ GPU_TEST_P(CopyMakeBorder, Accuracy)
|
|||||||
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
|
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, CopyMakeBorder, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, CopyMakeBorder, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
testing::Values(MatType(CV_8UC1),
|
testing::Values(MatType(CV_8UC1),
|
||||||
|
|||||||
@ -75,7 +75,7 @@ PARAM_TEST_CASE(Add_Array, cv::cuda::DeviceInfo, cv::Size, std::pair<MatDepth, M
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Add_Array, Accuracy)
|
CUDA_TEST_P(Add_Array, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat mat1 = randomMat(size, stype);
|
cv::Mat mat1 = randomMat(size, stype);
|
||||||
cv::Mat mat2 = randomMat(size, stype);
|
cv::Mat mat2 = randomMat(size, stype);
|
||||||
@ -105,7 +105,7 @@ GPU_TEST_P(Add_Array, Accuracy)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Add_Array, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, Add_Array, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
DEPTH_PAIRS,
|
DEPTH_PAIRS,
|
||||||
@ -136,7 +136,7 @@ PARAM_TEST_CASE(Add_Array_Mask, cv::cuda::DeviceInfo, cv::Size, std::pair<MatDep
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Add_Array_Mask, Accuracy)
|
CUDA_TEST_P(Add_Array_Mask, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat mat1 = randomMat(size, stype);
|
cv::Mat mat1 = randomMat(size, stype);
|
||||||
cv::Mat mat2 = randomMat(size, stype);
|
cv::Mat mat2 = randomMat(size, stype);
|
||||||
@ -167,7 +167,7 @@ GPU_TEST_P(Add_Array_Mask, Accuracy)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Add_Array_Mask, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, Add_Array_Mask, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
DEPTH_PAIRS,
|
DEPTH_PAIRS,
|
||||||
@ -194,7 +194,7 @@ PARAM_TEST_CASE(Add_Scalar, cv::cuda::DeviceInfo, cv::Size, std::pair<MatDepth,
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Add_Scalar, WithOutMask)
|
CUDA_TEST_P(Add_Scalar, WithOutMask)
|
||||||
{
|
{
|
||||||
cv::Mat mat = randomMat(size, depth.first);
|
cv::Mat mat = randomMat(size, depth.first);
|
||||||
cv::Scalar val = randomScalar(0, 255);
|
cv::Scalar val = randomScalar(0, 255);
|
||||||
@ -224,7 +224,7 @@ GPU_TEST_P(Add_Scalar, WithOutMask)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Add_Scalar, WithMask)
|
CUDA_TEST_P(Add_Scalar, WithMask)
|
||||||
{
|
{
|
||||||
cv::Mat mat = randomMat(size, depth.first);
|
cv::Mat mat = randomMat(size, depth.first);
|
||||||
cv::Scalar val = randomScalar(0, 255);
|
cv::Scalar val = randomScalar(0, 255);
|
||||||
@ -255,7 +255,7 @@ GPU_TEST_P(Add_Scalar, WithMask)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Add_Scalar, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, Add_Scalar, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
DEPTH_PAIRS,
|
DEPTH_PAIRS,
|
||||||
@ -282,7 +282,7 @@ PARAM_TEST_CASE(Add_Scalar_First, cv::cuda::DeviceInfo, cv::Size, std::pair<MatD
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Add_Scalar_First, WithOutMask)
|
CUDA_TEST_P(Add_Scalar_First, WithOutMask)
|
||||||
{
|
{
|
||||||
cv::Mat mat = randomMat(size, depth.first);
|
cv::Mat mat = randomMat(size, depth.first);
|
||||||
cv::Scalar val = randomScalar(0, 255);
|
cv::Scalar val = randomScalar(0, 255);
|
||||||
@ -312,7 +312,7 @@ GPU_TEST_P(Add_Scalar_First, WithOutMask)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Add_Scalar_First, WithMask)
|
CUDA_TEST_P(Add_Scalar_First, WithMask)
|
||||||
{
|
{
|
||||||
cv::Mat mat = randomMat(size, depth.first);
|
cv::Mat mat = randomMat(size, depth.first);
|
||||||
cv::Scalar val = randomScalar(0, 255);
|
cv::Scalar val = randomScalar(0, 255);
|
||||||
@ -343,7 +343,7 @@ GPU_TEST_P(Add_Scalar_First, WithMask)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Add_Scalar_First, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, Add_Scalar_First, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
DEPTH_PAIRS,
|
DEPTH_PAIRS,
|
||||||
@ -378,7 +378,7 @@ PARAM_TEST_CASE(Subtract_Array, cv::cuda::DeviceInfo, cv::Size, std::pair<MatDep
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Subtract_Array, Accuracy)
|
CUDA_TEST_P(Subtract_Array, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat mat1 = randomMat(size, stype);
|
cv::Mat mat1 = randomMat(size, stype);
|
||||||
cv::Mat mat2 = randomMat(size, stype);
|
cv::Mat mat2 = randomMat(size, stype);
|
||||||
@ -408,7 +408,7 @@ GPU_TEST_P(Subtract_Array, Accuracy)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Subtract_Array, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, Subtract_Array, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
DEPTH_PAIRS,
|
DEPTH_PAIRS,
|
||||||
@ -439,7 +439,7 @@ PARAM_TEST_CASE(Subtract_Array_Mask, cv::cuda::DeviceInfo, cv::Size, std::pair<M
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Subtract_Array_Mask, Accuracy)
|
CUDA_TEST_P(Subtract_Array_Mask, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat mat1 = randomMat(size, stype);
|
cv::Mat mat1 = randomMat(size, stype);
|
||||||
cv::Mat mat2 = randomMat(size, stype);
|
cv::Mat mat2 = randomMat(size, stype);
|
||||||
@ -470,7 +470,7 @@ GPU_TEST_P(Subtract_Array_Mask, Accuracy)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Subtract_Array_Mask, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, Subtract_Array_Mask, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
DEPTH_PAIRS,
|
DEPTH_PAIRS,
|
||||||
@ -497,7 +497,7 @@ PARAM_TEST_CASE(Subtract_Scalar, cv::cuda::DeviceInfo, cv::Size, std::pair<MatDe
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Subtract_Scalar, WithOutMask)
|
CUDA_TEST_P(Subtract_Scalar, WithOutMask)
|
||||||
{
|
{
|
||||||
cv::Mat mat = randomMat(size, depth.first);
|
cv::Mat mat = randomMat(size, depth.first);
|
||||||
cv::Scalar val = randomScalar(0, 255);
|
cv::Scalar val = randomScalar(0, 255);
|
||||||
@ -527,7 +527,7 @@ GPU_TEST_P(Subtract_Scalar, WithOutMask)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Subtract_Scalar, WithMask)
|
CUDA_TEST_P(Subtract_Scalar, WithMask)
|
||||||
{
|
{
|
||||||
cv::Mat mat = randomMat(size, depth.first);
|
cv::Mat mat = randomMat(size, depth.first);
|
||||||
cv::Scalar val = randomScalar(0, 255);
|
cv::Scalar val = randomScalar(0, 255);
|
||||||
@ -558,7 +558,7 @@ GPU_TEST_P(Subtract_Scalar, WithMask)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Subtract_Scalar, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, Subtract_Scalar, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
DEPTH_PAIRS,
|
DEPTH_PAIRS,
|
||||||
@ -585,7 +585,7 @@ PARAM_TEST_CASE(Subtract_Scalar_First, cv::cuda::DeviceInfo, cv::Size, std::pair
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Subtract_Scalar_First, WithOutMask)
|
CUDA_TEST_P(Subtract_Scalar_First, WithOutMask)
|
||||||
{
|
{
|
||||||
cv::Mat mat = randomMat(size, depth.first);
|
cv::Mat mat = randomMat(size, depth.first);
|
||||||
cv::Scalar val = randomScalar(0, 255);
|
cv::Scalar val = randomScalar(0, 255);
|
||||||
@ -615,7 +615,7 @@ GPU_TEST_P(Subtract_Scalar_First, WithOutMask)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Subtract_Scalar_First, WithMask)
|
CUDA_TEST_P(Subtract_Scalar_First, WithMask)
|
||||||
{
|
{
|
||||||
cv::Mat mat = randomMat(size, depth.first);
|
cv::Mat mat = randomMat(size, depth.first);
|
||||||
cv::Scalar val = randomScalar(0, 255);
|
cv::Scalar val = randomScalar(0, 255);
|
||||||
@ -646,7 +646,7 @@ GPU_TEST_P(Subtract_Scalar_First, WithMask)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Subtract_Scalar_First, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, Subtract_Scalar_First, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
DEPTH_PAIRS,
|
DEPTH_PAIRS,
|
||||||
@ -681,7 +681,7 @@ PARAM_TEST_CASE(Multiply_Array, cv::cuda::DeviceInfo, cv::Size, std::pair<MatDep
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Multiply_Array, WithOutScale)
|
CUDA_TEST_P(Multiply_Array, WithOutScale)
|
||||||
{
|
{
|
||||||
cv::Mat mat1 = randomMat(size, stype);
|
cv::Mat mat1 = randomMat(size, stype);
|
||||||
cv::Mat mat2 = randomMat(size, stype);
|
cv::Mat mat2 = randomMat(size, stype);
|
||||||
@ -710,7 +710,7 @@ GPU_TEST_P(Multiply_Array, WithOutScale)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Multiply_Array, WithScale)
|
CUDA_TEST_P(Multiply_Array, WithScale)
|
||||||
{
|
{
|
||||||
cv::Mat mat1 = randomMat(size, stype);
|
cv::Mat mat1 = randomMat(size, stype);
|
||||||
cv::Mat mat2 = randomMat(size, stype);
|
cv::Mat mat2 = randomMat(size, stype);
|
||||||
@ -740,7 +740,7 @@ GPU_TEST_P(Multiply_Array, WithScale)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Multiply_Array, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, Multiply_Array, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
DEPTH_PAIRS,
|
DEPTH_PAIRS,
|
||||||
@ -766,7 +766,7 @@ PARAM_TEST_CASE(Multiply_Array_Special, cv::cuda::DeviceInfo, cv::Size, UseRoi)
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Multiply_Array_Special, Case_8UC4x_32FC1)
|
CUDA_TEST_P(Multiply_Array_Special, Case_8UC4x_32FC1)
|
||||||
{
|
{
|
||||||
cv::Mat mat1 = randomMat(size, CV_8UC4);
|
cv::Mat mat1 = randomMat(size, CV_8UC4);
|
||||||
cv::Mat mat2 = randomMat(size, CV_32FC1);
|
cv::Mat mat2 = randomMat(size, CV_32FC1);
|
||||||
@ -803,7 +803,7 @@ GPU_TEST_P(Multiply_Array_Special, Case_8UC4x_32FC1)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Multiply_Array_Special, Case_16SC4x_32FC1)
|
CUDA_TEST_P(Multiply_Array_Special, Case_16SC4x_32FC1)
|
||||||
{
|
{
|
||||||
cv::Mat mat1 = randomMat(size, CV_16SC4);
|
cv::Mat mat1 = randomMat(size, CV_16SC4);
|
||||||
cv::Mat mat2 = randomMat(size, CV_32FC1);
|
cv::Mat mat2 = randomMat(size, CV_32FC1);
|
||||||
@ -840,7 +840,7 @@ GPU_TEST_P(Multiply_Array_Special, Case_16SC4x_32FC1)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Multiply_Array_Special, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, Multiply_Array_Special, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
WHOLE_SUBMAT));
|
WHOLE_SUBMAT));
|
||||||
@ -866,7 +866,7 @@ PARAM_TEST_CASE(Multiply_Scalar, cv::cuda::DeviceInfo, cv::Size, std::pair<MatDe
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Multiply_Scalar, WithOutScale)
|
CUDA_TEST_P(Multiply_Scalar, WithOutScale)
|
||||||
{
|
{
|
||||||
cv::Mat mat = randomMat(size, depth.first);
|
cv::Mat mat = randomMat(size, depth.first);
|
||||||
cv::Scalar val = randomScalar(0, 255);
|
cv::Scalar val = randomScalar(0, 255);
|
||||||
@ -896,7 +896,7 @@ GPU_TEST_P(Multiply_Scalar, WithOutScale)
|
|||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
GPU_TEST_P(Multiply_Scalar, WithScale)
|
CUDA_TEST_P(Multiply_Scalar, WithScale)
|
||||||
{
|
{
|
||||||
cv::Mat mat = randomMat(size, depth.first);
|
cv::Mat mat = randomMat(size, depth.first);
|
||||||
cv::Scalar val = randomScalar(0, 255);
|
cv::Scalar val = randomScalar(0, 255);
|
||||||
@ -926,7 +926,7 @@ GPU_TEST_P(Multiply_Scalar, WithScale)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Multiply_Scalar, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, Multiply_Scalar, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
DEPTH_PAIRS,
|
DEPTH_PAIRS,
|
||||||
@ -953,7 +953,7 @@ PARAM_TEST_CASE(Multiply_Scalar_First, cv::cuda::DeviceInfo, cv::Size, std::pair
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Multiply_Scalar_First, WithOutScale)
|
CUDA_TEST_P(Multiply_Scalar_First, WithOutScale)
|
||||||
{
|
{
|
||||||
cv::Mat mat = randomMat(size, depth.first);
|
cv::Mat mat = randomMat(size, depth.first);
|
||||||
cv::Scalar val = randomScalar(0, 255);
|
cv::Scalar val = randomScalar(0, 255);
|
||||||
@ -983,7 +983,7 @@ GPU_TEST_P(Multiply_Scalar_First, WithOutScale)
|
|||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
GPU_TEST_P(Multiply_Scalar_First, WithScale)
|
CUDA_TEST_P(Multiply_Scalar_First, WithScale)
|
||||||
{
|
{
|
||||||
cv::Mat mat = randomMat(size, depth.first);
|
cv::Mat mat = randomMat(size, depth.first);
|
||||||
cv::Scalar val = randomScalar(0, 255);
|
cv::Scalar val = randomScalar(0, 255);
|
||||||
@ -1013,7 +1013,7 @@ GPU_TEST_P(Multiply_Scalar_First, WithScale)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Multiply_Scalar_First, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, Multiply_Scalar_First, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
DEPTH_PAIRS,
|
DEPTH_PAIRS,
|
||||||
@ -1048,7 +1048,7 @@ PARAM_TEST_CASE(Divide_Array, cv::cuda::DeviceInfo, cv::Size, std::pair<MatDepth
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Divide_Array, WithOutScale)
|
CUDA_TEST_P(Divide_Array, WithOutScale)
|
||||||
{
|
{
|
||||||
cv::Mat mat1 = randomMat(size, stype);
|
cv::Mat mat1 = randomMat(size, stype);
|
||||||
cv::Mat mat2 = randomMat(size, stype, 1.0, 255.0);
|
cv::Mat mat2 = randomMat(size, stype, 1.0, 255.0);
|
||||||
@ -1077,7 +1077,7 @@ GPU_TEST_P(Divide_Array, WithOutScale)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Divide_Array, WithScale)
|
CUDA_TEST_P(Divide_Array, WithScale)
|
||||||
{
|
{
|
||||||
cv::Mat mat1 = randomMat(size, stype);
|
cv::Mat mat1 = randomMat(size, stype);
|
||||||
cv::Mat mat2 = randomMat(size, stype, 1.0, 255.0);
|
cv::Mat mat2 = randomMat(size, stype, 1.0, 255.0);
|
||||||
@ -1107,7 +1107,7 @@ GPU_TEST_P(Divide_Array, WithScale)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Divide_Array, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, Divide_Array, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
DEPTH_PAIRS,
|
DEPTH_PAIRS,
|
||||||
@ -1133,7 +1133,7 @@ PARAM_TEST_CASE(Divide_Array_Special, cv::cuda::DeviceInfo, cv::Size, UseRoi)
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Divide_Array_Special, Case_8UC4x_32FC1)
|
CUDA_TEST_P(Divide_Array_Special, Case_8UC4x_32FC1)
|
||||||
{
|
{
|
||||||
cv::Mat mat1 = randomMat(size, CV_8UC4);
|
cv::Mat mat1 = randomMat(size, CV_8UC4);
|
||||||
cv::Mat mat2 = randomMat(size, CV_32FC1, 1.0, 255.0);
|
cv::Mat mat2 = randomMat(size, CV_32FC1, 1.0, 255.0);
|
||||||
@ -1170,7 +1170,7 @@ GPU_TEST_P(Divide_Array_Special, Case_8UC4x_32FC1)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Divide_Array_Special, Case_16SC4x_32FC1)
|
CUDA_TEST_P(Divide_Array_Special, Case_16SC4x_32FC1)
|
||||||
{
|
{
|
||||||
cv::Mat mat1 = randomMat(size, CV_16SC4);
|
cv::Mat mat1 = randomMat(size, CV_16SC4);
|
||||||
cv::Mat mat2 = randomMat(size, CV_32FC1, 1.0, 255.0);
|
cv::Mat mat2 = randomMat(size, CV_32FC1, 1.0, 255.0);
|
||||||
@ -1207,7 +1207,7 @@ GPU_TEST_P(Divide_Array_Special, Case_16SC4x_32FC1)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Divide_Array_Special, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, Divide_Array_Special, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
WHOLE_SUBMAT));
|
WHOLE_SUBMAT));
|
||||||
@ -1233,7 +1233,7 @@ PARAM_TEST_CASE(Divide_Scalar, cv::cuda::DeviceInfo, cv::Size, std::pair<MatDept
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Divide_Scalar, WithOutScale)
|
CUDA_TEST_P(Divide_Scalar, WithOutScale)
|
||||||
{
|
{
|
||||||
cv::Mat mat = randomMat(size, depth.first);
|
cv::Mat mat = randomMat(size, depth.first);
|
||||||
cv::Scalar val = randomScalar(1.0, 255.0);
|
cv::Scalar val = randomScalar(1.0, 255.0);
|
||||||
@ -1262,7 +1262,7 @@ GPU_TEST_P(Divide_Scalar, WithOutScale)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Divide_Scalar, WithScale)
|
CUDA_TEST_P(Divide_Scalar, WithScale)
|
||||||
{
|
{
|
||||||
cv::Mat mat = randomMat(size, depth.first);
|
cv::Mat mat = randomMat(size, depth.first);
|
||||||
cv::Scalar val = randomScalar(1.0, 255.0);
|
cv::Scalar val = randomScalar(1.0, 255.0);
|
||||||
@ -1292,7 +1292,7 @@ GPU_TEST_P(Divide_Scalar, WithScale)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Divide_Scalar, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, Divide_Scalar, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
DEPTH_PAIRS,
|
DEPTH_PAIRS,
|
||||||
@ -1319,7 +1319,7 @@ PARAM_TEST_CASE(Divide_Scalar_First, cv::cuda::DeviceInfo, cv::Size, std::pair<M
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Divide_Scalar_First, Accuracy)
|
CUDA_TEST_P(Divide_Scalar_First, Accuracy)
|
||||||
{
|
{
|
||||||
double scale = randomDouble(0.0, 255.0);
|
double scale = randomDouble(0.0, 255.0);
|
||||||
cv::Mat mat = randomMat(size, depth.first, 1.0, 255.0);
|
cv::Mat mat = randomMat(size, depth.first, 1.0, 255.0);
|
||||||
@ -1348,7 +1348,7 @@ GPU_TEST_P(Divide_Scalar_First, Accuracy)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Divide_Scalar_First, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, Divide_Scalar_First, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
DEPTH_PAIRS,
|
DEPTH_PAIRS,
|
||||||
@ -1375,7 +1375,7 @@ PARAM_TEST_CASE(AbsDiff, cv::cuda::DeviceInfo, cv::Size, MatDepth, UseRoi)
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(AbsDiff, Array)
|
CUDA_TEST_P(AbsDiff, Array)
|
||||||
{
|
{
|
||||||
cv::Mat src1 = randomMat(size, depth);
|
cv::Mat src1 = randomMat(size, depth);
|
||||||
cv::Mat src2 = randomMat(size, depth);
|
cv::Mat src2 = randomMat(size, depth);
|
||||||
@ -1404,7 +1404,7 @@ GPU_TEST_P(AbsDiff, Array)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(AbsDiff, Scalar)
|
CUDA_TEST_P(AbsDiff, Scalar)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, depth);
|
cv::Mat src = randomMat(size, depth);
|
||||||
cv::Scalar val = randomScalar(0.0, 255.0);
|
cv::Scalar val = randomScalar(0.0, 255.0);
|
||||||
@ -1433,7 +1433,7 @@ GPU_TEST_P(AbsDiff, Scalar)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(AbsDiff, Scalar_First)
|
CUDA_TEST_P(AbsDiff, Scalar_First)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, depth);
|
cv::Mat src = randomMat(size, depth);
|
||||||
cv::Scalar val = randomScalar(0.0, 255.0);
|
cv::Scalar val = randomScalar(0.0, 255.0);
|
||||||
@ -1462,7 +1462,7 @@ GPU_TEST_P(AbsDiff, Scalar_First)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, AbsDiff, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, AbsDiff, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
ALL_DEPTH,
|
ALL_DEPTH,
|
||||||
@ -1489,7 +1489,7 @@ PARAM_TEST_CASE(Abs, cv::cuda::DeviceInfo, cv::Size, MatDepth, UseRoi)
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Abs, Accuracy)
|
CUDA_TEST_P(Abs, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, depth);
|
cv::Mat src = randomMat(size, depth);
|
||||||
|
|
||||||
@ -1501,7 +1501,7 @@ GPU_TEST_P(Abs, Accuracy)
|
|||||||
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
|
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Abs, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, Abs, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
testing::Values(MatDepth(CV_16S), MatDepth(CV_32F)),
|
testing::Values(MatDepth(CV_16S), MatDepth(CV_32F)),
|
||||||
@ -1528,7 +1528,7 @@ PARAM_TEST_CASE(Sqr, cv::cuda::DeviceInfo, cv::Size, MatDepth, UseRoi)
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Sqr, Accuracy)
|
CUDA_TEST_P(Sqr, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, depth, 0, depth == CV_8U ? 16 : 255);
|
cv::Mat src = randomMat(size, depth, 0, depth == CV_8U ? 16 : 255);
|
||||||
|
|
||||||
@ -1541,7 +1541,7 @@ GPU_TEST_P(Sqr, Accuracy)
|
|||||||
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
|
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Sqr, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, Sqr, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
testing::Values(MatDepth(CV_8U),
|
testing::Values(MatDepth(CV_8U),
|
||||||
@ -1598,7 +1598,7 @@ PARAM_TEST_CASE(Sqrt, cv::cuda::DeviceInfo, cv::Size, MatDepth, UseRoi)
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Sqrt, Accuracy)
|
CUDA_TEST_P(Sqrt, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, depth);
|
cv::Mat src = randomMat(size, depth);
|
||||||
|
|
||||||
@ -1611,7 +1611,7 @@ GPU_TEST_P(Sqrt, Accuracy)
|
|||||||
EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 1.0 : 1e-5);
|
EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 1.0 : 1e-5);
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Sqrt, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, Sqrt, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
testing::Values(MatDepth(CV_8U),
|
testing::Values(MatDepth(CV_8U),
|
||||||
@ -1668,7 +1668,7 @@ PARAM_TEST_CASE(Log, cv::cuda::DeviceInfo, cv::Size, MatDepth, UseRoi)
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Log, Accuracy)
|
CUDA_TEST_P(Log, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, depth, 1.0, 255.0);
|
cv::Mat src = randomMat(size, depth, 1.0, 255.0);
|
||||||
|
|
||||||
@ -1681,7 +1681,7 @@ GPU_TEST_P(Log, Accuracy)
|
|||||||
EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 1.0 : 1e-6);
|
EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 1.0 : 1e-6);
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Log, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, Log, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
testing::Values(MatDepth(CV_8U),
|
testing::Values(MatDepth(CV_8U),
|
||||||
@ -1748,7 +1748,7 @@ PARAM_TEST_CASE(Exp, cv::cuda::DeviceInfo, cv::Size, MatDepth, UseRoi)
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Exp, Accuracy)
|
CUDA_TEST_P(Exp, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, depth, 0.0, 10.0);
|
cv::Mat src = randomMat(size, depth, 0.0, 10.0);
|
||||||
|
|
||||||
@ -1761,7 +1761,7 @@ GPU_TEST_P(Exp, Accuracy)
|
|||||||
EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 1.0 : 1e-2);
|
EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 1.0 : 1e-2);
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Exp, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, Exp, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
testing::Values(MatDepth(CV_8U),
|
testing::Values(MatDepth(CV_8U),
|
||||||
@ -1791,7 +1791,7 @@ PARAM_TEST_CASE(Pow, cv::cuda::DeviceInfo, cv::Size, MatDepth, UseRoi)
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Pow, Accuracy)
|
CUDA_TEST_P(Pow, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, depth, 0.0, 10.0);
|
cv::Mat src = randomMat(size, depth, 0.0, 10.0);
|
||||||
double power = randomDouble(2.0, 4.0);
|
double power = randomDouble(2.0, 4.0);
|
||||||
@ -1823,7 +1823,7 @@ GPU_TEST_P(Pow, Accuracy)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Pow, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, Pow, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
ALL_DEPTH,
|
ALL_DEPTH,
|
||||||
@ -1855,7 +1855,7 @@ PARAM_TEST_CASE(Compare_Array, cv::cuda::DeviceInfo, cv::Size, MatDepth, CmpCode
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Compare_Array, Accuracy)
|
CUDA_TEST_P(Compare_Array, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat src1 = randomMat(size, depth);
|
cv::Mat src1 = randomMat(size, depth);
|
||||||
cv::Mat src2 = randomMat(size, depth);
|
cv::Mat src2 = randomMat(size, depth);
|
||||||
@ -1884,7 +1884,7 @@ GPU_TEST_P(Compare_Array, Accuracy)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Compare_Array, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, Compare_Array, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
ALL_DEPTH,
|
ALL_DEPTH,
|
||||||
@ -1957,7 +1957,7 @@ PARAM_TEST_CASE(Compare_Scalar, cv::cuda::DeviceInfo, cv::Size, MatType, CmpCode
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Compare_Scalar, Accuracy)
|
CUDA_TEST_P(Compare_Scalar, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, type);
|
cv::Mat src = randomMat(size, type);
|
||||||
cv::Scalar sc = randomScalar(0.0, 255.0);
|
cv::Scalar sc = randomScalar(0.0, 255.0);
|
||||||
@ -1995,7 +1995,7 @@ GPU_TEST_P(Compare_Scalar, Accuracy)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Compare_Scalar, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, Compare_Scalar, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
TYPES(CV_8U, CV_64F, 1, 4),
|
TYPES(CV_8U, CV_64F, 1, 4),
|
||||||
@ -2027,7 +2027,7 @@ PARAM_TEST_CASE(Bitwise_Array, cv::cuda::DeviceInfo, cv::Size, MatType)
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Bitwise_Array, Not)
|
CUDA_TEST_P(Bitwise_Array, Not)
|
||||||
{
|
{
|
||||||
cv::cuda::GpuMat dst;
|
cv::cuda::GpuMat dst;
|
||||||
cv::cuda::bitwise_not(loadMat(src1), dst);
|
cv::cuda::bitwise_not(loadMat(src1), dst);
|
||||||
@ -2037,7 +2037,7 @@ GPU_TEST_P(Bitwise_Array, Not)
|
|||||||
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
|
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Bitwise_Array, Or)
|
CUDA_TEST_P(Bitwise_Array, Or)
|
||||||
{
|
{
|
||||||
cv::cuda::GpuMat dst;
|
cv::cuda::GpuMat dst;
|
||||||
cv::cuda::bitwise_or(loadMat(src1), loadMat(src2), dst);
|
cv::cuda::bitwise_or(loadMat(src1), loadMat(src2), dst);
|
||||||
@ -2047,7 +2047,7 @@ GPU_TEST_P(Bitwise_Array, Or)
|
|||||||
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
|
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Bitwise_Array, And)
|
CUDA_TEST_P(Bitwise_Array, And)
|
||||||
{
|
{
|
||||||
cv::cuda::GpuMat dst;
|
cv::cuda::GpuMat dst;
|
||||||
cv::cuda::bitwise_and(loadMat(src1), loadMat(src2), dst);
|
cv::cuda::bitwise_and(loadMat(src1), loadMat(src2), dst);
|
||||||
@ -2057,7 +2057,7 @@ GPU_TEST_P(Bitwise_Array, And)
|
|||||||
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
|
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Bitwise_Array, Xor)
|
CUDA_TEST_P(Bitwise_Array, Xor)
|
||||||
{
|
{
|
||||||
cv::cuda::GpuMat dst;
|
cv::cuda::GpuMat dst;
|
||||||
cv::cuda::bitwise_xor(loadMat(src1), loadMat(src2), dst);
|
cv::cuda::bitwise_xor(loadMat(src1), loadMat(src2), dst);
|
||||||
@ -2067,7 +2067,7 @@ GPU_TEST_P(Bitwise_Array, Xor)
|
|||||||
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
|
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Bitwise_Array, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, Bitwise_Array, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
TYPES(CV_8U, CV_32S, 1, 4)));
|
TYPES(CV_8U, CV_32S, 1, 4)));
|
||||||
@ -2100,7 +2100,7 @@ PARAM_TEST_CASE(Bitwise_Scalar, cv::cuda::DeviceInfo, cv::Size, MatDepth, Channe
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Bitwise_Scalar, Or)
|
CUDA_TEST_P(Bitwise_Scalar, Or)
|
||||||
{
|
{
|
||||||
cv::cuda::GpuMat dst;
|
cv::cuda::GpuMat dst;
|
||||||
cv::cuda::bitwise_or(loadMat(src), val, dst);
|
cv::cuda::bitwise_or(loadMat(src), val, dst);
|
||||||
@ -2111,7 +2111,7 @@ GPU_TEST_P(Bitwise_Scalar, Or)
|
|||||||
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
|
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Bitwise_Scalar, And)
|
CUDA_TEST_P(Bitwise_Scalar, And)
|
||||||
{
|
{
|
||||||
cv::cuda::GpuMat dst;
|
cv::cuda::GpuMat dst;
|
||||||
cv::cuda::bitwise_and(loadMat(src), val, dst);
|
cv::cuda::bitwise_and(loadMat(src), val, dst);
|
||||||
@ -2122,7 +2122,7 @@ GPU_TEST_P(Bitwise_Scalar, And)
|
|||||||
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
|
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Bitwise_Scalar, Xor)
|
CUDA_TEST_P(Bitwise_Scalar, Xor)
|
||||||
{
|
{
|
||||||
cv::cuda::GpuMat dst;
|
cv::cuda::GpuMat dst;
|
||||||
cv::cuda::bitwise_xor(loadMat(src), val, dst);
|
cv::cuda::bitwise_xor(loadMat(src), val, dst);
|
||||||
@ -2133,7 +2133,7 @@ GPU_TEST_P(Bitwise_Scalar, Xor)
|
|||||||
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
|
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Bitwise_Scalar, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, Bitwise_Scalar, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_32S)),
|
testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_32S)),
|
||||||
@ -2193,7 +2193,7 @@ PARAM_TEST_CASE(RShift, cv::cuda::DeviceInfo, cv::Size, MatDepth, Channels, UseR
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(RShift, Accuracy)
|
CUDA_TEST_P(RShift, Accuracy)
|
||||||
{
|
{
|
||||||
int type = CV_MAKE_TYPE(depth, channels);
|
int type = CV_MAKE_TYPE(depth, channels);
|
||||||
cv::Mat src = randomMat(size, type);
|
cv::Mat src = randomMat(size, type);
|
||||||
@ -2208,7 +2208,7 @@ GPU_TEST_P(RShift, Accuracy)
|
|||||||
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
|
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, RShift, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, RShift, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
testing::Values(MatDepth(CV_8U),
|
testing::Values(MatDepth(CV_8U),
|
||||||
@ -2273,7 +2273,7 @@ PARAM_TEST_CASE(LShift, cv::cuda::DeviceInfo, cv::Size, MatDepth, Channels, UseR
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(LShift, Accuracy)
|
CUDA_TEST_P(LShift, Accuracy)
|
||||||
{
|
{
|
||||||
int type = CV_MAKE_TYPE(depth, channels);
|
int type = CV_MAKE_TYPE(depth, channels);
|
||||||
cv::Mat src = randomMat(size, type);
|
cv::Mat src = randomMat(size, type);
|
||||||
@ -2288,7 +2288,7 @@ GPU_TEST_P(LShift, Accuracy)
|
|||||||
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
|
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, LShift, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, LShift, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_32S)),
|
testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_32S)),
|
||||||
@ -2316,7 +2316,7 @@ PARAM_TEST_CASE(Min, cv::cuda::DeviceInfo, cv::Size, MatDepth, UseRoi)
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Min, Array)
|
CUDA_TEST_P(Min, Array)
|
||||||
{
|
{
|
||||||
cv::Mat src1 = randomMat(size, depth);
|
cv::Mat src1 = randomMat(size, depth);
|
||||||
cv::Mat src2 = randomMat(size, depth);
|
cv::Mat src2 = randomMat(size, depth);
|
||||||
@ -2344,7 +2344,7 @@ GPU_TEST_P(Min, Array)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Min, Scalar)
|
CUDA_TEST_P(Min, Scalar)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, depth);
|
cv::Mat src = randomMat(size, depth);
|
||||||
double val = randomDouble(0.0, 255.0);
|
double val = randomDouble(0.0, 255.0);
|
||||||
@ -2372,7 +2372,7 @@ GPU_TEST_P(Min, Scalar)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Min, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, Min, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
ALL_DEPTH,
|
ALL_DEPTH,
|
||||||
@ -2399,7 +2399,7 @@ PARAM_TEST_CASE(Max, cv::cuda::DeviceInfo, cv::Size, MatDepth, UseRoi)
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Max, Array)
|
CUDA_TEST_P(Max, Array)
|
||||||
{
|
{
|
||||||
cv::Mat src1 = randomMat(size, depth);
|
cv::Mat src1 = randomMat(size, depth);
|
||||||
cv::Mat src2 = randomMat(size, depth);
|
cv::Mat src2 = randomMat(size, depth);
|
||||||
@ -2427,7 +2427,7 @@ GPU_TEST_P(Max, Array)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Max, Scalar)
|
CUDA_TEST_P(Max, Scalar)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, depth);
|
cv::Mat src = randomMat(size, depth);
|
||||||
double val = randomDouble(0.0, 255.0);
|
double val = randomDouble(0.0, 255.0);
|
||||||
@ -2455,7 +2455,7 @@ GPU_TEST_P(Max, Scalar)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Max, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, Max, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
ALL_DEPTH,
|
ALL_DEPTH,
|
||||||
@ -2486,7 +2486,7 @@ PARAM_TEST_CASE(AddWeighted, cv::cuda::DeviceInfo, cv::Size, MatDepth, MatDepth,
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(AddWeighted, Accuracy)
|
CUDA_TEST_P(AddWeighted, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat src1 = randomMat(size, depth1);
|
cv::Mat src1 = randomMat(size, depth1);
|
||||||
cv::Mat src2 = randomMat(size, depth2);
|
cv::Mat src2 = randomMat(size, depth2);
|
||||||
@ -2518,7 +2518,7 @@ GPU_TEST_P(AddWeighted, Accuracy)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, AddWeighted, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, AddWeighted, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
ALL_DEPTH,
|
ALL_DEPTH,
|
||||||
@ -2552,7 +2552,7 @@ PARAM_TEST_CASE(Threshold, cv::cuda::DeviceInfo, cv::Size, MatType, ThreshOp, Us
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Threshold, Accuracy)
|
CUDA_TEST_P(Threshold, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, type);
|
cv::Mat src = randomMat(size, type);
|
||||||
double maxVal = randomDouble(20.0, 127.0);
|
double maxVal = randomDouble(20.0, 127.0);
|
||||||
@ -2567,7 +2567,7 @@ GPU_TEST_P(Threshold, Accuracy)
|
|||||||
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
|
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Threshold, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, Threshold, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
testing::Values(MatType(CV_8UC1), MatType(CV_16SC1), MatType(CV_32FC1)),
|
testing::Values(MatType(CV_8UC1), MatType(CV_16SC1), MatType(CV_32FC1)),
|
||||||
@ -2593,7 +2593,7 @@ PARAM_TEST_CASE(Magnitude, cv::cuda::DeviceInfo, cv::Size, UseRoi)
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Magnitude, NPP)
|
CUDA_TEST_P(Magnitude, NPP)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, CV_32FC2);
|
cv::Mat src = randomMat(size, CV_32FC2);
|
||||||
|
|
||||||
@ -2608,7 +2608,7 @@ GPU_TEST_P(Magnitude, NPP)
|
|||||||
EXPECT_MAT_NEAR(dst_gold, dst, 1e-4);
|
EXPECT_MAT_NEAR(dst_gold, dst, 1e-4);
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Magnitude, Sqr_NPP)
|
CUDA_TEST_P(Magnitude, Sqr_NPP)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, CV_32FC2);
|
cv::Mat src = randomMat(size, CV_32FC2);
|
||||||
|
|
||||||
@ -2624,7 +2624,7 @@ GPU_TEST_P(Magnitude, Sqr_NPP)
|
|||||||
EXPECT_MAT_NEAR(dst_gold, dst, 1e-1);
|
EXPECT_MAT_NEAR(dst_gold, dst, 1e-1);
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Magnitude, Accuracy)
|
CUDA_TEST_P(Magnitude, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat x = randomMat(size, CV_32FC1);
|
cv::Mat x = randomMat(size, CV_32FC1);
|
||||||
cv::Mat y = randomMat(size, CV_32FC1);
|
cv::Mat y = randomMat(size, CV_32FC1);
|
||||||
@ -2638,7 +2638,7 @@ GPU_TEST_P(Magnitude, Accuracy)
|
|||||||
EXPECT_MAT_NEAR(dst_gold, dst, 1e-4);
|
EXPECT_MAT_NEAR(dst_gold, dst, 1e-4);
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Magnitude, Sqr_Accuracy)
|
CUDA_TEST_P(Magnitude, Sqr_Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat x = randomMat(size, CV_32FC1);
|
cv::Mat x = randomMat(size, CV_32FC1);
|
||||||
cv::Mat y = randomMat(size, CV_32FC1);
|
cv::Mat y = randomMat(size, CV_32FC1);
|
||||||
@ -2653,7 +2653,7 @@ GPU_TEST_P(Magnitude, Sqr_Accuracy)
|
|||||||
EXPECT_MAT_NEAR(dst_gold, dst, 1e-1);
|
EXPECT_MAT_NEAR(dst_gold, dst, 1e-1);
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Magnitude, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, Magnitude, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
WHOLE_SUBMAT));
|
WHOLE_SUBMAT));
|
||||||
@ -2684,7 +2684,7 @@ PARAM_TEST_CASE(Phase, cv::cuda::DeviceInfo, cv::Size, AngleInDegrees, UseRoi)
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Phase, Accuracy)
|
CUDA_TEST_P(Phase, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat x = randomMat(size, CV_32FC1);
|
cv::Mat x = randomMat(size, CV_32FC1);
|
||||||
cv::Mat y = randomMat(size, CV_32FC1);
|
cv::Mat y = randomMat(size, CV_32FC1);
|
||||||
@ -2698,7 +2698,7 @@ GPU_TEST_P(Phase, Accuracy)
|
|||||||
EXPECT_MAT_NEAR(dst_gold, dst, angleInDegrees ? 1e-2 : 1e-3);
|
EXPECT_MAT_NEAR(dst_gold, dst, angleInDegrees ? 1e-2 : 1e-3);
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Phase, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, Phase, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
testing::Values(AngleInDegrees(false), AngleInDegrees(true)),
|
testing::Values(AngleInDegrees(false), AngleInDegrees(true)),
|
||||||
@ -2725,7 +2725,7 @@ PARAM_TEST_CASE(CartToPolar, cv::cuda::DeviceInfo, cv::Size, AngleInDegrees, Use
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(CartToPolar, Accuracy)
|
CUDA_TEST_P(CartToPolar, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat x = randomMat(size, CV_32FC1);
|
cv::Mat x = randomMat(size, CV_32FC1);
|
||||||
cv::Mat y = randomMat(size, CV_32FC1);
|
cv::Mat y = randomMat(size, CV_32FC1);
|
||||||
@ -2742,7 +2742,7 @@ GPU_TEST_P(CartToPolar, Accuracy)
|
|||||||
EXPECT_MAT_NEAR(angle_gold, angle, angleInDegrees ? 1e-2 : 1e-3);
|
EXPECT_MAT_NEAR(angle_gold, angle, angleInDegrees ? 1e-2 : 1e-3);
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, CartToPolar, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, CartToPolar, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
testing::Values(AngleInDegrees(false), AngleInDegrees(true)),
|
testing::Values(AngleInDegrees(false), AngleInDegrees(true)),
|
||||||
@ -2769,7 +2769,7 @@ PARAM_TEST_CASE(PolarToCart, cv::cuda::DeviceInfo, cv::Size, AngleInDegrees, Use
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(PolarToCart, Accuracy)
|
CUDA_TEST_P(PolarToCart, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat magnitude = randomMat(size, CV_32FC1);
|
cv::Mat magnitude = randomMat(size, CV_32FC1);
|
||||||
cv::Mat angle = randomMat(size, CV_32FC1);
|
cv::Mat angle = randomMat(size, CV_32FC1);
|
||||||
@ -2786,7 +2786,7 @@ GPU_TEST_P(PolarToCart, Accuracy)
|
|||||||
EXPECT_MAT_NEAR(y_gold, y, 1e-4);
|
EXPECT_MAT_NEAR(y_gold, y, 1e-4);
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, PolarToCart, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, PolarToCart, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
testing::Values(AngleInDegrees(false), AngleInDegrees(true)),
|
testing::Values(AngleInDegrees(false), AngleInDegrees(true)),
|
||||||
|
|||||||
@ -42,4 +42,4 @@
|
|||||||
|
|
||||||
#include "test_precomp.hpp"
|
#include "test_precomp.hpp"
|
||||||
|
|
||||||
CV_GPU_TEST_MAIN("gpu")
|
CV_CUDA_TEST_MAIN("gpu")
|
||||||
|
|||||||
@ -69,7 +69,7 @@ PARAM_TEST_CASE(Norm, cv::cuda::DeviceInfo, cv::Size, MatDepth, NormCode, UseRoi
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Norm, Accuracy)
|
CUDA_TEST_P(Norm, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, depth);
|
cv::Mat src = randomMat(size, depth);
|
||||||
cv::Mat mask = randomMat(size, CV_8UC1, 0, 2);
|
cv::Mat mask = randomMat(size, CV_8UC1, 0, 2);
|
||||||
@ -82,7 +82,7 @@ GPU_TEST_P(Norm, Accuracy)
|
|||||||
EXPECT_NEAR(val_gold, val, depth < CV_32F ? 0.0 : 1.0);
|
EXPECT_NEAR(val_gold, val, depth < CV_32F ? 0.0 : 1.0);
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Norm, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, Norm, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
testing::Values(MatDepth(CV_8U),
|
testing::Values(MatDepth(CV_8U),
|
||||||
@ -115,7 +115,7 @@ PARAM_TEST_CASE(NormDiff, cv::cuda::DeviceInfo, cv::Size, NormCode, UseRoi)
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(NormDiff, Accuracy)
|
CUDA_TEST_P(NormDiff, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat src1 = randomMat(size, CV_8UC1);
|
cv::Mat src1 = randomMat(size, CV_8UC1);
|
||||||
cv::Mat src2 = randomMat(size, CV_8UC1);
|
cv::Mat src2 = randomMat(size, CV_8UC1);
|
||||||
@ -127,7 +127,7 @@ GPU_TEST_P(NormDiff, Accuracy)
|
|||||||
EXPECT_NEAR(val_gold, val, 0.0);
|
EXPECT_NEAR(val_gold, val, 0.0);
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, NormDiff, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, NormDiff, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
testing::Values(NormCode(cv::NORM_L1), NormCode(cv::NORM_L2), NormCode(cv::NORM_INF)),
|
testing::Values(NormCode(cv::NORM_L1), NormCode(cv::NORM_L2), NormCode(cv::NORM_INF)),
|
||||||
@ -238,7 +238,7 @@ PARAM_TEST_CASE(Sum, cv::cuda::DeviceInfo, cv::Size, MatType, UseRoi)
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Sum, Simple)
|
CUDA_TEST_P(Sum, Simple)
|
||||||
{
|
{
|
||||||
cv::Scalar val = cv::cuda::sum(loadMat(src, useRoi));
|
cv::Scalar val = cv::cuda::sum(loadMat(src, useRoi));
|
||||||
|
|
||||||
@ -247,7 +247,7 @@ GPU_TEST_P(Sum, Simple)
|
|||||||
EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5);
|
EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5);
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Sum, Abs)
|
CUDA_TEST_P(Sum, Abs)
|
||||||
{
|
{
|
||||||
cv::Scalar val = cv::cuda::absSum(loadMat(src, useRoi));
|
cv::Scalar val = cv::cuda::absSum(loadMat(src, useRoi));
|
||||||
|
|
||||||
@ -256,7 +256,7 @@ GPU_TEST_P(Sum, Abs)
|
|||||||
EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5);
|
EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5);
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Sum, Sqr)
|
CUDA_TEST_P(Sum, Sqr)
|
||||||
{
|
{
|
||||||
cv::Scalar val = cv::cuda::sqrSum(loadMat(src, useRoi));
|
cv::Scalar val = cv::cuda::sqrSum(loadMat(src, useRoi));
|
||||||
|
|
||||||
@ -265,7 +265,7 @@ GPU_TEST_P(Sum, Sqr)
|
|||||||
EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5);
|
EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5);
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Sum, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, Sum, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
TYPES(CV_8U, CV_64F, 1, 4),
|
TYPES(CV_8U, CV_64F, 1, 4),
|
||||||
@ -292,7 +292,7 @@ PARAM_TEST_CASE(MinMax, cv::cuda::DeviceInfo, cv::Size, MatDepth, UseRoi)
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(MinMax, WithoutMask)
|
CUDA_TEST_P(MinMax, WithoutMask)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, depth);
|
cv::Mat src = randomMat(size, depth);
|
||||||
|
|
||||||
@ -321,7 +321,7 @@ GPU_TEST_P(MinMax, WithoutMask)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(MinMax, WithMask)
|
CUDA_TEST_P(MinMax, WithMask)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, depth);
|
cv::Mat src = randomMat(size, depth);
|
||||||
cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
|
cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
|
||||||
@ -351,7 +351,7 @@ GPU_TEST_P(MinMax, WithMask)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(MinMax, NullPtr)
|
CUDA_TEST_P(MinMax, NullPtr)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, depth);
|
cv::Mat src = randomMat(size, depth);
|
||||||
|
|
||||||
@ -382,7 +382,7 @@ GPU_TEST_P(MinMax, NullPtr)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, MinMax, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, MinMax, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
ALL_DEPTH,
|
ALL_DEPTH,
|
||||||
@ -436,7 +436,7 @@ PARAM_TEST_CASE(MinMaxLoc, cv::cuda::DeviceInfo, cv::Size, MatDepth, UseRoi)
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(MinMaxLoc, WithoutMask)
|
CUDA_TEST_P(MinMaxLoc, WithoutMask)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, depth);
|
cv::Mat src = randomMat(size, depth);
|
||||||
|
|
||||||
@ -471,7 +471,7 @@ GPU_TEST_P(MinMaxLoc, WithoutMask)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(MinMaxLoc, WithMask)
|
CUDA_TEST_P(MinMaxLoc, WithMask)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, depth);
|
cv::Mat src = randomMat(size, depth);
|
||||||
cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
|
cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
|
||||||
@ -507,7 +507,7 @@ GPU_TEST_P(MinMaxLoc, WithMask)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(MinMaxLoc, NullPtr)
|
CUDA_TEST_P(MinMaxLoc, NullPtr)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, depth);
|
cv::Mat src = randomMat(size, depth);
|
||||||
|
|
||||||
@ -548,7 +548,7 @@ GPU_TEST_P(MinMaxLoc, NullPtr)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, MinMaxLoc, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, MinMaxLoc, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
ALL_DEPTH,
|
ALL_DEPTH,
|
||||||
@ -576,7 +576,7 @@ PARAM_TEST_CASE(CountNonZero, cv::cuda::DeviceInfo, cv::Size, MatDepth, UseRoi)
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(CountNonZero, Accuracy)
|
CUDA_TEST_P(CountNonZero, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat srcBase = randomMat(size, CV_8U, 0.0, 1.5);
|
cv::Mat srcBase = randomMat(size, CV_8U, 0.0, 1.5);
|
||||||
cv::Mat src;
|
cv::Mat src;
|
||||||
@ -603,7 +603,7 @@ GPU_TEST_P(CountNonZero, Accuracy)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, CountNonZero, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, CountNonZero, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
ALL_DEPTH,
|
ALL_DEPTH,
|
||||||
@ -653,7 +653,7 @@ PARAM_TEST_CASE(Reduce, cv::cuda::DeviceInfo, cv::Size, MatDepth, Channels, Redu
|
|||||||
|
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Reduce, Rows)
|
CUDA_TEST_P(Reduce, Rows)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, type);
|
cv::Mat src = randomMat(size, type);
|
||||||
|
|
||||||
@ -666,7 +666,7 @@ GPU_TEST_P(Reduce, Rows)
|
|||||||
EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 0.0 : 0.02);
|
EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 0.0 : 0.02);
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Reduce, Cols)
|
CUDA_TEST_P(Reduce, Cols)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, type);
|
cv::Mat src = randomMat(size, type);
|
||||||
|
|
||||||
@ -682,7 +682,7 @@ GPU_TEST_P(Reduce, Cols)
|
|||||||
EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 0.0 : 0.02);
|
EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 0.0 : 0.02);
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Reduce, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, Reduce, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
testing::Values(MatDepth(CV_8U),
|
testing::Values(MatDepth(CV_8U),
|
||||||
@ -724,7 +724,7 @@ PARAM_TEST_CASE(Normalize, cv::cuda::DeviceInfo, cv::Size, MatDepth, NormCode, U
|
|||||||
|
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Normalize, WithOutMask)
|
CUDA_TEST_P(Normalize, WithOutMask)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, type);
|
cv::Mat src = randomMat(size, type);
|
||||||
|
|
||||||
@ -737,7 +737,7 @@ GPU_TEST_P(Normalize, WithOutMask)
|
|||||||
EXPECT_MAT_NEAR(dst_gold, dst, 1e-6);
|
EXPECT_MAT_NEAR(dst_gold, dst, 1e-6);
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(Normalize, WithMask)
|
CUDA_TEST_P(Normalize, WithMask)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, type);
|
cv::Mat src = randomMat(size, type);
|
||||||
cv::Mat mask = randomMat(size, CV_8UC1, 0, 2);
|
cv::Mat mask = randomMat(size, CV_8UC1, 0, 2);
|
||||||
@ -753,7 +753,7 @@ GPU_TEST_P(Normalize, WithMask)
|
|||||||
EXPECT_MAT_NEAR(dst_gold, dst, 1e-6);
|
EXPECT_MAT_NEAR(dst_gold, dst, 1e-6);
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, Normalize, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, Normalize, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
ALL_DEPTH,
|
ALL_DEPTH,
|
||||||
@ -779,7 +779,7 @@ PARAM_TEST_CASE(MeanStdDev, cv::cuda::DeviceInfo, cv::Size, UseRoi)
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(MeanStdDev, Accuracy)
|
CUDA_TEST_P(MeanStdDev, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, CV_8UC1);
|
cv::Mat src = randomMat(size, CV_8UC1);
|
||||||
|
|
||||||
@ -811,7 +811,7 @@ GPU_TEST_P(MeanStdDev, Accuracy)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Arithm, MeanStdDev, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Arithm, MeanStdDev, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
WHOLE_SUBMAT));
|
WHOLE_SUBMAT));
|
||||||
|
|||||||
@ -100,7 +100,7 @@ PERF_TEST_P(Video, FGDStatModel,
|
|||||||
cap >> frame;
|
cap >> frame;
|
||||||
ASSERT_FALSE(frame.empty());
|
ASSERT_FALSE(frame.empty());
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
cv::cuda::GpuMat d_frame(frame), foreground;
|
cv::cuda::GpuMat d_frame(frame), foreground;
|
||||||
|
|
||||||
@ -119,13 +119,13 @@ PERF_TEST_P(Video, FGDStatModel,
|
|||||||
stopTimer();
|
stopTimer();
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_SANITY_CHECK(foreground, 1e-2, ERROR_RELATIVE);
|
CUDA_SANITY_CHECK(foreground, 1e-2, ERROR_RELATIVE);
|
||||||
|
|
||||||
#ifdef HAVE_OPENCV_CUDAIMGPROC
|
#ifdef HAVE_OPENCV_CUDAIMGPROC
|
||||||
cv::cuda::GpuMat background3, background;
|
cv::cuda::GpuMat background3, background;
|
||||||
d_fgd->getBackgroundImage(background3);
|
d_fgd->getBackgroundImage(background3);
|
||||||
cv::cuda::cvtColor(background3, background, cv::COLOR_BGR2BGRA);
|
cv::cuda::cvtColor(background3, background, cv::COLOR_BGR2BGRA);
|
||||||
GPU_SANITY_CHECK(background, 1e-2, ERROR_RELATIVE);
|
CUDA_SANITY_CHECK(background, 1e-2, ERROR_RELATIVE);
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
@ -168,7 +168,7 @@ DEF_PARAM_TEST(Video_Cn_LearningRate, string, MatCn, double);
|
|||||||
|
|
||||||
PERF_TEST_P(Video_Cn_LearningRate, MOG,
|
PERF_TEST_P(Video_Cn_LearningRate, MOG,
|
||||||
Combine(Values("gpu/video/768x576.avi", "gpu/video/1920x1080.avi"),
|
Combine(Values("gpu/video/768x576.avi", "gpu/video/1920x1080.avi"),
|
||||||
GPU_CHANNELS_1_3_4,
|
CUDA_CHANNELS_1_3_4,
|
||||||
Values(0.0, 0.01)))
|
Values(0.0, 0.01)))
|
||||||
{
|
{
|
||||||
const string inputFile = perf::TestBase::getDataPath(GET_PARAM(0));
|
const string inputFile = perf::TestBase::getDataPath(GET_PARAM(0));
|
||||||
@ -193,7 +193,7 @@ PERF_TEST_P(Video_Cn_LearningRate, MOG,
|
|||||||
cv::swap(temp, frame);
|
cv::swap(temp, frame);
|
||||||
}
|
}
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
cv::Ptr<cv::BackgroundSubtractor> d_mog = cv::cuda::createBackgroundSubtractorMOG();
|
cv::Ptr<cv::BackgroundSubtractor> d_mog = cv::cuda::createBackgroundSubtractorMOG();
|
||||||
|
|
||||||
@ -224,7 +224,7 @@ PERF_TEST_P(Video_Cn_LearningRate, MOG,
|
|||||||
stopTimer();
|
stopTimer();
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_SANITY_CHECK(foreground);
|
CUDA_SANITY_CHECK(foreground);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
@ -268,7 +268,7 @@ DEF_PARAM_TEST(Video_Cn, string, int);
|
|||||||
|
|
||||||
PERF_TEST_P(Video_Cn, MOG2,
|
PERF_TEST_P(Video_Cn, MOG2,
|
||||||
Combine(Values("gpu/video/768x576.avi", "gpu/video/1920x1080.avi"),
|
Combine(Values("gpu/video/768x576.avi", "gpu/video/1920x1080.avi"),
|
||||||
GPU_CHANNELS_1_3_4))
|
CUDA_CHANNELS_1_3_4))
|
||||||
{
|
{
|
||||||
const string inputFile = perf::TestBase::getDataPath(GET_PARAM(0));
|
const string inputFile = perf::TestBase::getDataPath(GET_PARAM(0));
|
||||||
const int cn = GET_PARAM(1);
|
const int cn = GET_PARAM(1);
|
||||||
@ -291,7 +291,7 @@ PERF_TEST_P(Video_Cn, MOG2,
|
|||||||
cv::swap(temp, frame);
|
cv::swap(temp, frame);
|
||||||
}
|
}
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
cv::Ptr<cv::BackgroundSubtractorMOG2> d_mog2 = cv::cuda::createBackgroundSubtractorMOG2();
|
cv::Ptr<cv::BackgroundSubtractorMOG2> d_mog2 = cv::cuda::createBackgroundSubtractorMOG2();
|
||||||
d_mog2->setDetectShadows(false);
|
d_mog2->setDetectShadows(false);
|
||||||
@ -323,7 +323,7 @@ PERF_TEST_P(Video_Cn, MOG2,
|
|||||||
stopTimer();
|
stopTimer();
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_SANITY_CHECK(foreground);
|
CUDA_SANITY_CHECK(foreground);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
@ -367,7 +367,7 @@ PERF_TEST_P(Video_Cn, MOG2,
|
|||||||
|
|
||||||
PERF_TEST_P(Video_Cn, MOG2GetBackgroundImage,
|
PERF_TEST_P(Video_Cn, MOG2GetBackgroundImage,
|
||||||
Combine(Values("gpu/video/768x576.avi", "gpu/video/1920x1080.avi"),
|
Combine(Values("gpu/video/768x576.avi", "gpu/video/1920x1080.avi"),
|
||||||
GPU_CHANNELS_1_3_4))
|
CUDA_CHANNELS_1_3_4))
|
||||||
{
|
{
|
||||||
const string inputFile = perf::TestBase::getDataPath(GET_PARAM(0));
|
const string inputFile = perf::TestBase::getDataPath(GET_PARAM(0));
|
||||||
const int cn = GET_PARAM(1);
|
const int cn = GET_PARAM(1);
|
||||||
@ -377,7 +377,7 @@ PERF_TEST_P(Video_Cn, MOG2GetBackgroundImage,
|
|||||||
|
|
||||||
cv::Mat frame;
|
cv::Mat frame;
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
cv::Ptr<cv::BackgroundSubtractor> d_mog2 = cv::cuda::createBackgroundSubtractorMOG2();
|
cv::Ptr<cv::BackgroundSubtractor> d_mog2 = cv::cuda::createBackgroundSubtractorMOG2();
|
||||||
|
|
||||||
@ -408,7 +408,7 @@ PERF_TEST_P(Video_Cn, MOG2GetBackgroundImage,
|
|||||||
|
|
||||||
TEST_CYCLE() d_mog2->getBackgroundImage(background);
|
TEST_CYCLE() d_mog2->getBackgroundImage(background);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(background, 1);
|
CUDA_SANITY_CHECK(background, 1);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
@ -452,7 +452,7 @@ DEF_PARAM_TEST(Video_Cn_MaxFeatures, string, MatCn, int);
|
|||||||
|
|
||||||
PERF_TEST_P(Video_Cn_MaxFeatures, GMG,
|
PERF_TEST_P(Video_Cn_MaxFeatures, GMG,
|
||||||
Combine(Values(string("gpu/video/768x576.avi")),
|
Combine(Values(string("gpu/video/768x576.avi")),
|
||||||
GPU_CHANNELS_1_3_4,
|
CUDA_CHANNELS_1_3_4,
|
||||||
Values(20, 40, 60)))
|
Values(20, 40, 60)))
|
||||||
{
|
{
|
||||||
const std::string inputFile = perf::TestBase::getDataPath(GET_PARAM(0));
|
const std::string inputFile = perf::TestBase::getDataPath(GET_PARAM(0));
|
||||||
@ -476,7 +476,7 @@ PERF_TEST_P(Video_Cn_MaxFeatures, GMG,
|
|||||||
cv::swap(temp, frame);
|
cv::swap(temp, frame);
|
||||||
}
|
}
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
cv::cuda::GpuMat d_frame(frame);
|
cv::cuda::GpuMat d_frame(frame);
|
||||||
cv::cuda::GpuMat foreground;
|
cv::cuda::GpuMat foreground;
|
||||||
@ -513,7 +513,7 @@ PERF_TEST_P(Video_Cn_MaxFeatures, GMG,
|
|||||||
stopTimer();
|
stopTimer();
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_SANITY_CHECK(foreground);
|
CUDA_SANITY_CHECK(foreground);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
|
|||||||
@ -90,7 +90,7 @@ PARAM_TEST_CASE(FGDStatModel, cv::cuda::DeviceInfo, std::string)
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(FGDStatModel, Update)
|
CUDA_TEST_P(FGDStatModel, Update)
|
||||||
{
|
{
|
||||||
cv::VideoCapture cap(inputFile);
|
cv::VideoCapture cap(inputFile);
|
||||||
ASSERT_TRUE(cap.isOpened());
|
ASSERT_TRUE(cap.isOpened());
|
||||||
@ -131,7 +131,7 @@ GPU_TEST_P(FGDStatModel, Update)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_BgSegm, FGDStatModel, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_BgSegm, FGDStatModel, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
testing::Values(std::string("768x576.avi"))));
|
testing::Values(std::string("768x576.avi"))));
|
||||||
|
|
||||||
@ -171,7 +171,7 @@ PARAM_TEST_CASE(MOG, cv::cuda::DeviceInfo, std::string, UseGray, LearningRate, U
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(MOG, Update)
|
CUDA_TEST_P(MOG, Update)
|
||||||
{
|
{
|
||||||
cv::VideoCapture cap(inputFile);
|
cv::VideoCapture cap(inputFile);
|
||||||
ASSERT_TRUE(cap.isOpened());
|
ASSERT_TRUE(cap.isOpened());
|
||||||
@ -206,7 +206,7 @@ GPU_TEST_P(MOG, Update)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_BgSegm, MOG, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_BgSegm, MOG, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
testing::Values(std::string("768x576.avi")),
|
testing::Values(std::string("768x576.avi")),
|
||||||
testing::Values(UseGray(true), UseGray(false)),
|
testing::Values(UseGray(true), UseGray(false)),
|
||||||
@ -245,7 +245,7 @@ PARAM_TEST_CASE(MOG2, cv::cuda::DeviceInfo, std::string, UseGray, DetectShadow,
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(MOG2, Update)
|
CUDA_TEST_P(MOG2, Update)
|
||||||
{
|
{
|
||||||
cv::VideoCapture cap(inputFile);
|
cv::VideoCapture cap(inputFile);
|
||||||
ASSERT_TRUE(cap.isOpened());
|
ASSERT_TRUE(cap.isOpened());
|
||||||
@ -289,7 +289,7 @@ GPU_TEST_P(MOG2, Update)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(MOG2, getBackgroundImage)
|
CUDA_TEST_P(MOG2, getBackgroundImage)
|
||||||
{
|
{
|
||||||
if (useGray)
|
if (useGray)
|
||||||
return;
|
return;
|
||||||
@ -326,7 +326,7 @@ GPU_TEST_P(MOG2, getBackgroundImage)
|
|||||||
ASSERT_MAT_NEAR(background_gold, background, 0);
|
ASSERT_MAT_NEAR(background_gold, background, 0);
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_BgSegm, MOG2, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_BgSegm, MOG2, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
testing::Values(std::string("768x576.avi")),
|
testing::Values(std::string("768x576.avi")),
|
||||||
testing::Values(UseGray(true), UseGray(false)),
|
testing::Values(UseGray(true), UseGray(false)),
|
||||||
@ -342,7 +342,7 @@ PARAM_TEST_CASE(GMG, cv::cuda::DeviceInfo, cv::Size, MatDepth, Channels, UseRoi)
|
|||||||
{
|
{
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(GMG, Accuracy)
|
CUDA_TEST_P(GMG, Accuracy)
|
||||||
{
|
{
|
||||||
const cv::cuda::DeviceInfo devInfo = GET_PARAM(0);
|
const cv::cuda::DeviceInfo devInfo = GET_PARAM(0);
|
||||||
cv::cuda::setDevice(devInfo.deviceID());
|
cv::cuda::setDevice(devInfo.deviceID());
|
||||||
@ -381,7 +381,7 @@ GPU_TEST_P(GMG, Accuracy)
|
|||||||
ASSERT_MAT_NEAR(fullfg, d_fgmask, 0);
|
ASSERT_MAT_NEAR(fullfg, d_fgmask, 0);
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_BgSegm, GMG, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_BgSegm, GMG, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
testing::Values(MatType(CV_8U), MatType(CV_16U), MatType(CV_32F)),
|
testing::Values(MatType(CV_8U), MatType(CV_16U), MatType(CV_32F)),
|
||||||
|
|||||||
@ -42,4 +42,4 @@
|
|||||||
|
|
||||||
#include "test_precomp.hpp"
|
#include "test_precomp.hpp"
|
||||||
|
|
||||||
CV_GPU_TEST_MAIN("gpu")
|
CV_CUDA_TEST_MAIN("gpu")
|
||||||
|
|||||||
@ -73,7 +73,7 @@ PERF_TEST_P(FileName, VideoReader, Values("gpu/video/768x576.avi", "gpu/video/19
|
|||||||
|
|
||||||
const string inputFile = perf::TestBase::getDataPath(GetParam());
|
const string inputFile = perf::TestBase::getDataPath(GetParam());
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
cv::Ptr<cv::cudacodec::VideoReader> d_reader = cv::cudacodec::createVideoReader(inputFile);
|
cv::Ptr<cv::cudacodec::VideoReader> d_reader = cv::cudacodec::createVideoReader(inputFile);
|
||||||
|
|
||||||
@ -81,7 +81,7 @@ PERF_TEST_P(FileName, VideoReader, Values("gpu/video/768x576.avi", "gpu/video/19
|
|||||||
|
|
||||||
TEST_CYCLE_N(10) d_reader->nextFrame(frame);
|
TEST_CYCLE_N(10) d_reader->nextFrame(frame);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(frame);
|
CUDA_SANITY_CHECK(frame);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
@ -117,7 +117,7 @@ PERF_TEST_P(FileName, VideoWriter, Values("gpu/video/768x576.avi", "gpu/video/19
|
|||||||
|
|
||||||
cv::Mat frame;
|
cv::Mat frame;
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
cv::Ptr<cv::cudacodec::VideoWriter> d_writer;
|
cv::Ptr<cv::cudacodec::VideoWriter> d_writer;
|
||||||
|
|
||||||
|
|||||||
@ -42,4 +42,4 @@
|
|||||||
|
|
||||||
#include "test_precomp.hpp"
|
#include "test_precomp.hpp"
|
||||||
|
|
||||||
CV_GPU_TEST_MAIN("gpu")
|
CV_CUDA_TEST_MAIN("gpu")
|
||||||
|
|||||||
@ -51,7 +51,7 @@ PARAM_TEST_CASE(Video, cv::cuda::DeviceInfo, std::string)
|
|||||||
//////////////////////////////////////////////////////
|
//////////////////////////////////////////////////////
|
||||||
// VideoReader
|
// VideoReader
|
||||||
|
|
||||||
GPU_TEST_P(Video, Reader)
|
CUDA_TEST_P(Video, Reader)
|
||||||
{
|
{
|
||||||
cv::cuda::setDevice(GET_PARAM(0).deviceID());
|
cv::cuda::setDevice(GET_PARAM(0).deviceID());
|
||||||
|
|
||||||
@ -73,7 +73,7 @@ GPU_TEST_P(Video, Reader)
|
|||||||
|
|
||||||
#ifdef WIN32
|
#ifdef WIN32
|
||||||
|
|
||||||
GPU_TEST_P(Video, Writer)
|
CUDA_TEST_P(Video, Writer)
|
||||||
{
|
{
|
||||||
cv::cuda::setDevice(GET_PARAM(0).deviceID());
|
cv::cuda::setDevice(GET_PARAM(0).deviceID());
|
||||||
|
|
||||||
@ -118,7 +118,7 @@ GPU_TEST_P(Video, Writer)
|
|||||||
|
|
||||||
#endif // WIN32
|
#endif // WIN32
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Codec, Video, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Codec, Video, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
testing::Values(std::string("768x576.avi"), std::string("1920x1080.avi"))));
|
testing::Values(std::string("768x576.avi"), std::string("1920x1080.avi"))));
|
||||||
|
|
||||||
|
|||||||
@ -52,10 +52,10 @@
|
|||||||
|
|
||||||
namespace cv { namespace cuda {
|
namespace cv { namespace cuda {
|
||||||
|
|
||||||
class CV_EXPORTS BFMatcher_GPU
|
class CV_EXPORTS BFMatcher_CUDA
|
||||||
{
|
{
|
||||||
public:
|
public:
|
||||||
explicit BFMatcher_GPU(int norm = cv::NORM_L2);
|
explicit BFMatcher_CUDA(int norm = cv::NORM_L2);
|
||||||
|
|
||||||
// Add descriptors to train descriptor collection
|
// Add descriptors to train descriptor collection
|
||||||
void add(const std::vector<GpuMat>& descCollection);
|
void add(const std::vector<GpuMat>& descCollection);
|
||||||
@ -203,7 +203,7 @@ private:
|
|||||||
std::vector<GpuMat> trainDescCollection;
|
std::vector<GpuMat> trainDescCollection;
|
||||||
};
|
};
|
||||||
|
|
||||||
class CV_EXPORTS FAST_GPU
|
class CV_EXPORTS FAST_CUDA
|
||||||
{
|
{
|
||||||
public:
|
public:
|
||||||
enum
|
enum
|
||||||
@ -216,7 +216,7 @@ public:
|
|||||||
// all features have same size
|
// all features have same size
|
||||||
static const int FEATURE_SIZE = 7;
|
static const int FEATURE_SIZE = 7;
|
||||||
|
|
||||||
explicit FAST_GPU(int threshold, bool nonmaxSupression = true, double keypointsRatio = 0.05);
|
explicit FAST_CUDA(int threshold, bool nonmaxSupression = true, double keypointsRatio = 0.05);
|
||||||
|
|
||||||
//! finds the keypoints using FAST detector
|
//! finds the keypoints using FAST detector
|
||||||
//! supports only CV_8UC1 images
|
//! supports only CV_8UC1 images
|
||||||
@ -257,7 +257,7 @@ private:
|
|||||||
GpuMat d_keypoints_;
|
GpuMat d_keypoints_;
|
||||||
};
|
};
|
||||||
|
|
||||||
class CV_EXPORTS ORB_GPU
|
class CV_EXPORTS ORB_CUDA
|
||||||
{
|
{
|
||||||
public:
|
public:
|
||||||
enum
|
enum
|
||||||
@ -277,7 +277,7 @@ public:
|
|||||||
};
|
};
|
||||||
|
|
||||||
//! Constructor
|
//! Constructor
|
||||||
explicit ORB_GPU(int nFeatures = 500, float scaleFactor = 1.2f, int nLevels = 8, int edgeThreshold = 31,
|
explicit ORB_CUDA(int nFeatures = 500, float scaleFactor = 1.2f, int nLevels = 8, int edgeThreshold = 31,
|
||||||
int firstLevel = 0, int WTA_K = 2, int scoreType = 0, int patchSize = 31);
|
int firstLevel = 0, int WTA_K = 2, int scoreType = 0, int patchSize = 31);
|
||||||
|
|
||||||
//! Compute the ORB features on an image
|
//! Compute the ORB features on an image
|
||||||
@ -349,7 +349,7 @@ private:
|
|||||||
std::vector<GpuMat> keyPointsPyr_;
|
std::vector<GpuMat> keyPointsPyr_;
|
||||||
std::vector<int> keyPointsCount_;
|
std::vector<int> keyPointsCount_;
|
||||||
|
|
||||||
FAST_GPU fastDetector_;
|
FAST_CUDA fastDetector_;
|
||||||
|
|
||||||
Ptr<cuda::Filter> blurFilter;
|
Ptr<cuda::Filter> blurFilter;
|
||||||
|
|
||||||
|
|||||||
@ -62,9 +62,9 @@ PERF_TEST_P(Image_Threshold_NonMaxSupression, FAST,
|
|||||||
const int threshold = GET_PARAM(1);
|
const int threshold = GET_PARAM(1);
|
||||||
const bool nonMaxSuppersion = GET_PARAM(2);
|
const bool nonMaxSuppersion = GET_PARAM(2);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
cv::cuda::FAST_GPU d_fast(threshold, nonMaxSuppersion, 0.5);
|
cv::cuda::FAST_CUDA d_fast(threshold, nonMaxSuppersion, 0.5);
|
||||||
|
|
||||||
const cv::cuda::GpuMat d_img(img);
|
const cv::cuda::GpuMat d_img(img);
|
||||||
cv::cuda::GpuMat d_keypoints;
|
cv::cuda::GpuMat d_keypoints;
|
||||||
@ -104,9 +104,9 @@ PERF_TEST_P(Image_NFeatures, ORB,
|
|||||||
|
|
||||||
const int nFeatures = GET_PARAM(1);
|
const int nFeatures = GET_PARAM(1);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
cv::cuda::ORB_GPU d_orb(nFeatures);
|
cv::cuda::ORB_CUDA d_orb(nFeatures);
|
||||||
|
|
||||||
const cv::cuda::GpuMat d_img(img);
|
const cv::cuda::GpuMat d_img(img);
|
||||||
cv::cuda::GpuMat d_keypoints, d_descriptors;
|
cv::cuda::GpuMat d_keypoints, d_descriptors;
|
||||||
@ -162,9 +162,9 @@ PERF_TEST_P(DescSize_Norm, BFMatch,
|
|||||||
cv::Mat train(3000, desc_size, type);
|
cv::Mat train(3000, desc_size, type);
|
||||||
declare.in(train, WARMUP_RNG);
|
declare.in(train, WARMUP_RNG);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
cv::cuda::BFMatcher_GPU d_matcher(normType);
|
cv::cuda::BFMatcher_CUDA d_matcher(normType);
|
||||||
|
|
||||||
const cv::cuda::GpuMat d_query(query);
|
const cv::cuda::GpuMat d_query(query);
|
||||||
const cv::cuda::GpuMat d_train(train);
|
const cv::cuda::GpuMat d_train(train);
|
||||||
@ -221,9 +221,9 @@ PERF_TEST_P(DescSize_K_Norm, BFKnnMatch,
|
|||||||
cv::Mat train(3000, desc_size, type);
|
cv::Mat train(3000, desc_size, type);
|
||||||
declare.in(train, WARMUP_RNG);
|
declare.in(train, WARMUP_RNG);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
cv::cuda::BFMatcher_GPU d_matcher(normType);
|
cv::cuda::BFMatcher_CUDA d_matcher(normType);
|
||||||
|
|
||||||
const cv::cuda::GpuMat d_query(query);
|
const cv::cuda::GpuMat d_query(query);
|
||||||
const cv::cuda::GpuMat d_train(train);
|
const cv::cuda::GpuMat d_train(train);
|
||||||
@ -275,9 +275,9 @@ PERF_TEST_P(DescSize_Norm, BFRadiusMatch,
|
|||||||
cv::Mat train(3000, desc_size, type);
|
cv::Mat train(3000, desc_size, type);
|
||||||
declare.in(train, WARMUP_RNG);
|
declare.in(train, WARMUP_RNG);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
cv::cuda::BFMatcher_GPU d_matcher(normType);
|
cv::cuda::BFMatcher_CUDA d_matcher(normType);
|
||||||
|
|
||||||
const cv::cuda::GpuMat d_query(query);
|
const cv::cuda::GpuMat d_query(query);
|
||||||
const cv::cuda::GpuMat d_train(train);
|
const cv::cuda::GpuMat d_train(train);
|
||||||
|
|||||||
@ -47,37 +47,37 @@ using namespace cv::cuda;
|
|||||||
|
|
||||||
#if !defined (HAVE_CUDA) || defined (CUDA_DISABLER)
|
#if !defined (HAVE_CUDA) || defined (CUDA_DISABLER)
|
||||||
|
|
||||||
cv::cuda::BFMatcher_GPU::BFMatcher_GPU(int) { throw_no_cuda(); }
|
cv::cuda::BFMatcher_CUDA::BFMatcher_CUDA(int) { throw_no_cuda(); }
|
||||||
void cv::cuda::BFMatcher_GPU::add(const std::vector<GpuMat>&) { throw_no_cuda(); }
|
void cv::cuda::BFMatcher_CUDA::add(const std::vector<GpuMat>&) { throw_no_cuda(); }
|
||||||
const std::vector<GpuMat>& cv::cuda::BFMatcher_GPU::getTrainDescriptors() const { throw_no_cuda(); return trainDescCollection; }
|
const std::vector<GpuMat>& cv::cuda::BFMatcher_CUDA::getTrainDescriptors() const { throw_no_cuda(); return trainDescCollection; }
|
||||||
void cv::cuda::BFMatcher_GPU::clear() { throw_no_cuda(); }
|
void cv::cuda::BFMatcher_CUDA::clear() { throw_no_cuda(); }
|
||||||
bool cv::cuda::BFMatcher_GPU::empty() const { throw_no_cuda(); return true; }
|
bool cv::cuda::BFMatcher_CUDA::empty() const { throw_no_cuda(); return true; }
|
||||||
bool cv::cuda::BFMatcher_GPU::isMaskSupported() const { throw_no_cuda(); return true; }
|
bool cv::cuda::BFMatcher_CUDA::isMaskSupported() const { throw_no_cuda(); return true; }
|
||||||
void cv::cuda::BFMatcher_GPU::matchSingle(const GpuMat&, const GpuMat&, GpuMat&, GpuMat&, const GpuMat&, Stream&) { throw_no_cuda(); }
|
void cv::cuda::BFMatcher_CUDA::matchSingle(const GpuMat&, const GpuMat&, GpuMat&, GpuMat&, const GpuMat&, Stream&) { throw_no_cuda(); }
|
||||||
void cv::cuda::BFMatcher_GPU::matchDownload(const GpuMat&, const GpuMat&, std::vector<DMatch>&) { throw_no_cuda(); }
|
void cv::cuda::BFMatcher_CUDA::matchDownload(const GpuMat&, const GpuMat&, std::vector<DMatch>&) { throw_no_cuda(); }
|
||||||
void cv::cuda::BFMatcher_GPU::matchConvert(const Mat&, const Mat&, std::vector<DMatch>&) { throw_no_cuda(); }
|
void cv::cuda::BFMatcher_CUDA::matchConvert(const Mat&, const Mat&, std::vector<DMatch>&) { throw_no_cuda(); }
|
||||||
void cv::cuda::BFMatcher_GPU::match(const GpuMat&, const GpuMat&, std::vector<DMatch>&, const GpuMat&) { throw_no_cuda(); }
|
void cv::cuda::BFMatcher_CUDA::match(const GpuMat&, const GpuMat&, std::vector<DMatch>&, const GpuMat&) { throw_no_cuda(); }
|
||||||
void cv::cuda::BFMatcher_GPU::makeGpuCollection(GpuMat&, GpuMat&, const std::vector<GpuMat>&) { throw_no_cuda(); }
|
void cv::cuda::BFMatcher_CUDA::makeGpuCollection(GpuMat&, GpuMat&, const std::vector<GpuMat>&) { throw_no_cuda(); }
|
||||||
void cv::cuda::BFMatcher_GPU::matchCollection(const GpuMat&, const GpuMat&, GpuMat&, GpuMat&, GpuMat&, const GpuMat&, Stream&) { throw_no_cuda(); }
|
void cv::cuda::BFMatcher_CUDA::matchCollection(const GpuMat&, const GpuMat&, GpuMat&, GpuMat&, GpuMat&, const GpuMat&, Stream&) { throw_no_cuda(); }
|
||||||
void cv::cuda::BFMatcher_GPU::matchDownload(const GpuMat&, const GpuMat&, const GpuMat&, std::vector<DMatch>&) { throw_no_cuda(); }
|
void cv::cuda::BFMatcher_CUDA::matchDownload(const GpuMat&, const GpuMat&, const GpuMat&, std::vector<DMatch>&) { throw_no_cuda(); }
|
||||||
void cv::cuda::BFMatcher_GPU::matchConvert(const Mat&, const Mat&, const Mat&, std::vector<DMatch>&) { throw_no_cuda(); }
|
void cv::cuda::BFMatcher_CUDA::matchConvert(const Mat&, const Mat&, const Mat&, std::vector<DMatch>&) { throw_no_cuda(); }
|
||||||
void cv::cuda::BFMatcher_GPU::match(const GpuMat&, std::vector<DMatch>&, const std::vector<GpuMat>&) { throw_no_cuda(); }
|
void cv::cuda::BFMatcher_CUDA::match(const GpuMat&, std::vector<DMatch>&, const std::vector<GpuMat>&) { throw_no_cuda(); }
|
||||||
void cv::cuda::BFMatcher_GPU::knnMatchSingle(const GpuMat&, const GpuMat&, GpuMat&, GpuMat&, GpuMat&, int, const GpuMat&, Stream&) { throw_no_cuda(); }
|
void cv::cuda::BFMatcher_CUDA::knnMatchSingle(const GpuMat&, const GpuMat&, GpuMat&, GpuMat&, GpuMat&, int, const GpuMat&, Stream&) { throw_no_cuda(); }
|
||||||
void cv::cuda::BFMatcher_GPU::knnMatchDownload(const GpuMat&, const GpuMat&, std::vector< std::vector<DMatch> >&, bool) { throw_no_cuda(); }
|
void cv::cuda::BFMatcher_CUDA::knnMatchDownload(const GpuMat&, const GpuMat&, std::vector< std::vector<DMatch> >&, bool) { throw_no_cuda(); }
|
||||||
void cv::cuda::BFMatcher_GPU::knnMatchConvert(const Mat&, const Mat&, std::vector< std::vector<DMatch> >&, bool) { throw_no_cuda(); }
|
void cv::cuda::BFMatcher_CUDA::knnMatchConvert(const Mat&, const Mat&, std::vector< std::vector<DMatch> >&, bool) { throw_no_cuda(); }
|
||||||
void cv::cuda::BFMatcher_GPU::knnMatch(const GpuMat&, const GpuMat&, std::vector< std::vector<DMatch> >&, int, const GpuMat&, bool) { throw_no_cuda(); }
|
void cv::cuda::BFMatcher_CUDA::knnMatch(const GpuMat&, const GpuMat&, std::vector< std::vector<DMatch> >&, int, const GpuMat&, bool) { throw_no_cuda(); }
|
||||||
void cv::cuda::BFMatcher_GPU::knnMatch2Collection(const GpuMat&, const GpuMat&, GpuMat&, GpuMat&, GpuMat&, const GpuMat&, Stream&) { throw_no_cuda(); }
|
void cv::cuda::BFMatcher_CUDA::knnMatch2Collection(const GpuMat&, const GpuMat&, GpuMat&, GpuMat&, GpuMat&, const GpuMat&, Stream&) { throw_no_cuda(); }
|
||||||
void cv::cuda::BFMatcher_GPU::knnMatch2Download(const GpuMat&, const GpuMat&, const GpuMat&, std::vector< std::vector<DMatch> >&, bool) { throw_no_cuda(); }
|
void cv::cuda::BFMatcher_CUDA::knnMatch2Download(const GpuMat&, const GpuMat&, const GpuMat&, std::vector< std::vector<DMatch> >&, bool) { throw_no_cuda(); }
|
||||||
void cv::cuda::BFMatcher_GPU::knnMatch2Convert(const Mat&, const Mat&, const Mat&, std::vector< std::vector<DMatch> >&, bool) { throw_no_cuda(); }
|
void cv::cuda::BFMatcher_CUDA::knnMatch2Convert(const Mat&, const Mat&, const Mat&, std::vector< std::vector<DMatch> >&, bool) { throw_no_cuda(); }
|
||||||
void cv::cuda::BFMatcher_GPU::knnMatch(const GpuMat&, std::vector< std::vector<DMatch> >&, int, const std::vector<GpuMat>&, bool) { throw_no_cuda(); }
|
void cv::cuda::BFMatcher_CUDA::knnMatch(const GpuMat&, std::vector< std::vector<DMatch> >&, int, const std::vector<GpuMat>&, bool) { throw_no_cuda(); }
|
||||||
void cv::cuda::BFMatcher_GPU::radiusMatchSingle(const GpuMat&, const GpuMat&, GpuMat&, GpuMat&, GpuMat&, float, const GpuMat&, Stream&) { throw_no_cuda(); }
|
void cv::cuda::BFMatcher_CUDA::radiusMatchSingle(const GpuMat&, const GpuMat&, GpuMat&, GpuMat&, GpuMat&, float, const GpuMat&, Stream&) { throw_no_cuda(); }
|
||||||
void cv::cuda::BFMatcher_GPU::radiusMatchDownload(const GpuMat&, const GpuMat&, const GpuMat&, std::vector< std::vector<DMatch> >&, bool) { throw_no_cuda(); }
|
void cv::cuda::BFMatcher_CUDA::radiusMatchDownload(const GpuMat&, const GpuMat&, const GpuMat&, std::vector< std::vector<DMatch> >&, bool) { throw_no_cuda(); }
|
||||||
void cv::cuda::BFMatcher_GPU::radiusMatchConvert(const Mat&, const Mat&, const Mat&, std::vector< std::vector<DMatch> >&, bool) { throw_no_cuda(); }
|
void cv::cuda::BFMatcher_CUDA::radiusMatchConvert(const Mat&, const Mat&, const Mat&, std::vector< std::vector<DMatch> >&, bool) { throw_no_cuda(); }
|
||||||
void cv::cuda::BFMatcher_GPU::radiusMatch(const GpuMat&, const GpuMat&, std::vector< std::vector<DMatch> >&, float, const GpuMat&, bool) { throw_no_cuda(); }
|
void cv::cuda::BFMatcher_CUDA::radiusMatch(const GpuMat&, const GpuMat&, std::vector< std::vector<DMatch> >&, float, const GpuMat&, bool) { throw_no_cuda(); }
|
||||||
void cv::cuda::BFMatcher_GPU::radiusMatchCollection(const GpuMat&, GpuMat&, GpuMat&, GpuMat&, GpuMat&, float, const std::vector<GpuMat>&, Stream&) { throw_no_cuda(); }
|
void cv::cuda::BFMatcher_CUDA::radiusMatchCollection(const GpuMat&, GpuMat&, GpuMat&, GpuMat&, GpuMat&, float, const std::vector<GpuMat>&, Stream&) { throw_no_cuda(); }
|
||||||
void cv::cuda::BFMatcher_GPU::radiusMatchDownload(const GpuMat&, const GpuMat&, const GpuMat&, const GpuMat&, std::vector< std::vector<DMatch> >&, bool) { throw_no_cuda(); }
|
void cv::cuda::BFMatcher_CUDA::radiusMatchDownload(const GpuMat&, const GpuMat&, const GpuMat&, const GpuMat&, std::vector< std::vector<DMatch> >&, bool) { throw_no_cuda(); }
|
||||||
void cv::cuda::BFMatcher_GPU::radiusMatchConvert(const Mat&, const Mat&, const Mat&, const Mat&, std::vector< std::vector<DMatch> >&, bool) { throw_no_cuda(); }
|
void cv::cuda::BFMatcher_CUDA::radiusMatchConvert(const Mat&, const Mat&, const Mat&, const Mat&, std::vector< std::vector<DMatch> >&, bool) { throw_no_cuda(); }
|
||||||
void cv::cuda::BFMatcher_GPU::radiusMatch(const GpuMat&, std::vector< std::vector<DMatch> >&, float, const std::vector<GpuMat>&, bool) { throw_no_cuda(); }
|
void cv::cuda::BFMatcher_CUDA::radiusMatch(const GpuMat&, std::vector< std::vector<DMatch> >&, float, const std::vector<GpuMat>&, bool) { throw_no_cuda(); }
|
||||||
|
|
||||||
#else /* !defined (HAVE_CUDA) */
|
#else /* !defined (HAVE_CUDA) */
|
||||||
|
|
||||||
@ -158,31 +158,31 @@ namespace cv { namespace cuda { namespace device
|
|||||||
////////////////////////////////////////////////////////////////////
|
////////////////////////////////////////////////////////////////////
|
||||||
// Train collection
|
// Train collection
|
||||||
|
|
||||||
cv::cuda::BFMatcher_GPU::BFMatcher_GPU(int norm_) : norm(norm_)
|
cv::cuda::BFMatcher_CUDA::BFMatcher_CUDA(int norm_) : norm(norm_)
|
||||||
{
|
{
|
||||||
}
|
}
|
||||||
|
|
||||||
void cv::cuda::BFMatcher_GPU::add(const std::vector<GpuMat>& descCollection)
|
void cv::cuda::BFMatcher_CUDA::add(const std::vector<GpuMat>& descCollection)
|
||||||
{
|
{
|
||||||
trainDescCollection.insert(trainDescCollection.end(), descCollection.begin(), descCollection.end());
|
trainDescCollection.insert(trainDescCollection.end(), descCollection.begin(), descCollection.end());
|
||||||
}
|
}
|
||||||
|
|
||||||
const std::vector<GpuMat>& cv::cuda::BFMatcher_GPU::getTrainDescriptors() const
|
const std::vector<GpuMat>& cv::cuda::BFMatcher_CUDA::getTrainDescriptors() const
|
||||||
{
|
{
|
||||||
return trainDescCollection;
|
return trainDescCollection;
|
||||||
}
|
}
|
||||||
|
|
||||||
void cv::cuda::BFMatcher_GPU::clear()
|
void cv::cuda::BFMatcher_CUDA::clear()
|
||||||
{
|
{
|
||||||
trainDescCollection.clear();
|
trainDescCollection.clear();
|
||||||
}
|
}
|
||||||
|
|
||||||
bool cv::cuda::BFMatcher_GPU::empty() const
|
bool cv::cuda::BFMatcher_CUDA::empty() const
|
||||||
{
|
{
|
||||||
return trainDescCollection.empty();
|
return trainDescCollection.empty();
|
||||||
}
|
}
|
||||||
|
|
||||||
bool cv::cuda::BFMatcher_GPU::isMaskSupported() const
|
bool cv::cuda::BFMatcher_CUDA::isMaskSupported() const
|
||||||
{
|
{
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
@ -190,7 +190,7 @@ bool cv::cuda::BFMatcher_GPU::isMaskSupported() const
|
|||||||
////////////////////////////////////////////////////////////////////
|
////////////////////////////////////////////////////////////////////
|
||||||
// Match
|
// Match
|
||||||
|
|
||||||
void cv::cuda::BFMatcher_GPU::matchSingle(const GpuMat& query, const GpuMat& train,
|
void cv::cuda::BFMatcher_CUDA::matchSingle(const GpuMat& query, const GpuMat& train,
|
||||||
GpuMat& trainIdx, GpuMat& distance,
|
GpuMat& trainIdx, GpuMat& distance,
|
||||||
const GpuMat& mask, Stream& stream)
|
const GpuMat& mask, Stream& stream)
|
||||||
{
|
{
|
||||||
@ -240,7 +240,7 @@ void cv::cuda::BFMatcher_GPU::matchSingle(const GpuMat& query, const GpuMat& tra
|
|||||||
func(query, train, mask, trainIdx, distance, StreamAccessor::getStream(stream));
|
func(query, train, mask, trainIdx, distance, StreamAccessor::getStream(stream));
|
||||||
}
|
}
|
||||||
|
|
||||||
void cv::cuda::BFMatcher_GPU::matchDownload(const GpuMat& trainIdx, const GpuMat& distance, std::vector<DMatch>& matches)
|
void cv::cuda::BFMatcher_CUDA::matchDownload(const GpuMat& trainIdx, const GpuMat& distance, std::vector<DMatch>& matches)
|
||||||
{
|
{
|
||||||
if (trainIdx.empty() || distance.empty())
|
if (trainIdx.empty() || distance.empty())
|
||||||
return;
|
return;
|
||||||
@ -251,7 +251,7 @@ void cv::cuda::BFMatcher_GPU::matchDownload(const GpuMat& trainIdx, const GpuMat
|
|||||||
matchConvert(trainIdxCPU, distanceCPU, matches);
|
matchConvert(trainIdxCPU, distanceCPU, matches);
|
||||||
}
|
}
|
||||||
|
|
||||||
void cv::cuda::BFMatcher_GPU::matchConvert(const Mat& trainIdx, const Mat& distance, std::vector<DMatch>& matches)
|
void cv::cuda::BFMatcher_CUDA::matchConvert(const Mat& trainIdx, const Mat& distance, std::vector<DMatch>& matches)
|
||||||
{
|
{
|
||||||
if (trainIdx.empty() || distance.empty())
|
if (trainIdx.empty() || distance.empty())
|
||||||
return;
|
return;
|
||||||
@ -281,7 +281,7 @@ void cv::cuda::BFMatcher_GPU::matchConvert(const Mat& trainIdx, const Mat& dista
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void cv::cuda::BFMatcher_GPU::match(const GpuMat& query, const GpuMat& train,
|
void cv::cuda::BFMatcher_CUDA::match(const GpuMat& query, const GpuMat& train,
|
||||||
std::vector<DMatch>& matches, const GpuMat& mask)
|
std::vector<DMatch>& matches, const GpuMat& mask)
|
||||||
{
|
{
|
||||||
GpuMat trainIdx, distance;
|
GpuMat trainIdx, distance;
|
||||||
@ -289,7 +289,7 @@ void cv::cuda::BFMatcher_GPU::match(const GpuMat& query, const GpuMat& train,
|
|||||||
matchDownload(trainIdx, distance, matches);
|
matchDownload(trainIdx, distance, matches);
|
||||||
}
|
}
|
||||||
|
|
||||||
void cv::cuda::BFMatcher_GPU::makeGpuCollection(GpuMat& trainCollection, GpuMat& maskCollection,
|
void cv::cuda::BFMatcher_CUDA::makeGpuCollection(GpuMat& trainCollection, GpuMat& maskCollection,
|
||||||
const std::vector<GpuMat>& masks)
|
const std::vector<GpuMat>& masks)
|
||||||
{
|
{
|
||||||
if (empty())
|
if (empty())
|
||||||
@ -333,7 +333,7 @@ void cv::cuda::BFMatcher_GPU::makeGpuCollection(GpuMat& trainCollection, GpuMat&
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void cv::cuda::BFMatcher_GPU::matchCollection(const GpuMat& query, const GpuMat& trainCollection,
|
void cv::cuda::BFMatcher_CUDA::matchCollection(const GpuMat& query, const GpuMat& trainCollection,
|
||||||
GpuMat& trainIdx, GpuMat& imgIdx, GpuMat& distance,
|
GpuMat& trainIdx, GpuMat& imgIdx, GpuMat& distance,
|
||||||
const GpuMat& masks, Stream& stream)
|
const GpuMat& masks, Stream& stream)
|
||||||
{
|
{
|
||||||
@ -382,7 +382,7 @@ void cv::cuda::BFMatcher_GPU::matchCollection(const GpuMat& query, const GpuMat&
|
|||||||
func(query, trainCollection, masks, trainIdx, imgIdx, distance, StreamAccessor::getStream(stream));
|
func(query, trainCollection, masks, trainIdx, imgIdx, distance, StreamAccessor::getStream(stream));
|
||||||
}
|
}
|
||||||
|
|
||||||
void cv::cuda::BFMatcher_GPU::matchDownload(const GpuMat& trainIdx, const GpuMat& imgIdx, const GpuMat& distance, std::vector<DMatch>& matches)
|
void cv::cuda::BFMatcher_CUDA::matchDownload(const GpuMat& trainIdx, const GpuMat& imgIdx, const GpuMat& distance, std::vector<DMatch>& matches)
|
||||||
{
|
{
|
||||||
if (trainIdx.empty() || imgIdx.empty() || distance.empty())
|
if (trainIdx.empty() || imgIdx.empty() || distance.empty())
|
||||||
return;
|
return;
|
||||||
@ -394,7 +394,7 @@ void cv::cuda::BFMatcher_GPU::matchDownload(const GpuMat& trainIdx, const GpuMat
|
|||||||
matchConvert(trainIdxCPU, imgIdxCPU, distanceCPU, matches);
|
matchConvert(trainIdxCPU, imgIdxCPU, distanceCPU, matches);
|
||||||
}
|
}
|
||||||
|
|
||||||
void cv::cuda::BFMatcher_GPU::matchConvert(const Mat& trainIdx, const Mat& imgIdx, const Mat& distance, std::vector<DMatch>& matches)
|
void cv::cuda::BFMatcher_CUDA::matchConvert(const Mat& trainIdx, const Mat& imgIdx, const Mat& distance, std::vector<DMatch>& matches)
|
||||||
{
|
{
|
||||||
if (trainIdx.empty() || imgIdx.empty() || distance.empty())
|
if (trainIdx.empty() || imgIdx.empty() || distance.empty())
|
||||||
return;
|
return;
|
||||||
@ -428,7 +428,7 @@ void cv::cuda::BFMatcher_GPU::matchConvert(const Mat& trainIdx, const Mat& imgId
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void cv::cuda::BFMatcher_GPU::match(const GpuMat& query, std::vector<DMatch>& matches, const std::vector<GpuMat>& masks)
|
void cv::cuda::BFMatcher_CUDA::match(const GpuMat& query, std::vector<DMatch>& matches, const std::vector<GpuMat>& masks)
|
||||||
{
|
{
|
||||||
GpuMat trainCollection;
|
GpuMat trainCollection;
|
||||||
GpuMat maskCollection;
|
GpuMat maskCollection;
|
||||||
@ -444,7 +444,7 @@ void cv::cuda::BFMatcher_GPU::match(const GpuMat& query, std::vector<DMatch>& ma
|
|||||||
////////////////////////////////////////////////////////////////////
|
////////////////////////////////////////////////////////////////////
|
||||||
// KnnMatch
|
// KnnMatch
|
||||||
|
|
||||||
void cv::cuda::BFMatcher_GPU::knnMatchSingle(const GpuMat& query, const GpuMat& train,
|
void cv::cuda::BFMatcher_CUDA::knnMatchSingle(const GpuMat& query, const GpuMat& train,
|
||||||
GpuMat& trainIdx, GpuMat& distance, GpuMat& allDist, int k,
|
GpuMat& trainIdx, GpuMat& distance, GpuMat& allDist, int k,
|
||||||
const GpuMat& mask, Stream& stream)
|
const GpuMat& mask, Stream& stream)
|
||||||
{
|
{
|
||||||
@ -505,7 +505,7 @@ void cv::cuda::BFMatcher_GPU::knnMatchSingle(const GpuMat& query, const GpuMat&
|
|||||||
func(query, train, k, mask, trainIdx, distance, allDist, StreamAccessor::getStream(stream));
|
func(query, train, k, mask, trainIdx, distance, allDist, StreamAccessor::getStream(stream));
|
||||||
}
|
}
|
||||||
|
|
||||||
void cv::cuda::BFMatcher_GPU::knnMatchDownload(const GpuMat& trainIdx, const GpuMat& distance,
|
void cv::cuda::BFMatcher_CUDA::knnMatchDownload(const GpuMat& trainIdx, const GpuMat& distance,
|
||||||
std::vector< std::vector<DMatch> >& matches, bool compactResult)
|
std::vector< std::vector<DMatch> >& matches, bool compactResult)
|
||||||
{
|
{
|
||||||
if (trainIdx.empty() || distance.empty())
|
if (trainIdx.empty() || distance.empty())
|
||||||
@ -517,7 +517,7 @@ void cv::cuda::BFMatcher_GPU::knnMatchDownload(const GpuMat& trainIdx, const Gpu
|
|||||||
knnMatchConvert(trainIdxCPU, distanceCPU, matches, compactResult);
|
knnMatchConvert(trainIdxCPU, distanceCPU, matches, compactResult);
|
||||||
}
|
}
|
||||||
|
|
||||||
void cv::cuda::BFMatcher_GPU::knnMatchConvert(const Mat& trainIdx, const Mat& distance,
|
void cv::cuda::BFMatcher_CUDA::knnMatchConvert(const Mat& trainIdx, const Mat& distance,
|
||||||
std::vector< std::vector<DMatch> >& matches, bool compactResult)
|
std::vector< std::vector<DMatch> >& matches, bool compactResult)
|
||||||
{
|
{
|
||||||
if (trainIdx.empty() || distance.empty())
|
if (trainIdx.empty() || distance.empty())
|
||||||
@ -562,7 +562,7 @@ void cv::cuda::BFMatcher_GPU::knnMatchConvert(const Mat& trainIdx, const Mat& di
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void cv::cuda::BFMatcher_GPU::knnMatch(const GpuMat& query, const GpuMat& train,
|
void cv::cuda::BFMatcher_CUDA::knnMatch(const GpuMat& query, const GpuMat& train,
|
||||||
std::vector< std::vector<DMatch> >& matches, int k, const GpuMat& mask, bool compactResult)
|
std::vector< std::vector<DMatch> >& matches, int k, const GpuMat& mask, bool compactResult)
|
||||||
{
|
{
|
||||||
GpuMat trainIdx, distance, allDist;
|
GpuMat trainIdx, distance, allDist;
|
||||||
@ -570,7 +570,7 @@ void cv::cuda::BFMatcher_GPU::knnMatch(const GpuMat& query, const GpuMat& train,
|
|||||||
knnMatchDownload(trainIdx, distance, matches, compactResult);
|
knnMatchDownload(trainIdx, distance, matches, compactResult);
|
||||||
}
|
}
|
||||||
|
|
||||||
void cv::cuda::BFMatcher_GPU::knnMatch2Collection(const GpuMat& query, const GpuMat& trainCollection,
|
void cv::cuda::BFMatcher_CUDA::knnMatch2Collection(const GpuMat& query, const GpuMat& trainCollection,
|
||||||
GpuMat& trainIdx, GpuMat& imgIdx, GpuMat& distance,
|
GpuMat& trainIdx, GpuMat& imgIdx, GpuMat& distance,
|
||||||
const GpuMat& maskCollection, Stream& stream)
|
const GpuMat& maskCollection, Stream& stream)
|
||||||
{
|
{
|
||||||
@ -621,7 +621,7 @@ void cv::cuda::BFMatcher_GPU::knnMatch2Collection(const GpuMat& query, const Gpu
|
|||||||
func(query, trainCollection, maskCollection, trainIdx, imgIdx, distance, StreamAccessor::getStream(stream));
|
func(query, trainCollection, maskCollection, trainIdx, imgIdx, distance, StreamAccessor::getStream(stream));
|
||||||
}
|
}
|
||||||
|
|
||||||
void cv::cuda::BFMatcher_GPU::knnMatch2Download(const GpuMat& trainIdx, const GpuMat& imgIdx, const GpuMat& distance,
|
void cv::cuda::BFMatcher_CUDA::knnMatch2Download(const GpuMat& trainIdx, const GpuMat& imgIdx, const GpuMat& distance,
|
||||||
std::vector< std::vector<DMatch> >& matches, bool compactResult)
|
std::vector< std::vector<DMatch> >& matches, bool compactResult)
|
||||||
{
|
{
|
||||||
if (trainIdx.empty() || imgIdx.empty() || distance.empty())
|
if (trainIdx.empty() || imgIdx.empty() || distance.empty())
|
||||||
@ -634,7 +634,7 @@ void cv::cuda::BFMatcher_GPU::knnMatch2Download(const GpuMat& trainIdx, const Gp
|
|||||||
knnMatch2Convert(trainIdxCPU, imgIdxCPU, distanceCPU, matches, compactResult);
|
knnMatch2Convert(trainIdxCPU, imgIdxCPU, distanceCPU, matches, compactResult);
|
||||||
}
|
}
|
||||||
|
|
||||||
void cv::cuda::BFMatcher_GPU::knnMatch2Convert(const Mat& trainIdx, const Mat& imgIdx, const Mat& distance,
|
void cv::cuda::BFMatcher_CUDA::knnMatch2Convert(const Mat& trainIdx, const Mat& imgIdx, const Mat& distance,
|
||||||
std::vector< std::vector<DMatch> >& matches, bool compactResult)
|
std::vector< std::vector<DMatch> >& matches, bool compactResult)
|
||||||
{
|
{
|
||||||
if (trainIdx.empty() || imgIdx.empty() || distance.empty())
|
if (trainIdx.empty() || imgIdx.empty() || distance.empty())
|
||||||
@ -690,7 +690,7 @@ namespace
|
|||||||
};
|
};
|
||||||
}
|
}
|
||||||
|
|
||||||
void cv::cuda::BFMatcher_GPU::knnMatch(const GpuMat& query, std::vector< std::vector<DMatch> >& matches, int k,
|
void cv::cuda::BFMatcher_CUDA::knnMatch(const GpuMat& query, std::vector< std::vector<DMatch> >& matches, int k,
|
||||||
const std::vector<GpuMat>& masks, bool compactResult)
|
const std::vector<GpuMat>& masks, bool compactResult)
|
||||||
{
|
{
|
||||||
if (k == 2)
|
if (k == 2)
|
||||||
@ -748,7 +748,7 @@ void cv::cuda::BFMatcher_GPU::knnMatch(const GpuMat& query, std::vector< std::ve
|
|||||||
////////////////////////////////////////////////////////////////////
|
////////////////////////////////////////////////////////////////////
|
||||||
// RadiusMatch
|
// RadiusMatch
|
||||||
|
|
||||||
void cv::cuda::BFMatcher_GPU::radiusMatchSingle(const GpuMat& query, const GpuMat& train,
|
void cv::cuda::BFMatcher_CUDA::radiusMatchSingle(const GpuMat& query, const GpuMat& train,
|
||||||
GpuMat& trainIdx, GpuMat& distance, GpuMat& nMatches, float maxDistance,
|
GpuMat& trainIdx, GpuMat& distance, GpuMat& nMatches, float maxDistance,
|
||||||
const GpuMat& mask, Stream& stream)
|
const GpuMat& mask, Stream& stream)
|
||||||
{
|
{
|
||||||
@ -805,7 +805,7 @@ void cv::cuda::BFMatcher_GPU::radiusMatchSingle(const GpuMat& query, const GpuMa
|
|||||||
func(query, train, maxDistance, mask, trainIdx, distance, nMatches, StreamAccessor::getStream(stream));
|
func(query, train, maxDistance, mask, trainIdx, distance, nMatches, StreamAccessor::getStream(stream));
|
||||||
}
|
}
|
||||||
|
|
||||||
void cv::cuda::BFMatcher_GPU::radiusMatchDownload(const GpuMat& trainIdx, const GpuMat& distance, const GpuMat& nMatches,
|
void cv::cuda::BFMatcher_CUDA::radiusMatchDownload(const GpuMat& trainIdx, const GpuMat& distance, const GpuMat& nMatches,
|
||||||
std::vector< std::vector<DMatch> >& matches, bool compactResult)
|
std::vector< std::vector<DMatch> >& matches, bool compactResult)
|
||||||
{
|
{
|
||||||
if (trainIdx.empty() || distance.empty() || nMatches.empty())
|
if (trainIdx.empty() || distance.empty() || nMatches.empty())
|
||||||
@ -818,7 +818,7 @@ void cv::cuda::BFMatcher_GPU::radiusMatchDownload(const GpuMat& trainIdx, const
|
|||||||
radiusMatchConvert(trainIdxCPU, distanceCPU, nMatchesCPU, matches, compactResult);
|
radiusMatchConvert(trainIdxCPU, distanceCPU, nMatchesCPU, matches, compactResult);
|
||||||
}
|
}
|
||||||
|
|
||||||
void cv::cuda::BFMatcher_GPU::radiusMatchConvert(const Mat& trainIdx, const Mat& distance, const Mat& nMatches,
|
void cv::cuda::BFMatcher_CUDA::radiusMatchConvert(const Mat& trainIdx, const Mat& distance, const Mat& nMatches,
|
||||||
std::vector< std::vector<DMatch> >& matches, bool compactResult)
|
std::vector< std::vector<DMatch> >& matches, bool compactResult)
|
||||||
{
|
{
|
||||||
if (trainIdx.empty() || distance.empty() || nMatches.empty())
|
if (trainIdx.empty() || distance.empty() || nMatches.empty())
|
||||||
@ -867,7 +867,7 @@ void cv::cuda::BFMatcher_GPU::radiusMatchConvert(const Mat& trainIdx, const Mat&
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void cv::cuda::BFMatcher_GPU::radiusMatch(const GpuMat& query, const GpuMat& train,
|
void cv::cuda::BFMatcher_CUDA::radiusMatch(const GpuMat& query, const GpuMat& train,
|
||||||
std::vector< std::vector<DMatch> >& matches, float maxDistance, const GpuMat& mask, bool compactResult)
|
std::vector< std::vector<DMatch> >& matches, float maxDistance, const GpuMat& mask, bool compactResult)
|
||||||
{
|
{
|
||||||
GpuMat trainIdx, distance, nMatches;
|
GpuMat trainIdx, distance, nMatches;
|
||||||
@ -875,7 +875,7 @@ void cv::cuda::BFMatcher_GPU::radiusMatch(const GpuMat& query, const GpuMat& tra
|
|||||||
radiusMatchDownload(trainIdx, distance, nMatches, matches, compactResult);
|
radiusMatchDownload(trainIdx, distance, nMatches, matches, compactResult);
|
||||||
}
|
}
|
||||||
|
|
||||||
void cv::cuda::BFMatcher_GPU::radiusMatchCollection(const GpuMat& query, GpuMat& trainIdx, GpuMat& imgIdx, GpuMat& distance, GpuMat& nMatches,
|
void cv::cuda::BFMatcher_CUDA::radiusMatchCollection(const GpuMat& query, GpuMat& trainIdx, GpuMat& imgIdx, GpuMat& distance, GpuMat& nMatches,
|
||||||
float maxDistance, const std::vector<GpuMat>& masks, Stream& stream)
|
float maxDistance, const std::vector<GpuMat>& masks, Stream& stream)
|
||||||
{
|
{
|
||||||
if (query.empty() || empty())
|
if (query.empty() || empty())
|
||||||
@ -934,7 +934,7 @@ void cv::cuda::BFMatcher_GPU::radiusMatchCollection(const GpuMat& query, GpuMat&
|
|||||||
trainIdx, imgIdx, distance, nMatches, StreamAccessor::getStream(stream));
|
trainIdx, imgIdx, distance, nMatches, StreamAccessor::getStream(stream));
|
||||||
}
|
}
|
||||||
|
|
||||||
void cv::cuda::BFMatcher_GPU::radiusMatchDownload(const GpuMat& trainIdx, const GpuMat& imgIdx, const GpuMat& distance, const GpuMat& nMatches,
|
void cv::cuda::BFMatcher_CUDA::radiusMatchDownload(const GpuMat& trainIdx, const GpuMat& imgIdx, const GpuMat& distance, const GpuMat& nMatches,
|
||||||
std::vector< std::vector<DMatch> >& matches, bool compactResult)
|
std::vector< std::vector<DMatch> >& matches, bool compactResult)
|
||||||
{
|
{
|
||||||
if (trainIdx.empty() || imgIdx.empty() || distance.empty() || nMatches.empty())
|
if (trainIdx.empty() || imgIdx.empty() || distance.empty() || nMatches.empty())
|
||||||
@ -948,7 +948,7 @@ void cv::cuda::BFMatcher_GPU::radiusMatchDownload(const GpuMat& trainIdx, const
|
|||||||
radiusMatchConvert(trainIdxCPU, imgIdxCPU, distanceCPU, nMatchesCPU, matches, compactResult);
|
radiusMatchConvert(trainIdxCPU, imgIdxCPU, distanceCPU, nMatchesCPU, matches, compactResult);
|
||||||
}
|
}
|
||||||
|
|
||||||
void cv::cuda::BFMatcher_GPU::radiusMatchConvert(const Mat& trainIdx, const Mat& imgIdx, const Mat& distance, const Mat& nMatches,
|
void cv::cuda::BFMatcher_CUDA::radiusMatchConvert(const Mat& trainIdx, const Mat& imgIdx, const Mat& distance, const Mat& nMatches,
|
||||||
std::vector< std::vector<DMatch> >& matches, bool compactResult)
|
std::vector< std::vector<DMatch> >& matches, bool compactResult)
|
||||||
{
|
{
|
||||||
if (trainIdx.empty() || imgIdx.empty() || distance.empty() || nMatches.empty())
|
if (trainIdx.empty() || imgIdx.empty() || distance.empty() || nMatches.empty())
|
||||||
@ -1000,7 +1000,7 @@ void cv::cuda::BFMatcher_GPU::radiusMatchConvert(const Mat& trainIdx, const Mat&
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void cv::cuda::BFMatcher_GPU::radiusMatch(const GpuMat& query, std::vector< std::vector<DMatch> >& matches,
|
void cv::cuda::BFMatcher_CUDA::radiusMatch(const GpuMat& query, std::vector< std::vector<DMatch> >& matches,
|
||||||
float maxDistance, const std::vector<GpuMat>& masks, bool compactResult)
|
float maxDistance, const std::vector<GpuMat>& masks, bool compactResult)
|
||||||
{
|
{
|
||||||
GpuMat trainIdx, imgIdx, distance, nMatches;
|
GpuMat trainIdx, imgIdx, distance, nMatches;
|
||||||
|
|||||||
@ -47,23 +47,23 @@ using namespace cv::cuda;
|
|||||||
|
|
||||||
#if !defined (HAVE_CUDA) || defined (CUDA_DISABLER)
|
#if !defined (HAVE_CUDA) || defined (CUDA_DISABLER)
|
||||||
|
|
||||||
cv::cuda::FAST_GPU::FAST_GPU(int, bool, double) { throw_no_cuda(); }
|
cv::cuda::FAST_CUDA::FAST_CUDA(int, bool, double) { throw_no_cuda(); }
|
||||||
void cv::cuda::FAST_GPU::operator ()(const GpuMat&, const GpuMat&, GpuMat&) { throw_no_cuda(); }
|
void cv::cuda::FAST_CUDA::operator ()(const GpuMat&, const GpuMat&, GpuMat&) { throw_no_cuda(); }
|
||||||
void cv::cuda::FAST_GPU::operator ()(const GpuMat&, const GpuMat&, std::vector<KeyPoint>&) { throw_no_cuda(); }
|
void cv::cuda::FAST_CUDA::operator ()(const GpuMat&, const GpuMat&, std::vector<KeyPoint>&) { throw_no_cuda(); }
|
||||||
void cv::cuda::FAST_GPU::downloadKeypoints(const GpuMat&, std::vector<KeyPoint>&) { throw_no_cuda(); }
|
void cv::cuda::FAST_CUDA::downloadKeypoints(const GpuMat&, std::vector<KeyPoint>&) { throw_no_cuda(); }
|
||||||
void cv::cuda::FAST_GPU::convertKeypoints(const Mat&, std::vector<KeyPoint>&) { throw_no_cuda(); }
|
void cv::cuda::FAST_CUDA::convertKeypoints(const Mat&, std::vector<KeyPoint>&) { throw_no_cuda(); }
|
||||||
void cv::cuda::FAST_GPU::release() { throw_no_cuda(); }
|
void cv::cuda::FAST_CUDA::release() { throw_no_cuda(); }
|
||||||
int cv::cuda::FAST_GPU::calcKeyPointsLocation(const GpuMat&, const GpuMat&) { throw_no_cuda(); return 0; }
|
int cv::cuda::FAST_CUDA::calcKeyPointsLocation(const GpuMat&, const GpuMat&) { throw_no_cuda(); return 0; }
|
||||||
int cv::cuda::FAST_GPU::getKeyPoints(GpuMat&) { throw_no_cuda(); return 0; }
|
int cv::cuda::FAST_CUDA::getKeyPoints(GpuMat&) { throw_no_cuda(); return 0; }
|
||||||
|
|
||||||
#else /* !defined (HAVE_CUDA) */
|
#else /* !defined (HAVE_CUDA) */
|
||||||
|
|
||||||
cv::cuda::FAST_GPU::FAST_GPU(int _threshold, bool _nonmaxSupression, double _keypointsRatio) :
|
cv::cuda::FAST_CUDA::FAST_CUDA(int _threshold, bool _nonmaxSupression, double _keypointsRatio) :
|
||||||
nonmaxSupression(_nonmaxSupression), threshold(_threshold), keypointsRatio(_keypointsRatio), count_(0)
|
nonmaxSupression(_nonmaxSupression), threshold(_threshold), keypointsRatio(_keypointsRatio), count_(0)
|
||||||
{
|
{
|
||||||
}
|
}
|
||||||
|
|
||||||
void cv::cuda::FAST_GPU::operator ()(const GpuMat& image, const GpuMat& mask, std::vector<KeyPoint>& keypoints)
|
void cv::cuda::FAST_CUDA::operator ()(const GpuMat& image, const GpuMat& mask, std::vector<KeyPoint>& keypoints)
|
||||||
{
|
{
|
||||||
if (image.empty())
|
if (image.empty())
|
||||||
return;
|
return;
|
||||||
@ -72,7 +72,7 @@ void cv::cuda::FAST_GPU::operator ()(const GpuMat& image, const GpuMat& mask, st
|
|||||||
downloadKeypoints(d_keypoints_, keypoints);
|
downloadKeypoints(d_keypoints_, keypoints);
|
||||||
}
|
}
|
||||||
|
|
||||||
void cv::cuda::FAST_GPU::downloadKeypoints(const GpuMat& d_keypoints, std::vector<KeyPoint>& keypoints)
|
void cv::cuda::FAST_CUDA::downloadKeypoints(const GpuMat& d_keypoints, std::vector<KeyPoint>& keypoints)
|
||||||
{
|
{
|
||||||
if (d_keypoints.empty())
|
if (d_keypoints.empty())
|
||||||
return;
|
return;
|
||||||
@ -81,7 +81,7 @@ void cv::cuda::FAST_GPU::downloadKeypoints(const GpuMat& d_keypoints, std::vecto
|
|||||||
convertKeypoints(h_keypoints, keypoints);
|
convertKeypoints(h_keypoints, keypoints);
|
||||||
}
|
}
|
||||||
|
|
||||||
void cv::cuda::FAST_GPU::convertKeypoints(const Mat& h_keypoints, std::vector<KeyPoint>& keypoints)
|
void cv::cuda::FAST_CUDA::convertKeypoints(const Mat& h_keypoints, std::vector<KeyPoint>& keypoints)
|
||||||
{
|
{
|
||||||
if (h_keypoints.empty())
|
if (h_keypoints.empty())
|
||||||
return;
|
return;
|
||||||
@ -102,7 +102,7 @@ void cv::cuda::FAST_GPU::convertKeypoints(const Mat& h_keypoints, std::vector<Ke
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void cv::cuda::FAST_GPU::operator ()(const GpuMat& img, const GpuMat& mask, GpuMat& keypoints)
|
void cv::cuda::FAST_CUDA::operator ()(const GpuMat& img, const GpuMat& mask, GpuMat& keypoints)
|
||||||
{
|
{
|
||||||
calcKeyPointsLocation(img, mask);
|
calcKeyPointsLocation(img, mask);
|
||||||
keypoints.cols = getKeyPoints(keypoints);
|
keypoints.cols = getKeyPoints(keypoints);
|
||||||
@ -117,7 +117,7 @@ namespace cv { namespace cuda { namespace device
|
|||||||
}
|
}
|
||||||
}}}
|
}}}
|
||||||
|
|
||||||
int cv::cuda::FAST_GPU::calcKeyPointsLocation(const GpuMat& img, const GpuMat& mask)
|
int cv::cuda::FAST_CUDA::calcKeyPointsLocation(const GpuMat& img, const GpuMat& mask)
|
||||||
{
|
{
|
||||||
using namespace cv::cuda::device::fast;
|
using namespace cv::cuda::device::fast;
|
||||||
|
|
||||||
@ -140,7 +140,7 @@ int cv::cuda::FAST_GPU::calcKeyPointsLocation(const GpuMat& img, const GpuMat& m
|
|||||||
return count_;
|
return count_;
|
||||||
}
|
}
|
||||||
|
|
||||||
int cv::cuda::FAST_GPU::getKeyPoints(GpuMat& keypoints)
|
int cv::cuda::FAST_CUDA::getKeyPoints(GpuMat& keypoints)
|
||||||
{
|
{
|
||||||
using namespace cv::cuda::device::fast;
|
using namespace cv::cuda::device::fast;
|
||||||
|
|
||||||
@ -159,7 +159,7 @@ int cv::cuda::FAST_GPU::getKeyPoints(GpuMat& keypoints)
|
|||||||
return count_;
|
return count_;
|
||||||
}
|
}
|
||||||
|
|
||||||
void cv::cuda::FAST_GPU::release()
|
void cv::cuda::FAST_CUDA::release()
|
||||||
{
|
{
|
||||||
kpLoc_.release();
|
kpLoc_.release();
|
||||||
score_.release();
|
score_.release();
|
||||||
|
|||||||
@ -47,18 +47,18 @@ using namespace cv::cuda;
|
|||||||
|
|
||||||
#if !defined (HAVE_CUDA) || defined (CUDA_DISABLER)
|
#if !defined (HAVE_CUDA) || defined (CUDA_DISABLER)
|
||||||
|
|
||||||
cv::cuda::ORB_GPU::ORB_GPU(int, float, int, int, int, int, int, int) : fastDetector_(20) { throw_no_cuda(); }
|
cv::cuda::ORB_CUDA::ORB_CUDA(int, float, int, int, int, int, int, int) : fastDetector_(20) { throw_no_cuda(); }
|
||||||
void cv::cuda::ORB_GPU::operator()(const GpuMat&, const GpuMat&, std::vector<KeyPoint>&) { throw_no_cuda(); }
|
void cv::cuda::ORB_CUDA::operator()(const GpuMat&, const GpuMat&, std::vector<KeyPoint>&) { throw_no_cuda(); }
|
||||||
void cv::cuda::ORB_GPU::operator()(const GpuMat&, const GpuMat&, GpuMat&) { throw_no_cuda(); }
|
void cv::cuda::ORB_CUDA::operator()(const GpuMat&, const GpuMat&, GpuMat&) { throw_no_cuda(); }
|
||||||
void cv::cuda::ORB_GPU::operator()(const GpuMat&, const GpuMat&, std::vector<KeyPoint>&, GpuMat&) { throw_no_cuda(); }
|
void cv::cuda::ORB_CUDA::operator()(const GpuMat&, const GpuMat&, std::vector<KeyPoint>&, GpuMat&) { throw_no_cuda(); }
|
||||||
void cv::cuda::ORB_GPU::operator()(const GpuMat&, const GpuMat&, GpuMat&, GpuMat&) { throw_no_cuda(); }
|
void cv::cuda::ORB_CUDA::operator()(const GpuMat&, const GpuMat&, GpuMat&, GpuMat&) { throw_no_cuda(); }
|
||||||
void cv::cuda::ORB_GPU::downloadKeyPoints(const GpuMat&, std::vector<KeyPoint>&) { throw_no_cuda(); }
|
void cv::cuda::ORB_CUDA::downloadKeyPoints(const GpuMat&, std::vector<KeyPoint>&) { throw_no_cuda(); }
|
||||||
void cv::cuda::ORB_GPU::convertKeyPoints(const Mat&, std::vector<KeyPoint>&) { throw_no_cuda(); }
|
void cv::cuda::ORB_CUDA::convertKeyPoints(const Mat&, std::vector<KeyPoint>&) { throw_no_cuda(); }
|
||||||
void cv::cuda::ORB_GPU::release() { throw_no_cuda(); }
|
void cv::cuda::ORB_CUDA::release() { throw_no_cuda(); }
|
||||||
void cv::cuda::ORB_GPU::buildScalePyramids(const GpuMat&, const GpuMat&) { throw_no_cuda(); }
|
void cv::cuda::ORB_CUDA::buildScalePyramids(const GpuMat&, const GpuMat&) { throw_no_cuda(); }
|
||||||
void cv::cuda::ORB_GPU::computeKeyPointsPyramid() { throw_no_cuda(); }
|
void cv::cuda::ORB_CUDA::computeKeyPointsPyramid() { throw_no_cuda(); }
|
||||||
void cv::cuda::ORB_GPU::computeDescriptors(GpuMat&) { throw_no_cuda(); }
|
void cv::cuda::ORB_CUDA::computeDescriptors(GpuMat&) { throw_no_cuda(); }
|
||||||
void cv::cuda::ORB_GPU::mergeKeyPoints(GpuMat&) { throw_no_cuda(); }
|
void cv::cuda::ORB_CUDA::mergeKeyPoints(GpuMat&) { throw_no_cuda(); }
|
||||||
|
|
||||||
#else /* !defined (HAVE_CUDA) */
|
#else /* !defined (HAVE_CUDA) */
|
||||||
|
|
||||||
@ -395,7 +395,7 @@ namespace
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
cv::cuda::ORB_GPU::ORB_GPU(int nFeatures, float scaleFactor, int nLevels, int edgeThreshold, int firstLevel, int WTA_K, int scoreType, int patchSize) :
|
cv::cuda::ORB_CUDA::ORB_CUDA(int nFeatures, float scaleFactor, int nLevels, int edgeThreshold, int firstLevel, int WTA_K, int scoreType, int patchSize) :
|
||||||
nFeatures_(nFeatures), scaleFactor_(scaleFactor), nLevels_(nLevels), edgeThreshold_(edgeThreshold), firstLevel_(firstLevel), WTA_K_(WTA_K),
|
nFeatures_(nFeatures), scaleFactor_(scaleFactor), nLevels_(nLevels), edgeThreshold_(edgeThreshold), firstLevel_(firstLevel), WTA_K_(WTA_K),
|
||||||
scoreType_(scoreType), patchSize_(patchSize),
|
scoreType_(scoreType), patchSize_(patchSize),
|
||||||
fastDetector_(DEFAULT_FAST_THRESHOLD)
|
fastDetector_(DEFAULT_FAST_THRESHOLD)
|
||||||
@ -481,7 +481,7 @@ namespace
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void cv::cuda::ORB_GPU::buildScalePyramids(const GpuMat& image, const GpuMat& mask)
|
void cv::cuda::ORB_CUDA::buildScalePyramids(const GpuMat& image, const GpuMat& mask)
|
||||||
{
|
{
|
||||||
CV_Assert(image.type() == CV_8UC1);
|
CV_Assert(image.type() == CV_8UC1);
|
||||||
CV_Assert(mask.empty() || (mask.type() == CV_8UC1 && mask.size() == image.size()));
|
CV_Assert(mask.empty() || (mask.type() == CV_8UC1 && mask.size() == image.size()));
|
||||||
@ -554,12 +554,12 @@ namespace
|
|||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
count = cull_gpu(keypoints.ptr<int>(FAST_GPU::LOCATION_ROW), keypoints.ptr<float>(FAST_GPU::RESPONSE_ROW), count, n_points);
|
count = cull_gpu(keypoints.ptr<int>(FAST_CUDA::LOCATION_ROW), keypoints.ptr<float>(FAST_CUDA::RESPONSE_ROW), count, n_points);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void cv::cuda::ORB_GPU::computeKeyPointsPyramid()
|
void cv::cuda::ORB_CUDA::computeKeyPointsPyramid()
|
||||||
{
|
{
|
||||||
using namespace cv::cuda::device::orb;
|
using namespace cv::cuda::device::orb;
|
||||||
|
|
||||||
@ -602,7 +602,7 @@ void cv::cuda::ORB_GPU::computeKeyPointsPyramid()
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void cv::cuda::ORB_GPU::computeDescriptors(GpuMat& descriptors)
|
void cv::cuda::ORB_CUDA::computeDescriptors(GpuMat& descriptors)
|
||||||
{
|
{
|
||||||
using namespace cv::cuda::device::orb;
|
using namespace cv::cuda::device::orb;
|
||||||
|
|
||||||
@ -642,7 +642,7 @@ void cv::cuda::ORB_GPU::computeDescriptors(GpuMat& descriptors)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void cv::cuda::ORB_GPU::mergeKeyPoints(GpuMat& keypoints)
|
void cv::cuda::ORB_CUDA::mergeKeyPoints(GpuMat& keypoints)
|
||||||
{
|
{
|
||||||
using namespace cv::cuda::device::orb;
|
using namespace cv::cuda::device::orb;
|
||||||
|
|
||||||
@ -684,7 +684,7 @@ void cv::cuda::ORB_GPU::mergeKeyPoints(GpuMat& keypoints)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void cv::cuda::ORB_GPU::downloadKeyPoints(const GpuMat &d_keypoints, std::vector<KeyPoint>& keypoints)
|
void cv::cuda::ORB_CUDA::downloadKeyPoints(const GpuMat &d_keypoints, std::vector<KeyPoint>& keypoints)
|
||||||
{
|
{
|
||||||
if (d_keypoints.empty())
|
if (d_keypoints.empty())
|
||||||
{
|
{
|
||||||
@ -697,7 +697,7 @@ void cv::cuda::ORB_GPU::downloadKeyPoints(const GpuMat &d_keypoints, std::vector
|
|||||||
convertKeyPoints(h_keypoints, keypoints);
|
convertKeyPoints(h_keypoints, keypoints);
|
||||||
}
|
}
|
||||||
|
|
||||||
void cv::cuda::ORB_GPU::convertKeyPoints(const Mat &d_keypoints, std::vector<KeyPoint>& keypoints)
|
void cv::cuda::ORB_CUDA::convertKeyPoints(const Mat &d_keypoints, std::vector<KeyPoint>& keypoints)
|
||||||
{
|
{
|
||||||
if (d_keypoints.empty())
|
if (d_keypoints.empty())
|
||||||
{
|
{
|
||||||
@ -731,14 +731,14 @@ void cv::cuda::ORB_GPU::convertKeyPoints(const Mat &d_keypoints, std::vector<Key
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void cv::cuda::ORB_GPU::operator()(const GpuMat& image, const GpuMat& mask, GpuMat& keypoints)
|
void cv::cuda::ORB_CUDA::operator()(const GpuMat& image, const GpuMat& mask, GpuMat& keypoints)
|
||||||
{
|
{
|
||||||
buildScalePyramids(image, mask);
|
buildScalePyramids(image, mask);
|
||||||
computeKeyPointsPyramid();
|
computeKeyPointsPyramid();
|
||||||
mergeKeyPoints(keypoints);
|
mergeKeyPoints(keypoints);
|
||||||
}
|
}
|
||||||
|
|
||||||
void cv::cuda::ORB_GPU::operator()(const GpuMat& image, const GpuMat& mask, GpuMat& keypoints, GpuMat& descriptors)
|
void cv::cuda::ORB_CUDA::operator()(const GpuMat& image, const GpuMat& mask, GpuMat& keypoints, GpuMat& descriptors)
|
||||||
{
|
{
|
||||||
buildScalePyramids(image, mask);
|
buildScalePyramids(image, mask);
|
||||||
computeKeyPointsPyramid();
|
computeKeyPointsPyramid();
|
||||||
@ -746,19 +746,19 @@ void cv::cuda::ORB_GPU::operator()(const GpuMat& image, const GpuMat& mask, GpuM
|
|||||||
mergeKeyPoints(keypoints);
|
mergeKeyPoints(keypoints);
|
||||||
}
|
}
|
||||||
|
|
||||||
void cv::cuda::ORB_GPU::operator()(const GpuMat& image, const GpuMat& mask, std::vector<KeyPoint>& keypoints)
|
void cv::cuda::ORB_CUDA::operator()(const GpuMat& image, const GpuMat& mask, std::vector<KeyPoint>& keypoints)
|
||||||
{
|
{
|
||||||
(*this)(image, mask, d_keypoints_);
|
(*this)(image, mask, d_keypoints_);
|
||||||
downloadKeyPoints(d_keypoints_, keypoints);
|
downloadKeyPoints(d_keypoints_, keypoints);
|
||||||
}
|
}
|
||||||
|
|
||||||
void cv::cuda::ORB_GPU::operator()(const GpuMat& image, const GpuMat& mask, std::vector<KeyPoint>& keypoints, GpuMat& descriptors)
|
void cv::cuda::ORB_CUDA::operator()(const GpuMat& image, const GpuMat& mask, std::vector<KeyPoint>& keypoints, GpuMat& descriptors)
|
||||||
{
|
{
|
||||||
(*this)(image, mask, d_keypoints_, descriptors);
|
(*this)(image, mask, d_keypoints_, descriptors);
|
||||||
downloadKeyPoints(d_keypoints_, keypoints);
|
downloadKeyPoints(d_keypoints_, keypoints);
|
||||||
}
|
}
|
||||||
|
|
||||||
void cv::cuda::ORB_GPU::release()
|
void cv::cuda::ORB_CUDA::release()
|
||||||
{
|
{
|
||||||
imagePyr_.clear();
|
imagePyr_.clear();
|
||||||
maskPyr_.clear();
|
maskPyr_.clear();
|
||||||
|
|||||||
@ -71,12 +71,12 @@ PARAM_TEST_CASE(FAST, cv::cuda::DeviceInfo, FAST_Threshold, FAST_NonmaxSupressio
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(FAST, Accuracy)
|
CUDA_TEST_P(FAST, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
|
cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
|
||||||
ASSERT_FALSE(image.empty());
|
ASSERT_FALSE(image.empty());
|
||||||
|
|
||||||
cv::cuda::FAST_GPU fast(threshold);
|
cv::cuda::FAST_CUDA fast(threshold);
|
||||||
fast.nonmaxSupression = nonmaxSupression;
|
fast.nonmaxSupression = nonmaxSupression;
|
||||||
|
|
||||||
if (!supportFeature(devInfo, cv::cuda::GLOBAL_ATOMICS))
|
if (!supportFeature(devInfo, cv::cuda::GLOBAL_ATOMICS))
|
||||||
@ -103,7 +103,7 @@ GPU_TEST_P(FAST, Accuracy)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Features2D, FAST, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Features2D, FAST, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
testing::Values(FAST_Threshold(25), FAST_Threshold(50)),
|
testing::Values(FAST_Threshold(25), FAST_Threshold(50)),
|
||||||
testing::Values(FAST_NonmaxSupression(false), FAST_NonmaxSupression(true))));
|
testing::Values(FAST_NonmaxSupression(false), FAST_NonmaxSupression(true))));
|
||||||
@ -155,7 +155,7 @@ PARAM_TEST_CASE(ORB, cv::cuda::DeviceInfo, ORB_FeaturesCount, ORB_ScaleFactor, O
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(ORB, Accuracy)
|
CUDA_TEST_P(ORB, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
|
cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
|
||||||
ASSERT_FALSE(image.empty());
|
ASSERT_FALSE(image.empty());
|
||||||
@ -163,7 +163,7 @@ GPU_TEST_P(ORB, Accuracy)
|
|||||||
cv::Mat mask(image.size(), CV_8UC1, cv::Scalar::all(1));
|
cv::Mat mask(image.size(), CV_8UC1, cv::Scalar::all(1));
|
||||||
mask(cv::Range(0, image.rows / 2), cv::Range(0, image.cols / 2)).setTo(cv::Scalar::all(0));
|
mask(cv::Range(0, image.rows / 2), cv::Range(0, image.cols / 2)).setTo(cv::Scalar::all(0));
|
||||||
|
|
||||||
cv::cuda::ORB_GPU orb(nFeatures, scaleFactor, nLevels, edgeThreshold, firstLevel, WTA_K, scoreType, patchSize);
|
cv::cuda::ORB_CUDA orb(nFeatures, scaleFactor, nLevels, edgeThreshold, firstLevel, WTA_K, scoreType, patchSize);
|
||||||
orb.blurForDescriptor = blurForDescriptor;
|
orb.blurForDescriptor = blurForDescriptor;
|
||||||
|
|
||||||
if (!supportFeature(devInfo, cv::cuda::GLOBAL_ATOMICS))
|
if (!supportFeature(devInfo, cv::cuda::GLOBAL_ATOMICS))
|
||||||
@ -202,7 +202,7 @@ GPU_TEST_P(ORB, Accuracy)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Features2D, ORB, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Features2D, ORB, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
testing::Values(ORB_FeaturesCount(1000)),
|
testing::Values(ORB_FeaturesCount(1000)),
|
||||||
testing::Values(ORB_ScaleFactor(1.2f)),
|
testing::Values(ORB_ScaleFactor(1.2f)),
|
||||||
@ -283,9 +283,9 @@ PARAM_TEST_CASE(BruteForceMatcher, cv::cuda::DeviceInfo, NormCode, DescriptorSiz
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(BruteForceMatcher, Match_Single)
|
CUDA_TEST_P(BruteForceMatcher, Match_Single)
|
||||||
{
|
{
|
||||||
cv::cuda::BFMatcher_GPU matcher(normCode);
|
cv::cuda::BFMatcher_CUDA matcher(normCode);
|
||||||
|
|
||||||
cv::cuda::GpuMat mask;
|
cv::cuda::GpuMat mask;
|
||||||
if (useMask)
|
if (useMask)
|
||||||
@ -310,9 +310,9 @@ GPU_TEST_P(BruteForceMatcher, Match_Single)
|
|||||||
ASSERT_EQ(0, badCount);
|
ASSERT_EQ(0, badCount);
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(BruteForceMatcher, Match_Collection)
|
CUDA_TEST_P(BruteForceMatcher, Match_Collection)
|
||||||
{
|
{
|
||||||
cv::cuda::BFMatcher_GPU matcher(normCode);
|
cv::cuda::BFMatcher_CUDA matcher(normCode);
|
||||||
|
|
||||||
cv::cuda::GpuMat d_train(train);
|
cv::cuda::GpuMat d_train(train);
|
||||||
|
|
||||||
@ -364,9 +364,9 @@ GPU_TEST_P(BruteForceMatcher, Match_Collection)
|
|||||||
ASSERT_EQ(0, badCount);
|
ASSERT_EQ(0, badCount);
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(BruteForceMatcher, KnnMatch_2_Single)
|
CUDA_TEST_P(BruteForceMatcher, KnnMatch_2_Single)
|
||||||
{
|
{
|
||||||
cv::cuda::BFMatcher_GPU matcher(normCode);
|
cv::cuda::BFMatcher_CUDA matcher(normCode);
|
||||||
|
|
||||||
const int knn = 2;
|
const int knn = 2;
|
||||||
|
|
||||||
@ -403,9 +403,9 @@ GPU_TEST_P(BruteForceMatcher, KnnMatch_2_Single)
|
|||||||
ASSERT_EQ(0, badCount);
|
ASSERT_EQ(0, badCount);
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(BruteForceMatcher, KnnMatch_3_Single)
|
CUDA_TEST_P(BruteForceMatcher, KnnMatch_3_Single)
|
||||||
{
|
{
|
||||||
cv::cuda::BFMatcher_GPU matcher(normCode);
|
cv::cuda::BFMatcher_CUDA matcher(normCode);
|
||||||
|
|
||||||
const int knn = 3;
|
const int knn = 3;
|
||||||
|
|
||||||
@ -442,9 +442,9 @@ GPU_TEST_P(BruteForceMatcher, KnnMatch_3_Single)
|
|||||||
ASSERT_EQ(0, badCount);
|
ASSERT_EQ(0, badCount);
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(BruteForceMatcher, KnnMatch_2_Collection)
|
CUDA_TEST_P(BruteForceMatcher, KnnMatch_2_Collection)
|
||||||
{
|
{
|
||||||
cv::cuda::BFMatcher_GPU matcher(normCode);
|
cv::cuda::BFMatcher_CUDA matcher(normCode);
|
||||||
|
|
||||||
const int knn = 2;
|
const int knn = 2;
|
||||||
|
|
||||||
@ -504,9 +504,9 @@ GPU_TEST_P(BruteForceMatcher, KnnMatch_2_Collection)
|
|||||||
ASSERT_EQ(0, badCount);
|
ASSERT_EQ(0, badCount);
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(BruteForceMatcher, KnnMatch_3_Collection)
|
CUDA_TEST_P(BruteForceMatcher, KnnMatch_3_Collection)
|
||||||
{
|
{
|
||||||
cv::cuda::BFMatcher_GPU matcher(normCode);
|
cv::cuda::BFMatcher_CUDA matcher(normCode);
|
||||||
|
|
||||||
const int knn = 3;
|
const int knn = 3;
|
||||||
|
|
||||||
@ -566,9 +566,9 @@ GPU_TEST_P(BruteForceMatcher, KnnMatch_3_Collection)
|
|||||||
ASSERT_EQ(0, badCount);
|
ASSERT_EQ(0, badCount);
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(BruteForceMatcher, RadiusMatch_Single)
|
CUDA_TEST_P(BruteForceMatcher, RadiusMatch_Single)
|
||||||
{
|
{
|
||||||
cv::cuda::BFMatcher_GPU matcher(normCode);
|
cv::cuda::BFMatcher_CUDA matcher(normCode);
|
||||||
|
|
||||||
const float radius = 1.f / countFactor;
|
const float radius = 1.f / countFactor;
|
||||||
|
|
||||||
@ -615,9 +615,9 @@ GPU_TEST_P(BruteForceMatcher, RadiusMatch_Single)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
GPU_TEST_P(BruteForceMatcher, RadiusMatch_Collection)
|
CUDA_TEST_P(BruteForceMatcher, RadiusMatch_Collection)
|
||||||
{
|
{
|
||||||
cv::cuda::BFMatcher_GPU matcher(normCode);
|
cv::cuda::BFMatcher_CUDA matcher(normCode);
|
||||||
|
|
||||||
const int n = 3;
|
const int n = 3;
|
||||||
const float radius = 1.f / countFactor * n;
|
const float radius = 1.f / countFactor * n;
|
||||||
@ -694,7 +694,7 @@ GPU_TEST_P(BruteForceMatcher, RadiusMatch_Collection)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Features2D, BruteForceMatcher, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Features2D, BruteForceMatcher, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
testing::Values(NormCode(cv::NORM_L1), NormCode(cv::NORM_L2)),
|
testing::Values(NormCode(cv::NORM_L1), NormCode(cv::NORM_L2)),
|
||||||
testing::Values(DescriptorSize(57), DescriptorSize(64), DescriptorSize(83), DescriptorSize(128), DescriptorSize(179), DescriptorSize(256), DescriptorSize(304)),
|
testing::Values(DescriptorSize(57), DescriptorSize(64), DescriptorSize(83), DescriptorSize(128), DescriptorSize(179), DescriptorSize(256), DescriptorSize(304)),
|
||||||
|
|||||||
@ -42,4 +42,4 @@
|
|||||||
|
|
||||||
#include "test_precomp.hpp"
|
#include "test_precomp.hpp"
|
||||||
|
|
||||||
CV_GPU_TEST_MAIN("gpu")
|
CV_CUDA_TEST_MAIN("gpu")
|
||||||
|
|||||||
@ -52,7 +52,7 @@ using namespace perf;
|
|||||||
DEF_PARAM_TEST(Sz_Type_KernelSz, cv::Size, MatType, int);
|
DEF_PARAM_TEST(Sz_Type_KernelSz, cv::Size, MatType, int);
|
||||||
|
|
||||||
PERF_TEST_P(Sz_Type_KernelSz, Blur,
|
PERF_TEST_P(Sz_Type_KernelSz, Blur,
|
||||||
Combine(GPU_TYPICAL_MAT_SIZES,
|
Combine(CUDA_TYPICAL_MAT_SIZES,
|
||||||
Values(CV_8UC1, CV_8UC4),
|
Values(CV_8UC1, CV_8UC4),
|
||||||
Values(3, 5, 7)))
|
Values(3, 5, 7)))
|
||||||
{
|
{
|
||||||
@ -65,7 +65,7 @@ PERF_TEST_P(Sz_Type_KernelSz, Blur,
|
|||||||
cv::Mat src(size, type);
|
cv::Mat src(size, type);
|
||||||
declare.in(src, WARMUP_RNG);
|
declare.in(src, WARMUP_RNG);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_src(src);
|
const cv::cuda::GpuMat d_src(src);
|
||||||
cv::cuda::GpuMat dst;
|
cv::cuda::GpuMat dst;
|
||||||
@ -74,7 +74,7 @@ PERF_TEST_P(Sz_Type_KernelSz, Blur,
|
|||||||
|
|
||||||
TEST_CYCLE() blurFilter->apply(d_src, dst);
|
TEST_CYCLE() blurFilter->apply(d_src, dst);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst, 1);
|
CUDA_SANITY_CHECK(dst, 1);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
@ -89,7 +89,7 @@ PERF_TEST_P(Sz_Type_KernelSz, Blur,
|
|||||||
//////////////////////////////////////////////////////////////////////
|
//////////////////////////////////////////////////////////////////////
|
||||||
// Filter2D
|
// Filter2D
|
||||||
|
|
||||||
PERF_TEST_P(Sz_Type_KernelSz, Filter2D, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8UC4, CV_32FC1, CV_32FC4), Values(3, 5, 7, 9, 11, 13, 15)))
|
PERF_TEST_P(Sz_Type_KernelSz, Filter2D, Combine(CUDA_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8UC4, CV_32FC1, CV_32FC4), Values(3, 5, 7, 9, 11, 13, 15)))
|
||||||
{
|
{
|
||||||
declare.time(20.0);
|
declare.time(20.0);
|
||||||
|
|
||||||
@ -103,7 +103,7 @@ PERF_TEST_P(Sz_Type_KernelSz, Filter2D, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV
|
|||||||
cv::Mat kernel(ksize, ksize, CV_32FC1);
|
cv::Mat kernel(ksize, ksize, CV_32FC1);
|
||||||
declare.in(kernel, WARMUP_RNG);
|
declare.in(kernel, WARMUP_RNG);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_src(src);
|
const cv::cuda::GpuMat d_src(src);
|
||||||
cv::cuda::GpuMat dst;
|
cv::cuda::GpuMat dst;
|
||||||
@ -112,7 +112,7 @@ PERF_TEST_P(Sz_Type_KernelSz, Filter2D, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV
|
|||||||
|
|
||||||
TEST_CYCLE() filter2D->apply(d_src, dst);
|
TEST_CYCLE() filter2D->apply(d_src, dst);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst);
|
CUDA_SANITY_CHECK(dst);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
@ -127,7 +127,7 @@ PERF_TEST_P(Sz_Type_KernelSz, Filter2D, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV
|
|||||||
//////////////////////////////////////////////////////////////////////
|
//////////////////////////////////////////////////////////////////////
|
||||||
// Laplacian
|
// Laplacian
|
||||||
|
|
||||||
PERF_TEST_P(Sz_Type_KernelSz, Laplacian, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8UC4, CV_32FC1, CV_32FC4), Values(1, 3)))
|
PERF_TEST_P(Sz_Type_KernelSz, Laplacian, Combine(CUDA_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8UC4, CV_32FC1, CV_32FC4), Values(1, 3)))
|
||||||
{
|
{
|
||||||
declare.time(20.0);
|
declare.time(20.0);
|
||||||
|
|
||||||
@ -138,7 +138,7 @@ PERF_TEST_P(Sz_Type_KernelSz, Laplacian, Combine(GPU_TYPICAL_MAT_SIZES, Values(C
|
|||||||
cv::Mat src(size, type);
|
cv::Mat src(size, type);
|
||||||
declare.in(src, WARMUP_RNG);
|
declare.in(src, WARMUP_RNG);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_src(src);
|
const cv::cuda::GpuMat d_src(src);
|
||||||
cv::cuda::GpuMat dst;
|
cv::cuda::GpuMat dst;
|
||||||
@ -147,7 +147,7 @@ PERF_TEST_P(Sz_Type_KernelSz, Laplacian, Combine(GPU_TYPICAL_MAT_SIZES, Values(C
|
|||||||
|
|
||||||
TEST_CYCLE() laplacian->apply(d_src, dst);
|
TEST_CYCLE() laplacian->apply(d_src, dst);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst);
|
CUDA_SANITY_CHECK(dst);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
@ -162,7 +162,7 @@ PERF_TEST_P(Sz_Type_KernelSz, Laplacian, Combine(GPU_TYPICAL_MAT_SIZES, Values(C
|
|||||||
//////////////////////////////////////////////////////////////////////
|
//////////////////////////////////////////////////////////////////////
|
||||||
// Sobel
|
// Sobel
|
||||||
|
|
||||||
PERF_TEST_P(Sz_Type_KernelSz, Sobel, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8UC4, CV_32FC1), Values(3, 5, 7, 9, 11, 13, 15)))
|
PERF_TEST_P(Sz_Type_KernelSz, Sobel, Combine(CUDA_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8UC4, CV_32FC1), Values(3, 5, 7, 9, 11, 13, 15)))
|
||||||
{
|
{
|
||||||
declare.time(20.0);
|
declare.time(20.0);
|
||||||
|
|
||||||
@ -173,7 +173,7 @@ PERF_TEST_P(Sz_Type_KernelSz, Sobel, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U
|
|||||||
cv::Mat src(size, type);
|
cv::Mat src(size, type);
|
||||||
declare.in(src, WARMUP_RNG);
|
declare.in(src, WARMUP_RNG);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_src(src);
|
const cv::cuda::GpuMat d_src(src);
|
||||||
cv::cuda::GpuMat dst;
|
cv::cuda::GpuMat dst;
|
||||||
@ -182,7 +182,7 @@ PERF_TEST_P(Sz_Type_KernelSz, Sobel, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U
|
|||||||
|
|
||||||
TEST_CYCLE() sobel->apply(d_src, dst);
|
TEST_CYCLE() sobel->apply(d_src, dst);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst);
|
CUDA_SANITY_CHECK(dst);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
@ -197,7 +197,7 @@ PERF_TEST_P(Sz_Type_KernelSz, Sobel, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U
|
|||||||
//////////////////////////////////////////////////////////////////////
|
//////////////////////////////////////////////////////////////////////
|
||||||
// Scharr
|
// Scharr
|
||||||
|
|
||||||
PERF_TEST_P(Sz_Type, Scharr, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8UC4, CV_32FC1)))
|
PERF_TEST_P(Sz_Type, Scharr, Combine(CUDA_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8UC4, CV_32FC1)))
|
||||||
{
|
{
|
||||||
declare.time(20.0);
|
declare.time(20.0);
|
||||||
|
|
||||||
@ -207,7 +207,7 @@ PERF_TEST_P(Sz_Type, Scharr, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8
|
|||||||
cv::Mat src(size, type);
|
cv::Mat src(size, type);
|
||||||
declare.in(src, WARMUP_RNG);
|
declare.in(src, WARMUP_RNG);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_src(src);
|
const cv::cuda::GpuMat d_src(src);
|
||||||
cv::cuda::GpuMat dst;
|
cv::cuda::GpuMat dst;
|
||||||
@ -216,7 +216,7 @@ PERF_TEST_P(Sz_Type, Scharr, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8
|
|||||||
|
|
||||||
TEST_CYCLE() scharr->apply(d_src, dst);
|
TEST_CYCLE() scharr->apply(d_src, dst);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst);
|
CUDA_SANITY_CHECK(dst);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
@ -231,7 +231,7 @@ PERF_TEST_P(Sz_Type, Scharr, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8
|
|||||||
//////////////////////////////////////////////////////////////////////
|
//////////////////////////////////////////////////////////////////////
|
||||||
// GaussianBlur
|
// GaussianBlur
|
||||||
|
|
||||||
PERF_TEST_P(Sz_Type_KernelSz, GaussianBlur, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8UC4, CV_32FC1), Values(3, 5, 7, 9, 11, 13, 15)))
|
PERF_TEST_P(Sz_Type_KernelSz, GaussianBlur, Combine(CUDA_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8UC4, CV_32FC1), Values(3, 5, 7, 9, 11, 13, 15)))
|
||||||
{
|
{
|
||||||
declare.time(20.0);
|
declare.time(20.0);
|
||||||
|
|
||||||
@ -242,7 +242,7 @@ PERF_TEST_P(Sz_Type_KernelSz, GaussianBlur, Combine(GPU_TYPICAL_MAT_SIZES, Value
|
|||||||
cv::Mat src(size, type);
|
cv::Mat src(size, type);
|
||||||
declare.in(src, WARMUP_RNG);
|
declare.in(src, WARMUP_RNG);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_src(src);
|
const cv::cuda::GpuMat d_src(src);
|
||||||
cv::cuda::GpuMat dst;
|
cv::cuda::GpuMat dst;
|
||||||
@ -251,7 +251,7 @@ PERF_TEST_P(Sz_Type_KernelSz, GaussianBlur, Combine(GPU_TYPICAL_MAT_SIZES, Value
|
|||||||
|
|
||||||
TEST_CYCLE() gauss->apply(d_src, dst);
|
TEST_CYCLE() gauss->apply(d_src, dst);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst);
|
CUDA_SANITY_CHECK(dst);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
@ -266,7 +266,7 @@ PERF_TEST_P(Sz_Type_KernelSz, GaussianBlur, Combine(GPU_TYPICAL_MAT_SIZES, Value
|
|||||||
//////////////////////////////////////////////////////////////////////
|
//////////////////////////////////////////////////////////////////////
|
||||||
// Erode
|
// Erode
|
||||||
|
|
||||||
PERF_TEST_P(Sz_Type, Erode, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8UC4)))
|
PERF_TEST_P(Sz_Type, Erode, Combine(CUDA_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8UC4)))
|
||||||
{
|
{
|
||||||
declare.time(20.0);
|
declare.time(20.0);
|
||||||
|
|
||||||
@ -278,7 +278,7 @@ PERF_TEST_P(Sz_Type, Erode, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8U
|
|||||||
|
|
||||||
const cv::Mat ker = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3));
|
const cv::Mat ker = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3));
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_src(src);
|
const cv::cuda::GpuMat d_src(src);
|
||||||
cv::cuda::GpuMat dst;
|
cv::cuda::GpuMat dst;
|
||||||
@ -287,7 +287,7 @@ PERF_TEST_P(Sz_Type, Erode, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8U
|
|||||||
|
|
||||||
TEST_CYCLE() erode->apply(d_src, dst);
|
TEST_CYCLE() erode->apply(d_src, dst);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst);
|
CUDA_SANITY_CHECK(dst);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
@ -302,7 +302,7 @@ PERF_TEST_P(Sz_Type, Erode, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8U
|
|||||||
//////////////////////////////////////////////////////////////////////
|
//////////////////////////////////////////////////////////////////////
|
||||||
// Dilate
|
// Dilate
|
||||||
|
|
||||||
PERF_TEST_P(Sz_Type, Dilate, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8UC4)))
|
PERF_TEST_P(Sz_Type, Dilate, Combine(CUDA_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8UC4)))
|
||||||
{
|
{
|
||||||
declare.time(20.0);
|
declare.time(20.0);
|
||||||
|
|
||||||
@ -314,7 +314,7 @@ PERF_TEST_P(Sz_Type, Dilate, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8
|
|||||||
|
|
||||||
const cv::Mat ker = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3));
|
const cv::Mat ker = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3));
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_src(src);
|
const cv::cuda::GpuMat d_src(src);
|
||||||
cv::cuda::GpuMat dst;
|
cv::cuda::GpuMat dst;
|
||||||
@ -323,7 +323,7 @@ PERF_TEST_P(Sz_Type, Dilate, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8
|
|||||||
|
|
||||||
TEST_CYCLE() dilate->apply(d_src, dst);
|
TEST_CYCLE() dilate->apply(d_src, dst);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst);
|
CUDA_SANITY_CHECK(dst);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
@ -342,7 +342,7 @@ CV_ENUM(MorphOp, MORPH_OPEN, MORPH_CLOSE, MORPH_GRADIENT, MORPH_TOPHAT, MORPH_BL
|
|||||||
|
|
||||||
DEF_PARAM_TEST(Sz_Type_Op, cv::Size, MatType, MorphOp);
|
DEF_PARAM_TEST(Sz_Type_Op, cv::Size, MatType, MorphOp);
|
||||||
|
|
||||||
PERF_TEST_P(Sz_Type_Op, MorphologyEx, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8UC4), MorphOp::all()))
|
PERF_TEST_P(Sz_Type_Op, MorphologyEx, Combine(CUDA_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8UC4), MorphOp::all()))
|
||||||
{
|
{
|
||||||
declare.time(20.0);
|
declare.time(20.0);
|
||||||
|
|
||||||
@ -355,7 +355,7 @@ PERF_TEST_P(Sz_Type_Op, MorphologyEx, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8
|
|||||||
|
|
||||||
const cv::Mat ker = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3));
|
const cv::Mat ker = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3));
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_src(src);
|
const cv::cuda::GpuMat d_src(src);
|
||||||
cv::cuda::GpuMat dst;
|
cv::cuda::GpuMat dst;
|
||||||
@ -364,7 +364,7 @@ PERF_TEST_P(Sz_Type_Op, MorphologyEx, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8
|
|||||||
|
|
||||||
TEST_CYCLE() morph->apply(d_src, dst);
|
TEST_CYCLE() morph->apply(d_src, dst);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst);
|
CUDA_SANITY_CHECK(dst);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
|
|||||||
@ -94,7 +94,7 @@ PARAM_TEST_CASE(Blur, cv::cuda::DeviceInfo, cv::Size, MatType, KSize, Anchor, Bo
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Blur, Accuracy)
|
CUDA_TEST_P(Blur, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, type);
|
cv::Mat src = randomMat(size, type);
|
||||||
|
|
||||||
@ -109,7 +109,7 @@ GPU_TEST_P(Blur, Accuracy)
|
|||||||
EXPECT_MAT_NEAR(dst_gold, dst, 1.0);
|
EXPECT_MAT_NEAR(dst_gold, dst, 1.0);
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Filters, Blur, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Filters, Blur, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
testing::Values(MatType(CV_8UC1), MatType(CV_8UC4)),
|
testing::Values(MatType(CV_8UC1), MatType(CV_8UC4)),
|
||||||
@ -145,7 +145,7 @@ PARAM_TEST_CASE(Filter2D, cv::cuda::DeviceInfo, cv::Size, MatType, KSize, Anchor
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Filter2D, Accuracy)
|
CUDA_TEST_P(Filter2D, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, type);
|
cv::Mat src = randomMat(size, type);
|
||||||
cv::Mat kernel = randomMat(cv::Size(ksize.width, ksize.height), CV_32FC1, 0.0, 1.0);
|
cv::Mat kernel = randomMat(cv::Size(ksize.width, ksize.height), CV_32FC1, 0.0, 1.0);
|
||||||
@ -161,7 +161,7 @@ GPU_TEST_P(Filter2D, Accuracy)
|
|||||||
EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) == CV_32F ? 1e-1 : 1.0);
|
EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) == CV_32F ? 1e-1 : 1.0);
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Filters, Filter2D, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Filters, Filter2D, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
testing::Values(MatType(CV_8UC1), MatType(CV_8UC4), MatType(CV_16UC1), MatType(CV_16UC4), MatType(CV_32FC1), MatType(CV_32FC4)),
|
testing::Values(MatType(CV_8UC1), MatType(CV_8UC4), MatType(CV_16UC1), MatType(CV_16UC4), MatType(CV_32FC1), MatType(CV_32FC4)),
|
||||||
@ -193,7 +193,7 @@ PARAM_TEST_CASE(Laplacian, cv::cuda::DeviceInfo, cv::Size, MatType, KSize, UseRo
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Laplacian, Accuracy)
|
CUDA_TEST_P(Laplacian, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, type);
|
cv::Mat src = randomMat(size, type);
|
||||||
|
|
||||||
@ -208,7 +208,7 @@ GPU_TEST_P(Laplacian, Accuracy)
|
|||||||
EXPECT_MAT_NEAR(dst_gold, dst, src.depth() < CV_32F ? 0.0 : 1e-3);
|
EXPECT_MAT_NEAR(dst_gold, dst, src.depth() < CV_32F ? 0.0 : 1e-3);
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Filters, Laplacian, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Filters, Laplacian, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
testing::Values(MatType(CV_8UC1), MatType(CV_8UC4), MatType(CV_32FC1)),
|
testing::Values(MatType(CV_8UC1), MatType(CV_8UC4), MatType(CV_32FC1)),
|
||||||
@ -248,7 +248,7 @@ PARAM_TEST_CASE(SeparableLinearFilter, cv::cuda::DeviceInfo, cv::Size, MatDepth,
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(SeparableLinearFilter, Accuracy)
|
CUDA_TEST_P(SeparableLinearFilter, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, type);
|
cv::Mat src = randomMat(size, type);
|
||||||
cv::Mat rowKernel = randomMat(Size(ksize.width, 1), CV_32FC1, 0.0, 1.0);
|
cv::Mat rowKernel = randomMat(Size(ksize.width, 1), CV_32FC1, 0.0, 1.0);
|
||||||
@ -265,7 +265,7 @@ GPU_TEST_P(SeparableLinearFilter, Accuracy)
|
|||||||
EXPECT_MAT_NEAR(dst_gold, dst, src.depth() < CV_32F ? 1.0 : 1e-2);
|
EXPECT_MAT_NEAR(dst_gold, dst, src.depth() < CV_32F ? 1.0 : 1e-2);
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Filters, SeparableLinearFilter, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Filters, SeparableLinearFilter, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_16S), MatDepth(CV_32F)),
|
testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_16S), MatDepth(CV_32F)),
|
||||||
@ -319,7 +319,7 @@ PARAM_TEST_CASE(Sobel, cv::cuda::DeviceInfo, cv::Size, MatDepth, Channels, KSize
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Sobel, Accuracy)
|
CUDA_TEST_P(Sobel, Accuracy)
|
||||||
{
|
{
|
||||||
if (dx == 0 && dy == 0)
|
if (dx == 0 && dy == 0)
|
||||||
return;
|
return;
|
||||||
@ -337,7 +337,7 @@ GPU_TEST_P(Sobel, Accuracy)
|
|||||||
EXPECT_MAT_NEAR(dst_gold, dst, src.depth() < CV_32F ? 0.0 : 0.1);
|
EXPECT_MAT_NEAR(dst_gold, dst, src.depth() < CV_32F ? 0.0 : 0.1);
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Filters, Sobel, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Filters, Sobel, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_16S), MatDepth(CV_32F)),
|
testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_16S), MatDepth(CV_32F)),
|
||||||
@ -384,7 +384,7 @@ PARAM_TEST_CASE(Scharr, cv::cuda::DeviceInfo, cv::Size, MatDepth, Channels, Deri
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Scharr, Accuracy)
|
CUDA_TEST_P(Scharr, Accuracy)
|
||||||
{
|
{
|
||||||
if (dx + dy != 1)
|
if (dx + dy != 1)
|
||||||
return;
|
return;
|
||||||
@ -402,7 +402,7 @@ GPU_TEST_P(Scharr, Accuracy)
|
|||||||
EXPECT_MAT_NEAR(dst_gold, dst, src.depth() < CV_32F ? 0.0 : 0.1);
|
EXPECT_MAT_NEAR(dst_gold, dst, src.depth() < CV_32F ? 0.0 : 0.1);
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Filters, Scharr, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Filters, Scharr, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_16S), MatDepth(CV_32F)),
|
testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_16S), MatDepth(CV_32F)),
|
||||||
@ -446,7 +446,7 @@ PARAM_TEST_CASE(GaussianBlur, cv::cuda::DeviceInfo, cv::Size, MatDepth, Channels
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(GaussianBlur, Accuracy)
|
CUDA_TEST_P(GaussianBlur, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, type);
|
cv::Mat src = randomMat(size, type);
|
||||||
double sigma1 = randomDouble(0.1, 1.0);
|
double sigma1 = randomDouble(0.1, 1.0);
|
||||||
@ -463,7 +463,7 @@ GPU_TEST_P(GaussianBlur, Accuracy)
|
|||||||
EXPECT_MAT_NEAR(dst_gold, dst, src.depth() < CV_32F ? 4.0 : 1e-4);
|
EXPECT_MAT_NEAR(dst_gold, dst, src.depth() < CV_32F ? 4.0 : 1e-4);
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Filters, GaussianBlur, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Filters, GaussianBlur, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_16S), MatDepth(CV_32F)),
|
testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_16S), MatDepth(CV_32F)),
|
||||||
@ -514,7 +514,7 @@ PARAM_TEST_CASE(Erode, cv::cuda::DeviceInfo, cv::Size, MatType, Anchor, Iteratio
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Erode, Accuracy)
|
CUDA_TEST_P(Erode, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, type);
|
cv::Mat src = randomMat(size, type);
|
||||||
cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U);
|
cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U);
|
||||||
@ -532,7 +532,7 @@ GPU_TEST_P(Erode, Accuracy)
|
|||||||
EXPECT_MAT_NEAR(getInnerROI(dst_gold, ksize), getInnerROI(dst, ksize), 0.0);
|
EXPECT_MAT_NEAR(getInnerROI(dst_gold, ksize), getInnerROI(dst, ksize), 0.0);
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Filters, Erode, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Filters, Erode, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
testing::Values(MatType(CV_8UC1), MatType(CV_8UC4)),
|
testing::Values(MatType(CV_8UC1), MatType(CV_8UC4)),
|
||||||
@ -565,7 +565,7 @@ PARAM_TEST_CASE(Dilate, cv::cuda::DeviceInfo, cv::Size, MatType, Anchor, Iterati
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Dilate, Accuracy)
|
CUDA_TEST_P(Dilate, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, type);
|
cv::Mat src = randomMat(size, type);
|
||||||
cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U);
|
cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U);
|
||||||
@ -583,7 +583,7 @@ GPU_TEST_P(Dilate, Accuracy)
|
|||||||
EXPECT_MAT_NEAR(getInnerROI(dst_gold, ksize), getInnerROI(dst, ksize), 0.0);
|
EXPECT_MAT_NEAR(getInnerROI(dst_gold, ksize), getInnerROI(dst, ksize), 0.0);
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Filters, Dilate, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Filters, Dilate, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
testing::Values(MatType(CV_8UC1), MatType(CV_8UC4)),
|
testing::Values(MatType(CV_8UC1), MatType(CV_8UC4)),
|
||||||
@ -620,7 +620,7 @@ PARAM_TEST_CASE(MorphEx, cv::cuda::DeviceInfo, cv::Size, MatType, MorphOp, Ancho
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(MorphEx, Accuracy)
|
CUDA_TEST_P(MorphEx, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, type);
|
cv::Mat src = randomMat(size, type);
|
||||||
cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U);
|
cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U);
|
||||||
@ -638,7 +638,7 @@ GPU_TEST_P(MorphEx, Accuracy)
|
|||||||
EXPECT_MAT_NEAR(getInnerROI(dst_gold, border), getInnerROI(dst, border), 0.0);
|
EXPECT_MAT_NEAR(getInnerROI(dst_gold, border), getInnerROI(dst, border), 0.0);
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_Filters, MorphEx, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_Filters, MorphEx, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
testing::Values(MatType(CV_8UC1), MatType(CV_8UC4)),
|
testing::Values(MatType(CV_8UC1), MatType(CV_8UC4)),
|
||||||
|
|||||||
@ -42,4 +42,4 @@
|
|||||||
|
|
||||||
#include "test_precomp.hpp"
|
#include "test_precomp.hpp"
|
||||||
|
|
||||||
CV_GPU_TEST_MAIN("gpu")
|
CV_CUDA_TEST_MAIN("gpu")
|
||||||
|
|||||||
@ -52,9 +52,9 @@ using namespace perf;
|
|||||||
DEF_PARAM_TEST(Sz_Depth_Cn_KernelSz, cv::Size, MatDepth, MatCn, int);
|
DEF_PARAM_TEST(Sz_Depth_Cn_KernelSz, cv::Size, MatDepth, MatCn, int);
|
||||||
|
|
||||||
PERF_TEST_P(Sz_Depth_Cn_KernelSz, BilateralFilter,
|
PERF_TEST_P(Sz_Depth_Cn_KernelSz, BilateralFilter,
|
||||||
Combine(GPU_TYPICAL_MAT_SIZES,
|
Combine(CUDA_TYPICAL_MAT_SIZES,
|
||||||
Values(CV_8U, CV_32F),
|
Values(CV_8U, CV_32F),
|
||||||
GPU_CHANNELS_1_3,
|
CUDA_CHANNELS_1_3,
|
||||||
Values(3, 5, 9)))
|
Values(3, 5, 9)))
|
||||||
{
|
{
|
||||||
declare.time(60.0);
|
declare.time(60.0);
|
||||||
@ -73,14 +73,14 @@ PERF_TEST_P(Sz_Depth_Cn_KernelSz, BilateralFilter,
|
|||||||
cv::Mat src(size, type);
|
cv::Mat src(size, type);
|
||||||
declare.in(src, WARMUP_RNG);
|
declare.in(src, WARMUP_RNG);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_src(src);
|
const cv::cuda::GpuMat d_src(src);
|
||||||
cv::cuda::GpuMat dst;
|
cv::cuda::GpuMat dst;
|
||||||
|
|
||||||
TEST_CYCLE() cv::cuda::bilateralFilter(d_src, dst, kernel_size, sigma_color, sigma_spatial, borderMode);
|
TEST_CYCLE() cv::cuda::bilateralFilter(d_src, dst, kernel_size, sigma_color, sigma_spatial, borderMode);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst);
|
CUDA_SANITY_CHECK(dst);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
|
|||||||
@ -50,9 +50,9 @@ using namespace perf;
|
|||||||
// BlendLinear
|
// BlendLinear
|
||||||
|
|
||||||
PERF_TEST_P(Sz_Depth_Cn, BlendLinear,
|
PERF_TEST_P(Sz_Depth_Cn, BlendLinear,
|
||||||
Combine(GPU_TYPICAL_MAT_SIZES,
|
Combine(CUDA_TYPICAL_MAT_SIZES,
|
||||||
Values(CV_8U, CV_32F),
|
Values(CV_8U, CV_32F),
|
||||||
GPU_CHANNELS_1_3_4))
|
CUDA_CHANNELS_1_3_4))
|
||||||
{
|
{
|
||||||
const cv::Size size = GET_PARAM(0);
|
const cv::Size size = GET_PARAM(0);
|
||||||
const int depth = GET_PARAM(1);
|
const int depth = GET_PARAM(1);
|
||||||
@ -67,7 +67,7 @@ PERF_TEST_P(Sz_Depth_Cn, BlendLinear,
|
|||||||
const cv::Mat weights1(size, CV_32FC1, cv::Scalar::all(0.5));
|
const cv::Mat weights1(size, CV_32FC1, cv::Scalar::all(0.5));
|
||||||
const cv::Mat weights2(size, CV_32FC1, cv::Scalar::all(0.5));
|
const cv::Mat weights2(size, CV_32FC1, cv::Scalar::all(0.5));
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_img1(img1);
|
const cv::cuda::GpuMat d_img1(img1);
|
||||||
const cv::cuda::GpuMat d_img2(img2);
|
const cv::cuda::GpuMat d_img2(img2);
|
||||||
@ -77,7 +77,7 @@ PERF_TEST_P(Sz_Depth_Cn, BlendLinear,
|
|||||||
|
|
||||||
TEST_CYCLE() cv::cuda::blendLinear(d_img1, d_img2, d_weights1, d_weights2, dst);
|
TEST_CYCLE() cv::cuda::blendLinear(d_img1, d_img2, d_weights1, d_weights2, dst);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst);
|
CUDA_SANITY_CHECK(dst);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
|
|||||||
@ -66,7 +66,7 @@ PERF_TEST_P(Image_AppertureSz_L2gradient, Canny,
|
|||||||
const double low_thresh = 50.0;
|
const double low_thresh = 50.0;
|
||||||
const double high_thresh = 100.0;
|
const double high_thresh = 100.0;
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_image(image);
|
const cv::cuda::GpuMat d_image(image);
|
||||||
cv::cuda::GpuMat dst;
|
cv::cuda::GpuMat dst;
|
||||||
@ -75,7 +75,7 @@ PERF_TEST_P(Image_AppertureSz_L2gradient, Canny,
|
|||||||
|
|
||||||
TEST_CYCLE() canny->detect(d_image, dst);
|
TEST_CYCLE() canny->detect(d_image, dst);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst);
|
CUDA_SANITY_CHECK(dst);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
|
|||||||
@ -52,7 +52,7 @@ using namespace perf;
|
|||||||
DEF_PARAM_TEST(Sz_Depth_Code, cv::Size, MatDepth, CvtColorInfo);
|
DEF_PARAM_TEST(Sz_Depth_Code, cv::Size, MatDepth, CvtColorInfo);
|
||||||
|
|
||||||
PERF_TEST_P(Sz_Depth_Code, CvtColor,
|
PERF_TEST_P(Sz_Depth_Code, CvtColor,
|
||||||
Combine(GPU_TYPICAL_MAT_SIZES,
|
Combine(CUDA_TYPICAL_MAT_SIZES,
|
||||||
Values(CV_8U, CV_32F),
|
Values(CV_8U, CV_32F),
|
||||||
Values(CvtColorInfo(4, 4, cv::COLOR_RGBA2BGRA),
|
Values(CvtColorInfo(4, 4, cv::COLOR_RGBA2BGRA),
|
||||||
CvtColorInfo(4, 1, cv::COLOR_BGRA2GRAY),
|
CvtColorInfo(4, 1, cv::COLOR_BGRA2GRAY),
|
||||||
@ -83,14 +83,14 @@ PERF_TEST_P(Sz_Depth_Code, CvtColor,
|
|||||||
cv::Mat src(size, CV_MAKETYPE(depth, info.scn));
|
cv::Mat src(size, CV_MAKETYPE(depth, info.scn));
|
||||||
cv::randu(src, 0, depth == CV_8U ? 255.0 : 1.0);
|
cv::randu(src, 0, depth == CV_8U ? 255.0 : 1.0);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_src(src);
|
const cv::cuda::GpuMat d_src(src);
|
||||||
cv::cuda::GpuMat dst;
|
cv::cuda::GpuMat dst;
|
||||||
|
|
||||||
TEST_CYCLE() cv::cuda::cvtColor(d_src, dst, info.code, info.dcn);
|
TEST_CYCLE() cv::cuda::cvtColor(d_src, dst, info.code, info.dcn);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst, 1e-4);
|
CUDA_SANITY_CHECK(dst, 1e-4);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
@ -103,7 +103,7 @@ PERF_TEST_P(Sz_Depth_Code, CvtColor,
|
|||||||
}
|
}
|
||||||
|
|
||||||
PERF_TEST_P(Sz_Depth_Code, CvtColorBayer,
|
PERF_TEST_P(Sz_Depth_Code, CvtColorBayer,
|
||||||
Combine(GPU_TYPICAL_MAT_SIZES,
|
Combine(CUDA_TYPICAL_MAT_SIZES,
|
||||||
Values(CV_8U, CV_16U),
|
Values(CV_8U, CV_16U),
|
||||||
Values(CvtColorInfo(1, 3, cv::COLOR_BayerBG2BGR),
|
Values(CvtColorInfo(1, 3, cv::COLOR_BayerBG2BGR),
|
||||||
CvtColorInfo(1, 3, cv::COLOR_BayerGB2BGR),
|
CvtColorInfo(1, 3, cv::COLOR_BayerGB2BGR),
|
||||||
@ -122,14 +122,14 @@ PERF_TEST_P(Sz_Depth_Code, CvtColorBayer,
|
|||||||
cv::Mat src(size, CV_MAKETYPE(depth, info.scn));
|
cv::Mat src(size, CV_MAKETYPE(depth, info.scn));
|
||||||
declare.in(src, WARMUP_RNG);
|
declare.in(src, WARMUP_RNG);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_src(src);
|
const cv::cuda::GpuMat d_src(src);
|
||||||
cv::cuda::GpuMat dst;
|
cv::cuda::GpuMat dst;
|
||||||
|
|
||||||
TEST_CYCLE() cv::cuda::cvtColor(d_src, dst, info.code, info.dcn);
|
TEST_CYCLE() cv::cuda::cvtColor(d_src, dst, info.code, info.dcn);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst);
|
CUDA_SANITY_CHECK(dst);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
@ -153,7 +153,7 @@ CV_ENUM(DemosaicingCode,
|
|||||||
DEF_PARAM_TEST(Sz_Code, cv::Size, DemosaicingCode);
|
DEF_PARAM_TEST(Sz_Code, cv::Size, DemosaicingCode);
|
||||||
|
|
||||||
PERF_TEST_P(Sz_Code, Demosaicing,
|
PERF_TEST_P(Sz_Code, Demosaicing,
|
||||||
Combine(GPU_TYPICAL_MAT_SIZES,
|
Combine(CUDA_TYPICAL_MAT_SIZES,
|
||||||
DemosaicingCode::all()))
|
DemosaicingCode::all()))
|
||||||
{
|
{
|
||||||
const cv::Size size = GET_PARAM(0);
|
const cv::Size size = GET_PARAM(0);
|
||||||
@ -162,14 +162,14 @@ PERF_TEST_P(Sz_Code, Demosaicing,
|
|||||||
cv::Mat src(size, CV_8UC1);
|
cv::Mat src(size, CV_8UC1);
|
||||||
declare.in(src, WARMUP_RNG);
|
declare.in(src, WARMUP_RNG);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_src(src);
|
const cv::cuda::GpuMat d_src(src);
|
||||||
cv::cuda::GpuMat dst;
|
cv::cuda::GpuMat dst;
|
||||||
|
|
||||||
TEST_CYCLE() cv::cuda::demosaicing(d_src, dst, code);
|
TEST_CYCLE() cv::cuda::demosaicing(d_src, dst, code);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst);
|
CUDA_SANITY_CHECK(dst);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
@ -192,7 +192,7 @@ PERF_TEST_P(Sz_Code, Demosaicing,
|
|||||||
// SwapChannels
|
// SwapChannels
|
||||||
|
|
||||||
PERF_TEST_P(Sz, SwapChannels,
|
PERF_TEST_P(Sz, SwapChannels,
|
||||||
GPU_TYPICAL_MAT_SIZES)
|
CUDA_TYPICAL_MAT_SIZES)
|
||||||
{
|
{
|
||||||
const cv::Size size = GetParam();
|
const cv::Size size = GetParam();
|
||||||
|
|
||||||
@ -201,13 +201,13 @@ PERF_TEST_P(Sz, SwapChannels,
|
|||||||
|
|
||||||
const int dstOrder[] = {2, 1, 0, 3};
|
const int dstOrder[] = {2, 1, 0, 3};
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
cv::cuda::GpuMat dst(src);
|
cv::cuda::GpuMat dst(src);
|
||||||
|
|
||||||
TEST_CYCLE() cv::cuda::swapChannels(dst, dstOrder);
|
TEST_CYCLE() cv::cuda::swapChannels(dst, dstOrder);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst);
|
CUDA_SANITY_CHECK(dst);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
@ -223,7 +223,7 @@ CV_ENUM(AlphaOp, cv::cuda::ALPHA_OVER, cv::cuda::ALPHA_IN, cv::cuda::ALPHA_OUT,
|
|||||||
DEF_PARAM_TEST(Sz_Type_Op, cv::Size, MatType, AlphaOp);
|
DEF_PARAM_TEST(Sz_Type_Op, cv::Size, MatType, AlphaOp);
|
||||||
|
|
||||||
PERF_TEST_P(Sz_Type_Op, AlphaComp,
|
PERF_TEST_P(Sz_Type_Op, AlphaComp,
|
||||||
Combine(GPU_TYPICAL_MAT_SIZES,
|
Combine(CUDA_TYPICAL_MAT_SIZES,
|
||||||
Values(CV_8UC4, CV_16UC4, CV_32SC4, CV_32FC4),
|
Values(CV_8UC4, CV_16UC4, CV_32SC4, CV_32FC4),
|
||||||
AlphaOp::all()))
|
AlphaOp::all()))
|
||||||
{
|
{
|
||||||
@ -235,7 +235,7 @@ PERF_TEST_P(Sz_Type_Op, AlphaComp,
|
|||||||
cv::Mat img2(size, type);
|
cv::Mat img2(size, type);
|
||||||
declare.in(img1, img2, WARMUP_RNG);
|
declare.in(img1, img2, WARMUP_RNG);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_img1(img1);
|
const cv::cuda::GpuMat d_img1(img1);
|
||||||
const cv::cuda::GpuMat d_img2(img2);
|
const cv::cuda::GpuMat d_img2(img2);
|
||||||
@ -243,7 +243,7 @@ PERF_TEST_P(Sz_Type_Op, AlphaComp,
|
|||||||
|
|
||||||
TEST_CYCLE() cv::cuda::alphaComp(d_img1, d_img2, dst, alpha_op);
|
TEST_CYCLE() cv::cuda::alphaComp(d_img1, d_img2, dst, alpha_op);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst, 1e-3, ERROR_RELATIVE);
|
CUDA_SANITY_CHECK(dst, 1e-3, ERROR_RELATIVE);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
|
|||||||
@ -71,7 +71,7 @@ PERF_TEST_P(Image_Type_Border_BlockSz_ApertureSz, CornerHarris,
|
|||||||
|
|
||||||
const double k = 0.5;
|
const double k = 0.5;
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_img(img);
|
const cv::cuda::GpuMat d_img(img);
|
||||||
cv::cuda::GpuMat dst;
|
cv::cuda::GpuMat dst;
|
||||||
@ -80,7 +80,7 @@ PERF_TEST_P(Image_Type_Border_BlockSz_ApertureSz, CornerHarris,
|
|||||||
|
|
||||||
TEST_CYCLE() harris->compute(d_img, dst);
|
TEST_CYCLE() harris->compute(d_img, dst);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst, 1e-4);
|
CUDA_SANITY_CHECK(dst, 1e-4);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
@ -113,7 +113,7 @@ PERF_TEST_P(Image_Type_Border_BlockSz_ApertureSz, CornerMinEigenVal,
|
|||||||
|
|
||||||
img.convertTo(img, type, type == CV_32F ? 1.0 / 255.0 : 1.0);
|
img.convertTo(img, type, type == CV_32F ? 1.0 / 255.0 : 1.0);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_img(img);
|
const cv::cuda::GpuMat d_img(img);
|
||||||
cv::cuda::GpuMat dst;
|
cv::cuda::GpuMat dst;
|
||||||
@ -122,7 +122,7 @@ PERF_TEST_P(Image_Type_Border_BlockSz_ApertureSz, CornerMinEigenVal,
|
|||||||
|
|
||||||
TEST_CYCLE() minEigenVal->compute(d_img, dst);
|
TEST_CYCLE() minEigenVal->compute(d_img, dst);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst, 1e-4);
|
CUDA_SANITY_CHECK(dst, 1e-4);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
|
|||||||
@ -64,7 +64,7 @@ PERF_TEST_P(Image_MinDistance, GoodFeaturesToTrack,
|
|||||||
const int maxCorners = 8000;
|
const int maxCorners = 8000;
|
||||||
const double qualityLevel = 0.01;
|
const double qualityLevel = 0.01;
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
cv::Ptr<cv::cuda::CornersDetector> d_detector = cv::cuda::createGoodFeaturesToTrackDetector(image.type(), maxCorners, qualityLevel, minDistance);
|
cv::Ptr<cv::cuda::CornersDetector> d_detector = cv::cuda::createGoodFeaturesToTrackDetector(image.type(), maxCorners, qualityLevel, minDistance);
|
||||||
|
|
||||||
@ -73,7 +73,7 @@ PERF_TEST_P(Image_MinDistance, GoodFeaturesToTrack,
|
|||||||
|
|
||||||
TEST_CYCLE() d_detector->detect(d_image, pts);
|
TEST_CYCLE() d_detector->detect(d_image, pts);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(pts);
|
CUDA_SANITY_CHECK(pts);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
|
|||||||
@ -50,7 +50,7 @@ using namespace perf;
|
|||||||
// HistEvenC1
|
// HistEvenC1
|
||||||
|
|
||||||
PERF_TEST_P(Sz_Depth, HistEvenC1,
|
PERF_TEST_P(Sz_Depth, HistEvenC1,
|
||||||
Combine(GPU_TYPICAL_MAT_SIZES,
|
Combine(CUDA_TYPICAL_MAT_SIZES,
|
||||||
Values(CV_8U, CV_16U, CV_16S)))
|
Values(CV_8U, CV_16U, CV_16S)))
|
||||||
{
|
{
|
||||||
const cv::Size size = GET_PARAM(0);
|
const cv::Size size = GET_PARAM(0);
|
||||||
@ -59,7 +59,7 @@ PERF_TEST_P(Sz_Depth, HistEvenC1,
|
|||||||
cv::Mat src(size, depth);
|
cv::Mat src(size, depth);
|
||||||
declare.in(src, WARMUP_RNG);
|
declare.in(src, WARMUP_RNG);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_src(src);
|
const cv::cuda::GpuMat d_src(src);
|
||||||
cv::cuda::GpuMat dst;
|
cv::cuda::GpuMat dst;
|
||||||
@ -67,7 +67,7 @@ PERF_TEST_P(Sz_Depth, HistEvenC1,
|
|||||||
|
|
||||||
TEST_CYCLE() cv::cuda::histEven(d_src, dst, d_buf, 30, 0, 180);
|
TEST_CYCLE() cv::cuda::histEven(d_src, dst, d_buf, 30, 0, 180);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst);
|
CUDA_SANITY_CHECK(dst);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
@ -89,7 +89,7 @@ PERF_TEST_P(Sz_Depth, HistEvenC1,
|
|||||||
// HistEvenC4
|
// HistEvenC4
|
||||||
|
|
||||||
PERF_TEST_P(Sz_Depth, HistEvenC4,
|
PERF_TEST_P(Sz_Depth, HistEvenC4,
|
||||||
Combine(GPU_TYPICAL_MAT_SIZES,
|
Combine(CUDA_TYPICAL_MAT_SIZES,
|
||||||
Values(CV_8U, CV_16U, CV_16S)))
|
Values(CV_8U, CV_16U, CV_16S)))
|
||||||
{
|
{
|
||||||
const cv::Size size = GET_PARAM(0);
|
const cv::Size size = GET_PARAM(0);
|
||||||
@ -102,7 +102,7 @@ PERF_TEST_P(Sz_Depth, HistEvenC4,
|
|||||||
int lowerLevel[] = {0, 0, 0, 0};
|
int lowerLevel[] = {0, 0, 0, 0};
|
||||||
int upperLevel[] = {180, 180, 180, 180};
|
int upperLevel[] = {180, 180, 180, 180};
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_src(src);
|
const cv::cuda::GpuMat d_src(src);
|
||||||
cv::cuda::GpuMat d_hist[4];
|
cv::cuda::GpuMat d_hist[4];
|
||||||
@ -130,21 +130,21 @@ PERF_TEST_P(Sz_Depth, HistEvenC4,
|
|||||||
// CalcHist
|
// CalcHist
|
||||||
|
|
||||||
PERF_TEST_P(Sz, CalcHist,
|
PERF_TEST_P(Sz, CalcHist,
|
||||||
GPU_TYPICAL_MAT_SIZES)
|
CUDA_TYPICAL_MAT_SIZES)
|
||||||
{
|
{
|
||||||
const cv::Size size = GetParam();
|
const cv::Size size = GetParam();
|
||||||
|
|
||||||
cv::Mat src(size, CV_8UC1);
|
cv::Mat src(size, CV_8UC1);
|
||||||
declare.in(src, WARMUP_RNG);
|
declare.in(src, WARMUP_RNG);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_src(src);
|
const cv::cuda::GpuMat d_src(src);
|
||||||
cv::cuda::GpuMat dst;
|
cv::cuda::GpuMat dst;
|
||||||
|
|
||||||
TEST_CYCLE() cv::cuda::calcHist(d_src, dst);
|
TEST_CYCLE() cv::cuda::calcHist(d_src, dst);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst);
|
CUDA_SANITY_CHECK(dst);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
@ -156,14 +156,14 @@ PERF_TEST_P(Sz, CalcHist,
|
|||||||
// EqualizeHist
|
// EqualizeHist
|
||||||
|
|
||||||
PERF_TEST_P(Sz, EqualizeHist,
|
PERF_TEST_P(Sz, EqualizeHist,
|
||||||
GPU_TYPICAL_MAT_SIZES)
|
CUDA_TYPICAL_MAT_SIZES)
|
||||||
{
|
{
|
||||||
const cv::Size size = GetParam();
|
const cv::Size size = GetParam();
|
||||||
|
|
||||||
cv::Mat src(size, CV_8UC1);
|
cv::Mat src(size, CV_8UC1);
|
||||||
declare.in(src, WARMUP_RNG);
|
declare.in(src, WARMUP_RNG);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_src(src);
|
const cv::cuda::GpuMat d_src(src);
|
||||||
cv::cuda::GpuMat dst;
|
cv::cuda::GpuMat dst;
|
||||||
@ -171,7 +171,7 @@ PERF_TEST_P(Sz, EqualizeHist,
|
|||||||
|
|
||||||
TEST_CYCLE() cv::cuda::equalizeHist(d_src, dst, d_buf);
|
TEST_CYCLE() cv::cuda::equalizeHist(d_src, dst, d_buf);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst);
|
CUDA_SANITY_CHECK(dst);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
@ -189,7 +189,7 @@ PERF_TEST_P(Sz, EqualizeHist,
|
|||||||
DEF_PARAM_TEST(Sz_ClipLimit, cv::Size, double);
|
DEF_PARAM_TEST(Sz_ClipLimit, cv::Size, double);
|
||||||
|
|
||||||
PERF_TEST_P(Sz_ClipLimit, CLAHE,
|
PERF_TEST_P(Sz_ClipLimit, CLAHE,
|
||||||
Combine(GPU_TYPICAL_MAT_SIZES,
|
Combine(CUDA_TYPICAL_MAT_SIZES,
|
||||||
Values(0.0, 40.0)))
|
Values(0.0, 40.0)))
|
||||||
{
|
{
|
||||||
const cv::Size size = GET_PARAM(0);
|
const cv::Size size = GET_PARAM(0);
|
||||||
@ -198,7 +198,7 @@ PERF_TEST_P(Sz_ClipLimit, CLAHE,
|
|||||||
cv::Mat src(size, CV_8UC1);
|
cv::Mat src(size, CV_8UC1);
|
||||||
declare.in(src, WARMUP_RNG);
|
declare.in(src, WARMUP_RNG);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
cv::Ptr<cv::cuda::CLAHE> clahe = cv::cuda::createCLAHE(clipLimit);
|
cv::Ptr<cv::cuda::CLAHE> clahe = cv::cuda::createCLAHE(clipLimit);
|
||||||
cv::cuda::GpuMat d_src(src);
|
cv::cuda::GpuMat d_src(src);
|
||||||
@ -206,7 +206,7 @@ PERF_TEST_P(Sz_ClipLimit, CLAHE,
|
|||||||
|
|
||||||
TEST_CYCLE() clahe->apply(d_src, dst);
|
TEST_CYCLE() clahe->apply(d_src, dst);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst);
|
CUDA_SANITY_CHECK(dst);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
|
|||||||
@ -81,7 +81,7 @@ namespace
|
|||||||
}
|
}
|
||||||
|
|
||||||
PERF_TEST_P(Sz, HoughLines,
|
PERF_TEST_P(Sz, HoughLines,
|
||||||
GPU_TYPICAL_MAT_SIZES)
|
CUDA_TYPICAL_MAT_SIZES)
|
||||||
{
|
{
|
||||||
declare.time(30.0);
|
declare.time(30.0);
|
||||||
|
|
||||||
@ -99,7 +99,7 @@ PERF_TEST_P(Sz, HoughLines,
|
|||||||
cv::line(src, cv::Point(200, 0), cv::Point(200, src.rows), cv::Scalar::all(255), 1);
|
cv::line(src, cv::Point(200, 0), cv::Point(200, src.rows), cv::Scalar::all(255), 1);
|
||||||
cv::line(src, cv::Point(400, 0), cv::Point(400, src.rows), cv::Scalar::all(255), 1);
|
cv::line(src, cv::Point(400, 0), cv::Point(400, src.rows), cv::Scalar::all(255), 1);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_src(src);
|
const cv::cuda::GpuMat d_src(src);
|
||||||
cv::cuda::GpuMat d_lines;
|
cv::cuda::GpuMat d_lines;
|
||||||
@ -148,7 +148,7 @@ PERF_TEST_P(Image, HoughLinesP,
|
|||||||
cv::Mat mask;
|
cv::Mat mask;
|
||||||
cv::Canny(image, mask, 50, 100);
|
cv::Canny(image, mask, 50, 100);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_mask(mask);
|
const cv::cuda::GpuMat d_mask(mask);
|
||||||
cv::cuda::GpuMat d_lines;
|
cv::cuda::GpuMat d_lines;
|
||||||
@ -179,7 +179,7 @@ PERF_TEST_P(Image, HoughLinesP,
|
|||||||
DEF_PARAM_TEST(Sz_Dp_MinDist, cv::Size, float, float);
|
DEF_PARAM_TEST(Sz_Dp_MinDist, cv::Size, float, float);
|
||||||
|
|
||||||
PERF_TEST_P(Sz_Dp_MinDist, HoughCircles,
|
PERF_TEST_P(Sz_Dp_MinDist, HoughCircles,
|
||||||
Combine(GPU_TYPICAL_MAT_SIZES,
|
Combine(CUDA_TYPICAL_MAT_SIZES,
|
||||||
Values(1.0f, 2.0f, 4.0f),
|
Values(1.0f, 2.0f, 4.0f),
|
||||||
Values(1.0f)))
|
Values(1.0f)))
|
||||||
{
|
{
|
||||||
@ -199,7 +199,7 @@ PERF_TEST_P(Sz_Dp_MinDist, HoughCircles,
|
|||||||
cv::circle(src, cv::Point(200, 200), 25, cv::Scalar::all(255), -1);
|
cv::circle(src, cv::Point(200, 200), 25, cv::Scalar::all(255), -1);
|
||||||
cv::circle(src, cv::Point(200, 100), 25, cv::Scalar::all(255), -1);
|
cv::circle(src, cv::Point(200, 100), 25, cv::Scalar::all(255), -1);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_src(src);
|
const cv::cuda::GpuMat d_src(src);
|
||||||
cv::cuda::GpuMat d_circles;
|
cv::cuda::GpuMat d_circles;
|
||||||
@ -227,7 +227,7 @@ PERF_TEST_P(Sz_Dp_MinDist, HoughCircles,
|
|||||||
//////////////////////////////////////////////////////////////////////
|
//////////////////////////////////////////////////////////////////////
|
||||||
// GeneralizedHough
|
// GeneralizedHough
|
||||||
|
|
||||||
PERF_TEST_P(Sz, GeneralizedHoughBallard, GPU_TYPICAL_MAT_SIZES)
|
PERF_TEST_P(Sz, GeneralizedHoughBallard, CUDA_TYPICAL_MAT_SIZES)
|
||||||
{
|
{
|
||||||
declare.time(10);
|
declare.time(10);
|
||||||
|
|
||||||
@ -246,7 +246,7 @@ PERF_TEST_P(Sz, GeneralizedHoughBallard, GPU_TYPICAL_MAT_SIZES)
|
|||||||
cv::Sobel(image, dx, CV_32F, 1, 0);
|
cv::Sobel(image, dx, CV_32F, 1, 0);
|
||||||
cv::Sobel(image, dy, CV_32F, 0, 1);
|
cv::Sobel(image, dy, CV_32F, 0, 1);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
cv::Ptr<cv::GeneralizedHoughBallard> alg = cv::cuda::createGeneralizedHoughBallard();
|
cv::Ptr<cv::GeneralizedHoughBallard> alg = cv::cuda::createGeneralizedHoughBallard();
|
||||||
|
|
||||||
@ -259,7 +259,7 @@ PERF_TEST_P(Sz, GeneralizedHoughBallard, GPU_TYPICAL_MAT_SIZES)
|
|||||||
|
|
||||||
TEST_CYCLE() alg->detect(d_edges, d_dx, d_dy, positions);
|
TEST_CYCLE() alg->detect(d_edges, d_dx, d_dy, positions);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(positions);
|
CUDA_SANITY_CHECK(positions);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
@ -275,7 +275,7 @@ PERF_TEST_P(Sz, GeneralizedHoughBallard, GPU_TYPICAL_MAT_SIZES)
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
PERF_TEST_P(Sz, GeneralizedHoughGuil, GPU_TYPICAL_MAT_SIZES)
|
PERF_TEST_P(Sz, GeneralizedHoughGuil, CUDA_TYPICAL_MAT_SIZES)
|
||||||
{
|
{
|
||||||
declare.time(10);
|
declare.time(10);
|
||||||
|
|
||||||
@ -315,7 +315,7 @@ PERF_TEST_P(Sz, GeneralizedHoughGuil, GPU_TYPICAL_MAT_SIZES)
|
|||||||
cv::Sobel(image, dx, CV_32F, 1, 0);
|
cv::Sobel(image, dx, CV_32F, 1, 0);
|
||||||
cv::Sobel(image, dy, CV_32F, 0, 1);
|
cv::Sobel(image, dy, CV_32F, 0, 1);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
cv::Ptr<cv::GeneralizedHoughGuil> alg = cv::cuda::createGeneralizedHoughGuil();
|
cv::Ptr<cv::GeneralizedHoughGuil> alg = cv::cuda::createGeneralizedHoughGuil();
|
||||||
alg->setMaxAngle(90.0);
|
alg->setMaxAngle(90.0);
|
||||||
@ -330,7 +330,7 @@ PERF_TEST_P(Sz, GeneralizedHoughGuil, GPU_TYPICAL_MAT_SIZES)
|
|||||||
|
|
||||||
TEST_CYCLE() alg->detect(d_edges, d_dx, d_dy, positions);
|
TEST_CYCLE() alg->detect(d_edges, d_dx, d_dy, positions);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(positions);
|
CUDA_SANITY_CHECK(positions);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
|
|||||||
@ -54,9 +54,9 @@ CV_ENUM(TemplateMethod, TM_SQDIFF, TM_SQDIFF_NORMED, TM_CCORR, TM_CCORR_NORMED,
|
|||||||
DEF_PARAM_TEST(Sz_TemplateSz_Cn_Method, cv::Size, cv::Size, MatCn, TemplateMethod);
|
DEF_PARAM_TEST(Sz_TemplateSz_Cn_Method, cv::Size, cv::Size, MatCn, TemplateMethod);
|
||||||
|
|
||||||
PERF_TEST_P(Sz_TemplateSz_Cn_Method, MatchTemplate8U,
|
PERF_TEST_P(Sz_TemplateSz_Cn_Method, MatchTemplate8U,
|
||||||
Combine(GPU_TYPICAL_MAT_SIZES,
|
Combine(CUDA_TYPICAL_MAT_SIZES,
|
||||||
Values(cv::Size(5, 5), cv::Size(16, 16), cv::Size(30, 30)),
|
Values(cv::Size(5, 5), cv::Size(16, 16), cv::Size(30, 30)),
|
||||||
GPU_CHANNELS_1_3_4,
|
CUDA_CHANNELS_1_3_4,
|
||||||
TemplateMethod::all()))
|
TemplateMethod::all()))
|
||||||
{
|
{
|
||||||
declare.time(300.0);
|
declare.time(300.0);
|
||||||
@ -70,7 +70,7 @@ PERF_TEST_P(Sz_TemplateSz_Cn_Method, MatchTemplate8U,
|
|||||||
cv::Mat templ(templ_size, CV_MAKE_TYPE(CV_8U, cn));
|
cv::Mat templ(templ_size, CV_MAKE_TYPE(CV_8U, cn));
|
||||||
declare.in(image, templ, WARMUP_RNG);
|
declare.in(image, templ, WARMUP_RNG);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_image(image);
|
const cv::cuda::GpuMat d_image(image);
|
||||||
const cv::cuda::GpuMat d_templ(templ);
|
const cv::cuda::GpuMat d_templ(templ);
|
||||||
@ -80,7 +80,7 @@ PERF_TEST_P(Sz_TemplateSz_Cn_Method, MatchTemplate8U,
|
|||||||
|
|
||||||
TEST_CYCLE() alg->match(d_image, d_templ, dst);
|
TEST_CYCLE() alg->match(d_image, d_templ, dst);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst, 1e-5, ERROR_RELATIVE);
|
CUDA_SANITY_CHECK(dst, 1e-5, ERROR_RELATIVE);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
@ -96,9 +96,9 @@ PERF_TEST_P(Sz_TemplateSz_Cn_Method, MatchTemplate8U,
|
|||||||
// MatchTemplate32F
|
// MatchTemplate32F
|
||||||
|
|
||||||
PERF_TEST_P(Sz_TemplateSz_Cn_Method, MatchTemplate32F,
|
PERF_TEST_P(Sz_TemplateSz_Cn_Method, MatchTemplate32F,
|
||||||
Combine(GPU_TYPICAL_MAT_SIZES,
|
Combine(CUDA_TYPICAL_MAT_SIZES,
|
||||||
Values(cv::Size(5, 5), cv::Size(16, 16), cv::Size(30, 30)),
|
Values(cv::Size(5, 5), cv::Size(16, 16), cv::Size(30, 30)),
|
||||||
GPU_CHANNELS_1_3_4,
|
CUDA_CHANNELS_1_3_4,
|
||||||
Values(TemplateMethod(cv::TM_SQDIFF), TemplateMethod(cv::TM_CCORR))))
|
Values(TemplateMethod(cv::TM_SQDIFF), TemplateMethod(cv::TM_CCORR))))
|
||||||
{
|
{
|
||||||
declare.time(300.0);
|
declare.time(300.0);
|
||||||
@ -112,7 +112,7 @@ PERF_TEST_P(Sz_TemplateSz_Cn_Method, MatchTemplate32F,
|
|||||||
cv::Mat templ(templ_size, CV_MAKE_TYPE(CV_32F, cn));
|
cv::Mat templ(templ_size, CV_MAKE_TYPE(CV_32F, cn));
|
||||||
declare.in(image, templ, WARMUP_RNG);
|
declare.in(image, templ, WARMUP_RNG);
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_image(image);
|
const cv::cuda::GpuMat d_image(image);
|
||||||
const cv::cuda::GpuMat d_templ(templ);
|
const cv::cuda::GpuMat d_templ(templ);
|
||||||
@ -122,7 +122,7 @@ PERF_TEST_P(Sz_TemplateSz_Cn_Method, MatchTemplate32F,
|
|||||||
|
|
||||||
TEST_CYCLE() alg->match(d_image, d_templ, dst);
|
TEST_CYCLE() alg->match(d_image, d_templ, dst);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst, 1e-6, ERROR_RELATIVE);
|
CUDA_SANITY_CHECK(dst, 1e-6, ERROR_RELATIVE);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
|
|||||||
@ -65,14 +65,14 @@ PERF_TEST_P(Image, MeanShiftFiltering,
|
|||||||
const int sp = 50;
|
const int sp = 50;
|
||||||
const int sr = 50;
|
const int sr = 50;
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_src(rgba);
|
const cv::cuda::GpuMat d_src(rgba);
|
||||||
cv::cuda::GpuMat dst;
|
cv::cuda::GpuMat dst;
|
||||||
|
|
||||||
TEST_CYCLE() cv::cuda::meanShiftFiltering(d_src, dst, sp, sr);
|
TEST_CYCLE() cv::cuda::meanShiftFiltering(d_src, dst, sp, sr);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst);
|
CUDA_SANITY_CHECK(dst);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
@ -101,7 +101,7 @@ PERF_TEST_P(Image, MeanShiftProc,
|
|||||||
const int sp = 50;
|
const int sp = 50;
|
||||||
const int sr = 50;
|
const int sr = 50;
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_src(rgba);
|
const cv::cuda::GpuMat d_src(rgba);
|
||||||
cv::cuda::GpuMat dstr;
|
cv::cuda::GpuMat dstr;
|
||||||
@ -109,8 +109,8 @@ PERF_TEST_P(Image, MeanShiftProc,
|
|||||||
|
|
||||||
TEST_CYCLE() cv::cuda::meanShiftProc(d_src, dstr, dstsp, sp, sr);
|
TEST_CYCLE() cv::cuda::meanShiftProc(d_src, dstr, dstsp, sp, sr);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dstr);
|
CUDA_SANITY_CHECK(dstr);
|
||||||
GPU_SANITY_CHECK(dstsp);
|
CUDA_SANITY_CHECK(dstsp);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
@ -136,14 +136,14 @@ PERF_TEST_P(Image, MeanShiftSegmentation,
|
|||||||
const int sr = 10;
|
const int sr = 10;
|
||||||
const int minsize = 20;
|
const int minsize = 20;
|
||||||
|
|
||||||
if (PERF_RUN_GPU())
|
if (PERF_RUN_CUDA())
|
||||||
{
|
{
|
||||||
const cv::cuda::GpuMat d_src(rgba);
|
const cv::cuda::GpuMat d_src(rgba);
|
||||||
cv::Mat dst;
|
cv::Mat dst;
|
||||||
|
|
||||||
TEST_CYCLE() cv::cuda::meanShiftSegmentation(d_src, dst, sp, sr, minsize);
|
TEST_CYCLE() cv::cuda::meanShiftSegmentation(d_src, dst, sp, sr, minsize);
|
||||||
|
|
||||||
GPU_SANITY_CHECK(dst);
|
CUDA_SANITY_CHECK(dst);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
|
|||||||
@ -93,7 +93,7 @@ namespace
|
|||||||
|
|
||||||
void write(FileStorage& fs) const
|
void write(FileStorage& fs) const
|
||||||
{
|
{
|
||||||
fs << "name" << "Canny_GPU"
|
fs << "name" << "Canny_CUDA"
|
||||||
<< "low_thresh" << low_thresh_
|
<< "low_thresh" << low_thresh_
|
||||||
<< "high_thresh" << high_thresh_
|
<< "high_thresh" << high_thresh_
|
||||||
<< "apperture_size" << apperture_size_
|
<< "apperture_size" << apperture_size_
|
||||||
@ -102,7 +102,7 @@ namespace
|
|||||||
|
|
||||||
void read(const FileNode& fn)
|
void read(const FileNode& fn)
|
||||||
{
|
{
|
||||||
CV_Assert( String(fn["name"]) == "Canny_GPU" );
|
CV_Assert( String(fn["name"]) == "Canny_CUDA" );
|
||||||
low_thresh_ = (double)fn["low_thresh"];
|
low_thresh_ = (double)fn["low_thresh"];
|
||||||
high_thresh_ = (double)fn["high_thresh"];
|
high_thresh_ = (double)fn["high_thresh"];
|
||||||
apperture_size_ = (int)fn["apperture_size"];
|
apperture_size_ = (int)fn["apperture_size"];
|
||||||
|
|||||||
@ -49,181 +49,181 @@
|
|||||||
|
|
||||||
namespace cv { namespace cuda { namespace device
|
namespace cv { namespace cuda { namespace device
|
||||||
{
|
{
|
||||||
OPENCV_GPU_TRANSFORM_FUNCTOR_TRAITS(bgra_to_rgba_traits<uchar>::functor_type)
|
OPENCV_CUDA_TRANSFORM_FUNCTOR_TRAITS(bgra_to_rgba_traits<uchar>::functor_type)
|
||||||
{
|
{
|
||||||
enum { smart_block_dim_x = 8 };
|
enum { smart_block_dim_x = 8 };
|
||||||
enum { smart_block_dim_y = 8 };
|
enum { smart_block_dim_y = 8 };
|
||||||
enum { smart_shift = 4 };
|
enum { smart_shift = 4 };
|
||||||
};
|
};
|
||||||
|
|
||||||
OPENCV_GPU_TRANSFORM_FUNCTOR_TRAITS(bgra_to_bgr555_traits::functor_type)
|
OPENCV_CUDA_TRANSFORM_FUNCTOR_TRAITS(bgra_to_bgr555_traits::functor_type)
|
||||||
{
|
{
|
||||||
enum { smart_block_dim_y = 8 };
|
enum { smart_block_dim_y = 8 };
|
||||||
enum { smart_shift = 4 };
|
enum { smart_shift = 4 };
|
||||||
};
|
};
|
||||||
OPENCV_GPU_TRANSFORM_FUNCTOR_TRAITS(rgba_to_bgr555_traits::functor_type)
|
OPENCV_CUDA_TRANSFORM_FUNCTOR_TRAITS(rgba_to_bgr555_traits::functor_type)
|
||||||
{
|
{
|
||||||
enum { smart_block_dim_y = 8 };
|
enum { smart_block_dim_y = 8 };
|
||||||
enum { smart_shift = 4 };
|
enum { smart_shift = 4 };
|
||||||
};
|
};
|
||||||
OPENCV_GPU_TRANSFORM_FUNCTOR_TRAITS(bgra_to_bgr565_traits::functor_type)
|
OPENCV_CUDA_TRANSFORM_FUNCTOR_TRAITS(bgra_to_bgr565_traits::functor_type)
|
||||||
{
|
{
|
||||||
enum { smart_block_dim_y = 8 };
|
enum { smart_block_dim_y = 8 };
|
||||||
enum { smart_shift = 4 };
|
enum { smart_shift = 4 };
|
||||||
};
|
};
|
||||||
OPENCV_GPU_TRANSFORM_FUNCTOR_TRAITS(rgba_to_bgr565_traits::functor_type)
|
OPENCV_CUDA_TRANSFORM_FUNCTOR_TRAITS(rgba_to_bgr565_traits::functor_type)
|
||||||
{
|
{
|
||||||
enum { smart_block_dim_y = 8 };
|
enum { smart_block_dim_y = 8 };
|
||||||
enum { smart_shift = 4 };
|
enum { smart_shift = 4 };
|
||||||
};
|
};
|
||||||
|
|
||||||
OPENCV_GPU_TRANSFORM_FUNCTOR_TRAITS(bgr555_to_bgra_traits::functor_type)
|
OPENCV_CUDA_TRANSFORM_FUNCTOR_TRAITS(bgr555_to_bgra_traits::functor_type)
|
||||||
{
|
{
|
||||||
enum { smart_block_dim_y = 8 };
|
enum { smart_block_dim_y = 8 };
|
||||||
enum { smart_shift = 4 };
|
enum { smart_shift = 4 };
|
||||||
};
|
};
|
||||||
OPENCV_GPU_TRANSFORM_FUNCTOR_TRAITS(bgr555_to_rgba_traits::functor_type)
|
OPENCV_CUDA_TRANSFORM_FUNCTOR_TRAITS(bgr555_to_rgba_traits::functor_type)
|
||||||
{
|
{
|
||||||
enum { smart_block_dim_y = 8 };
|
enum { smart_block_dim_y = 8 };
|
||||||
enum { smart_shift = 4 };
|
enum { smart_shift = 4 };
|
||||||
};
|
};
|
||||||
OPENCV_GPU_TRANSFORM_FUNCTOR_TRAITS(bgr565_to_bgra_traits::functor_type)
|
OPENCV_CUDA_TRANSFORM_FUNCTOR_TRAITS(bgr565_to_bgra_traits::functor_type)
|
||||||
{
|
{
|
||||||
enum { smart_block_dim_y = 8 };
|
enum { smart_block_dim_y = 8 };
|
||||||
enum { smart_shift = 4 };
|
enum { smart_shift = 4 };
|
||||||
};
|
};
|
||||||
OPENCV_GPU_TRANSFORM_FUNCTOR_TRAITS(bgr565_to_rgba_traits::functor_type)
|
OPENCV_CUDA_TRANSFORM_FUNCTOR_TRAITS(bgr565_to_rgba_traits::functor_type)
|
||||||
{
|
{
|
||||||
enum { smart_block_dim_y = 8 };
|
enum { smart_block_dim_y = 8 };
|
||||||
enum { smart_shift = 4 };
|
enum { smart_shift = 4 };
|
||||||
};
|
};
|
||||||
|
|
||||||
OPENCV_GPU_TRANSFORM_FUNCTOR_TRAITS(gray_to_bgra_traits<uchar>::functor_type)
|
OPENCV_CUDA_TRANSFORM_FUNCTOR_TRAITS(gray_to_bgra_traits<uchar>::functor_type)
|
||||||
{
|
{
|
||||||
enum { smart_block_dim_y = 8 };
|
enum { smart_block_dim_y = 8 };
|
||||||
enum { smart_shift = 4 };
|
enum { smart_shift = 4 };
|
||||||
};
|
};
|
||||||
|
|
||||||
OPENCV_GPU_TRANSFORM_FUNCTOR_TRAITS(gray_to_bgr555_traits::functor_type)
|
OPENCV_CUDA_TRANSFORM_FUNCTOR_TRAITS(gray_to_bgr555_traits::functor_type)
|
||||||
{
|
{
|
||||||
enum { smart_shift = 4 };
|
enum { smart_shift = 4 };
|
||||||
};
|
};
|
||||||
OPENCV_GPU_TRANSFORM_FUNCTOR_TRAITS(gray_to_bgr565_traits::functor_type)
|
OPENCV_CUDA_TRANSFORM_FUNCTOR_TRAITS(gray_to_bgr565_traits::functor_type)
|
||||||
{
|
{
|
||||||
enum { smart_shift = 4 };
|
enum { smart_shift = 4 };
|
||||||
};
|
};
|
||||||
|
|
||||||
OPENCV_GPU_TRANSFORM_FUNCTOR_TRAITS(bgra_to_yuv4_traits<uchar>::functor_type)
|
OPENCV_CUDA_TRANSFORM_FUNCTOR_TRAITS(bgra_to_yuv4_traits<uchar>::functor_type)
|
||||||
{
|
{
|
||||||
enum { smart_block_dim_y = 8 };
|
enum { smart_block_dim_y = 8 };
|
||||||
enum { smart_shift = 4 };
|
enum { smart_shift = 4 };
|
||||||
};
|
};
|
||||||
OPENCV_GPU_TRANSFORM_FUNCTOR_TRAITS(rgba_to_yuv4_traits<uchar>::functor_type)
|
OPENCV_CUDA_TRANSFORM_FUNCTOR_TRAITS(rgba_to_yuv4_traits<uchar>::functor_type)
|
||||||
{
|
{
|
||||||
enum { smart_block_dim_y = 8 };
|
enum { smart_block_dim_y = 8 };
|
||||||
enum { smart_shift = 4 };
|
enum { smart_shift = 4 };
|
||||||
};
|
};
|
||||||
|
|
||||||
OPENCV_GPU_TRANSFORM_FUNCTOR_TRAITS(yuv4_to_bgra_traits<uchar>::functor_type)
|
OPENCV_CUDA_TRANSFORM_FUNCTOR_TRAITS(yuv4_to_bgra_traits<uchar>::functor_type)
|
||||||
{
|
{
|
||||||
enum { smart_block_dim_y = 8 };
|
enum { smart_block_dim_y = 8 };
|
||||||
enum { smart_shift = 4 };
|
enum { smart_shift = 4 };
|
||||||
};
|
};
|
||||||
OPENCV_GPU_TRANSFORM_FUNCTOR_TRAITS(yuv4_to_rgba_traits<uchar>::functor_type)
|
OPENCV_CUDA_TRANSFORM_FUNCTOR_TRAITS(yuv4_to_rgba_traits<uchar>::functor_type)
|
||||||
{
|
{
|
||||||
enum { smart_block_dim_y = 8 };
|
enum { smart_block_dim_y = 8 };
|
||||||
enum { smart_shift = 4 };
|
enum { smart_shift = 4 };
|
||||||
};
|
};
|
||||||
|
|
||||||
OPENCV_GPU_TRANSFORM_FUNCTOR_TRAITS(bgra_to_YCrCb4_traits<uchar>::functor_type)
|
OPENCV_CUDA_TRANSFORM_FUNCTOR_TRAITS(bgra_to_YCrCb4_traits<uchar>::functor_type)
|
||||||
{
|
{
|
||||||
enum { smart_block_dim_y = 8 };
|
enum { smart_block_dim_y = 8 };
|
||||||
enum { smart_shift = 4 };
|
enum { smart_shift = 4 };
|
||||||
};
|
};
|
||||||
OPENCV_GPU_TRANSFORM_FUNCTOR_TRAITS(rgba_to_YCrCb4_traits<uchar>::functor_type)
|
OPENCV_CUDA_TRANSFORM_FUNCTOR_TRAITS(rgba_to_YCrCb4_traits<uchar>::functor_type)
|
||||||
{
|
{
|
||||||
enum { smart_block_dim_y = 8 };
|
enum { smart_block_dim_y = 8 };
|
||||||
enum { smart_shift = 4 };
|
enum { smart_shift = 4 };
|
||||||
};
|
};
|
||||||
|
|
||||||
OPENCV_GPU_TRANSFORM_FUNCTOR_TRAITS(YCrCb4_to_bgra_traits<uchar>::functor_type)
|
OPENCV_CUDA_TRANSFORM_FUNCTOR_TRAITS(YCrCb4_to_bgra_traits<uchar>::functor_type)
|
||||||
{
|
{
|
||||||
enum { smart_block_dim_y = 8 };
|
enum { smart_block_dim_y = 8 };
|
||||||
enum { smart_shift = 4 };
|
enum { smart_shift = 4 };
|
||||||
};
|
};
|
||||||
OPENCV_GPU_TRANSFORM_FUNCTOR_TRAITS(YCrCb4_to_rgba_traits<uchar>::functor_type)
|
OPENCV_CUDA_TRANSFORM_FUNCTOR_TRAITS(YCrCb4_to_rgba_traits<uchar>::functor_type)
|
||||||
{
|
{
|
||||||
enum { smart_block_dim_y = 8 };
|
enum { smart_block_dim_y = 8 };
|
||||||
enum { smart_shift = 4 };
|
enum { smart_shift = 4 };
|
||||||
};
|
};
|
||||||
|
|
||||||
OPENCV_GPU_TRANSFORM_FUNCTOR_TRAITS(bgra_to_xyz4_traits<uchar>::functor_type)
|
OPENCV_CUDA_TRANSFORM_FUNCTOR_TRAITS(bgra_to_xyz4_traits<uchar>::functor_type)
|
||||||
{
|
{
|
||||||
enum { smart_block_dim_y = 8 };
|
enum { smart_block_dim_y = 8 };
|
||||||
enum { smart_shift = 4 };
|
enum { smart_shift = 4 };
|
||||||
};
|
};
|
||||||
OPENCV_GPU_TRANSFORM_FUNCTOR_TRAITS(rgba_to_xyz4_traits<uchar>::functor_type)
|
OPENCV_CUDA_TRANSFORM_FUNCTOR_TRAITS(rgba_to_xyz4_traits<uchar>::functor_type)
|
||||||
{
|
{
|
||||||
enum { smart_block_dim_y = 8 };
|
enum { smart_block_dim_y = 8 };
|
||||||
enum { smart_shift = 4 };
|
enum { smart_shift = 4 };
|
||||||
};
|
};
|
||||||
|
|
||||||
OPENCV_GPU_TRANSFORM_FUNCTOR_TRAITS(xyz4_to_bgra_traits<uchar>::functor_type)
|
OPENCV_CUDA_TRANSFORM_FUNCTOR_TRAITS(xyz4_to_bgra_traits<uchar>::functor_type)
|
||||||
{
|
{
|
||||||
enum { smart_block_dim_y = 8 };
|
enum { smart_block_dim_y = 8 };
|
||||||
enum { smart_shift = 4 };
|
enum { smart_shift = 4 };
|
||||||
};
|
};
|
||||||
OPENCV_GPU_TRANSFORM_FUNCTOR_TRAITS(xyz4_to_rgba_traits<uchar>::functor_type)
|
OPENCV_CUDA_TRANSFORM_FUNCTOR_TRAITS(xyz4_to_rgba_traits<uchar>::functor_type)
|
||||||
{
|
{
|
||||||
enum { smart_block_dim_y = 8 };
|
enum { smart_block_dim_y = 8 };
|
||||||
enum { smart_shift = 4 };
|
enum { smart_shift = 4 };
|
||||||
};
|
};
|
||||||
|
|
||||||
OPENCV_GPU_TRANSFORM_FUNCTOR_TRAITS(bgra_to_hsv4_traits<uchar>::functor_type)
|
OPENCV_CUDA_TRANSFORM_FUNCTOR_TRAITS(bgra_to_hsv4_traits<uchar>::functor_type)
|
||||||
{
|
{
|
||||||
enum { smart_block_dim_y = 8 };
|
enum { smart_block_dim_y = 8 };
|
||||||
enum { smart_shift = 4 };
|
enum { smart_shift = 4 };
|
||||||
};
|
};
|
||||||
OPENCV_GPU_TRANSFORM_FUNCTOR_TRAITS(rgba_to_hsv4_traits<uchar>::functor_type)
|
OPENCV_CUDA_TRANSFORM_FUNCTOR_TRAITS(rgba_to_hsv4_traits<uchar>::functor_type)
|
||||||
{
|
{
|
||||||
enum { smart_block_dim_y = 8 };
|
enum { smart_block_dim_y = 8 };
|
||||||
enum { smart_shift = 4 };
|
enum { smart_shift = 4 };
|
||||||
};
|
};
|
||||||
|
|
||||||
OPENCV_GPU_TRANSFORM_FUNCTOR_TRAITS(hsv4_to_bgra_traits<uchar>::functor_type)
|
OPENCV_CUDA_TRANSFORM_FUNCTOR_TRAITS(hsv4_to_bgra_traits<uchar>::functor_type)
|
||||||
{
|
{
|
||||||
enum { smart_block_dim_y = 8 };
|
enum { smart_block_dim_y = 8 };
|
||||||
enum { smart_shift = 4 };
|
enum { smart_shift = 4 };
|
||||||
};
|
};
|
||||||
OPENCV_GPU_TRANSFORM_FUNCTOR_TRAITS(hsv4_to_rgba_traits<uchar>::functor_type)
|
OPENCV_CUDA_TRANSFORM_FUNCTOR_TRAITS(hsv4_to_rgba_traits<uchar>::functor_type)
|
||||||
{
|
{
|
||||||
enum { smart_block_dim_y = 8 };
|
enum { smart_block_dim_y = 8 };
|
||||||
enum { smart_shift = 4 };
|
enum { smart_shift = 4 };
|
||||||
};
|
};
|
||||||
|
|
||||||
OPENCV_GPU_TRANSFORM_FUNCTOR_TRAITS(bgra_to_hls4_traits<uchar>::functor_type)
|
OPENCV_CUDA_TRANSFORM_FUNCTOR_TRAITS(bgra_to_hls4_traits<uchar>::functor_type)
|
||||||
{
|
{
|
||||||
enum { smart_block_dim_y = 8 };
|
enum { smart_block_dim_y = 8 };
|
||||||
enum { smart_shift = 4 };
|
enum { smart_shift = 4 };
|
||||||
};
|
};
|
||||||
OPENCV_GPU_TRANSFORM_FUNCTOR_TRAITS(rgba_to_hls4_traits<uchar>::functor_type)
|
OPENCV_CUDA_TRANSFORM_FUNCTOR_TRAITS(rgba_to_hls4_traits<uchar>::functor_type)
|
||||||
{
|
{
|
||||||
enum { smart_block_dim_y = 8 };
|
enum { smart_block_dim_y = 8 };
|
||||||
enum { smart_shift = 4 };
|
enum { smart_shift = 4 };
|
||||||
};
|
};
|
||||||
|
|
||||||
OPENCV_GPU_TRANSFORM_FUNCTOR_TRAITS(hls4_to_bgra_traits<uchar>::functor_type)
|
OPENCV_CUDA_TRANSFORM_FUNCTOR_TRAITS(hls4_to_bgra_traits<uchar>::functor_type)
|
||||||
{
|
{
|
||||||
enum { smart_block_dim_y = 8 };
|
enum { smart_block_dim_y = 8 };
|
||||||
enum { smart_shift = 4 };
|
enum { smart_shift = 4 };
|
||||||
};
|
};
|
||||||
OPENCV_GPU_TRANSFORM_FUNCTOR_TRAITS(hls4_to_rgba_traits<uchar>::functor_type)
|
OPENCV_CUDA_TRANSFORM_FUNCTOR_TRAITS(hls4_to_rgba_traits<uchar>::functor_type)
|
||||||
{
|
{
|
||||||
enum { smart_block_dim_y = 8 };
|
enum { smart_block_dim_y = 8 };
|
||||||
enum { smart_shift = 4 };
|
enum { smart_shift = 4 };
|
||||||
};
|
};
|
||||||
|
|
||||||
#define OPENCV_GPU_IMPLEMENT_CVTCOLOR(name, traits) \
|
#define OPENCV_CUDA_IMPLEMENT_CVTCOLOR(name, traits) \
|
||||||
void name(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream) \
|
void name(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream) \
|
||||||
{ \
|
{ \
|
||||||
traits::functor_type functor = traits::create_functor(); \
|
traits::functor_type functor = traits::create_functor(); \
|
||||||
@ -232,230 +232,230 @@ namespace cv { namespace cuda { namespace device
|
|||||||
cv::cuda::device::transform((PtrStepSz<src_t>)src, (PtrStepSz<dst_t>)dst, functor, WithOutMask(), stream); \
|
cv::cuda::device::transform((PtrStepSz<src_t>)src, (PtrStepSz<dst_t>)dst, functor, WithOutMask(), stream); \
|
||||||
}
|
}
|
||||||
|
|
||||||
#define OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(name) \
|
#define OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ONE(name) \
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR(name, name ## _traits)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR(name, name ## _traits)
|
||||||
|
|
||||||
#define OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(name) \
|
#define OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(name) \
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR(name ## _8u, name ## _traits<uchar>) \
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR(name ## _8u, name ## _traits<uchar>) \
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR(name ## _16u, name ## _traits<ushort>) \
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR(name ## _16u, name ## _traits<ushort>) \
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR(name ## _32f, name ## _traits<float>)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR(name ## _32f, name ## _traits<float>)
|
||||||
|
|
||||||
#define OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(name) \
|
#define OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(name) \
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR(name ## _8u, name ## _traits<uchar>) \
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR(name ## _8u, name ## _traits<uchar>) \
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR(name ## _32f, name ## _traits<float>)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR(name ## _32f, name ## _traits<float>)
|
||||||
|
|
||||||
#define OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F_FULL(name) \
|
#define OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F_FULL(name) \
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR(name ## _8u, name ## _traits<uchar>) \
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR(name ## _8u, name ## _traits<uchar>) \
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR(name ## _32f, name ## _traits<float>) \
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR(name ## _32f, name ## _traits<float>) \
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR(name ## _full_8u, name ## _full_traits<uchar>) \
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR(name ## _full_8u, name ## _full_traits<uchar>) \
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR(name ## _full_32f, name ## _full_traits<float>)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR(name ## _full_32f, name ## _full_traits<float>)
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_rgb)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(bgr_to_rgb)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_bgra)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(bgr_to_bgra)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_rgba)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(bgr_to_rgba)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_bgr)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(bgra_to_bgr)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_rgb)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(bgra_to_rgb)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_rgba)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(bgra_to_rgba)
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr_to_bgr555)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ONE(bgr_to_bgr555)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr_to_bgr565)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ONE(bgr_to_bgr565)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(rgb_to_bgr555)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ONE(rgb_to_bgr555)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(rgb_to_bgr565)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ONE(rgb_to_bgr565)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgra_to_bgr555)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ONE(bgra_to_bgr555)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgra_to_bgr565)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ONE(bgra_to_bgr565)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(rgba_to_bgr555)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ONE(rgba_to_bgr555)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(rgba_to_bgr565)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ONE(rgba_to_bgr565)
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr555_to_rgb)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ONE(bgr555_to_rgb)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr565_to_rgb)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ONE(bgr565_to_rgb)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr555_to_bgr)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ONE(bgr555_to_bgr)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr565_to_bgr)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ONE(bgr565_to_bgr)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr555_to_rgba)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ONE(bgr555_to_rgba)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr565_to_rgba)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ONE(bgr565_to_rgba)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr555_to_bgra)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ONE(bgr555_to_bgra)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr565_to_bgra)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ONE(bgr565_to_bgra)
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(gray_to_bgr)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(gray_to_bgr)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(gray_to_bgra)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(gray_to_bgra)
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(gray_to_bgr555)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ONE(gray_to_bgr555)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(gray_to_bgr565)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ONE(gray_to_bgr565)
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr555_to_gray)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ONE(bgr555_to_gray)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr565_to_gray)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ONE(bgr565_to_gray)
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgb_to_gray)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(rgb_to_gray)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_gray)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(bgr_to_gray)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgba_to_gray)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(rgba_to_gray)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_gray)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(bgra_to_gray)
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgb_to_yuv)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(rgb_to_yuv)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgba_to_yuv)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(rgba_to_yuv)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgb_to_yuv4)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(rgb_to_yuv4)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgba_to_yuv4)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(rgba_to_yuv4)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_yuv)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(bgr_to_yuv)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_yuv)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(bgra_to_yuv)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_yuv4)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(bgr_to_yuv4)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_yuv4)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(bgra_to_yuv4)
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv_to_rgb)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(yuv_to_rgb)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv_to_rgba)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(yuv_to_rgba)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv4_to_rgb)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(yuv4_to_rgb)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv4_to_rgba)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(yuv4_to_rgba)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv_to_bgr)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(yuv_to_bgr)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv_to_bgra)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(yuv_to_bgra)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv4_to_bgr)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(yuv4_to_bgr)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv4_to_bgra)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(yuv4_to_bgra)
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgb_to_YCrCb)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(rgb_to_YCrCb)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgba_to_YCrCb)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(rgba_to_YCrCb)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgb_to_YCrCb4)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(rgb_to_YCrCb4)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgba_to_YCrCb4)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(rgba_to_YCrCb4)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_YCrCb)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(bgr_to_YCrCb)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_YCrCb)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(bgra_to_YCrCb)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_YCrCb4)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(bgr_to_YCrCb4)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_YCrCb4)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(bgra_to_YCrCb4)
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb_to_rgb)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(YCrCb_to_rgb)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb_to_rgba)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(YCrCb_to_rgba)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb4_to_rgb)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(YCrCb4_to_rgb)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb4_to_rgba)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(YCrCb4_to_rgba)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb_to_bgr)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(YCrCb_to_bgr)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb_to_bgra)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(YCrCb_to_bgra)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb4_to_bgr)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(YCrCb4_to_bgr)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb4_to_bgra)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(YCrCb4_to_bgra)
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgb_to_xyz)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(rgb_to_xyz)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgba_to_xyz)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(rgba_to_xyz)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgb_to_xyz4)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(rgb_to_xyz4)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgba_to_xyz4)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(rgba_to_xyz4)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_xyz)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(bgr_to_xyz)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_xyz)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(bgra_to_xyz)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_xyz4)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(bgr_to_xyz4)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_xyz4)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(bgra_to_xyz4)
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz_to_rgb)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(xyz_to_rgb)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz4_to_rgb)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(xyz4_to_rgb)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz_to_rgba)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(xyz_to_rgba)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz4_to_rgba)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(xyz4_to_rgba)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz_to_bgr)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(xyz_to_bgr)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz4_to_bgr)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(xyz4_to_bgr)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz_to_bgra)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(xyz_to_bgra)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz4_to_bgra)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL(xyz4_to_bgra)
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F_FULL(rgb_to_hsv)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F_FULL(rgb_to_hsv)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F_FULL(rgba_to_hsv)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F_FULL(rgba_to_hsv)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F_FULL(rgb_to_hsv4)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F_FULL(rgb_to_hsv4)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F_FULL(rgba_to_hsv4)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F_FULL(rgba_to_hsv4)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F_FULL(bgr_to_hsv)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F_FULL(bgr_to_hsv)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F_FULL(bgra_to_hsv)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F_FULL(bgra_to_hsv)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F_FULL(bgr_to_hsv4)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F_FULL(bgr_to_hsv4)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F_FULL(bgra_to_hsv4)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F_FULL(bgra_to_hsv4)
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F_FULL(hsv_to_rgb)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F_FULL(hsv_to_rgb)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F_FULL(hsv_to_rgba)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F_FULL(hsv_to_rgba)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F_FULL(hsv4_to_rgb)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F_FULL(hsv4_to_rgb)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F_FULL(hsv4_to_rgba)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F_FULL(hsv4_to_rgba)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F_FULL(hsv_to_bgr)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F_FULL(hsv_to_bgr)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F_FULL(hsv_to_bgra)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F_FULL(hsv_to_bgra)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F_FULL(hsv4_to_bgr)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F_FULL(hsv4_to_bgr)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F_FULL(hsv4_to_bgra)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F_FULL(hsv4_to_bgra)
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F_FULL(rgb_to_hls)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F_FULL(rgb_to_hls)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F_FULL(rgba_to_hls)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F_FULL(rgba_to_hls)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F_FULL(rgb_to_hls4)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F_FULL(rgb_to_hls4)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F_FULL(rgba_to_hls4)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F_FULL(rgba_to_hls4)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F_FULL(bgr_to_hls)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F_FULL(bgr_to_hls)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F_FULL(bgra_to_hls)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F_FULL(bgra_to_hls)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F_FULL(bgr_to_hls4)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F_FULL(bgr_to_hls4)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F_FULL(bgra_to_hls4)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F_FULL(bgra_to_hls4)
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F_FULL(hls_to_rgb)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F_FULL(hls_to_rgb)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F_FULL(hls_to_rgba)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F_FULL(hls_to_rgba)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F_FULL(hls4_to_rgb)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F_FULL(hls4_to_rgb)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F_FULL(hls4_to_rgba)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F_FULL(hls4_to_rgba)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F_FULL(hls_to_bgr)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F_FULL(hls_to_bgr)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F_FULL(hls_to_bgra)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F_FULL(hls_to_bgra)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F_FULL(hls4_to_bgr)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F_FULL(hls4_to_bgr)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F_FULL(hls4_to_bgra)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F_FULL(hls4_to_bgra)
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgb_to_lab)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(rgb_to_lab)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgba_to_lab)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(rgba_to_lab)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgb_to_lab4)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(rgb_to_lab4)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgba_to_lab4)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(rgba_to_lab4)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgr_to_lab)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(bgr_to_lab)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgra_to_lab)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(bgra_to_lab)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgr_to_lab4)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(bgr_to_lab4)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgra_to_lab4)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(bgra_to_lab4)
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(lrgb_to_lab)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(lrgb_to_lab)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(lrgba_to_lab)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(lrgba_to_lab)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(lrgb_to_lab4)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(lrgb_to_lab4)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(lrgba_to_lab4)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(lrgba_to_lab4)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(lbgr_to_lab)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(lbgr_to_lab)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(lbgra_to_lab)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(lbgra_to_lab)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(lbgr_to_lab4)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(lbgr_to_lab4)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(lbgra_to_lab4)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(lbgra_to_lab4)
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(lab_to_rgb)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(lab_to_rgb)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(lab4_to_rgb)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(lab4_to_rgb)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(lab_to_rgba)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(lab_to_rgba)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(lab4_to_rgba)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(lab4_to_rgba)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(lab_to_bgr)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(lab_to_bgr)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(lab4_to_bgr)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(lab4_to_bgr)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(lab_to_bgra)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(lab_to_bgra)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(lab4_to_bgra)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(lab4_to_bgra)
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(lab_to_lrgb)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(lab_to_lrgb)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(lab4_to_lrgb)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(lab4_to_lrgb)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(lab_to_lrgba)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(lab_to_lrgba)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(lab4_to_lrgba)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(lab4_to_lrgba)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(lab_to_lbgr)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(lab_to_lbgr)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(lab4_to_lbgr)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(lab4_to_lbgr)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(lab_to_lbgra)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(lab_to_lbgra)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(lab4_to_lbgra)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(lab4_to_lbgra)
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgb_to_luv)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(rgb_to_luv)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgba_to_luv)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(rgba_to_luv)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgb_to_luv4)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(rgb_to_luv4)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgba_to_luv4)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(rgba_to_luv4)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgr_to_luv)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(bgr_to_luv)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgra_to_luv)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(bgra_to_luv)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgr_to_luv4)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(bgr_to_luv4)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgra_to_luv4)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(bgra_to_luv4)
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(lrgb_to_luv)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(lrgb_to_luv)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(lrgba_to_luv)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(lrgba_to_luv)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(lrgb_to_luv4)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(lrgb_to_luv4)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(lrgba_to_luv4)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(lrgba_to_luv4)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(lbgr_to_luv)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(lbgr_to_luv)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(lbgra_to_luv)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(lbgra_to_luv)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(lbgr_to_luv4)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(lbgr_to_luv4)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(lbgra_to_luv4)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(lbgra_to_luv4)
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(luv_to_rgb)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(luv_to_rgb)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(luv4_to_rgb)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(luv4_to_rgb)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(luv_to_rgba)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(luv_to_rgba)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(luv4_to_rgba)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(luv4_to_rgba)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(luv_to_bgr)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(luv_to_bgr)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(luv4_to_bgr)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(luv4_to_bgr)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(luv_to_bgra)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(luv_to_bgra)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(luv4_to_bgra)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(luv4_to_bgra)
|
||||||
|
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(luv_to_lrgb)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(luv_to_lrgb)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(luv4_to_lrgb)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(luv4_to_lrgb)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(luv_to_lrgba)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(luv_to_lrgba)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(luv4_to_lrgba)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(luv4_to_lrgba)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(luv_to_lbgr)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(luv_to_lbgr)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(luv4_to_lbgr)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(luv4_to_lbgr)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(luv_to_lbgra)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(luv_to_lbgra)
|
||||||
OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(luv4_to_lbgra)
|
OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F(luv4_to_lbgra)
|
||||||
|
|
||||||
#undef OPENCV_GPU_IMPLEMENT_CVTCOLOR
|
#undef OPENCV_CUDA_IMPLEMENT_CVTCOLOR
|
||||||
#undef OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE
|
#undef OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ONE
|
||||||
#undef OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL
|
#undef OPENCV_CUDA_IMPLEMENT_CVTCOLOR_ALL
|
||||||
#undef OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F
|
#undef OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F
|
||||||
#undef OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F_FULL
|
#undef OPENCV_CUDA_IMPLEMENT_CVTCOLOR_8U32F_FULL
|
||||||
}}} // namespace cv { namespace cuda { namespace cudev
|
}}} // namespace cv { namespace cuda { namespace cudev
|
||||||
|
|
||||||
#endif /* CUDA_DISABLER */
|
#endif /* CUDA_DISABLER */
|
||||||
|
|||||||
@ -262,7 +262,7 @@ namespace cv { namespace cuda { namespace device
|
|||||||
//////////////////////////////////////////////////////////////////////
|
//////////////////////////////////////////////////////////////////////
|
||||||
// Prepared_SQDIFF_NORMED
|
// Prepared_SQDIFF_NORMED
|
||||||
|
|
||||||
// normAcc* are accurate normalization routines which make GPU matchTemplate
|
// normAcc* are accurate normalization routines which make CUDA matchTemplate
|
||||||
// consistent with CPU one
|
// consistent with CPU one
|
||||||
|
|
||||||
__device__ float normAcc(float num, float denum)
|
__device__ float normAcc(float num, float denum)
|
||||||
|
|||||||
@ -45,230 +45,230 @@
|
|||||||
|
|
||||||
namespace cv { namespace cuda { namespace device
|
namespace cv { namespace cuda { namespace device
|
||||||
{
|
{
|
||||||
#define OPENCV_GPU_DECLARE_CVTCOLOR_ONE(name) \
|
#define OPENCV_CUDA_DECLARE_CVTCOLOR_ONE(name) \
|
||||||
void name(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
|
void name(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
|
||||||
|
|
||||||
#define OPENCV_GPU_DECLARE_CVTCOLOR_ALL(name) \
|
#define OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(name) \
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ONE(name ## _8u) \
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ONE(name ## _8u) \
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ONE(name ## _16u) \
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ONE(name ## _16u) \
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ONE(name ## _32f)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ONE(name ## _32f)
|
||||||
|
|
||||||
#define OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(name) \
|
#define OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(name) \
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ONE(name ## _8u) \
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ONE(name ## _8u) \
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ONE(name ## _32f)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ONE(name ## _32f)
|
||||||
|
|
||||||
#define OPENCV_GPU_DECLARE_CVTCOLOR_8U32F_FULL(name) \
|
#define OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F_FULL(name) \
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ONE(name ## _8u) \
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ONE(name ## _8u) \
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ONE(name ## _32f) \
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ONE(name ## _32f) \
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ONE(name ## _full_8u) \
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ONE(name ## _full_8u) \
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ONE(name ## _full_32f)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ONE(name ## _full_32f)
|
||||||
|
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgr_to_rgb)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(bgr_to_rgb)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgr_to_bgra)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(bgr_to_bgra)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgr_to_rgba)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(bgr_to_rgba)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgra_to_bgr)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(bgra_to_bgr)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgra_to_rgb)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(bgra_to_rgb)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgra_to_rgba)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(bgra_to_rgba)
|
||||||
|
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr_to_bgr555)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ONE(bgr_to_bgr555)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr_to_bgr565)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ONE(bgr_to_bgr565)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ONE(rgb_to_bgr555)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ONE(rgb_to_bgr555)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ONE(rgb_to_bgr565)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ONE(rgb_to_bgr565)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgra_to_bgr555)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ONE(bgra_to_bgr555)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgra_to_bgr565)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ONE(bgra_to_bgr565)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ONE(rgba_to_bgr555)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ONE(rgba_to_bgr555)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ONE(rgba_to_bgr565)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ONE(rgba_to_bgr565)
|
||||||
|
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr555_to_rgb)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ONE(bgr555_to_rgb)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr565_to_rgb)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ONE(bgr565_to_rgb)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr555_to_bgr)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ONE(bgr555_to_bgr)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr565_to_bgr)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ONE(bgr565_to_bgr)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr555_to_rgba)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ONE(bgr555_to_rgba)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr565_to_rgba)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ONE(bgr565_to_rgba)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr555_to_bgra)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ONE(bgr555_to_bgra)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr565_to_bgra)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ONE(bgr565_to_bgra)
|
||||||
|
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(gray_to_bgr)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(gray_to_bgr)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(gray_to_bgra)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(gray_to_bgra)
|
||||||
|
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ONE(gray_to_bgr555)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ONE(gray_to_bgr555)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ONE(gray_to_bgr565)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ONE(gray_to_bgr565)
|
||||||
|
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr555_to_gray)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ONE(bgr555_to_gray)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr565_to_gray)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ONE(bgr565_to_gray)
|
||||||
|
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgb_to_gray)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(rgb_to_gray)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgr_to_gray)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(bgr_to_gray)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgba_to_gray)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(rgba_to_gray)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgra_to_gray)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(bgra_to_gray)
|
||||||
|
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgb_to_yuv)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(rgb_to_yuv)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgba_to_yuv)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(rgba_to_yuv)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgb_to_yuv4)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(rgb_to_yuv4)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgba_to_yuv4)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(rgba_to_yuv4)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgr_to_yuv)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(bgr_to_yuv)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgra_to_yuv)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(bgra_to_yuv)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgr_to_yuv4)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(bgr_to_yuv4)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgra_to_yuv4)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(bgra_to_yuv4)
|
||||||
|
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(yuv_to_rgb)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(yuv_to_rgb)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(yuv_to_rgba)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(yuv_to_rgba)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(yuv4_to_rgb)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(yuv4_to_rgb)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(yuv4_to_rgba)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(yuv4_to_rgba)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(yuv_to_bgr)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(yuv_to_bgr)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(yuv_to_bgra)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(yuv_to_bgra)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(yuv4_to_bgr)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(yuv4_to_bgr)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(yuv4_to_bgra)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(yuv4_to_bgra)
|
||||||
|
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgb_to_YCrCb)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(rgb_to_YCrCb)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgba_to_YCrCb)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(rgba_to_YCrCb)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgb_to_YCrCb4)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(rgb_to_YCrCb4)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgba_to_YCrCb4)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(rgba_to_YCrCb4)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgr_to_YCrCb)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(bgr_to_YCrCb)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgra_to_YCrCb)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(bgra_to_YCrCb)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgr_to_YCrCb4)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(bgr_to_YCrCb4)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgra_to_YCrCb4)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(bgra_to_YCrCb4)
|
||||||
|
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(YCrCb_to_rgb)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(YCrCb_to_rgb)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(YCrCb_to_rgba)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(YCrCb_to_rgba)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(YCrCb4_to_rgb)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(YCrCb4_to_rgb)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(YCrCb4_to_rgba)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(YCrCb4_to_rgba)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(YCrCb_to_bgr)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(YCrCb_to_bgr)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(YCrCb_to_bgra)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(YCrCb_to_bgra)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(YCrCb4_to_bgr)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(YCrCb4_to_bgr)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(YCrCb4_to_bgra)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(YCrCb4_to_bgra)
|
||||||
|
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgb_to_xyz)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(rgb_to_xyz)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgba_to_xyz)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(rgba_to_xyz)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgb_to_xyz4)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(rgb_to_xyz4)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgba_to_xyz4)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(rgba_to_xyz4)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgr_to_xyz)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(bgr_to_xyz)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgra_to_xyz)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(bgra_to_xyz)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgr_to_xyz4)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(bgr_to_xyz4)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgra_to_xyz4)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(bgra_to_xyz4)
|
||||||
|
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(xyz_to_rgb)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(xyz_to_rgb)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(xyz4_to_rgb)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(xyz4_to_rgb)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(xyz_to_rgba)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(xyz_to_rgba)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(xyz4_to_rgba)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(xyz4_to_rgba)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(xyz_to_bgr)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(xyz_to_bgr)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(xyz4_to_bgr)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(xyz4_to_bgr)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(xyz_to_bgra)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(xyz_to_bgra)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_ALL(xyz4_to_bgra)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_ALL(xyz4_to_bgra)
|
||||||
|
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F_FULL(rgb_to_hsv)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F_FULL(rgb_to_hsv)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F_FULL(rgba_to_hsv)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F_FULL(rgba_to_hsv)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F_FULL(rgb_to_hsv4)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F_FULL(rgb_to_hsv4)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F_FULL(rgba_to_hsv4)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F_FULL(rgba_to_hsv4)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F_FULL(bgr_to_hsv)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F_FULL(bgr_to_hsv)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F_FULL(bgra_to_hsv)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F_FULL(bgra_to_hsv)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F_FULL(bgr_to_hsv4)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F_FULL(bgr_to_hsv4)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F_FULL(bgra_to_hsv4)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F_FULL(bgra_to_hsv4)
|
||||||
|
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F_FULL(hsv_to_rgb)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F_FULL(hsv_to_rgb)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F_FULL(hsv_to_rgba)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F_FULL(hsv_to_rgba)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F_FULL(hsv4_to_rgb)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F_FULL(hsv4_to_rgb)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F_FULL(hsv4_to_rgba)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F_FULL(hsv4_to_rgba)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F_FULL(hsv_to_bgr)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F_FULL(hsv_to_bgr)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F_FULL(hsv_to_bgra)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F_FULL(hsv_to_bgra)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F_FULL(hsv4_to_bgr)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F_FULL(hsv4_to_bgr)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F_FULL(hsv4_to_bgra)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F_FULL(hsv4_to_bgra)
|
||||||
|
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F_FULL(rgb_to_hls)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F_FULL(rgb_to_hls)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F_FULL(rgba_to_hls)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F_FULL(rgba_to_hls)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F_FULL(rgb_to_hls4)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F_FULL(rgb_to_hls4)
|
||||||
|
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F_FULL(rgba_to_hls4)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F_FULL(rgba_to_hls4)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F_FULL(bgr_to_hls)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F_FULL(bgr_to_hls)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F_FULL(bgra_to_hls)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F_FULL(bgra_to_hls)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F_FULL(bgr_to_hls4)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F_FULL(bgr_to_hls4)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F_FULL(bgra_to_hls4)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F_FULL(bgra_to_hls4)
|
||||||
|
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F_FULL(hls_to_rgb)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F_FULL(hls_to_rgb)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F_FULL(hls_to_rgba)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F_FULL(hls_to_rgba)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F_FULL(hls4_to_rgb)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F_FULL(hls4_to_rgb)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F_FULL(hls4_to_rgba)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F_FULL(hls4_to_rgba)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F_FULL(hls_to_bgr)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F_FULL(hls_to_bgr)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F_FULL(hls_to_bgra)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F_FULL(hls_to_bgra)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F_FULL(hls4_to_bgr)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F_FULL(hls4_to_bgr)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F_FULL(hls4_to_bgra)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F_FULL(hls4_to_bgra)
|
||||||
|
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(rgb_to_lab)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(rgb_to_lab)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(rgba_to_lab)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(rgba_to_lab)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(rgb_to_lab4)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(rgb_to_lab4)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(rgba_to_lab4)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(rgba_to_lab4)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(bgr_to_lab)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(bgr_to_lab)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(bgra_to_lab)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(bgra_to_lab)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(bgr_to_lab4)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(bgr_to_lab4)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(bgra_to_lab4)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(bgra_to_lab4)
|
||||||
|
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(lrgb_to_lab)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(lrgb_to_lab)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(lrgba_to_lab)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(lrgba_to_lab)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(lrgb_to_lab4)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(lrgb_to_lab4)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(lrgba_to_lab4)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(lrgba_to_lab4)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(lbgr_to_lab)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(lbgr_to_lab)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(lbgra_to_lab)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(lbgra_to_lab)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(lbgr_to_lab4)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(lbgr_to_lab4)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(lbgra_to_lab4)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(lbgra_to_lab4)
|
||||||
|
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(lab_to_rgb)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(lab_to_rgb)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(lab4_to_rgb)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(lab4_to_rgb)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(lab_to_rgba)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(lab_to_rgba)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(lab4_to_rgba)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(lab4_to_rgba)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(lab_to_bgr)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(lab_to_bgr)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(lab4_to_bgr)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(lab4_to_bgr)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(lab_to_bgra)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(lab_to_bgra)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(lab4_to_bgra)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(lab4_to_bgra)
|
||||||
|
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(lab_to_lrgb)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(lab_to_lrgb)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(lab4_to_lrgb)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(lab4_to_lrgb)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(lab_to_lrgba)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(lab_to_lrgba)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(lab4_to_lrgba)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(lab4_to_lrgba)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(lab_to_lbgr)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(lab_to_lbgr)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(lab4_to_lbgr)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(lab4_to_lbgr)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(lab_to_lbgra)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(lab_to_lbgra)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(lab4_to_lbgra)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(lab4_to_lbgra)
|
||||||
|
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(rgb_to_luv)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(rgb_to_luv)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(rgba_to_luv)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(rgba_to_luv)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(rgb_to_luv4)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(rgb_to_luv4)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(rgba_to_luv4)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(rgba_to_luv4)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(bgr_to_luv)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(bgr_to_luv)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(bgra_to_luv)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(bgra_to_luv)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(bgr_to_luv4)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(bgr_to_luv4)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(bgra_to_luv4)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(bgra_to_luv4)
|
||||||
|
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(lrgb_to_luv)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(lrgb_to_luv)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(lrgba_to_luv)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(lrgba_to_luv)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(lrgb_to_luv4)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(lrgb_to_luv4)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(lrgba_to_luv4)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(lrgba_to_luv4)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(lbgr_to_luv)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(lbgr_to_luv)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(lbgra_to_luv)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(lbgra_to_luv)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(lbgr_to_luv4)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(lbgr_to_luv4)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(lbgra_to_luv4)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(lbgra_to_luv4)
|
||||||
|
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(luv_to_rgb)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(luv_to_rgb)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(luv4_to_rgb)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(luv4_to_rgb)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(luv_to_rgba)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(luv_to_rgba)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(luv4_to_rgba)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(luv4_to_rgba)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(luv_to_bgr)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(luv_to_bgr)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(luv4_to_bgr)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(luv4_to_bgr)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(luv_to_bgra)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(luv_to_bgra)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(luv4_to_bgra)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(luv4_to_bgra)
|
||||||
|
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(luv_to_lrgb)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(luv_to_lrgb)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(luv4_to_lrgb)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(luv4_to_lrgb)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(luv_to_lrgba)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(luv_to_lrgba)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(luv4_to_lrgba)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(luv4_to_lrgba)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(luv_to_lbgr)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(luv_to_lbgr)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(luv4_to_lbgr)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(luv4_to_lbgr)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(luv_to_lbgra)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(luv_to_lbgra)
|
||||||
OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(luv4_to_lbgra)
|
OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F(luv4_to_lbgra)
|
||||||
|
|
||||||
#undef OPENCV_GPU_DECLARE_CVTCOLOR_ONE
|
#undef OPENCV_CUDA_DECLARE_CVTCOLOR_ONE
|
||||||
#undef OPENCV_GPU_DECLARE_CVTCOLOR_ALL
|
#undef OPENCV_CUDA_DECLARE_CVTCOLOR_ALL
|
||||||
#undef OPENCV_GPU_DECLARE_CVTCOLOR_8U32F
|
#undef OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F
|
||||||
#undef OPENCV_GPU_DECLARE_CVTCOLOR_8U32F_FULL
|
#undef OPENCV_CUDA_DECLARE_CVTCOLOR_8U32F_FULL
|
||||||
}}}
|
}}}
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
|||||||
@ -167,7 +167,7 @@ namespace
|
|||||||
{
|
{
|
||||||
}
|
}
|
||||||
|
|
||||||
CV_INIT_ALGORITHM(CLAHE_Impl, "CLAHE_GPU",
|
CV_INIT_ALGORITHM(CLAHE_Impl, "CLAHE_CUDA",
|
||||||
obj.info()->addParam(obj, "clipLimit", obj.clipLimit_);
|
obj.info()->addParam(obj, "clipLimit", obj.clipLimit_);
|
||||||
obj.info()->addParam(obj, "tilesX", obj.tilesX_);
|
obj.info()->addParam(obj, "tilesX", obj.tilesX_);
|
||||||
obj.info()->addParam(obj, "tilesY", obj.tilesY_))
|
obj.info()->addParam(obj, "tilesY", obj.tilesY_))
|
||||||
|
|||||||
@ -99,7 +99,7 @@ namespace
|
|||||||
|
|
||||||
void write(FileStorage& fs) const
|
void write(FileStorage& fs) const
|
||||||
{
|
{
|
||||||
fs << "name" << "HoughCirclesDetector_GPU"
|
fs << "name" << "HoughCirclesDetector_CUDA"
|
||||||
<< "dp" << dp_
|
<< "dp" << dp_
|
||||||
<< "minDist" << minDist_
|
<< "minDist" << minDist_
|
||||||
<< "cannyThreshold" << cannyThreshold_
|
<< "cannyThreshold" << cannyThreshold_
|
||||||
@ -111,7 +111,7 @@ namespace
|
|||||||
|
|
||||||
void read(const FileNode& fn)
|
void read(const FileNode& fn)
|
||||||
{
|
{
|
||||||
CV_Assert( String(fn["name"]) == "HoughCirclesDetector_GPU" );
|
CV_Assert( String(fn["name"]) == "HoughCirclesDetector_CUDA" );
|
||||||
dp_ = (float)fn["dp"];
|
dp_ = (float)fn["dp"];
|
||||||
minDist_ = (float)fn["minDist"];
|
minDist_ = (float)fn["minDist"];
|
||||||
cannyThreshold_ = (int)fn["cannyThreshold"];
|
cannyThreshold_ = (int)fn["cannyThreshold"];
|
||||||
|
|||||||
@ -95,7 +95,7 @@ namespace
|
|||||||
|
|
||||||
void write(FileStorage& fs) const
|
void write(FileStorage& fs) const
|
||||||
{
|
{
|
||||||
fs << "name" << "HoughLinesDetector_GPU"
|
fs << "name" << "HoughLinesDetector_CUDA"
|
||||||
<< "rho" << rho_
|
<< "rho" << rho_
|
||||||
<< "theta" << theta_
|
<< "theta" << theta_
|
||||||
<< "threshold" << threshold_
|
<< "threshold" << threshold_
|
||||||
@ -105,7 +105,7 @@ namespace
|
|||||||
|
|
||||||
void read(const FileNode& fn)
|
void read(const FileNode& fn)
|
||||||
{
|
{
|
||||||
CV_Assert( String(fn["name"]) == "HoughLinesDetector_GPU" );
|
CV_Assert( String(fn["name"]) == "HoughLinesDetector_CUDA" );
|
||||||
rho_ = (float)fn["rho"];
|
rho_ = (float)fn["rho"];
|
||||||
theta_ = (float)fn["theta"];
|
theta_ = (float)fn["theta"];
|
||||||
threshold_ = (int)fn["threshold"];
|
threshold_ = (int)fn["threshold"];
|
||||||
|
|||||||
@ -98,7 +98,7 @@ namespace
|
|||||||
|
|
||||||
void write(FileStorage& fs) const
|
void write(FileStorage& fs) const
|
||||||
{
|
{
|
||||||
fs << "name" << "PHoughLinesDetector_GPU"
|
fs << "name" << "PHoughLinesDetector_CUDA"
|
||||||
<< "rho" << rho_
|
<< "rho" << rho_
|
||||||
<< "theta" << theta_
|
<< "theta" << theta_
|
||||||
<< "minLineLength" << minLineLength_
|
<< "minLineLength" << minLineLength_
|
||||||
@ -108,7 +108,7 @@ namespace
|
|||||||
|
|
||||||
void read(const FileNode& fn)
|
void read(const FileNode& fn)
|
||||||
{
|
{
|
||||||
CV_Assert( String(fn["name"]) == "PHoughLinesDetector_GPU" );
|
CV_Assert( String(fn["name"]) == "PHoughLinesDetector_CUDA" );
|
||||||
rho_ = (float)fn["rho"];
|
rho_ = (float)fn["rho"];
|
||||||
theta_ = (float)fn["theta"];
|
theta_ = (float)fn["theta"];
|
||||||
minLineLength_ = (int)fn["minLineLength"];
|
minLineLength_ = (int)fn["minLineLength"];
|
||||||
|
|||||||
@ -88,7 +88,7 @@ void cv::cuda::meanShiftFiltering(InputArray _src, OutputArray _dst, int sp, int
|
|||||||
}
|
}
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////
|
////////////////////////////////////////////////////////////////////////
|
||||||
// meanShiftProc_GPU
|
// meanShiftProc_CUDA
|
||||||
|
|
||||||
namespace cv { namespace cuda { namespace device
|
namespace cv { namespace cuda { namespace device
|
||||||
{
|
{
|
||||||
|
|||||||
@ -72,7 +72,7 @@ PARAM_TEST_CASE(BilateralFilter, cv::cuda::DeviceInfo, cv::Size, MatType)
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(BilateralFilter, Accuracy)
|
CUDA_TEST_P(BilateralFilter, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat src = randomMat(size, type);
|
cv::Mat src = randomMat(size, type);
|
||||||
|
|
||||||
@ -87,7 +87,7 @@ GPU_TEST_P(BilateralFilter, Accuracy)
|
|||||||
EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-3 : 1.0);
|
EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-3 : 1.0);
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, BilateralFilter, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_ImgProc, BilateralFilter, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
testing::Values(cv::Size(128, 128), cv::Size(113, 113), cv::Size(639, 481)),
|
testing::Values(cv::Size(128, 128), cv::Size(113, 113), cv::Size(639, 481)),
|
||||||
testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_32FC1), MatType(CV_32FC3))
|
testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_32FC1), MatType(CV_32FC3))
|
||||||
|
|||||||
@ -94,7 +94,7 @@ PARAM_TEST_CASE(Blend, cv::cuda::DeviceInfo, cv::Size, MatType, UseRoi)
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Blend, Accuracy)
|
CUDA_TEST_P(Blend, Accuracy)
|
||||||
{
|
{
|
||||||
int depth = CV_MAT_DEPTH(type);
|
int depth = CV_MAT_DEPTH(type);
|
||||||
|
|
||||||
@ -115,7 +115,7 @@ GPU_TEST_P(Blend, Accuracy)
|
|||||||
EXPECT_MAT_NEAR(result_gold, result, CV_MAT_DEPTH(type) == CV_8U ? 1.0 : 1e-5);
|
EXPECT_MAT_NEAR(result_gold, result, CV_MAT_DEPTH(type) == CV_8U ? 1.0 : 1e-5);
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Blend, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_ImgProc, Blend, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
DIFFERENT_SIZES,
|
DIFFERENT_SIZES,
|
||||||
testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
|
testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
|
||||||
|
|||||||
@ -73,7 +73,7 @@ PARAM_TEST_CASE(Canny, cv::cuda::DeviceInfo, AppertureSize, L2gradient, UseRoi)
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(Canny, Accuracy)
|
CUDA_TEST_P(Canny, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat img = readImage("stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);
|
cv::Mat img = readImage("stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);
|
||||||
ASSERT_FALSE(img.empty());
|
ASSERT_FALSE(img.empty());
|
||||||
@ -92,7 +92,7 @@ GPU_TEST_P(Canny, Accuracy)
|
|||||||
EXPECT_MAT_SIMILAR(edges_gold, edges, 2e-2);
|
EXPECT_MAT_SIMILAR(edges_gold, edges, 2e-2);
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Canny, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_ImgProc, Canny, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
testing::Values(AppertureSize(3), AppertureSize(5)),
|
testing::Values(AppertureSize(3), AppertureSize(5)),
|
||||||
testing::Values(L2gradient(false), L2gradient(true)),
|
testing::Values(L2gradient(false), L2gradient(true)),
|
||||||
|
|||||||
File diff suppressed because it is too large
Load Diff
@ -75,7 +75,7 @@ PARAM_TEST_CASE(CornerHarris, cv::cuda::DeviceInfo, MatType, BorderType, BlockSi
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(CornerHarris, Accuracy)
|
CUDA_TEST_P(CornerHarris, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat src = readImageType("stereobm/aloe-L.png", type);
|
cv::Mat src = readImageType("stereobm/aloe-L.png", type);
|
||||||
ASSERT_FALSE(src.empty());
|
ASSERT_FALSE(src.empty());
|
||||||
@ -93,7 +93,7 @@ GPU_TEST_P(CornerHarris, Accuracy)
|
|||||||
EXPECT_MAT_NEAR(dst_gold, dst, 0.02);
|
EXPECT_MAT_NEAR(dst_gold, dst, 0.02);
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CornerHarris, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_ImgProc, CornerHarris, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
testing::Values(MatType(CV_8UC1), MatType(CV_32FC1)),
|
testing::Values(MatType(CV_8UC1), MatType(CV_32FC1)),
|
||||||
testing::Values(BorderType(cv::BORDER_REFLECT101), BorderType(cv::BORDER_REPLICATE), BorderType(cv::BORDER_REFLECT)),
|
testing::Values(BorderType(cv::BORDER_REFLECT101), BorderType(cv::BORDER_REPLICATE), BorderType(cv::BORDER_REFLECT)),
|
||||||
@ -123,7 +123,7 @@ PARAM_TEST_CASE(CornerMinEigen, cv::cuda::DeviceInfo, MatType, BorderType, Block
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
GPU_TEST_P(CornerMinEigen, Accuracy)
|
CUDA_TEST_P(CornerMinEigen, Accuracy)
|
||||||
{
|
{
|
||||||
cv::Mat src = readImageType("stereobm/aloe-L.png", type);
|
cv::Mat src = readImageType("stereobm/aloe-L.png", type);
|
||||||
ASSERT_FALSE(src.empty());
|
ASSERT_FALSE(src.empty());
|
||||||
@ -139,7 +139,7 @@ GPU_TEST_P(CornerMinEigen, Accuracy)
|
|||||||
EXPECT_MAT_NEAR(dst_gold, dst, 0.02);
|
EXPECT_MAT_NEAR(dst_gold, dst, 0.02);
|
||||||
}
|
}
|
||||||
|
|
||||||
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CornerMinEigen, testing::Combine(
|
INSTANTIATE_TEST_CASE_P(CUDA_ImgProc, CornerMinEigen, testing::Combine(
|
||||||
ALL_DEVICES,
|
ALL_DEVICES,
|
||||||
testing::Values(MatType(CV_8UC1), MatType(CV_32FC1)),
|
testing::Values(MatType(CV_8UC1), MatType(CV_32FC1)),
|
||||||
testing::Values(BorderType(cv::BORDER_REFLECT101), BorderType(cv::BORDER_REPLICATE), BorderType(cv::BORDER_REFLECT)),
|
testing::Values(BorderType(cv::BORDER_REFLECT101), BorderType(cv::BORDER_REPLICATE), BorderType(cv::BORDER_REFLECT)),
|
||||||
|
|||||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user