mirror/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2024-11-28 05:06:29 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

renamed device -> cuda

Browse Source
This commit is contained in:
Vladislav Vinogradov 2013-04-03 16:04:04 +04:00
parent a57707b8d8
commit 28b1e81883
136 changed files with 762 additions and 780 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
cmake/OpenCVModule.cmake
View File

@ -432,16 +432,16 @@ macro(ocv_glob_module_sources)
file(GLOB lib_hdrs "include/opencv2/*.hpp" "include/opencv2/${name}/*.hpp" "include/opencv2/${name}/*.h")
file(GLOB lib_hdrs_detail "include/opencv2/${name}/detail/*.hpp" "include/opencv2/${name}/detail/*.h")
file(GLOB lib_device_srcs "src/cuda/*.cu")
set(device_objs "")
set(lib_device_hdrs "")
file(GLOB lib_cuda_srcs "src/cuda/*.cu")
set(cuda_objs "")
set(lib_cuda_hdrs "")
if (HAVE_CUDA AND lib_device_srcs)
if(HAVE_CUDA AND lib_cuda_srcs)
ocv_include_directories(${CUDA_INCLUDE_DIRS})
file(GLOB lib_device_hdrs "src/cuda/*.hpp")
file(GLOB lib_cuda_hdrs "src/cuda/*.hpp")
ocv_cuda_compile(device_objs ${lib_device_srcs} ${lib_device_hdrs})
source_group("Src\\Cuda" FILES ${lib_device_srcs} ${lib_device_hdrs})
ocv_cuda_compile(cuda_objs ${lib_cuda_srcs} ${lib_cuda_hdrs})
source_group("Src\\Cuda" FILES ${lib_cuda_srcs} ${lib_cuda_hdrs})
endif()
file(GLOB cl_kernels "src/opencl/*.cl")
@ -457,7 +457,7 @@ macro(ocv_glob_module_sources)
endif()
ocv_set_module_sources(${ARGN} HEADERS ${lib_hdrs} ${lib_hdrs_detail}
SOURCES ${lib_srcs} ${lib_int_hdrs} ${device_objs} ${lib_device_srcs} ${lib_device_hdrs})
SOURCES ${lib_srcs} ${lib_int_hdrs} ${cuda_objs} ${lib_cuda_srcs} ${lib_cuda_hdrs})
source_group("Src" FILES ${lib_srcs} ${lib_int_hdrs})
source_group("Include" FILES ${lib_hdrs})

6
modules/core/CMakeLists.txt
View File

@ -6,10 +6,10 @@ if(HAVE_CUDA)
ocv_warnings_disable(CMAKE_CXX_FLAGS -Wundef)
endif()
file(GLOB lib_device_hdrs "include/opencv2/${name}/device/*.hpp" "include/opencv2/${name}/device/*.h")
file(GLOB lib_device_hdrs_detail "include/opencv2/${name}/device/detail/*.hpp" "include/opencv2/${name}/device/detail/*.h")
file(GLOB lib_cuda_hdrs "include/opencv2/${name}/cuda/*.hpp" "include/opencv2/${name}/cuda/*.h")
file(GLOB lib_cuda_hdrs_detail "include/opencv2/${name}/cuda/detail/*.hpp" "include/opencv2/${name}/cuda/detail/*.h")
ocv_glob_module_sources(SOURCES "${opencv_core_BINARY_DIR}/version_string.inc"
HEADERS ${lib_device_hdrs} ${lib_device_hdrs_detail})
HEADERS ${lib_cuda_hdrs} ${lib_cuda_hdrs_detail})
ocv_create_module()
ocv_add_precompiled_headers(${the_module})

2
modules/core/include/opencv2/core/device/block.hpp → modules/core/include/opencv2/core/cuda/block.hpp
View File

@ -43,7 +43,7 @@
#ifndef __OPENCV_GPU_DEVICE_BLOCK_HPP__
#define __OPENCV_GPU_DEVICE_BLOCK_HPP__
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
struct Block
{

4
modules/core/include/opencv2/core/device/border_interpolate.hpp → modules/core/include/opencv2/core/cuda/border_interpolate.hpp
View File

@ -47,7 +47,7 @@
#include "vec_traits.hpp"
#include "vec_math.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
//////////////////////////////////////////////////////////////
// BrdConstant
@ -709,6 +709,6 @@ namespace cv { namespace gpu { namespace device
const int width;
const D val;
};
}}} // namespace cv { namespace gpu { namespace device
}}} // namespace cv { namespace gpu { namespace cuda
#endif // __OPENCV_GPU_BORDER_INTERPOLATE_HPP__

4
modules/core/include/opencv2/core/device/color.hpp → modules/core/include/opencv2/core/cuda/color.hpp
View File

@ -45,7 +45,7 @@
#include "detail/color_detail.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
// All OPENCV_GPU_IMPLEMENT_*_TRAITS(ColorSpace1_to_ColorSpace2, ...) macros implements
// template <typename T> class ColorSpace1_to_ColorSpace2_traits
@ -296,6 +296,6 @@ namespace cv { namespace gpu { namespace device
OPENCV_GPU_IMPLEMENT_Luv2RGB_TRAITS(luv4_to_lbgra, 4, 4, false, 0)
#undef OPENCV_GPU_IMPLEMENT_Luv2RGB_TRAITS
}}} // namespace cv { namespace gpu { namespace device
}}} // namespace cv { namespace gpu { namespace cuda
#endif // __OPENCV_GPU_BORDER_INTERPOLATE_HPP__

2
modules/core/include/opencv2/core/device/common.hpp → modules/core/include/opencv2/core/cuda/common.hpp
View File

@ -92,7 +92,7 @@ namespace cv { namespace gpu
return (total + grain - 1) / grain;
}
namespace device
namespace cuda
{
using cv::gpu::divUp;

4
modules/core/include/opencv2/core/device/datamov_utils.hpp → modules/core/include/opencv2/core/cuda/datamov_utils.hpp
View File

@ -45,7 +45,7 @@
#include "common.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
#if defined __CUDA_ARCH__ && __CUDA_ARCH__ >= 200
@ -100,6 +100,6 @@ namespace cv { namespace gpu { namespace device
#undef OPENCV_GPU_ASM_PTR
#endif // __CUDA_ARCH__ >= 200
}}} // namespace cv { namespace gpu { namespace device
}}} // namespace cv { namespace gpu { namespace cuda
#endif // __OPENCV_GPU_DATAMOV_UTILS_HPP__

70
modules/core/include/opencv2/core/device/detail/color_detail.hpp → modules/core/include/opencv2/core/cuda/detail/color_detail.hpp
View File

@ -49,7 +49,7 @@
#include "../limits.hpp"
#include "../functional.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
#ifndef CV_DESCALE
#define CV_DESCALE(x, n) (((x) + (1 << ((n)-1))) >> (n))
@ -149,7 +149,7 @@ namespace cv { namespace gpu { namespace device
#define OPENCV_GPU_IMPLEMENT_RGB2RGB_TRAITS(name, scn, dcn, bidx) \
template <typename T> struct name ## _traits \
{ \
typedef ::cv::gpu::device::color_detail::RGB2RGB<T, scn, dcn, bidx> functor_type; \
typedef ::cv::gpu::cuda::color_detail::RGB2RGB<T, scn, dcn, bidx> functor_type; \
static __host__ __device__ __forceinline__ functor_type create_functor() \
{ \
return functor_type(); \
@ -222,7 +222,7 @@ namespace cv { namespace gpu { namespace device
#define OPENCV_GPU_IMPLEMENT_RGB2RGB5x5_TRAITS(name, scn, bidx, green_bits) \
struct name ## _traits \
{ \
typedef ::cv::gpu::device::color_detail::RGB2RGB5x5<scn, bidx, green_bits> functor_type; \
typedef ::cv::gpu::cuda::color_detail::RGB2RGB5x5<scn, bidx, green_bits> functor_type; \
static __host__ __device__ __forceinline__ functor_type create_functor() \
{ \
return functor_type(); \
@ -303,7 +303,7 @@ namespace cv { namespace gpu { namespace device
#define OPENCV_GPU_IMPLEMENT_RGB5x52RGB_TRAITS(name, dcn, bidx, green_bits) \
struct name ## _traits \
{ \
typedef ::cv::gpu::device::color_detail::RGB5x52RGB<dcn, bidx, green_bits> functor_type; \
typedef ::cv::gpu::cuda::color_detail::RGB5x52RGB<dcn, bidx, green_bits> functor_type; \
static __host__ __device__ __forceinline__ functor_type create_functor() \
{ \
return functor_type(); \
@ -350,7 +350,7 @@ namespace cv { namespace gpu { namespace device
#define OPENCV_GPU_IMPLEMENT_GRAY2RGB_TRAITS(name, dcn) \
template <typename T> struct name ## _traits \
{ \
typedef ::cv::gpu::device::color_detail::Gray2RGB<T, dcn> functor_type; \
typedef ::cv::gpu::cuda::color_detail::Gray2RGB<T, dcn> functor_type; \
static __host__ __device__ __forceinline__ functor_type create_functor() \
{ \
return functor_type(); \
@ -392,7 +392,7 @@ namespace cv { namespace gpu { namespace device
#define OPENCV_GPU_IMPLEMENT_GRAY2RGB5x5_TRAITS(name, green_bits) \
struct name ## _traits \
{ \
typedef ::cv::gpu::device::color_detail::Gray2RGB5x5<green_bits> functor_type; \
typedef ::cv::gpu::cuda::color_detail::Gray2RGB5x5<green_bits> functor_type; \
static __host__ __device__ __forceinline__ functor_type create_functor() \
{ \
return functor_type(); \
@ -434,7 +434,7 @@ namespace cv { namespace gpu { namespace device
#define OPENCV_GPU_IMPLEMENT_RGB5x52GRAY_TRAITS(name, green_bits) \
struct name ## _traits \
{ \
typedef ::cv::gpu::device::color_detail::RGB5x52Gray<green_bits> functor_type; \
typedef ::cv::gpu::cuda::color_detail::RGB5x52Gray<green_bits> functor_type; \
static __host__ __device__ __forceinline__ functor_type create_functor() \
{ \
return functor_type(); \
@ -486,7 +486,7 @@ namespace cv { namespace gpu { namespace device
#define OPENCV_GPU_IMPLEMENT_RGB2GRAY_TRAITS(name, scn, bidx) \
template <typename T> struct name ## _traits \
{ \
typedef ::cv::gpu::device::color_detail::RGB2Gray<T, scn, bidx> functor_type; \
typedef ::cv::gpu::cuda::color_detail::RGB2Gray<T, scn, bidx> functor_type; \
static __host__ __device__ __forceinline__ functor_type create_functor() \
{ \
return functor_type(); \
@ -539,7 +539,7 @@ namespace cv { namespace gpu { namespace device
#define OPENCV_GPU_IMPLEMENT_RGB2YUV_TRAITS(name, scn, dcn, bidx) \
template <typename T> struct name ## _traits \
{ \
typedef ::cv::gpu::device::color_detail::RGB2YUV<T, scn, dcn, bidx> functor_type; \
typedef ::cv::gpu::cuda::color_detail::RGB2YUV<T, scn, dcn, bidx> functor_type; \
static __host__ __device__ __forceinline__ functor_type create_functor() \
{ \
return functor_type(); \
@ -629,7 +629,7 @@ namespace cv { namespace gpu { namespace device
#define OPENCV_GPU_IMPLEMENT_YUV2RGB_TRAITS(name, scn, dcn, bidx) \
template <typename T> struct name ## _traits \
{ \
typedef ::cv::gpu::device::color_detail::YUV2RGB<T, scn, dcn, bidx> functor_type; \
typedef ::cv::gpu::cuda::color_detail::YUV2RGB<T, scn, dcn, bidx> functor_type; \
static __host__ __device__ __forceinline__ functor_type create_functor() \
{ \
return functor_type(); \
@ -710,7 +710,7 @@ namespace cv { namespace gpu { namespace device
#define OPENCV_GPU_IMPLEMENT_RGB2YCrCb_TRAITS(name, scn, dcn, bidx) \
template <typename T> struct name ## _traits \
{ \
typedef ::cv::gpu::device::color_detail::RGB2YCrCb<T, scn, dcn, bidx> functor_type; \
typedef ::cv::gpu::cuda::color_detail::RGB2YCrCb<T, scn, dcn, bidx> functor_type; \
static __host__ __device__ __forceinline__ functor_type create_functor() \
{ \
return functor_type(); \
@ -791,7 +791,7 @@ namespace cv { namespace gpu { namespace device
#define OPENCV_GPU_IMPLEMENT_YCrCb2RGB_TRAITS(name, scn, dcn, bidx) \
template <typename T> struct name ## _traits \
{ \
typedef ::cv::gpu::device::color_detail::YCrCb2RGB<T, scn, dcn, bidx> functor_type; \
typedef ::cv::gpu::cuda::color_detail::YCrCb2RGB<T, scn, dcn, bidx> functor_type; \
static __host__ __device__ __forceinline__ functor_type create_functor() \
{ \
return functor_type(); \
@ -869,7 +869,7 @@ namespace cv { namespace gpu { namespace device
#define OPENCV_GPU_IMPLEMENT_RGB2XYZ_TRAITS(name, scn, dcn, bidx) \
template <typename T> struct name ## _traits \
{ \
typedef ::cv::gpu::device::color_detail::RGB2XYZ<T, scn, dcn, bidx> functor_type; \
typedef ::cv::gpu::cuda::color_detail::RGB2XYZ<T, scn, dcn, bidx> functor_type; \
static __host__ __device__ __forceinline__ functor_type create_functor() \
{ \
return functor_type(); \
@ -946,7 +946,7 @@ namespace cv { namespace gpu { namespace device
#define OPENCV_GPU_IMPLEMENT_XYZ2RGB_TRAITS(name, scn, dcn, bidx) \
template <typename T> struct name ## _traits \
{ \
typedef ::cv::gpu::device::color_detail::XYZ2RGB<T, scn, dcn, bidx> functor_type; \
typedef ::cv::gpu::cuda::color_detail::XYZ2RGB<T, scn, dcn, bidx> functor_type; \
static __host__ __device__ __forceinline__ functor_type create_functor() \
{ \
return functor_type(); \
@ -1086,7 +1086,7 @@ namespace cv { namespace gpu { namespace device
#define OPENCV_GPU_IMPLEMENT_RGB2HSV_TRAITS(name, scn, dcn, bidx) \
template <typename T> struct name ## _traits \
{ \
typedef ::cv::gpu::device::color_detail::RGB2HSV<T, scn, dcn, bidx, 180> functor_type; \
typedef ::cv::gpu::cuda::color_detail::RGB2HSV<T, scn, dcn, bidx, 180> functor_type; \
static __host__ __device__ __forceinline__ functor_type create_functor() \
{ \
return functor_type(); \
@ -1094,7 +1094,7 @@ namespace cv { namespace gpu { namespace device
}; \
template <typename T> struct name ## _full_traits \
{ \
typedef ::cv::gpu::device::color_detail::RGB2HSV<T, scn, dcn, bidx, 256> functor_type; \
typedef ::cv::gpu::cuda::color_detail::RGB2HSV<T, scn, dcn, bidx, 256> functor_type; \
static __host__ __device__ __forceinline__ functor_type create_functor() \
{ \
return functor_type(); \
@ -1102,7 +1102,7 @@ namespace cv { namespace gpu { namespace device
}; \
template <> struct name ## _traits<float> \
{ \
typedef ::cv::gpu::device::color_detail::RGB2HSV<float, scn, dcn, bidx, 360> functor_type; \
typedef ::cv::gpu::cuda::color_detail::RGB2HSV<float, scn, dcn, bidx, 360> functor_type; \
static __host__ __device__ __forceinline__ functor_type create_functor() \
{ \
return functor_type(); \
@ -1110,7 +1110,7 @@ namespace cv { namespace gpu { namespace device
}; \
template <> struct name ## _full_traits<float> \
{ \
typedef ::cv::gpu::device::color_detail::RGB2HSV<float, scn, dcn, bidx, 360> functor_type; \
typedef ::cv::gpu::cuda::color_detail::RGB2HSV<float, scn, dcn, bidx, 360> functor_type; \
static __host__ __device__ __forceinline__ functor_type create_functor() \
{ \
return functor_type(); \
@ -1228,7 +1228,7 @@ namespace cv { namespace gpu { namespace device
#define OPENCV_GPU_IMPLEMENT_HSV2RGB_TRAITS(name, scn, dcn, bidx) \
template <typename T> struct name ## _traits \
{ \
typedef ::cv::gpu::device::color_detail::HSV2RGB<T, scn, dcn, bidx, 180> functor_type; \
typedef ::cv::gpu::cuda::color_detail::HSV2RGB<T, scn, dcn, bidx, 180> functor_type; \
static __host__ __device__ __forceinline__ functor_type create_functor() \
{ \
return functor_type(); \
@ -1236,7 +1236,7 @@ namespace cv { namespace gpu { namespace device
}; \
template <typename T> struct name ## _full_traits \
{ \
typedef ::cv::gpu::device::color_detail::HSV2RGB<T, scn, dcn, bidx, 255> functor_type; \
typedef ::cv::gpu::cuda::color_detail::HSV2RGB<T, scn, dcn, bidx, 255> functor_type; \
static __host__ __device__ __forceinline__ functor_type create_functor() \
{ \
return functor_type(); \
@ -1244,7 +1244,7 @@ namespace cv { namespace gpu { namespace device
}; \
template <> struct name ## _traits<float> \
{ \
typedef ::cv::gpu::device::color_detail::HSV2RGB<float, scn, dcn, bidx, 360> functor_type; \
typedef ::cv::gpu::cuda::color_detail::HSV2RGB<float, scn, dcn, bidx, 360> functor_type; \
static __host__ __device__ __forceinline__ functor_type create_functor() \
{ \
return functor_type(); \
@ -1252,7 +1252,7 @@ namespace cv { namespace gpu { namespace device
}; \
template <> struct name ## _full_traits<float> \
{ \
typedef ::cv::gpu::device::color_detail::HSV2RGB<float, scn, dcn, bidx, 360> functor_type; \
typedef ::cv::gpu::cuda::color_detail::HSV2RGB<float, scn, dcn, bidx, 360> functor_type; \
static __host__ __device__ __forceinline__ functor_type create_functor() \
{ \
return functor_type(); \
@ -1363,7 +1363,7 @@ namespace cv { namespace gpu { namespace device
#define OPENCV_GPU_IMPLEMENT_RGB2HLS_TRAITS(name, scn, dcn, bidx) \
template <typename T> struct name ## _traits \
{ \
typedef ::cv::gpu::device::color_detail::RGB2HLS<T, scn, dcn, bidx, 180> functor_type; \
typedef ::cv::gpu::cuda::color_detail::RGB2HLS<T, scn, dcn, bidx, 180> functor_type; \
static __host__ __device__ __forceinline__ functor_type create_functor() \
{ \
return functor_type(); \
@ -1371,7 +1371,7 @@ namespace cv { namespace gpu { namespace device
}; \
template <typename T> struct name ## _full_traits \
{ \
typedef ::cv::gpu::device::color_detail::RGB2HLS<T, scn, dcn, bidx, 256> functor_type; \
typedef ::cv::gpu::cuda::color_detail::RGB2HLS<T, scn, dcn, bidx, 256> functor_type; \
static __host__ __device__ __forceinline__ functor_type create_functor() \
{ \
return functor_type(); \
@ -1379,7 +1379,7 @@ namespace cv { namespace gpu { namespace device
}; \
template <> struct name ## _traits<float> \
{ \
typedef ::cv::gpu::device::color_detail::RGB2HLS<float, scn, dcn, bidx, 360> functor_type; \
typedef ::cv::gpu::cuda::color_detail::RGB2HLS<float, scn, dcn, bidx, 360> functor_type; \
static __host__ __device__ __forceinline__ functor_type create_functor() \
{ \
return functor_type(); \
@ -1387,7 +1387,7 @@ namespace cv { namespace gpu { namespace device
}; \
template <> struct name ## _full_traits<float> \
{ \
typedef ::cv::gpu::device::color_detail::RGB2HLS<float, scn, dcn, bidx, 360> functor_type; \
typedef ::cv::gpu::cuda::color_detail::RGB2HLS<float, scn, dcn, bidx, 360> functor_type; \
static __host__ __device__ __forceinline__ functor_type create_functor() \
{ \
return functor_type(); \
@ -1505,7 +1505,7 @@ namespace cv { namespace gpu { namespace device
#define OPENCV_GPU_IMPLEMENT_HLS2RGB_TRAITS(name, scn, dcn, bidx) \
template <typename T> struct name ## _traits \
{ \
typedef ::cv::gpu::device::color_detail::HLS2RGB<T, scn, dcn, bidx, 180> functor_type; \
typedef ::cv::gpu::cuda::color_detail::HLS2RGB<T, scn, dcn, bidx, 180> functor_type; \
static __host__ __device__ __forceinline__ functor_type create_functor() \
{ \
return functor_type(); \
@ -1513,7 +1513,7 @@ namespace cv { namespace gpu { namespace device
}; \
template <typename T> struct name ## _full_traits \
{ \
typedef ::cv::gpu::device::color_detail::HLS2RGB<T, scn, dcn, bidx, 255> functor_type; \
typedef ::cv::gpu::cuda::color_detail::HLS2RGB<T, scn, dcn, bidx, 255> functor_type; \
static __host__ __device__ __forceinline__ functor_type create_functor() \
{ \
return functor_type(); \
@ -1521,7 +1521,7 @@ namespace cv { namespace gpu { namespace device
}; \
template <> struct name ## _traits<float> \
{ \
typedef ::cv::gpu::device::color_detail::HLS2RGB<float, scn, dcn, bidx, 360> functor_type; \
typedef ::cv::gpu::cuda::color_detail::HLS2RGB<float, scn, dcn, bidx, 360> functor_type; \
static __host__ __device__ __forceinline__ functor_type create_functor() \
{ \
return functor_type(); \
@ -1529,7 +1529,7 @@ namespace cv { namespace gpu { namespace device
}; \
template <> struct name ## _full_traits<float> \
{ \
typedef ::cv::gpu::device::color_detail::HLS2RGB<float, scn, dcn, bidx, 360> functor_type; \
typedef ::cv::gpu::cuda::color_detail::HLS2RGB<float, scn, dcn, bidx, 360> functor_type; \
static __host__ __device__ __forceinline__ functor_type create_functor() \
{ \
return functor_type(); \
@ -1674,7 +1674,7 @@ namespace cv { namespace gpu { namespace device
#define OPENCV_GPU_IMPLEMENT_RGB2Lab_TRAITS(name, scn, dcn, srgb, blueIdx) \
template <typename T> struct name ## _traits \
{ \
typedef ::cv::gpu::device::color_detail::RGB2Lab<T, scn, dcn, srgb, blueIdx> functor_type; \
typedef ::cv::gpu::cuda::color_detail::RGB2Lab<T, scn, dcn, srgb, blueIdx> functor_type; \
static __host__ __device__ __forceinline__ functor_type create_functor() \
{ \
return functor_type(); \
@ -1787,7 +1787,7 @@ namespace cv { namespace gpu { namespace device
#define OPENCV_GPU_IMPLEMENT_Lab2RGB_TRAITS(name, scn, dcn, srgb, blueIdx) \
template <typename T> struct name ## _traits \
{ \
typedef ::cv::gpu::device::color_detail::Lab2RGB<T, scn, dcn, srgb, blueIdx> functor_type; \
typedef ::cv::gpu::cuda::color_detail::Lab2RGB<T, scn, dcn, srgb, blueIdx> functor_type; \
static __host__ __device__ __forceinline__ functor_type create_functor() \
{ \
return functor_type(); \
@ -1886,7 +1886,7 @@ namespace cv { namespace gpu { namespace device
#define OPENCV_GPU_IMPLEMENT_RGB2Luv_TRAITS(name, scn, dcn, srgb, blueIdx) \
template <typename T> struct name ## _traits \
{ \
typedef ::cv::gpu::device::color_detail::RGB2Luv<T, scn, dcn, srgb, blueIdx> functor_type; \
typedef ::cv::gpu::cuda::color_detail::RGB2Luv<T, scn, dcn, srgb, blueIdx> functor_type; \
static __host__ __device__ __forceinline__ functor_type create_functor() \
{ \
return functor_type(); \
@ -1987,7 +1987,7 @@ namespace cv { namespace gpu { namespace device
#define OPENCV_GPU_IMPLEMENT_Luv2RGB_TRAITS(name, scn, dcn, srgb, blueIdx) \
template <typename T> struct name ## _traits \
{ \
typedef ::cv::gpu::device::color_detail::Luv2RGB<T, scn, dcn, srgb, blueIdx> functor_type; \
typedef ::cv::gpu::cuda::color_detail::Luv2RGB<T, scn, dcn, srgb, blueIdx> functor_type; \
static __host__ __device__ __forceinline__ functor_type create_functor() \
{ \
return functor_type(); \
@ -1996,6 +1996,6 @@ namespace cv { namespace gpu { namespace device
#undef CV_DESCALE
}}} // namespace cv { namespace gpu { namespace device
}}} // namespace cv { namespace gpu { namespace cuda
#endif // __OPENCV_GPU_COLOR_DETAIL_HPP__

2
modules/core/include/opencv2/core/device/detail/reduce.hpp → modules/core/include/opencv2/core/cuda/detail/reduce.hpp
View File

@ -47,7 +47,7 @@
#include "../warp.hpp"
#include "../warp_shuffle.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace reduce_detail
{

2
modules/core/include/opencv2/core/device/detail/reduce_key_val.hpp → modules/core/include/opencv2/core/cuda/detail/reduce_key_val.hpp
View File

@ -47,7 +47,7 @@
#include "../warp.hpp"
#include "../warp_shuffle.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace reduce_key_val_detail
{

4
modules/core/include/opencv2/core/device/detail/transform_detail.hpp → modules/core/include/opencv2/core/cuda/detail/transform_detail.hpp
View File

@ -47,7 +47,7 @@
#include "../vec_traits.hpp"
#include "../functional.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace transform_detail
{
@ -390,6 +390,6 @@ namespace cv { namespace gpu { namespace device
}
};
} // namespace transform_detail
}}} // namespace cv { namespace gpu { namespace device
}}} // namespace cv { namespace gpu { namespace cuda
#endif // __OPENCV_GPU_TRANSFORM_DETAIL_HPP__

4
modules/core/include/opencv2/core/device/detail/type_traits_detail.hpp → modules/core/include/opencv2/core/cuda/detail/type_traits_detail.hpp
View File

@ -46,7 +46,7 @@
#include "../common.hpp"
#include "../vec_traits.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace type_traits_detail
{
@ -182,6 +182,6 @@ namespace cv { namespace gpu { namespace device
enum { value = 1 };
};
} // namespace type_traits_detail
}}} // namespace cv { namespace gpu { namespace device
}}} // namespace cv { namespace gpu { namespace cuda
#endif // __OPENCV_GPU_TYPE_TRAITS_DETAIL_HPP__

4
modules/core/include/opencv2/core/device/detail/vec_distance_detail.hpp → modules/core/include/opencv2/core/cuda/detail/vec_distance_detail.hpp
View File

@ -45,7 +45,7 @@
#include "../datamov_utils.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace vec_distance_detail
{
@ -112,6 +112,6 @@ namespace cv { namespace gpu { namespace device
}
};
} // namespace vec_distance_detail
}}} // namespace cv { namespace gpu { namespace device
}}} // namespace cv { namespace gpu { namespace cuda
#endif // __OPENCV_GPU_VEC_DISTANCE_DETAIL_HPP__

2
modules/core/include/opencv2/core/device/dynamic_smem.hpp → modules/core/include/opencv2/core/cuda/dynamic_smem.hpp
View File

@ -43,7 +43,7 @@
#ifndef __OPENCV_GPU_DYNAMIC_SMEM_HPP__
#define __OPENCV_GPU_DYNAMIC_SMEM_HPP__
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
template<class T> struct DynamicSharedMem
{

4
modules/core/include/opencv2/core/device/emulation.hpp → modules/core/include/opencv2/core/cuda/emulation.hpp
View File

@ -45,7 +45,7 @@
#include "warp_reduce.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
struct Emulation
{
@ -133,6 +133,6 @@ namespace cv { namespace gpu { namespace device
}
};
};
}}} // namespace cv { namespace gpu { namespace device
}}} // namespace cv { namespace gpu { namespace cuda
#endif /* OPENCV_GPU_EMULATION_HPP_ */

4
modules/core/include/opencv2/core/device/filters.hpp → modules/core/include/opencv2/core/cuda/filters.hpp
View File

@ -48,7 +48,7 @@
#include "vec_math.hpp"
#include "type_traits.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
template <typename Ptr2D> struct PointFilter
{
@ -273,6 +273,6 @@ namespace cv { namespace gpu { namespace device
float scale_x, scale_y;
int width, haight;
};
}}} // namespace cv { namespace gpu { namespace device
}}} // namespace cv { namespace gpu { namespace cuda
#endif // __OPENCV_GPU_FILTERS_HPP__

4
modules/core/include/opencv2/core/device/funcattrib.hpp → modules/core/include/opencv2/core/cuda/funcattrib.hpp
View File

@ -45,7 +45,7 @@
#include <cstdio>
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
template<class Func>
void printFuncAttrib(Func& func)
@ -66,6 +66,6 @@ namespace cv { namespace gpu { namespace device
printf("\n");
fflush(stdout);
}
}}} // namespace cv { namespace gpu { namespace device
}}} // namespace cv { namespace gpu { namespace cuda
#endif /* __OPENCV_GPU_DEVICE_FUNCATTRIB_HPP_ */

4
modules/core/include/opencv2/core/device/functional.hpp → modules/core/include/opencv2/core/cuda/functional.hpp
View File

@ -49,7 +49,7 @@
#include "type_traits.hpp"
#include "device_functions.h"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
// Function Objects
template<typename Argument, typename Result> struct unary_function : public std::unary_function<Argument, Result> {};
@ -786,6 +786,6 @@ namespace cv { namespace gpu { namespace device
#define OPENCV_GPU_TRANSFORM_FUNCTOR_TRAITS(type) \
template <> struct TransformFunctorTraits< type > : DefaultTransformFunctorTraits< type >
}}} // namespace cv { namespace gpu { namespace device
}}} // namespace cv { namespace gpu { namespace cuda
#endif // __OPENCV_GPU_FUNCTIONAL_HPP__

4
modules/core/include/opencv2/core/device/limits.hpp → modules/core/include/opencv2/core/cuda/limits.hpp
View File

@ -46,7 +46,7 @@
#include <limits>
#include "common.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
template<class T> struct numeric_limits
{
@ -230,6 +230,6 @@ namespace cv { namespace gpu { namespace device
__device__ __forceinline__ static type signaling_NaN();
static const bool is_signed = true;
};
}}} // namespace cv { namespace gpu { namespace device {
}}} // namespace cv { namespace gpu { namespace cuda {
#endif // __OPENCV_GPU_LIMITS_GPU_HPP__

2
modules/core/include/opencv2/core/device/reduce.hpp → modules/core/include/opencv2/core/cuda/reduce.hpp
View File

@ -47,7 +47,7 @@
#include "detail/reduce.hpp"
#include "detail/reduce_key_val.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
template <int N, typename T, class Op>
__device__ __forceinline__ void reduce(volatile T* smem, T& val, unsigned int tid, const Op& op)

2
modules/core/include/opencv2/core/device/saturate_cast.hpp → modules/core/include/opencv2/core/cuda/saturate_cast.hpp
View File

@ -45,7 +45,7 @@
#include "common.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
template<typename _Tp> __device__ __forceinline__ _Tp saturate_cast(uchar v) { return _Tp(v); }
template<typename _Tp> __device__ __forceinline__ _Tp saturate_cast(schar v) { return _Tp(v); }

14
modules/core/include/opencv2/core/device/scan.hpp → modules/core/include/opencv2/core/cuda/scan.hpp
View File

@ -43,12 +43,12 @@
#ifndef __OPENCV_GPU_SCAN_HPP__
#define __OPENCV_GPU_SCAN_HPP__
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/device/utility.hpp"
#include "opencv2/core/device/warp.hpp"
#include "opencv2/core/device/warp_shuffle.hpp"
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/utility.hpp"
#include "opencv2/core/cuda/warp.hpp"
#include "opencv2/core/cuda/warp_shuffle.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
enum ScanKind { EXCLUSIVE = 0, INCLUSIVE = 1 };
@ -174,13 +174,13 @@ namespace cv { namespace gpu { namespace device
__device__ T warpScanInclusive(T idata, volatile T* s_Data, unsigned int tid)
{
#if __CUDA_ARCH__ >= 300
const unsigned int laneId = cv::gpu::device::Warp::laneId();
const unsigned int laneId = cv::gpu::cuda::Warp::laneId();
// scan on shuffl functions
#pragma unroll
for (int i = 1; i <= (OPENCV_GPU_WARP_SIZE / 2); i *= 2)
{
const T n = cv::gpu::device::shfl_up(idata, i);
const T n = cv::gpu::cuda::shfl_up(idata, i);
if (laneId >= i)
idata += n;
}

2
modules/core/include/opencv2/core/device/simd_functions.hpp → modules/core/include/opencv2/core/cuda/simd_functions.hpp
View File

@ -123,7 +123,7 @@
vmin4(a,b) per-byte unsigned minimum: min(a, b)
*/
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
// 2

2
modules/core/include/opencv2/core/device/static_check.hpp → modules/core/include/opencv2/core/cuda/static_check.hpp
View File

@ -51,7 +51,7 @@
namespace cv { namespace gpu
{
namespace device
namespace cuda
{
template<bool expr> struct Static {};

2
modules/core/include/opencv2/core/device/transform.hpp → modules/core/include/opencv2/core/cuda/transform.hpp
View File

@ -47,7 +47,7 @@
#include "utility.hpp"
#include "detail/transform_detail.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
template <typename T, typename D, typename UnOp, typename Mask>
static inline void transform(PtrStepSz<T> src, PtrStepSz<D> dst, UnOp op, const Mask& mask, cudaStream_t stream)

2
modules/core/include/opencv2/core/device/type_traits.hpp → modules/core/include/opencv2/core/cuda/type_traits.hpp
View File

@ -45,7 +45,7 @@
#include "detail/type_traits_detail.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
template <typename T> struct IsSimpleParameter
{

4
modules/core/include/opencv2/core/device/utility.hpp → modules/core/include/opencv2/core/cuda/utility.hpp
View File

@ -46,7 +46,7 @@
#include "saturate_cast.hpp"
#include "datamov_utils.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
#define OPENCV_GPU_LOG_WARP_SIZE (5)
#define OPENCV_GPU_WARP_SIZE (1 << OPENCV_GPU_LOG_WARP_SIZE)
@ -208,6 +208,6 @@ namespace cv { namespace gpu { namespace device
return false;
}
}}} // namespace cv { namespace gpu { namespace device
}}} // namespace cv { namespace gpu { namespace cuda
#endif // __OPENCV_GPU_UTILITY_HPP__

4
modules/core/include/opencv2/core/device/vec_distance.hpp → modules/core/include/opencv2/core/cuda/vec_distance.hpp
View File

@ -47,7 +47,7 @@
#include "functional.hpp"
#include "detail/vec_distance_detail.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
template <typename T> struct L1Dist
{
@ -219,6 +219,6 @@ namespace cv { namespace gpu { namespace device
U vec1Vals[MAX_LEN / THREAD_DIM];
};
}}} // namespace cv { namespace gpu { namespace device
}}} // namespace cv { namespace gpu { namespace cuda
#endif // __OPENCV_GPU_VEC_DISTANCE_HPP__

4
modules/core/include/opencv2/core/device/vec_math.hpp → modules/core/include/opencv2/core/cuda/vec_math.hpp
View File

@ -47,7 +47,7 @@
#include "vec_traits.hpp"
#include "functional.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace vec_math_detail
{
@ -325,6 +325,6 @@ namespace cv { namespace gpu { namespace device
#undef OPENCV_GPU_IMPLEMENT_VEC_BINOP
#undef OPENCV_GPU_IMPLEMENT_VEC_OP
#undef OPENCV_GPU_IMPLEMENT_VEC_INT_OP
}}} // namespace cv { namespace gpu { namespace device
}}} // namespace cv { namespace gpu { namespace cuda
#endif // __OPENCV_GPU_VECMATH_HPP__

4
modules/core/include/opencv2/core/device/vec_traits.hpp → modules/core/include/opencv2/core/cuda/vec_traits.hpp
View File

@ -45,7 +45,7 @@
#include "common.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
template<typename T, int N> struct TypeVec;
@ -275,6 +275,6 @@ namespace cv { namespace gpu { namespace device
static __device__ __host__ __forceinline__ char8 make(schar a0, schar a1, schar a2, schar a3, schar a4, schar a5, schar a6, schar a7) {return make_char8(a0, a1, a2, a3, a4, a5, a6, a7);}
static __device__ __host__ __forceinline__ char8 make(const schar* v) {return make_char8(v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7]);}
};
}}} // namespace cv { namespace gpu { namespace device
}}} // namespace cv { namespace gpu { namespace cuda
#endif // __OPENCV_GPU_VEC_TRAITS_HPP__

4
modules/core/include/opencv2/core/device/warp.hpp → modules/core/include/opencv2/core/cuda/warp.hpp
View File

@ -43,7 +43,7 @@
#ifndef __OPENCV_GPU_DEVICE_WARP_HPP__
#define __OPENCV_GPU_DEVICE_WARP_HPP__
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
struct Warp
{
@ -126,6 +126,6 @@ namespace cv { namespace gpu { namespace device
*t = value;
}
};
}}} // namespace cv { namespace gpu { namespace device
}}} // namespace cv { namespace gpu { namespace cuda
#endif /* __OPENCV_GPU_DEVICE_WARP_HPP__ */

4
modules/core/include/opencv2/core/device/warp_reduce.hpp → modules/core/include/opencv2/core/cuda/warp_reduce.hpp
View File

@ -43,7 +43,7 @@
#ifndef OPENCV_GPU_WARP_REDUCE_HPP__
#define OPENCV_GPU_WARP_REDUCE_HPP__
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
template <class T>
__device__ __forceinline__ T warp_reduce(volatile T *ptr , const unsigned int tid = threadIdx.x)
@ -63,6 +63,6 @@ namespace cv { namespace gpu { namespace device
return ptr[tid - lane];
}
}}} // namespace cv { namespace gpu { namespace device {
}}} // namespace cv { namespace gpu { namespace cuda {
#endif /* OPENCV_GPU_WARP_REDUCE_HPP__ */

2
modules/core/include/opencv2/core/device/warp_shuffle.hpp → modules/core/include/opencv2/core/cuda/warp_shuffle.hpp
View File

@ -43,7 +43,7 @@
#ifndef __OPENCV_GPU_WARP_SHUFFLE_HPP__
#define __OPENCV_GPU_WARP_SHUFFLE_HPP__
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
template <typename T>
__device__ __forceinline__ T shfl(T val, int srcLane, int width = warpSize)

18
modules/core/include/opencv2/core/cuda_devptrs.hpp
View File

@ -148,24 +148,6 @@ namespace cv
typedef DevMem2Db DevMem2D;
typedef DevMem2D_<float> DevMem2Df;
typedef DevMem2D_<int> DevMem2Di;
//#undef __CV_GPU_DEPR_BEFORE__
//#undef __CV_GPU_DEPR_AFTER__
namespace device
{
using cv::gpu::PtrSz;
using cv::gpu::PtrStep;
using cv::gpu::PtrStepSz;
using cv::gpu::PtrStepSzb;
using cv::gpu::PtrStepSzf;
using cv::gpu::PtrStepSzi;
using cv::gpu::PtrStepb;
using cv::gpu::PtrStepf;
using cv::gpu::PtrStepi;
}
}
}

20
modules/core/src/cuda/matrix_operations.cu
View File

@ -40,12 +40,12 @@
//
//M*/
#include "opencv2/core/device/saturate_cast.hpp"
#include "opencv2/core/device/transform.hpp"
#include "opencv2/core/device/functional.hpp"
#include "opencv2/core/device/type_traits.hpp"
#include "opencv2/core/cuda/saturate_cast.hpp"
#include "opencv2/core/cuda/transform.hpp"
#include "opencv2/core/cuda/functional.hpp"
#include "opencv2/core/cuda/type_traits.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
void writeScalar(const uchar*);
void writeScalar(const schar*);
@ -58,7 +58,7 @@ namespace cv { namespace gpu { namespace device
void convert_gpu(PtrStepSzb, int, PtrStepSzb, int, double, double, cudaStream_t);
}}}
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
template <typename T> struct shift_and_sizeof;
template <> struct shift_and_sizeof<signed char> { enum { shift = 0 }; };
@ -76,9 +76,9 @@ namespace cv { namespace gpu { namespace device
template <typename T> void copyToWithMask(PtrStepSzb src, PtrStepSzb dst, int cn, PtrStepSzb mask, bool colorMask, cudaStream_t stream)
{
if (colorMask)
cv::gpu::device::transform((PtrStepSz<T>)src, (PtrStepSz<T>)dst, identity<T>(), SingleMask(mask), stream);
cv::gpu::cuda::transform((PtrStepSz<T>)src, (PtrStepSz<T>)dst, identity<T>(), SingleMask(mask), stream);
else
cv::gpu::device::transform((PtrStepSz<T>)src, (PtrStepSz<T>)dst, identity<T>(), SingleMaskChannels(mask, cn), stream);
cv::gpu::cuda::transform((PtrStepSz<T>)src, (PtrStepSz<T>)dst, identity<T>(), SingleMaskChannels(mask, cn), stream);
}
void copyToWithMask_gpu(PtrStepSzb src, PtrStepSzb dst, size_t elemSize1, int cn, PtrStepSzb mask, bool colorMask, cudaStream_t stream)
@ -293,7 +293,7 @@ namespace cv { namespace gpu { namespace device
cudaSafeCall( cudaSetDoubleForDevice(&alpha) );
cudaSafeCall( cudaSetDoubleForDevice(&beta) );
Convertor<T, D, S> op(static_cast<S>(alpha), static_cast<S>(beta));
cv::gpu::device::transform((PtrStepSz<T>)src, (PtrStepSz<D>)dst, op, WithOutMask(), stream);
cv::gpu::cuda::transform((PtrStepSz<T>)src, (PtrStepSz<D>)dst, op, WithOutMask(), stream);
}
#if defined __clang__
@ -379,4 +379,4 @@ namespace cv { namespace gpu { namespace device
#if defined __clang__
# pragma clang diagnostic pop
#endif
}}} // namespace cv { namespace gpu { namespace device
}}} // namespace cv { namespace gpu { namespace cuda

12
modules/core/src/gpumat.cpp
View File

@ -870,7 +870,7 @@ namespace
#else // HAVE_CUDA
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
void copyToWithMask_gpu(PtrStepSzb src, PtrStepSzb dst, size_t elemSize1, int cn, PtrStepSzb mask, bool colorMask, cudaStream_t stream);
@ -888,13 +888,13 @@ namespace
template <typename T> void kernelSetCaller(GpuMat& src, Scalar s, cudaStream_t stream)
{
Scalar_<T> sf = s;
cv::gpu::device::set_to_gpu(src, sf.val, src.channels(), stream);
cv::gpu::cuda::set_to_gpu(src, sf.val, src.channels(), stream);
}
template <typename T> void kernelSetCaller(GpuMat& src, Scalar s, const GpuMat& mask, cudaStream_t stream)
{
Scalar_<T> sf = s;
cv::gpu::device::set_to_gpu(src, sf.val, mask, src.channels(), stream);
cv::gpu::cuda::set_to_gpu(src, sf.val, mask, src.channels(), stream);
}
}
@ -918,17 +918,17 @@ namespace cv { namespace gpu
CV_Assert(src.size() == dst.size() && src.type() == dst.type());
CV_Assert(src.size() == mask.size() && mask.depth() == CV_8U && (mask.channels() == 1 || mask.channels() == src.channels()));
cv::gpu::device::copyToWithMask_gpu(src.reshape(1), dst.reshape(1), src.elemSize1(), src.channels(), mask.reshape(1), mask.channels() != 1, stream);
cv::gpu::cuda::copyToWithMask_gpu(src.reshape(1), dst.reshape(1), src.elemSize1(), src.channels(), mask.reshape(1), mask.channels() != 1, stream);
}
void convertTo(const GpuMat& src, GpuMat& dst)
{
cv::gpu::device::convert_gpu(src.reshape(1), src.depth(), dst.reshape(1), dst.depth(), 1.0, 0.0, 0);
cv::gpu::cuda::convert_gpu(src.reshape(1), src.depth(), dst.reshape(1), dst.depth(), 1.0, 0.0, 0);
}
void convertTo(const GpuMat& src, GpuMat& dst, double alpha, double beta, cudaStream_t stream = 0)
{
cv::gpu::device::convert_gpu(src.reshape(1), src.depth(), dst.reshape(1), dst.depth(), alpha, beta, stream);
cv::gpu::cuda::convert_gpu(src.reshape(1), src.depth(), dst.reshape(1), dst.depth(), alpha, beta, stream);
}
void setTo(GpuMat& src, Scalar s, cudaStream_t stream)

6
modules/gpu/src/arithm.cpp
View File

@ -444,7 +444,7 @@ void cv::gpu::magnitudeSqr(const GpuMat& src, GpuMat& dst, Stream& stream)
////////////////////////////////////////////////////////////////////////
// Polar <-> Cart
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace mathfunc
{
@ -457,7 +457,7 @@ namespace
{
inline void cartToPolar_caller(const GpuMat& x, const GpuMat& y, GpuMat* mag, bool magSqr, GpuMat* angle, bool angleInDegrees, cudaStream_t stream)
{
using namespace ::cv::gpu::device::mathfunc;
using namespace ::cv::gpu::cuda::mathfunc;
CV_Assert(x.size() == y.size() && x.type() == y.type());
CV_Assert(x.depth() == CV_32F);
@ -477,7 +477,7 @@ namespace
inline void polarToCart_caller(const GpuMat& mag, const GpuMat& angle, GpuMat& x, GpuMat& y, bool angleInDegrees, cudaStream_t stream)
{
using namespace ::cv::gpu::device::mathfunc;
using namespace ::cv::gpu::cuda::mathfunc;
CV_Assert((mag.empty() || mag.size() == angle.size()) && mag.type() == angle.type());
CV_Assert(mag.depth() == CV_32F);

6
modules/gpu/src/bgfg_gmg.cpp
View File

@ -51,7 +51,7 @@ void cv::gpu::GMG_GPU::release() {}
#else
namespace cv { namespace gpu { namespace device {
namespace cv { namespace gpu { namespace cuda {
namespace bgfg_gmg
{
void loadConstants(int width, int height, float minVal, float maxVal, int quantizationLevels, float backgroundPrior,
@ -77,7 +77,7 @@ cv::gpu::GMG_GPU::GMG_GPU()
void cv::gpu::GMG_GPU::initialize(cv::Size frameSize, float min, float max)
{
using namespace cv::gpu::device::bgfg_gmg;
using namespace cv::gpu::cuda::bgfg_gmg;
CV_Assert(min < max);
CV_Assert(maxFeatures > 0);
@ -107,7 +107,7 @@ void cv::gpu::GMG_GPU::initialize(cv::Size frameSize, float min, float max)
void cv::gpu::GMG_GPU::operator ()(const cv::gpu::GpuMat& frame, cv::gpu::GpuMat& fgmask, float newLearningRate, cv::gpu::Stream& stream)
{
using namespace cv::gpu::device::bgfg_gmg;
using namespace cv::gpu::cuda::bgfg_gmg;
typedef void (*func_t)(PtrStepSzb frame, PtrStepb fgmask, PtrStepSzi colors, PtrStepf weights, PtrStepi nfeatures,
int frameNum, float learningRate, bool updateBackgroundModel, cudaStream_t stream);

12
modules/gpu/src/bgfg_mog.cpp
View File

@ -58,7 +58,7 @@ void cv::gpu::MOG2_GPU::release() {}
#else
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace mog
{
@ -123,7 +123,7 @@ void cv::gpu::MOG_GPU::initialize(cv::Size frameSize, int frameType)
void cv::gpu::MOG_GPU::operator()(const cv::gpu::GpuMat& frame, cv::gpu::GpuMat& fgmask, float learningRate, Stream& stream)
{
using namespace cv::gpu::device::mog;
using namespace cv::gpu::cuda::mog;
CV_Assert(frame.depth() == CV_8U);
@ -146,7 +146,7 @@ void cv::gpu::MOG_GPU::operator()(const cv::gpu::GpuMat& frame, cv::gpu::GpuMat&
void cv::gpu::MOG_GPU::getBackgroundImage(GpuMat& backgroundImage, Stream& stream) const
{
using namespace cv::gpu::device::mog;
using namespace cv::gpu::cuda::mog;
backgroundImage.create(frameSize_, frameType_);
@ -208,7 +208,7 @@ cv::gpu::MOG2_GPU::MOG2_GPU(int nmixtures) :
void cv::gpu::MOG2_GPU::initialize(cv::Size frameSize, int frameType)
{
using namespace cv::gpu::device::mog;
using namespace cv::gpu::cuda::mog;
CV_Assert(frameType == CV_8UC1 || frameType == CV_8UC3 || frameType == CV_8UC4);
@ -236,7 +236,7 @@ void cv::gpu::MOG2_GPU::initialize(cv::Size frameSize, int frameType)
void cv::gpu::MOG2_GPU::operator()(const GpuMat& frame, GpuMat& fgmask, float learningRate, Stream& stream)
{
using namespace cv::gpu::device::mog;
using namespace cv::gpu::cuda::mog;
int ch = frame.channels();
int work_ch = ch;
@ -256,7 +256,7 @@ void cv::gpu::MOG2_GPU::operator()(const GpuMat& frame, GpuMat& fgmask, float le
void cv::gpu::MOG2_GPU::getBackgroundImage(GpuMat& backgroundImage, Stream& stream) const
{
using namespace cv::gpu::device::mog;
using namespace cv::gpu::cuda::mog;
backgroundImage.create(frameSize_, frameType_);

4
modules/gpu/src/bilateral_filter.cpp
View File

@ -54,7 +54,7 @@ void cv::gpu::DisparityBilateralFilter::operator()(const GpuMat&, const GpuMat&,
#else /* !defined (HAVE_CUDA) */
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace disp_bilateral_filter
{
@ -65,7 +65,7 @@ namespace cv { namespace gpu { namespace device
}
}}}
using namespace ::cv::gpu::device::disp_bilateral_filter;
using namespace ::cv::gpu::cuda::disp_bilateral_filter;
namespace
{

4
modules/gpu/src/blend.cpp
View File

@ -51,7 +51,7 @@ void cv::gpu::blendLinear(const GpuMat&, const GpuMat&, const GpuMat&, const Gpu
#else
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace blend
{
@ -62,7 +62,7 @@ namespace cv { namespace gpu { namespace device
}
}}}
using namespace ::cv::gpu::device::blend;
using namespace ::cv::gpu::cuda::blend;
void cv::gpu::blendLinear(const GpuMat& img1, const GpuMat& img2, const GpuMat& weights1, const GpuMat& weights2,
GpuMat& result, Stream& stream)

14
modules/gpu/src/brute_force_matcher.cpp
View File

@ -81,7 +81,7 @@ void cv::gpu::BFMatcher_GPU::radiusMatch(const GpuMat&, std::vector< std::vector
#else /* !defined (HAVE_CUDA) */
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace bf_match
{
@ -197,7 +197,7 @@ void cv::gpu::BFMatcher_GPU::matchSingle(const GpuMat& query, const GpuMat& trai
if (query.empty() || train.empty())
return;
using namespace cv::gpu::device::bf_match;
using namespace cv::gpu::cuda::bf_match;
typedef void (*caller_t)(const PtrStepSzb& query, const PtrStepSzb& train, const PtrStepSzb& mask,
const PtrStepSzi& trainIdx, const PtrStepSzf& distance,
@ -340,7 +340,7 @@ void cv::gpu::BFMatcher_GPU::matchCollection(const GpuMat& query, const GpuMat&
if (query.empty() || trainCollection.empty())
return;
using namespace cv::gpu::device::bf_match;
using namespace cv::gpu::cuda::bf_match;
typedef void (*caller_t)(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks,
const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance,
@ -451,7 +451,7 @@ void cv::gpu::BFMatcher_GPU::knnMatchSingle(const GpuMat& query, const GpuMat& t
if (query.empty() || train.empty())
return;
using namespace cv::gpu::device::bf_knnmatch;
using namespace cv::gpu::cuda::bf_knnmatch;
typedef void (*caller_t)(const PtrStepSzb& query, const PtrStepSzb& train, int k, const PtrStepSzb& mask,
const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist,
@ -580,7 +580,7 @@ void cv::gpu::BFMatcher_GPU::knnMatch2Collection(const GpuMat& query, const GpuM
if (query.empty() || trainCollection.empty())
return;
using namespace cv::gpu::device::bf_knnmatch;
using namespace cv::gpu::cuda::bf_knnmatch;
typedef void (*caller_t)(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks,
const PtrStepSzb& trainIdx, const PtrStepSzb& imgIdx, const PtrStepSzb& distance,
@ -761,7 +761,7 @@ void cv::gpu::BFMatcher_GPU::radiusMatchSingle(const GpuMat& query, const GpuMat
if (query.empty() || train.empty())
return;
using namespace cv::gpu::device::bf_radius_match;
using namespace cv::gpu::cuda::bf_radius_match;
typedef void (*caller_t)(const PtrStepSzb& query, const PtrStepSzb& train, float maxDistance, const PtrStepSzb& mask,
const PtrStepSzi& trainIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches,
@ -890,7 +890,7 @@ void cv::gpu::BFMatcher_GPU::radiusMatchCollection(const GpuMat& query, GpuMat&
if (query.empty() || empty())
return;
using namespace cv::gpu::device::bf_radius_match;
using namespace cv::gpu::cuda::bf_radius_match;
typedef void (*caller_t)(const PtrStepSzb& query, const PtrStepSzb* trains, int n, float maxDistance, const PtrStepSzb* masks,
const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches,

4
modules/gpu/src/calib3d.cpp
View File

@ -55,7 +55,7 @@ void cv::gpu::solvePnPRansac(const Mat&, const Mat&, const Mat&, const Mat&, Mat
#else
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace transform_points
{
@ -78,7 +78,7 @@ namespace cv { namespace gpu { namespace device
}
}}}
using namespace ::cv::gpu::device;
using namespace ::cv::gpu::cuda;
namespace
{

6
modules/gpu/src/cascadeclassifier.cpp
View File

@ -340,7 +340,7 @@ struct PyrLavel
cv::Size sWindow;
};
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace lbp
{
@ -441,7 +441,7 @@ public:
acc += level.sFrame.width + 1;
}
device::lbp::classifyPyramid(image.cols, image.rows, NxM.width - 1, NxM.height - 1, iniScale, scaleFactor, total, stage_mat, stage_mat.cols / sizeof(Stage), nodes_mat,
cuda::lbp::classifyPyramid(image.cols, image.rows, NxM.width - 1, NxM.height - 1, iniScale, scaleFactor, total, stage_mat, stage_mat.cols / sizeof(Stage), nodes_mat,
leaves_mat, subsets_mat, features_mat, subsetSize, candidates, dclassified.ptr<unsigned int>(), integral);
}
@ -449,7 +449,7 @@ public:
return 0;
cudaSafeCall( cudaMemcpy(&classified, dclassified.ptr(), sizeof(int), cudaMemcpyDeviceToHost) );
device::lbp::connectedConmonents(candidates, classified, objects, groupThreshold, grouping_eps, dclassified.ptr<unsigned int>());
cuda::lbp::connectedConmonents(candidates, classified, objects, groupThreshold, grouping_eps, dclassified.ptr<unsigned int>());
cudaSafeCall( cudaMemcpy(&classified, dclassified.ptr(), sizeof(int), cudaMemcpyDeviceToHost) );
cudaSafeCall( cudaDeviceSynchronize() );

162
modules/gpu/src/color.cpp
View File

@ -57,7 +57,7 @@ void cv::gpu::gammaCorrection(const GpuMat&, GpuMat&, bool, Stream&) { throw_nog
#include "cvt_color_internal.h"
namespace cv { namespace gpu {
namespace device
namespace cuda
{
template <int cn>
void Bayer2BGR_8u_gpu(PtrStepSzb src, PtrStepSzb dst, bool blue_last, bool start_with_green, cudaStream_t stream);
@ -69,7 +69,7 @@ namespace cv { namespace gpu {
}
}}
using namespace ::cv::gpu::device;
using namespace ::cv::gpu::cuda;
namespace
{
@ -77,7 +77,7 @@ namespace
void bgr_to_rgb(const GpuMat& src, GpuMat& dst, int, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[] = {bgr_to_rgb_8u, 0, bgr_to_rgb_16u, 0, 0, bgr_to_rgb_32f};
CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_32F);
@ -90,7 +90,7 @@ namespace
void bgr_to_bgra(const GpuMat& src, GpuMat& dst, int, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[] = {bgr_to_bgra_8u, 0, bgr_to_bgra_16u, 0, 0, bgr_to_bgra_32f};
CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_32F);
@ -103,7 +103,7 @@ namespace
void bgr_to_rgba(const GpuMat& src, GpuMat& dst, int, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[] = {bgr_to_rgba_8u, 0, bgr_to_rgba_16u, 0, 0, bgr_to_rgba_32f};
CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_32F);
@ -116,7 +116,7 @@ namespace
void bgra_to_bgr(const GpuMat& src, GpuMat& dst, int, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[] = {bgra_to_bgr_8u, 0, bgra_to_bgr_16u, 0, 0, bgra_to_bgr_32f};
CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_32F);
@ -129,7 +129,7 @@ namespace
void bgra_to_rgb(const GpuMat& src, GpuMat& dst, int, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[] = {bgra_to_rgb_8u, 0, bgra_to_rgb_16u, 0, 0, bgra_to_rgb_32f};
CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_32F);
@ -142,7 +142,7 @@ namespace
void bgra_to_rgba(const GpuMat& src, GpuMat& dst, int, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[] = {bgra_to_rgba_8u, 0, bgra_to_rgba_16u, 0, 0, bgra_to_rgba_32f};
CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_32F);
@ -160,7 +160,7 @@ namespace
dst.create(src.size(), CV_8UC2);
device::bgr_to_bgr555(src, dst, StreamAccessor::getStream(stream));
cuda::bgr_to_bgr555(src, dst, StreamAccessor::getStream(stream));
}
void bgr_to_bgr565(const GpuMat& src, GpuMat& dst, int, Stream& stream)
@ -170,7 +170,7 @@ namespace
dst.create(src.size(), CV_8UC2);
device::bgr_to_bgr565(src, dst, StreamAccessor::getStream(stream));
cuda::bgr_to_bgr565(src, dst, StreamAccessor::getStream(stream));
}
void rgb_to_bgr555(const GpuMat& src, GpuMat& dst, int, Stream& stream)
@ -180,7 +180,7 @@ namespace
dst.create(src.size(), CV_8UC2);
device::rgb_to_bgr555(src, dst, StreamAccessor::getStream(stream));
cuda::rgb_to_bgr555(src, dst, StreamAccessor::getStream(stream));
}
void rgb_to_bgr565(const GpuMat& src, GpuMat& dst, int, Stream& stream)
@ -190,7 +190,7 @@ namespace
dst.create(src.size(), CV_8UC2);
device::rgb_to_bgr565(src, dst, StreamAccessor::getStream(stream));
cuda::rgb_to_bgr565(src, dst, StreamAccessor::getStream(stream));
}
void bgra_to_bgr555(const GpuMat& src, GpuMat& dst, int, Stream& stream)
@ -200,7 +200,7 @@ namespace
dst.create(src.size(), CV_8UC2);
device::bgra_to_bgr555(src, dst, StreamAccessor::getStream(stream));
cuda::bgra_to_bgr555(src, dst, StreamAccessor::getStream(stream));
}
void bgra_to_bgr565(const GpuMat& src, GpuMat& dst, int, Stream& stream)
@ -210,7 +210,7 @@ namespace
dst.create(src.size(), CV_8UC2);
device::bgra_to_bgr565(src, dst, StreamAccessor::getStream(stream));
cuda::bgra_to_bgr565(src, dst, StreamAccessor::getStream(stream));
}
void rgba_to_bgr555(const GpuMat& src, GpuMat& dst, int, Stream& stream)
@ -220,7 +220,7 @@ namespace
dst.create(src.size(), CV_8UC2);
device::rgba_to_bgr555(src, dst, StreamAccessor::getStream(stream));
cuda::rgba_to_bgr555(src, dst, StreamAccessor::getStream(stream));
}
void rgba_to_bgr565(const GpuMat& src, GpuMat& dst, int, Stream& stream)
@ -230,7 +230,7 @@ namespace
dst.create(src.size(), CV_8UC2);
device::rgba_to_bgr565(src, dst, StreamAccessor::getStream(stream));
cuda::rgba_to_bgr565(src, dst, StreamAccessor::getStream(stream));
}
void bgr555_to_rgb(const GpuMat& src, GpuMat& dst, int, Stream& stream)
@ -240,7 +240,7 @@ namespace
dst.create(src.size(), CV_8UC3);
device::bgr555_to_rgb(src, dst, StreamAccessor::getStream(stream));
cuda::bgr555_to_rgb(src, dst, StreamAccessor::getStream(stream));
}
void bgr565_to_rgb(const GpuMat& src, GpuMat& dst, int, Stream& stream)
@ -250,7 +250,7 @@ namespace
dst.create(src.size(), CV_8UC3);
device::bgr565_to_rgb(src, dst, StreamAccessor::getStream(stream));
cuda::bgr565_to_rgb(src, dst, StreamAccessor::getStream(stream));
}
void bgr555_to_bgr(const GpuMat& src, GpuMat& dst, int, Stream& stream)
@ -260,7 +260,7 @@ namespace
dst.create(src.size(), CV_8UC3);
device::bgr555_to_bgr(src, dst, StreamAccessor::getStream(stream));
cuda::bgr555_to_bgr(src, dst, StreamAccessor::getStream(stream));
}
void bgr565_to_bgr(const GpuMat& src, GpuMat& dst, int, Stream& stream)
@ -270,7 +270,7 @@ namespace
dst.create(src.size(), CV_8UC3);
device::bgr565_to_bgr(src, dst, StreamAccessor::getStream(stream));
cuda::bgr565_to_bgr(src, dst, StreamAccessor::getStream(stream));
}
void bgr555_to_rgba(const GpuMat& src, GpuMat& dst, int, Stream& stream)
@ -280,7 +280,7 @@ namespace
dst.create(src.size(), CV_8UC4);
device::bgr555_to_rgba(src, dst, StreamAccessor::getStream(stream));
cuda::bgr555_to_rgba(src, dst, StreamAccessor::getStream(stream));
}
void bgr565_to_rgba(const GpuMat& src, GpuMat& dst, int, Stream& stream)
@ -290,7 +290,7 @@ namespace
dst.create(src.size(), CV_8UC4);
device::bgr565_to_rgba(src, dst, StreamAccessor::getStream(stream));
cuda::bgr565_to_rgba(src, dst, StreamAccessor::getStream(stream));
}
void bgr555_to_bgra(const GpuMat& src, GpuMat& dst, int, Stream& stream)
@ -300,7 +300,7 @@ namespace
dst.create(src.size(), CV_8UC4);
device::bgr555_to_bgra(src, dst, StreamAccessor::getStream(stream));
cuda::bgr555_to_bgra(src, dst, StreamAccessor::getStream(stream));
}
void bgr565_to_bgra(const GpuMat& src, GpuMat& dst, int, Stream& stream)
@ -310,12 +310,12 @@ namespace
dst.create(src.size(), CV_8UC4);
device::bgr565_to_bgra(src, dst, StreamAccessor::getStream(stream));
cuda::bgr565_to_bgra(src, dst, StreamAccessor::getStream(stream));
}
void gray_to_bgr(const GpuMat& src, GpuMat& dst, int, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[] = {gray_to_bgr_8u, 0, gray_to_bgr_16u, 0, 0, gray_to_bgr_32f};
CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_32F);
@ -328,7 +328,7 @@ namespace
void gray_to_bgra(const GpuMat& src, GpuMat& dst, int, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[] = {gray_to_bgra_8u, 0, gray_to_bgra_16u, 0, 0, gray_to_bgra_32f};
CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_32F);
@ -346,7 +346,7 @@ namespace
dst.create(src.size(), CV_8UC2);
device::gray_to_bgr555(src, dst, StreamAccessor::getStream(stream));
cuda::gray_to_bgr555(src, dst, StreamAccessor::getStream(stream));
}
void gray_to_bgr565(const GpuMat& src, GpuMat& dst, int, Stream& stream)
@ -356,7 +356,7 @@ namespace
dst.create(src.size(), CV_8UC2);
device::gray_to_bgr565(src, dst, StreamAccessor::getStream(stream));
cuda::gray_to_bgr565(src, dst, StreamAccessor::getStream(stream));
}
void bgr555_to_gray(const GpuMat& src, GpuMat& dst, int, Stream& stream)
@ -366,7 +366,7 @@ namespace
dst.create(src.size(), CV_8UC1);
device::bgr555_to_gray(src, dst, StreamAccessor::getStream(stream));
cuda::bgr555_to_gray(src, dst, StreamAccessor::getStream(stream));
}
void bgr565_to_gray(const GpuMat& src, GpuMat& dst, int, Stream& stream)
@ -376,12 +376,12 @@ namespace
dst.create(src.size(), CV_8UC1);
device::bgr565_to_gray(src, dst, StreamAccessor::getStream(stream));
cuda::bgr565_to_gray(src, dst, StreamAccessor::getStream(stream));
}
void rgb_to_gray(const GpuMat& src, GpuMat& dst, int, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[] = {rgb_to_gray_8u, 0, rgb_to_gray_16u, 0, 0, rgb_to_gray_32f};
CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_32F);
@ -394,7 +394,7 @@ namespace
void bgr_to_gray(const GpuMat& src, GpuMat& dst, int, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[] = {bgr_to_gray_8u, 0, bgr_to_gray_16u, 0, 0, bgr_to_gray_32f};
CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_32F);
@ -407,7 +407,7 @@ namespace
void rgba_to_gray(const GpuMat& src, GpuMat& dst, int, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[] = {rgba_to_gray_8u, 0, rgba_to_gray_16u, 0, 0, rgba_to_gray_32f};
CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_32F);
@ -420,7 +420,7 @@ namespace
void bgra_to_gray(const GpuMat& src, GpuMat& dst, int, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[] = {bgra_to_gray_8u, 0, bgra_to_gray_16u, 0, 0, bgra_to_gray_32f};
CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_32F);
@ -433,7 +433,7 @@ namespace
void rgb_to_yuv(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[2][2][6] =
{
{
@ -459,7 +459,7 @@ namespace
void bgr_to_yuv(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[2][2][6] =
{
{
@ -485,7 +485,7 @@ namespace
void yuv_to_rgb(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[2][2][6] =
{
{
@ -511,7 +511,7 @@ namespace
void yuv_to_bgr(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[2][2][6] =
{
{
@ -537,7 +537,7 @@ namespace
void rgb_to_YCrCb(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[2][2][6] =
{
{
@ -563,7 +563,7 @@ namespace
void bgr_to_YCrCb(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[2][2][6] =
{
{
@ -589,7 +589,7 @@ namespace
void YCrCb_to_rgb(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[2][2][6] =
{
{
@ -615,7 +615,7 @@ namespace
void YCrCb_to_bgr(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[2][2][6] =
{
{
@ -641,7 +641,7 @@ namespace
void rgb_to_xyz(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[2][2][6] =
{
{
@ -667,7 +667,7 @@ namespace
void bgr_to_xyz(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[2][2][6] =
{
{
@ -693,7 +693,7 @@ namespace
void xyz_to_rgb(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[2][2][6] =
{
{
@ -719,7 +719,7 @@ namespace
void xyz_to_bgr(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[2][2][6] =
{
{
@ -745,7 +745,7 @@ namespace
void rgb_to_hsv(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[2][2][6] =
{
{
@ -771,7 +771,7 @@ namespace
void bgr_to_hsv(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[2][2][6] =
{
{
@ -797,7 +797,7 @@ namespace
void hsv_to_rgb(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[2][2][6] =
{
{
@ -823,7 +823,7 @@ namespace
void hsv_to_bgr(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[2][2][6] =
{
{
@ -849,7 +849,7 @@ namespace
void rgb_to_hls(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[2][2][6] =
{
{
@ -875,7 +875,7 @@ namespace
void bgr_to_hls(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[2][2][6] =
{
{
@ -901,7 +901,7 @@ namespace
void hls_to_rgb(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[2][2][6] =
{
{
@ -927,7 +927,7 @@ namespace
void hls_to_bgr(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[2][2][6] =
{
{
@ -953,7 +953,7 @@ namespace
void rgb_to_hsv_full(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[2][2][6] =
{
{
@ -979,7 +979,7 @@ namespace
void bgr_to_hsv_full(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[2][2][6] =
{
{
@ -1005,7 +1005,7 @@ namespace
void hsv_to_rgb_full(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[2][2][6] =
{
{
@ -1031,7 +1031,7 @@ namespace
void hsv_to_bgr_full(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[2][2][6] =
{
{
@ -1057,7 +1057,7 @@ namespace
void rgb_to_hls_full(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[2][2][6] =
{
{
@ -1083,7 +1083,7 @@ namespace
void bgr_to_hls_full(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[2][2][6] =
{
{
@ -1109,7 +1109,7 @@ namespace
void hls_to_rgb_full(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[2][2][6] =
{
{
@ -1135,7 +1135,7 @@ namespace
void hls_to_bgr_full(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[2][2][6] =
{
{
@ -1161,7 +1161,7 @@ namespace
void bgr_to_lab(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[2][2][2] =
{
{
@ -1187,7 +1187,7 @@ namespace
void rgb_to_lab(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[2][2][2] =
{
{
@ -1213,7 +1213,7 @@ namespace
void lbgr_to_lab(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[2][2][2] =
{
{
@ -1239,7 +1239,7 @@ namespace
void lrgb_to_lab(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[2][2][2] =
{
{
@ -1265,7 +1265,7 @@ namespace
void lab_to_bgr(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[2][2][2] =
{
{
@ -1291,7 +1291,7 @@ namespace
void lab_to_rgb(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[2][2][2] =
{
{
@ -1317,7 +1317,7 @@ namespace
void lab_to_lbgr(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[2][2][2] =
{
{
@ -1343,7 +1343,7 @@ namespace
void lab_to_lrgb(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[2][2][2] =
{
{
@ -1369,7 +1369,7 @@ namespace
void bgr_to_luv(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[2][2][2] =
{
{
@ -1395,7 +1395,7 @@ namespace
void rgb_to_luv(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[2][2][2] =
{
{
@ -1421,7 +1421,7 @@ namespace
void lbgr_to_luv(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[2][2][2] =
{
{
@ -1447,7 +1447,7 @@ namespace
void lrgb_to_luv(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[2][2][2] =
{
{
@ -1473,7 +1473,7 @@ namespace
void luv_to_bgr(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[2][2][2] =
{
{
@ -1499,7 +1499,7 @@ namespace
void luv_to_rgb(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[2][2][2] =
{
{
@ -1525,7 +1525,7 @@ namespace
void luv_to_lbgr(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[2][2][2] =
{
{
@ -1551,7 +1551,7 @@ namespace
void luv_to_lrgb(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
{
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
static const gpu_func_t funcs[2][2][2] =
{
{
@ -1895,9 +1895,9 @@ void cv::gpu::demosaicing(const GpuMat& src, GpuMat& dst, int code, int dcn, Str
code == COLOR_BayerRG2BGR_MHT || code == COLOR_BayerGR2BGR_MHT ? 0 : 1);
if (dcn == 3)
device::MHCdemosaic<3>(srcWhole, make_int2(ofs.x, ofs.y), dst, firstRed, StreamAccessor::getStream(stream));
cuda::MHCdemosaic<3>(srcWhole, make_int2(ofs.x, ofs.y), dst, firstRed, StreamAccessor::getStream(stream));
else
device::MHCdemosaic<4>(srcWhole, make_int2(ofs.x, ofs.y), dst, firstRed, StreamAccessor::getStream(stream));
cuda::MHCdemosaic<4>(srcWhole, make_int2(ofs.x, ofs.y), dst, firstRed, StreamAccessor::getStream(stream));
break;
}
@ -1917,7 +1917,7 @@ void cv::gpu::demosaicing(const GpuMat& src, GpuMat& dst, int code, int dcn, Str
const int2 firstRed = make_int2(code == COLOR_BayerRG2BGR_MHT || code == COLOR_BayerGB2BGR_MHT ? 0 : 1,
code == COLOR_BayerRG2BGR_MHT || code == COLOR_BayerGR2BGR_MHT ? 0 : 1);
device::MHCdemosaic<1>(srcWhole, make_int2(ofs.x, ofs.y), dst, firstRed, StreamAccessor::getStream(stream));
cuda::MHCdemosaic<1>(srcWhole, make_int2(ofs.x, ofs.y), dst, firstRed, StreamAccessor::getStream(stream));
break;
}

4
modules/gpu/src/cuda/NV12ToARGB.cu
View File

@ -49,9 +49,9 @@
#if !defined CUDA_DISABLER
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/cuda/common.hpp"
namespace cv { namespace gpu { namespace device {
namespace cv { namespace gpu { namespace cuda {
namespace video_decoding
{
__constant__ uint constAlpha = ((uint)0xff << 24);

18
modules/gpu/src/cuda/bf_knnmatch.cu
View File

@ -42,15 +42,15 @@
#if !defined CUDA_DISABLER
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/device/utility.hpp"
#include "opencv2/core/device/reduce.hpp"
#include "opencv2/core/device/limits.hpp"
#include "opencv2/core/device/vec_distance.hpp"
#include "opencv2/core/device/datamov_utils.hpp"
#include "opencv2/core/device/warp_shuffle.hpp"
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/utility.hpp"
#include "opencv2/core/cuda/reduce.hpp"
#include "opencv2/core/cuda/limits.hpp"
#include "opencv2/core/cuda/vec_distance.hpp"
#include "opencv2/core/cuda/datamov_utils.hpp"
#include "opencv2/core/cuda/warp_shuffle.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace bf_knnmatch
{
@ -1249,7 +1249,7 @@ namespace cv { namespace gpu { namespace device
//template void match2Hamming_gpu<short >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzb& trainIdx, const PtrStepSzb& imgIdx, const PtrStepSzb& distance, cudaStream_t stream);
template void match2Hamming_gpu<int >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzb& trainIdx, const PtrStepSzb& imgIdx, const PtrStepSzb& distance, cudaStream_t stream);
} // namespace bf_knnmatch
}}} // namespace cv { namespace gpu { namespace device {
}}} // namespace cv { namespace gpu { namespace cuda {
#endif /* CUDA_DISABLER */

16
modules/gpu/src/cuda/bf_match.cu
View File

@ -42,14 +42,14 @@
#if !defined CUDA_DISABLER
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/device/utility.hpp"
#include "opencv2/core/device/reduce.hpp"
#include "opencv2/core/device/limits.hpp"
#include "opencv2/core/device/vec_distance.hpp"
#include "opencv2/core/device/datamov_utils.hpp"
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/utility.hpp"
#include "opencv2/core/cuda/reduce.hpp"
#include "opencv2/core/cuda/limits.hpp"
#include "opencv2/core/cuda/vec_distance.hpp"
#include "opencv2/core/cuda/datamov_utils.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace bf_match
{
@ -768,7 +768,7 @@ namespace cv { namespace gpu { namespace device
//template void matchHamming_gpu<short >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, cudaStream_t stream);
template void matchHamming_gpu<int >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, cudaStream_t stream);
} // namespace bf_match
}}} // namespace cv { namespace gpu { namespace device {
}}} // namespace cv { namespace gpu { namespace cuda {
#endif /* CUDA_DISABLER */

14
modules/gpu/src/cuda/bf_radius_match.cu
View File

@ -42,13 +42,13 @@
#if !defined CUDA_DISABLER
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/device/utility.hpp"
#include "opencv2/core/device/limits.hpp"
#include "opencv2/core/device/vec_distance.hpp"
#include "opencv2/core/device/datamov_utils.hpp"
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/utility.hpp"
#include "opencv2/core/cuda/limits.hpp"
#include "opencv2/core/cuda/vec_distance.hpp"
#include "opencv2/core/cuda/datamov_utils.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace bf_radius_match
{
@ -457,7 +457,7 @@ namespace cv { namespace gpu { namespace device
//template void matchHamming_gpu<short >(const PtrStepSzb& query, const PtrStepSzb* trains, int n, float maxDistance, const PtrStepSzb* masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, cudaStream_t stream);
template void matchHamming_gpu<int >(const PtrStepSzb& query, const PtrStepSzb* trains, int n, float maxDistance, const PtrStepSzb* masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, cudaStream_t stream);
} // namespace bf_radius_match
}}} // namespace cv { namespace gpu { namespace device
}}} // namespace cv { namespace gpu { namespace cuda
#endif /* CUDA_DISABLER */

8
modules/gpu/src/cuda/bgfg_gmg.cu
View File

@ -42,11 +42,11 @@
#if !defined CUDA_DISABLER
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/device/vec_traits.hpp"
#include "opencv2/core/device/limits.hpp"
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/vec_traits.hpp"
#include "opencv2/core/cuda/limits.hpp"
namespace cv { namespace gpu { namespace device {
namespace cv { namespace gpu { namespace cuda {
namespace bgfg_gmg
{
__constant__ int c_width;

10
modules/gpu/src/cuda/bgfg_mog.cu
View File

@ -42,12 +42,12 @@
#if !defined CUDA_DISABLER
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/device/vec_traits.hpp"
#include "opencv2/core/device/vec_math.hpp"
#include "opencv2/core/device/limits.hpp"
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/vec_traits.hpp"
#include "opencv2/core/cuda/vec_math.hpp"
#include "opencv2/core/cuda/limits.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace mog
{

12
modules/gpu/src/cuda/bilateral_filter.cu
View File

@ -42,10 +42,10 @@
#if !defined CUDA_DISABLER
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/device/vec_traits.hpp"
#include "opencv2/core/device/vec_math.hpp"
#include "opencv2/core/device/border_interpolate.hpp"
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/vec_traits.hpp"
#include "opencv2/core/cuda/vec_math.hpp"
#include "opencv2/core/cuda/border_interpolate.hpp"
using namespace cv::gpu;
@ -55,7 +55,7 @@ typedef unsigned short ushort;
//////////////////////////////////////////////////////////////////////////////////
/// Bilateral filtering
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace imgproc
{
@ -163,7 +163,7 @@ namespace cv { namespace gpu { namespace device
#define OCV_INSTANTIATE_BILATERAL_FILTER(T) \
template void cv::gpu::device::imgproc::bilateral_filter_gpu<T>(const PtrStepSzb&, PtrStepSzb, int, float, float, int, cudaStream_t);
template void cv::gpu::cuda::imgproc::bilateral_filter_gpu<T>(const PtrStepSzb&, PtrStepSzb, int, float, float, int, cudaStream_t);
OCV_INSTANTIATE_BILATERAL_FILTER(uchar)
//OCV_INSTANTIATE_BILATERAL_FILTER(uchar2)

6
modules/gpu/src/cuda/blend.cu
View File

@ -42,9 +42,9 @@
#if !defined CUDA_DISABLER
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/cuda/common.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace blend
{
@ -115,7 +115,7 @@ namespace cv { namespace gpu { namespace device
cudaSafeCall(cudaDeviceSynchronize());
}
} // namespace blend
}}} // namespace cv { namespace gpu { namespace device
}}} // namespace cv { namespace gpu { namespace cuda
#endif /* CUDA_DISABLER */

16
modules/gpu/src/cuda/calib3d.cu
View File

@ -42,12 +42,12 @@
#if !defined CUDA_DISABLER
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/device/transform.hpp"
#include "opencv2/core/device/functional.hpp"
#include "opencv2/core/device/reduce.hpp"
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/transform.hpp"
#include "opencv2/core/cuda/functional.hpp"
#include "opencv2/core/cuda/reduce.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
#define SOLVE_PNP_RANSAC_MAX_NUM_ITERS 200
@ -79,7 +79,7 @@ namespace cv { namespace gpu { namespace device
cudaSafeCall(cudaMemcpyToSymbol(crot1, rot + 3, sizeof(float) * 3));
cudaSafeCall(cudaMemcpyToSymbol(crot2, rot + 6, sizeof(float) * 3));
cudaSafeCall(cudaMemcpyToSymbol(ctransl, transl, sizeof(float) * 3));
cv::gpu::device::transform(src, dst, TransformOp(), WithOutMask(), stream);
cv::gpu::cuda::transform(src, dst, TransformOp(), WithOutMask(), stream);
}
} // namespace transform_points
@ -120,7 +120,7 @@ namespace cv { namespace gpu { namespace device
cudaSafeCall(cudaMemcpyToSymbol(ctransl, transl, sizeof(float) * 3));
cudaSafeCall(cudaMemcpyToSymbol(cproj0, proj, sizeof(float) * 3));
cudaSafeCall(cudaMemcpyToSymbol(cproj1, proj + 3, sizeof(float) * 3));
cv::gpu::device::transform(src, dst, ProjectOp(), WithOutMask(), stream);
cv::gpu::cuda::transform(src, dst, ProjectOp(), WithOutMask(), stream);
}
} // namespace project_points
@ -187,7 +187,7 @@ namespace cv { namespace gpu { namespace device
cudaSafeCall( cudaDeviceSynchronize() );
}
} // namespace solvepnp_ransac
}}} // namespace cv { namespace gpu { namespace device
}}} // namespace cv { namespace gpu { namespace cuda
#endif /* CUDA_DISABLER */

16
modules/gpu/src/cuda/canny.cu
View File

@ -44,14 +44,14 @@
#include <utility>
#include <algorithm>//std::swap
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/device/emulation.hpp"
#include "opencv2/core/device/transform.hpp"
#include "opencv2/core/device/functional.hpp"
#include "opencv2/core/device/utility.hpp"
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/emulation.hpp"
#include "opencv2/core/cuda/transform.hpp"
#include "opencv2/core/cuda/functional.hpp"
#include "opencv2/core/cuda/utility.hpp"
using namespace cv::gpu;
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
namespace canny
{
@ -77,7 +77,7 @@ namespace canny
};
}
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
template <> struct TransformFunctorTraits<canny::L1> : DefaultTransformFunctorTraits<canny::L1>
{
@ -475,7 +475,7 @@ namespace canny
};
}
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
template <> struct TransformFunctorTraits<canny::GetEdges> : DefaultTransformFunctorTraits<canny::GetEdges>
{

10
modules/gpu/src/cuda/ccomponetns.cu
View File

@ -42,15 +42,15 @@
#if !defined CUDA_DISABLER
#include <opencv2/core/device/common.hpp>
#include <opencv2/core/device/vec_traits.hpp>
#include <opencv2/core/device/vec_math.hpp>
#include <opencv2/core/device/emulation.hpp>
#include <opencv2/core/cuda/common.hpp>
#include <opencv2/core/cuda/vec_traits.hpp>
#include <opencv2/core/cuda/vec_math.hpp>
#include <opencv2/core/cuda/emulation.hpp>
#include <iostream>
#include <stdio.h>
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace ccl
{

14
modules/gpu/src/cuda/clahe.cu
View File

@ -42,15 +42,15 @@
#if !defined CUDA_DISABLER
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/device/functional.hpp"
#include "opencv2/core/device/emulation.hpp"
#include "opencv2/core/device/scan.hpp"
#include "opencv2/core/device/reduce.hpp"
#include "opencv2/core/device/saturate_cast.hpp"
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/functional.hpp"
#include "opencv2/core/cuda/emulation.hpp"
#include "opencv2/core/cuda/scan.hpp"
#include "opencv2/core/cuda/reduce.hpp"
#include "opencv2/core/cuda/saturate_cast.hpp"
using namespace cv::gpu;
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
namespace clahe
{

12
modules/gpu/src/cuda/color.cu
View File

@ -42,12 +42,12 @@
#if !defined CUDA_DISABLER
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/device/transform.hpp"
#include "opencv2/core/device/color.hpp"
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/transform.hpp"
#include "opencv2/core/cuda/color.hpp"
#include "cvt_color_internal.h"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
OPENCV_GPU_TRANSFORM_FUNCTOR_TRAITS(bgra_to_rgba_traits<uchar>::functor_type)
{
@ -229,7 +229,7 @@ namespace cv { namespace gpu { namespace device
traits::functor_type functor = traits::create_functor(); \
typedef typename traits::functor_type::argument_type src_t; \
typedef typename traits::functor_type::result_type dst_t; \
cv::gpu::device::transform((PtrStepSz<src_t>)src, (PtrStepSz<dst_t>)dst, functor, WithOutMask(), stream); \
cv::gpu::cuda::transform((PtrStepSz<src_t>)src, (PtrStepSz<dst_t>)dst, functor, WithOutMask(), stream); \
}
#define OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(name) \
@ -456,6 +456,6 @@ namespace cv { namespace gpu { namespace device
#undef OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL
#undef OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F
#undef OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F_FULL
}}} // namespace cv { namespace gpu { namespace device
}}} // namespace cv { namespace gpu { namespace cuda
#endif /* CUDA_DISABLER */

10
modules/gpu/src/cuda/column_filter.h
View File

@ -40,13 +40,13 @@
//
//M*/
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/device/saturate_cast.hpp"
#include "opencv2/core/device/vec_math.hpp"
#include "opencv2/core/device/border_interpolate.hpp"
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/saturate_cast.hpp"
#include "opencv2/core/cuda/vec_math.hpp"
#include "opencv2/core/cuda/border_interpolate.hpp"
using namespace cv::gpu;
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
namespace column_filter
{

8
modules/gpu/src/cuda/copy_make_border.cu
View File

@ -42,10 +42,10 @@
#if !defined CUDA_DISABLER
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/device/border_interpolate.hpp"
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/border_interpolate.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace imgproc
{
@ -126,6 +126,6 @@ namespace cv { namespace gpu { namespace device
template void copyMakeBorder_gpu<float, 3>(const PtrStepSzb& src, const PtrStepSzb& dst, int top, int left, int borderMode, const float* borderValue, cudaStream_t stream);
template void copyMakeBorder_gpu<float, 4>(const PtrStepSzb& src, const PtrStepSzb& dst, int top, int left, int borderMode, const float* borderValue, cudaStream_t stream);
} // namespace imgproc
}}} // namespace cv { namespace gpu { namespace device
}}} // namespace cv { namespace gpu { namespace cuda
#endif /* CUDA_DISABLER */

14
modules/gpu/src/cuda/debayer.cu
View File

@ -42,14 +42,14 @@
#if !defined CUDA_DISABLER
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/device/vec_traits.hpp"
#include "opencv2/core/device/vec_math.hpp"
#include "opencv2/core/device/limits.hpp"
#include "opencv2/core/device/color.hpp"
#include "opencv2/core/device/saturate_cast.hpp"
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/vec_traits.hpp"
#include "opencv2/core/cuda/vec_math.hpp"
#include "opencv2/core/cuda/limits.hpp"
#include "opencv2/core/cuda/color.hpp"
#include "opencv2/core/cuda/saturate_cast.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
template <typename T> struct Bayer2BGR;

8
modules/gpu/src/cuda/disp_bilateral_filter.cu
View File

@ -42,10 +42,10 @@
#if !defined CUDA_DISABLER
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/device/limits.hpp"
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/limits.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace disp_bilateral_filter
{
@ -218,6 +218,6 @@ namespace cv { namespace gpu { namespace device
template void disp_bilateral_filter<uchar>(PtrStepSz<uchar> disp, PtrStepSzb img, int channels, int iters, cudaStream_t stream);
template void disp_bilateral_filter<short>(PtrStepSz<short> disp, PtrStepSzb img, int channels, int iters, cudaStream_t stream);
} // namespace bilateral_filter
}}} // namespace cv { namespace gpu { namespace device
}}} // namespace cv { namespace gpu { namespace cuda
#endif /* CUDA_DISABLER */

72
modules/gpu/src/cuda/element_operations.cu
View File

@ -42,16 +42,16 @@
#if !defined CUDA_DISABLER
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/device/functional.hpp"
#include "opencv2/core/device/vec_math.hpp"
#include "opencv2/core/device/transform.hpp"
#include "opencv2/core/device/limits.hpp"
#include "opencv2/core/device/saturate_cast.hpp"
#include "opencv2/core/device/simd_functions.hpp"
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/functional.hpp"
#include "opencv2/core/cuda/vec_math.hpp"
#include "opencv2/core/cuda/transform.hpp"
#include "opencv2/core/cuda/limits.hpp"
#include "opencv2/core/cuda/saturate_cast.hpp"
#include "opencv2/core/cuda/simd_functions.hpp"
using namespace cv::gpu;
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
namespace arithm
{
@ -193,7 +193,7 @@ namespace arithm
};
}
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
template <> struct TransformFunctorTraits< arithm::VAdd4 > : arithm::ArithmFuncTraits<sizeof(uint), sizeof(uint)>
{
@ -308,7 +308,7 @@ namespace arithm
};
}
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
template <typename T, typename S, typename D> struct TransformFunctorTraits< arithm::AddScalar<T, S, D> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(D)>
{
@ -428,7 +428,7 @@ namespace arithm
};
}
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
template <> struct TransformFunctorTraits< arithm::VSub4 > : arithm::ArithmFuncTraits<sizeof(uint), sizeof(uint)>
{
@ -657,7 +657,7 @@ namespace arithm
};
}
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
template <> struct TransformFunctorTraits<arithm::Mul_8uc4_32f> : arithm::ArithmFuncTraits<sizeof(uint), sizeof(uint)>
{
@ -774,7 +774,7 @@ namespace arithm
};
}
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
template <typename T, typename S, typename D> struct TransformFunctorTraits< arithm::MulScalar<T, S, D> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(D)>
{
@ -925,7 +925,7 @@ namespace arithm
};
}
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
template <> struct TransformFunctorTraits<arithm::Div_8uc4_32f> : arithm::ArithmFuncTraits<sizeof(uint), sizeof(uint)>
{
@ -1111,7 +1111,7 @@ namespace arithm
};
}
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
template <typename T, typename S, typename D> struct TransformFunctorTraits< arithm::DivInv<T, S, D> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(D)>
{
@ -1240,7 +1240,7 @@ namespace arithm
};
}
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
template <> struct TransformFunctorTraits< arithm::VAbsDiff4 > : arithm::ArithmFuncTraits<sizeof(uint), sizeof(uint)>
{
@ -1305,7 +1305,7 @@ namespace arithm
};
}
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
template <typename T, typename S> struct TransformFunctorTraits< arithm::AbsDiffScalar<T, S> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
{
@ -1334,7 +1334,7 @@ namespace arithm
//////////////////////////////////////////////////////////////////////////
// absMat
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
template <typename T> struct TransformFunctorTraits< abs_func<T> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
{
@ -1375,7 +1375,7 @@ namespace arithm
};
}
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
template <typename T> struct TransformFunctorTraits< arithm::Sqr<T> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
{
@ -1402,7 +1402,7 @@ namespace arithm
//////////////////////////////////////////////////////////////////////////
// sqrtMat
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
template <typename T> struct TransformFunctorTraits< sqrt_func<T> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
{
@ -1429,7 +1429,7 @@ namespace arithm
//////////////////////////////////////////////////////////////////////////
// logMat
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
template <typename T> struct TransformFunctorTraits< log_func<T> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
{
@ -1471,7 +1471,7 @@ namespace arithm
};
}
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
template <typename T> struct TransformFunctorTraits< arithm::Exp<T> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
{
@ -1554,7 +1554,7 @@ namespace arithm
};
}
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
template <> struct TransformFunctorTraits< arithm::VCmpEq4 > : arithm::ArithmFuncTraits<sizeof(uint), sizeof(uint)>
{
@ -1716,7 +1716,7 @@ namespace arithm
#undef TYPE_VEC
}
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
template <class Op, typename T> struct TransformFunctorTraits< arithm::CmpScalar<Op, T, 1> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(uchar)>
{
@ -1875,7 +1875,7 @@ namespace arithm
//////////////////////////////////////////////////////////////////////////////////////
// bitMat
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
template <typename T> struct TransformFunctorTraits< bit_not<T> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
{
@ -1948,7 +1948,7 @@ namespace arithm
//////////////////////////////////////////////////////////////////////////////////////
// bitScalar
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
template <typename T> struct TransformFunctorTraits< binder2nd< bit_and<T> > > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
{
@ -1967,17 +1967,17 @@ namespace arithm
{
template <typename T> void bitScalarAnd(PtrStepSzb src1, uint src2, PtrStepSzb dst, cudaStream_t stream)
{
transform((PtrStepSz<T>) src1, (PtrStepSz<T>) dst, cv::gpu::device::bind2nd(bit_and<T>(), src2), WithOutMask(), stream);
transform((PtrStepSz<T>) src1, (PtrStepSz<T>) dst, cv::gpu::cuda::bind2nd(bit_and<T>(), src2), WithOutMask(), stream);
}
template <typename T> void bitScalarOr(PtrStepSzb src1, uint src2, PtrStepSzb dst, cudaStream_t stream)
{
transform((PtrStepSz<T>) src1, (PtrStepSz<T>) dst, cv::gpu::device::bind2nd(bit_or<T>(), src2), WithOutMask(), stream);
transform((PtrStepSz<T>) src1, (PtrStepSz<T>) dst, cv::gpu::cuda::bind2nd(bit_or<T>(), src2), WithOutMask(), stream);
}
template <typename T> void bitScalarXor(PtrStepSzb src1, uint src2, PtrStepSzb dst, cudaStream_t stream)
{
transform((PtrStepSz<T>) src1, (PtrStepSz<T>) dst, cv::gpu::device::bind2nd(bit_xor<T>(), src2), WithOutMask(), stream);
transform((PtrStepSz<T>) src1, (PtrStepSz<T>) dst, cv::gpu::cuda::bind2nd(bit_xor<T>(), src2), WithOutMask(), stream);
}
template void bitScalarAnd<uchar>(PtrStepSzb src1, uint src2, PtrStepSzb dst, cudaStream_t stream);
@ -2026,7 +2026,7 @@ namespace arithm
};
}
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
template <> struct TransformFunctorTraits< arithm::VMin4 > : arithm::ArithmFuncTraits<sizeof(uint), sizeof(uint)>
{
@ -2076,7 +2076,7 @@ namespace arithm
template <typename T> void minScalar(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream)
{
transform((PtrStepSz<T>) src1, (PtrStepSz<T>) dst, cv::gpu::device::bind2nd(minimum<T>(), src2), WithOutMask(), stream);
transform((PtrStepSz<T>) src1, (PtrStepSz<T>) dst, cv::gpu::cuda::bind2nd(minimum<T>(), src2), WithOutMask(), stream);
}
template void minScalar<uchar >(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
@ -2118,7 +2118,7 @@ namespace arithm
};
}
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
template <> struct TransformFunctorTraits< arithm::VMax4 > : arithm::ArithmFuncTraits<sizeof(uint), sizeof(uint)>
{
@ -2168,7 +2168,7 @@ namespace arithm
template <typename T> void maxScalar(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream)
{
transform((PtrStepSz<T>) src1, (PtrStepSz<T>) dst, cv::gpu::device::bind2nd(maximum<T>(), src2), WithOutMask(), stream);
transform((PtrStepSz<T>) src1, (PtrStepSz<T>) dst, cv::gpu::cuda::bind2nd(maximum<T>(), src2), WithOutMask(), stream);
}
template void maxScalar<uchar >(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
@ -2183,7 +2183,7 @@ namespace arithm
//////////////////////////////////////////////////////////////////////////
// threshold
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
template <typename T> struct TransformFunctorTraits< thresh_binary_func<T> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
{
@ -2297,7 +2297,7 @@ namespace arithm
};
}
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
template <typename T> struct TransformFunctorTraits< arithm::PowOp<T> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
{
@ -2372,7 +2372,7 @@ namespace arithm
};
}
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
template <typename T1, typename T2, typename D, size_t src1_size, size_t src2_size, size_t dst_size> struct AddWeightedTraits : DefaultTransformFunctorTraits< arithm::AddWeighted<T1, T2, D> >
{

6
modules/gpu/src/cuda/fast.cu
View File

@ -42,10 +42,10 @@
#if !defined CUDA_DISABLER
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/device/utility.hpp"
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/utility.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace fast
{

14
modules/gpu/src/cuda/fgd_bgfg.cu
View File

@ -42,16 +42,16 @@
#if !defined CUDA_DISABLER
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/device/vec_math.hpp"
#include "opencv2/core/device/limits.hpp"
#include "opencv2/core/device/utility.hpp"
#include "opencv2/core/device/reduce.hpp"
#include "opencv2/core/device/functional.hpp"
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/vec_math.hpp"
#include "opencv2/core/cuda/limits.hpp"
#include "opencv2/core/cuda/utility.hpp"
#include "opencv2/core/cuda/reduce.hpp"
#include "opencv2/core/cuda/functional.hpp"
#include "fgd_bgfg_common.hpp"
using namespace cv::gpu;
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
namespace bgfg
{

6
modules/gpu/src/cuda/gftt.cu
View File

@ -45,10 +45,10 @@
#include <thrust/device_ptr.h>
#include <thrust/sort.h>
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/device/utility.hpp"
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/utility.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace gfft
{

4
modules/gpu/src/cuda/global_motion.cu
View File

@ -45,9 +45,9 @@
#include <thrust/device_ptr.h>
#include <thrust/remove.h>
#include <thrust/functional.h>
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/cuda/common.hpp"
namespace cv { namespace gpu { namespace device { namespace globmotion {
namespace cv { namespace gpu { namespace cuda { namespace globmotion {
__constant__ float cml[9];
__constant__ float cmr[9];

12
modules/gpu/src/cuda/hist.cu
View File

@ -42,13 +42,13 @@
#if !defined CUDA_DISABLER
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/device/functional.hpp"
#include "opencv2/core/device/emulation.hpp"
#include "opencv2/core/device/transform.hpp"
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/functional.hpp"
#include "opencv2/core/cuda/emulation.hpp"
#include "opencv2/core/cuda/transform.hpp"
using namespace cv::gpu;
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
namespace hist
{
@ -127,7 +127,7 @@ namespace hist
};
}
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
template <> struct TransformFunctorTraits<hist::EqualizeHist> : DefaultTransformFunctorTraits<hist::EqualizeHist>
{

12
modules/gpu/src/cuda/hog.cu
View File

@ -42,12 +42,12 @@
#if !defined CUDA_DISABLER
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/device/reduce.hpp"
#include "opencv2/core/device/functional.hpp"
#include "opencv2/core/device/warp_shuffle.hpp"
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/reduce.hpp"
#include "opencv2/core/cuda/functional.hpp"
#include "opencv2/core/cuda/warp_shuffle.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
// Other values are not supported
#define CELL_WIDTH 8
@ -808,7 +808,7 @@ namespace cv { namespace gpu { namespace device
void resize_8UC1(const PtrStepSzb& src, PtrStepSzb dst) { resize_for_hog<uchar> (src, dst, resize8UC1_tex); }
void resize_8UC4(const PtrStepSzb& src, PtrStepSzb dst) { resize_for_hog<uchar4>(src, dst, resize8UC4_tex); }
} // namespace hog
}}} // namespace cv { namespace gpu { namespace device
}}} // namespace cv { namespace gpu { namespace cuda
#endif /* CUDA_DISABLER */

14
modules/gpu/src/cuda/hough.cu
View File

@ -45,13 +45,13 @@
#include <thrust/device_ptr.h>
#include <thrust/sort.h>
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/device/emulation.hpp"
#include "opencv2/core/device/vec_math.hpp"
#include "opencv2/core/device/limits.hpp"
#include "opencv2/core/device/dynamic_smem.hpp"
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/emulation.hpp"
#include "opencv2/core/cuda/vec_math.hpp"
#include "opencv2/core/cuda/limits.hpp"
#include "opencv2/core/cuda/dynamic_smem.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace hough
{
@ -1424,7 +1424,7 @@ namespace cv { namespace gpu { namespace device
cudaSafeCall( cudaDeviceSynchronize() );
thrust::device_ptr<int> sizesPtr(sizes);
thrust::transform(sizesPtr, sizesPtr + levels + 1, sizesPtr, device::bind2nd(device::minimum<int>(), maxSize));
thrust::transform(sizesPtr, sizesPtr + levels + 1, sizesPtr, cuda::bind2nd(cuda::minimum<int>(), maxSize));
}
void GHT_Guil_Full_buildTemplFeatureList_gpu(const unsigned int* coordList, const float* thetaList, int pointsCount,

14
modules/gpu/src/cuda/imgproc.cu
View File

@ -42,14 +42,14 @@
#if !defined CUDA_DISABLER
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/device/vec_traits.hpp"
#include "opencv2/core/device/vec_math.hpp"
#include "opencv2/core/device/saturate_cast.hpp"
#include "opencv2/core/device/border_interpolate.hpp"
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/vec_traits.hpp"
#include "opencv2/core/cuda/vec_math.hpp"
#include "opencv2/core/cuda/saturate_cast.hpp"
#include "opencv2/core/cuda/border_interpolate.hpp"
#include "internal_shared.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace imgproc
{
@ -1002,7 +1002,7 @@ namespace cv { namespace gpu { namespace device
template void filter2D_gpu<float, float>(PtrStepSzb srcWhole, int ofsX, int ofsY, PtrStepSzb dst, int kWidth, int kHeight, int anchorX, int anchorY, const float* kernel, int borderMode, const float* borderValue, cudaStream_t stream);
template void filter2D_gpu<float4, float4>(PtrStepSzb srcWhole, int ofsX, int ofsY, PtrStepSzb dst, int kWidth, int kHeight, int anchorX, int anchorY, const float* kernel, int borderMode, const float* borderValue, cudaStream_t stream);
} // namespace imgproc
}}} // namespace cv { namespace gpu { namespace device {
}}} // namespace cv { namespace gpu { namespace cuda {
#endif /* CUDA_DISABLER */

4
modules/gpu/src/cuda/integral_image.cu
View File

@ -42,9 +42,9 @@
#if !defined CUDA_DISABLER
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/cuda/common.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace imgproc
{

2
modules/gpu/src/cuda/internal_shared.hpp
View File

@ -48,7 +48,7 @@
#include "NPP_staging.hpp"
#include "opencv2/gpu/devmem2d.hpp"
#include "safe_call.hpp"
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/cuda/common.hpp"
namespace cv { namespace gpu
{

6
modules/gpu/src/cuda/lbp.cu
View File

@ -43,10 +43,10 @@
#if !defined CUDA_DISABLER
#include "lbp.hpp"
#include "opencv2/core/device/vec_traits.hpp"
#include "opencv2/core/device/saturate_cast.hpp"
#include "opencv2/core/cuda/vec_traits.hpp"
#include "opencv2/core/cuda/saturate_cast.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace lbp
{

6
modules/gpu/src/cuda/lbp.hpp
View File

@ -43,10 +43,10 @@
#ifndef __OPENCV_GPU_DEVICE_LBP_HPP_
#define __OPENCV_GPU_DEVICE_LBP_HPP_
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/device/emulation.hpp"
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/emulation.hpp"
namespace cv { namespace gpu { namespace device {
namespace cv { namespace gpu { namespace cuda {
namespace lbp {

8
modules/gpu/src/cuda/match_template.cu
View File

@ -42,10 +42,10 @@
#if !defined CUDA_DISABLER
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/device/vec_math.hpp"
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/vec_math.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace match_template
{
@ -910,7 +910,7 @@ namespace cv { namespace gpu { namespace device
cudaSafeCall( cudaDeviceSynchronize() );
}
} //namespace match_template
}}} // namespace cv { namespace gpu { namespace device
}}} // namespace cv { namespace gpu { namespace cuda
#endif /* CUDA_DISABLER */

6
modules/gpu/src/cuda/mathfunc.cu
View File

@ -42,9 +42,9 @@
#if !defined CUDA_DISABLER
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/cuda/common.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace mathfunc
{
@ -212,6 +212,6 @@ namespace cv { namespace gpu { namespace device
callers[mag.data == 0](mag, angle, x, y, angleInDegrees, stream);
}
} // namespace mathfunc
}}} // namespace cv { namespace gpu { namespace device
}}} // namespace cv { namespace gpu { namespace cuda
#endif /* CUDA_DISABLER */

42
modules/gpu/src/cuda/matrix_reductions.cu
View File

@ -42,18 +42,18 @@
#if !defined CUDA_DISABLER
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/device/limits.hpp"
#include "opencv2/core/device/saturate_cast.hpp"
#include "opencv2/core/device/vec_traits.hpp"
#include "opencv2/core/device/vec_math.hpp"
#include "opencv2/core/device/reduce.hpp"
#include "opencv2/core/device/functional.hpp"
#include "opencv2/core/device/utility.hpp"
#include "opencv2/core/device/type_traits.hpp"
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/limits.hpp"
#include "opencv2/core/cuda/saturate_cast.hpp"
#include "opencv2/core/cuda/vec_traits.hpp"
#include "opencv2/core/cuda/vec_math.hpp"
#include "opencv2/core/cuda/reduce.hpp"
#include "opencv2/core/cuda/functional.hpp"
#include "opencv2/core/cuda/utility.hpp"
#include "opencv2/core/cuda/type_traits.hpp"
using namespace cv::gpu;
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
namespace detail
{
@ -205,7 +205,7 @@ namespace detail
template <int BLOCK_SIZE, typename R>
static __device__ __forceinline__ thrust::tuple<volatile R*, volatile R*> smem_tuple(R* smem)
{
return cv::gpu::device::smem_tuple(smem, smem + BLOCK_SIZE);
return cv::gpu::cuda::smem_tuple(smem, smem + BLOCK_SIZE);
}
template <typename R>
@ -225,7 +225,7 @@ namespace detail
template <int BLOCK_SIZE, typename R>
static __device__ __forceinline__ thrust::tuple<volatile R*, volatile R*, volatile R*> smem_tuple(R* smem)
{
return cv::gpu::device::smem_tuple(smem, smem + BLOCK_SIZE, smem + 2 * BLOCK_SIZE);
return cv::gpu::cuda::smem_tuple(smem, smem + BLOCK_SIZE, smem + 2 * BLOCK_SIZE);
}
template <typename R>
@ -245,7 +245,7 @@ namespace detail
template <int BLOCK_SIZE, typename R>
static __device__ __forceinline__ thrust::tuple<volatile R*, volatile R*, volatile R*, volatile R*> smem_tuple(R* smem)
{
return cv::gpu::device::smem_tuple(smem, smem + BLOCK_SIZE, smem + 2 * BLOCK_SIZE, smem + 3 * BLOCK_SIZE);
return cv::gpu::cuda::smem_tuple(smem, smem + BLOCK_SIZE, smem + 2 * BLOCK_SIZE, smem + 3 * BLOCK_SIZE);
}
template <typename R>
@ -340,7 +340,7 @@ namespace sum
{
sum = tid < gridDim.x * gridDim.y ? result[tid] : VecTraits<result_type>::all(0);
device::reduce<BLOCK_SIZE>(detail::Unroll<cn>::template smem_tuple<BLOCK_SIZE>(smem), detail::Unroll<cn>::tie(sum), tid, detail::Unroll<cn>::op(plus<R>()));
cuda::reduce<BLOCK_SIZE>(detail::Unroll<cn>::template smem_tuple<BLOCK_SIZE>(smem), detail::Unroll<cn>::tie(sum), tid, detail::Unroll<cn>::op(plus<R>()));
if (tid == 0)
{
@ -383,7 +383,7 @@ namespace sum
}
}
device::reduce<BLOCK_SIZE>(detail::Unroll<cn>::template smem_tuple<BLOCK_SIZE>(smem), detail::Unroll<cn>::tie(sum), tid, detail::Unroll<cn>::op(plus<R>()));
cuda::reduce<BLOCK_SIZE>(detail::Unroll<cn>::template smem_tuple<BLOCK_SIZE>(smem), detail::Unroll<cn>::tie(sum), tid, detail::Unroll<cn>::op(plus<R>()));
GlobalReduce<BLOCK_SIZE, R, cn>::run(sum, result, tid, bid, smem);
}
@ -642,7 +642,7 @@ namespace minMax
const minimum<R> minOp;
const maximum<R> maxOp;
device::reduce<BLOCK_SIZE>(smem_tuple(sminval, smaxval), thrust::tie(mymin, mymax), tid, thrust::make_tuple(minOp, maxOp));
cuda::reduce<BLOCK_SIZE>(smem_tuple(sminval, smaxval), thrust::tie(mymin, mymax), tid, thrust::make_tuple(minOp, maxOp));
if (tid == 0)
{
@ -690,7 +690,7 @@ namespace minMax
}
}
device::reduce<BLOCK_SIZE>(smem_tuple(sminval, smaxval), thrust::tie(mymin, mymax), tid, thrust::make_tuple(minOp, maxOp));
cuda::reduce<BLOCK_SIZE>(smem_tuple(sminval, smaxval), thrust::tie(mymin, mymax), tid, thrust::make_tuple(minOp, maxOp));
GlobalReduce<BLOCK_SIZE, R>::run(mymin, mymax, minval, maxval, tid, bid, sminval, smaxval);
}
@ -994,7 +994,7 @@ namespace countNonZero
}
}
device::reduce<BLOCK_SIZE>(scount, mycount, tid, plus<unsigned int>());
cuda::reduce<BLOCK_SIZE>(scount, mycount, tid, plus<unsigned int>());
#if __CUDA_ARCH__ >= 200
if (tid == 0)
@ -1019,7 +1019,7 @@ namespace countNonZero
{
mycount = tid < gridDim.x * gridDim.y ? count[tid] : 0;
device::reduce<BLOCK_SIZE>(scount, mycount, tid, plus<unsigned int>());
cuda::reduce<BLOCK_SIZE>(scount, mycount, tid, plus<unsigned int>());
if (tid == 0)
{
@ -1217,7 +1217,7 @@ namespace reduce
volatile S* srow = smem + threadIdx.y * 16;
myVal = srow[threadIdx.x];
device::reduce<16>(srow, myVal, threadIdx.x, op);
cuda::reduce<16>(srow, myVal, threadIdx.x, op);
if (threadIdx.x == 0)
srow[0] = myVal;
@ -1301,7 +1301,7 @@ namespace reduce
for (int x = threadIdx.x; x < src.cols; x += BLOCK_SIZE)
myVal = op(myVal, saturate_cast<work_type>(srcRow[x]));
device::reduce<BLOCK_SIZE>(detail::Unroll<cn>::template smem_tuple<BLOCK_SIZE>(smem), detail::Unroll<cn>::tie(myVal), threadIdx.x, detail::Unroll<cn>::op(op));
cuda::reduce<BLOCK_SIZE>(detail::Unroll<cn>::template smem_tuple<BLOCK_SIZE>(smem), detail::Unroll<cn>::tie(myVal), threadIdx.x, detail::Unroll<cn>::op(op));
if (threadIdx.x == 0)
dst[y] = saturate_cast<dst_type>(op.result(myVal, src.cols));

24
modules/gpu/src/cuda/nlm.cu
View File

@ -42,12 +42,12 @@
#if !defined CUDA_DISABLER
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/device/vec_traits.hpp"
#include "opencv2/core/device/vec_math.hpp"
#include "opencv2/core/device/functional.hpp"
#include "opencv2/core/device/reduce.hpp"
#include "opencv2/core/device/border_interpolate.hpp"
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/vec_traits.hpp"
#include "opencv2/core/cuda/vec_math.hpp"
#include "opencv2/core/cuda/functional.hpp"
#include "opencv2/core/cuda/reduce.hpp"
#include "opencv2/core/cuda/border_interpolate.hpp"
using namespace cv::gpu;
@ -57,7 +57,7 @@ typedef unsigned short ushort;
//////////////////////////////////////////////////////////////////////////////////
//// Non Local Means Denosing
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace imgproc
{
@ -179,7 +179,7 @@ namespace cv { namespace gpu { namespace device
//////////////////////////////////////////////////////////////////////////////////
//// Non Local Means Denosing (fast approximate version)
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace imgproc
{
@ -190,7 +190,7 @@ namespace cv { namespace gpu { namespace device
template <int BLOCK_SIZE>
static __device__ __forceinline__ thrust::tuple<volatile float*, volatile float*> smem_tuple(float* smem)
{
return cv::gpu::device::smem_tuple(smem, smem + BLOCK_SIZE);
return cv::gpu::cuda::smem_tuple(smem, smem + BLOCK_SIZE);
}
static __device__ __forceinline__ thrust::tuple<float&, float&> tie(float& val1, float& val2)
@ -209,7 +209,7 @@ namespace cv { namespace gpu { namespace device
template <int BLOCK_SIZE>
static __device__ __forceinline__ thrust::tuple<volatile float*, volatile float*, volatile float*> smem_tuple(float* smem)
{
return cv::gpu::device::smem_tuple(smem, smem + BLOCK_SIZE, smem + 2 * BLOCK_SIZE);
return cv::gpu::cuda::smem_tuple(smem, smem + BLOCK_SIZE, smem + 2 * BLOCK_SIZE);
}
static __device__ __forceinline__ thrust::tuple<float&, float&, float&> tie(float& val1, float2& val2)
@ -228,7 +228,7 @@ namespace cv { namespace gpu { namespace device
template <int BLOCK_SIZE>
static __device__ __forceinline__ thrust::tuple<volatile float*, volatile float*, volatile float*, volatile float*> smem_tuple(float* smem)
{
return cv::gpu::device::smem_tuple(smem, smem + BLOCK_SIZE, smem + 2 * BLOCK_SIZE, smem + 3 * BLOCK_SIZE);
return cv::gpu::cuda::smem_tuple(smem, smem + BLOCK_SIZE, smem + 2 * BLOCK_SIZE, smem + 3 * BLOCK_SIZE);
}
static __device__ __forceinline__ thrust::tuple<float&, float&, float&, float&> tie(float& val1, float3& val2)
@ -247,7 +247,7 @@ namespace cv { namespace gpu { namespace device
template <int BLOCK_SIZE>
static __device__ __forceinline__ thrust::tuple<volatile float*, volatile float*, volatile float*, volatile float*, volatile float*> smem_tuple(float* smem)
{
return cv::gpu::device::smem_tuple(smem, smem + BLOCK_SIZE, smem + 2 * BLOCK_SIZE, smem + 3 * BLOCK_SIZE, smem + 4 * BLOCK_SIZE);
return cv::gpu::cuda::smem_tuple(smem, smem + BLOCK_SIZE, smem + 2 * BLOCK_SIZE, smem + 3 * BLOCK_SIZE, smem + 4 * BLOCK_SIZE);
}
static __device__ __forceinline__ thrust::tuple<float&, float&, float&, float&, float&> tie(float& val1, float4& val2)

10
modules/gpu/src/cuda/optflowbm.cu
View File

@ -42,13 +42,13 @@
#if !defined CUDA_DISABLER
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/device/limits.hpp"
#include "opencv2/core/device/functional.hpp"
#include "opencv2/core/device/reduce.hpp"
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/limits.hpp"
#include "opencv2/core/cuda/functional.hpp"
#include "opencv2/core/cuda/reduce.hpp"
using namespace cv::gpu;
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
namespace optflowbm
{

4
modules/gpu/src/cuda/optical_flow.cu
View File

@ -42,9 +42,9 @@
#if !defined CUDA_DISABLER
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/cuda/common.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace optical_flow
{

8
modules/gpu/src/cuda/optical_flow_farneback.cu
View File

@ -42,8 +42,8 @@
#if !defined CUDA_DISABLER
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/device/border_interpolate.hpp"
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/border_interpolate.hpp"
#define tx threadIdx.x
#define ty threadIdx.y
@ -55,7 +55,7 @@
#define BORDER_SIZE 5
#define MAX_KSIZE_HALF 100
namespace cv { namespace gpu { namespace device { namespace optflow_farneback
namespace cv { namespace gpu { namespace cuda { namespace optflow_farneback
{
__constant__ float c_g[8];
__constant__ float c_xg[8];
@ -641,7 +641,7 @@ namespace cv { namespace gpu { namespace device { namespace optflow_farneback
callers[borderMode](src, ksizeHalf, dst, stream);
}
}}}} // namespace cv { namespace gpu { namespace device { namespace optflow_farneback
}}}} // namespace cv { namespace gpu { namespace cuda { namespace optflow_farneback
#endif /* CUDA_DISABLER */

8
modules/gpu/src/cuda/orb.cu
View File

@ -45,11 +45,11 @@
#include <thrust/device_ptr.h>
#include <thrust/sort.h>
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/device/reduce.hpp"
#include "opencv2/core/device/functional.hpp"
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/reduce.hpp"
#include "opencv2/core/cuda/functional.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace orb
{

14
modules/gpu/src/cuda/pyr_down.cu
View File

@ -42,13 +42,13 @@
#if !defined CUDA_DISABLER
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/device/border_interpolate.hpp"
#include "opencv2/core/device/vec_traits.hpp"
#include "opencv2/core/device/vec_math.hpp"
#include "opencv2/core/device/saturate_cast.hpp"
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/border_interpolate.hpp"
#include "opencv2/core/cuda/vec_traits.hpp"
#include "opencv2/core/cuda/vec_math.hpp"
#include "opencv2/core/cuda/saturate_cast.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace imgproc
{
@ -222,7 +222,7 @@ namespace cv { namespace gpu { namespace device
template void pyrDown_gpu<float3>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
template void pyrDown_gpu<float4>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
} // namespace imgproc
}}} // namespace cv { namespace gpu { namespace device
}}} // namespace cv { namespace gpu { namespace cuda
#endif /* CUDA_DISABLER */

14
modules/gpu/src/cuda/pyr_up.cu
View File

@ -42,13 +42,13 @@
#if !defined CUDA_DISABLER
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/device/border_interpolate.hpp"
#include "opencv2/core/device/vec_traits.hpp"
#include "opencv2/core/device/vec_math.hpp"
#include "opencv2/core/device/saturate_cast.hpp"
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/border_interpolate.hpp"
#include "opencv2/core/cuda/vec_traits.hpp"
#include "opencv2/core/cuda/vec_math.hpp"
#include "opencv2/core/cuda/saturate_cast.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace imgproc
{
@ -191,6 +191,6 @@ namespace cv { namespace gpu { namespace device
template void pyrUp_gpu<float3>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
template void pyrUp_gpu<float4>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
} // namespace imgproc
}}} // namespace cv { namespace gpu { namespace device
}}} // namespace cv { namespace gpu { namespace cuda
#endif /* CUDA_DISABLER */

14
modules/gpu/src/cuda/pyrlk.cu
View File

@ -42,15 +42,15 @@
#if !defined CUDA_DISABLER
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/device/utility.hpp"
#include "opencv2/core/device/functional.hpp"
#include "opencv2/core/device/limits.hpp"
#include "opencv2/core/device/vec_math.hpp"
#include "opencv2/core/device/reduce.hpp"
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/utility.hpp"
#include "opencv2/core/cuda/functional.hpp"
#include "opencv2/core/cuda/limits.hpp"
#include "opencv2/core/cuda/vec_math.hpp"
#include "opencv2/core/cuda/reduce.hpp"
using namespace cv::gpu;
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
namespace pyrlk
{

16
modules/gpu/src/cuda/remap.cu
View File

@ -42,14 +42,14 @@
#if !defined CUDA_DISABLER
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/device/border_interpolate.hpp"
#include "opencv2/core/device/vec_traits.hpp"
#include "opencv2/core/device/vec_math.hpp"
#include "opencv2/core/device/saturate_cast.hpp"
#include "opencv2/core/device/filters.hpp"
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/border_interpolate.hpp"
#include "opencv2/core/cuda/vec_traits.hpp"
#include "opencv2/core/cuda/vec_math.hpp"
#include "opencv2/core/cuda/saturate_cast.hpp"
#include "opencv2/core/cuda/filters.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace imgproc
{
@ -268,7 +268,7 @@ namespace cv { namespace gpu { namespace device
template void remap_gpu<float3>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
template void remap_gpu<float4>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
} // namespace imgproc
}}} // namespace cv { namespace gpu { namespace device
}}} // namespace cv { namespace gpu { namespace cuda
#endif /* CUDA_DISABLER */

18
modules/gpu/src/cuda/resize.cu
View File

@ -43,15 +43,15 @@
#if !defined CUDA_DISABLER
#include <cfloat>
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/device/border_interpolate.hpp"
#include "opencv2/core/device/vec_traits.hpp"
#include "opencv2/core/device/vec_math.hpp"
#include "opencv2/core/device/saturate_cast.hpp"
#include "opencv2/core/device/filters.hpp"
#include "opencv2/core/device/scan.hpp"
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/border_interpolate.hpp"
#include "opencv2/core/cuda/vec_traits.hpp"
#include "opencv2/core/cuda/vec_math.hpp"
#include "opencv2/core/cuda/saturate_cast.hpp"
#include "opencv2/core/cuda/filters.hpp"
#include "opencv2/core/cuda/scan.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace imgproc
{
@ -296,7 +296,7 @@ namespace cv { namespace gpu { namespace device
};
} // namespace imgproc
}}} // namespace cv { namespace gpu { namespace device
}}} // namespace cv { namespace gpu { namespace cuda
#endif /* CUDA_DISABLER */

6
modules/gpu/src/cuda/rgb_to_yv12.cu
View File

@ -42,10 +42,10 @@
#if !defined CUDA_DISABLER
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/device/vec_traits.hpp"
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/vec_traits.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace video_encoding
{

10
modules/gpu/src/cuda/row_filter.h
View File

@ -40,13 +40,13 @@
//
//M*/
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/device/saturate_cast.hpp"
#include "opencv2/core/device/vec_math.hpp"
#include "opencv2/core/device/border_interpolate.hpp"
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/saturate_cast.hpp"
#include "opencv2/core/cuda/vec_math.hpp"
#include "opencv2/core/cuda/border_interpolate.hpp"
using namespace cv::gpu;
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
namespace row_filter
{

6
modules/gpu/src/cuda/split_merge.cu
View File

@ -42,9 +42,9 @@
#if !defined CUDA_DISABLER
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/cuda/common.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace split_merge
{
@ -505,7 +505,7 @@ namespace cv { namespace gpu { namespace device
split_func(src, dst, stream);
}
} // namespace split_merge
}}} // namespace cv { namespace gpu { namespace device
}}} // namespace cv { namespace gpu { namespace cuda
#endif /* CUDA_DISABLER */

6
modules/gpu/src/cuda/stereobm.cu
View File

@ -42,9 +42,9 @@
#if !defined CUDA_DISABLER
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/cuda/common.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace stereobm
{
@ -534,7 +534,7 @@ namespace cv { namespace gpu { namespace device
cudaSafeCall( cudaUnbindTexture (texForTF) );
}
} // namespace stereobm
}}} // namespace cv { namespace gpu { namespace device
}}} // namespace cv { namespace gpu { namespace cuda
#endif /* CUDA_DISABLER */

12
modules/gpu/src/cuda/stereobp.cu
View File

@ -42,11 +42,11 @@
#if !defined CUDA_DISABLER
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/device/saturate_cast.hpp"
#include "opencv2/core/device/limits.hpp"
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/saturate_cast.hpp"
#include "opencv2/core/cuda/limits.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace stereobp
{
@ -384,7 +384,7 @@ namespace cv { namespace gpu { namespace device
template <typename T>
__device__ void message(const T* msg1, const T* msg2, const T* msg3, const T* data, T* dst, size_t msg_disp_step, size_t data_disp_step)
{
float minimum = device::numeric_limits<float>::max();
float minimum = cuda::numeric_limits<float>::max();
for(int i = 0; i < cndisp; ++i)
{
@ -533,6 +533,6 @@ namespace cv { namespace gpu { namespace device
template void output_gpu<short>(const PtrStepSzb& u, const PtrStepSzb& d, const PtrStepSzb& l, const PtrStepSzb& r, const PtrStepSzb& data, const PtrStepSz<short>& disp, cudaStream_t stream);
template void output_gpu<float>(const PtrStepSzb& u, const PtrStepSzb& d, const PtrStepSzb& l, const PtrStepSzb& r, const PtrStepSzb& data, const PtrStepSz<short>& disp, cudaStream_t stream);
} // namespace stereobp
}}} // namespace cv { namespace gpu { namespace device
}}} // namespace cv { namespace gpu { namespace cuda
#endif /* CUDA_DISABLER */

16
modules/gpu/src/cuda/stereocsbp.cu
View File

@ -42,13 +42,13 @@
#if !defined CUDA_DISABLER
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/device/saturate_cast.hpp"
#include "opencv2/core/device/limits.hpp"
#include "opencv2/core/device/reduce.hpp"
#include "opencv2/core/device/functional.hpp"
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/saturate_cast.hpp"
#include "opencv2/core/cuda/limits.hpp"
#include "opencv2/core/cuda/reduce.hpp"
#include "opencv2/core/cuda/functional.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace stereocsbp
{
@ -146,7 +146,7 @@ namespace cv { namespace gpu { namespace device
for(int i = 0; i < nr_plane; i++)
{
T minimum = device::numeric_limits<T>::max();
T minimum = cuda::numeric_limits<T>::max();
int id = 0;
for(int d = 0; d < cndisp; d++)
{
@ -859,6 +859,6 @@ namespace cv { namespace gpu { namespace device
template void compute_disp(const float* u, const float* d, const float* l, const float* r, const float* data_cost_selected, const float* disp_selected, size_t msg_step,
const PtrStepSz<short>& disp, int nr_plane, cudaStream_t stream);
} // namespace stereocsbp
}}} // namespace cv { namespace gpu { namespace device {
}}} // namespace cv { namespace gpu { namespace cuda {
#endif /* CUDA_DISABLER */

2
modules/gpu/src/cuda/texture_binder.hpp
View File

@ -83,7 +83,7 @@ namespace cv
};
}
namespace device
namespace cuda
{
using cv::gpu::TextureBinder;
}

8
modules/gpu/src/cuda/tvl1flow.cu
View File

@ -42,12 +42,12 @@
#if !defined CUDA_DISABLER
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/device/border_interpolate.hpp"
#include "opencv2/core/device/limits.hpp"
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/border_interpolate.hpp"
#include "opencv2/core/cuda/limits.hpp"
using namespace cv::gpu;
using namespace cv::gpu::device;
using namespace cv::gpu::cuda;
////////////////////////////////////////////////////////////
// centeredGradient

16
modules/gpu/src/cuda/warp.cu
View File

@ -42,14 +42,14 @@
#if !defined CUDA_DISABLER
#include "opencv2/core/device/common.hpp"
#include "opencv2/core/device/border_interpolate.hpp"
#include "opencv2/core/device/vec_traits.hpp"
#include "opencv2/core/device/vec_math.hpp"
#include "opencv2/core/device/saturate_cast.hpp"
#include "opencv2/core/device/filters.hpp"
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/border_interpolate.hpp"
#include "opencv2/core/cuda/vec_traits.hpp"
#include "opencv2/core/cuda/vec_math.hpp"
#include "opencv2/core/cuda/saturate_cast.hpp"
#include "opencv2/core/cuda/filters.hpp"
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace imgproc
{
@ -383,7 +383,7 @@ namespace cv { namespace gpu { namespace device
template void warpPerspective_gpu<float3>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
template void warpPerspective_gpu<float4>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
} // namespace imgproc
}}} // namespace cv { namespace gpu { namespace device
}}} // namespace cv { namespace gpu { namespace cuda
#endif /* CUDA_DISABLER */

2
modules/gpu/src/cvt_color_internal.h
View File

@ -43,7 +43,7 @@
#ifndef __cvt_color_internal_h__
#define __cvt_color_internal_h__
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
#define OPENCV_GPU_DECLARE_CVTCOLOR_ONE(name) \
void name(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);

16
modules/gpu/src/denoising.cpp
View File

@ -59,7 +59,7 @@ void cv::gpu::FastNonLocalMeansDenoising::labMethod( const GpuMat&, GpuMat&, flo
//////////////////////////////////////////////////////////////////////////////////
//// Non Local Means Denosing (brute force)
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace imgproc
{
@ -73,7 +73,7 @@ namespace cv { namespace gpu { namespace device
void cv::gpu::bilateralFilter(const GpuMat& src, GpuMat& dst, int kernel_size, float sigma_color, float sigma_spatial, int borderMode, Stream& s)
{
using cv::gpu::device::imgproc::bilateral_filter_gpu;
using cv::gpu::cuda::imgproc::bilateral_filter_gpu;
typedef void (*func_t)(const PtrStepSzb& src, PtrStepSzb dst, int kernel_size, float sigma_spatial, float sigma_color, int borderMode, cudaStream_t s);
@ -109,7 +109,7 @@ void cv::gpu::bilateralFilter(const GpuMat& src, GpuMat& dst, int kernel_size, f
void cv::gpu::nonLocalMeans(const GpuMat& src, GpuMat& dst, float h, int search_window, int block_window, int borderMode, Stream& s)
{
using cv::gpu::device::imgproc::nlm_bruteforce_gpu;
using cv::gpu::cuda::imgproc::nlm_bruteforce_gpu;
typedef void (*func_t)(const PtrStepSzb& src, PtrStepSzb dst, int search_radius, int block_radius, float h, int borderMode, cudaStream_t stream);
static const func_t funcs[4] = { nlm_bruteforce_gpu<uchar>, nlm_bruteforce_gpu<uchar2>, nlm_bruteforce_gpu<uchar3>, 0/*nlm_bruteforce_gpu<uchar4>,*/ };
@ -134,7 +134,7 @@ void cv::gpu::nonLocalMeans(const GpuMat& src, GpuMat& dst, float h, int search_
//// Non Local Means Denosing (fast approxinate)
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace imgproc
{
@ -163,10 +163,10 @@ void cv::gpu::FastNonLocalMeansDenoising::simpleMethod(const GpuMat& src, GpuMat
GpuMat src_hdr = extended_src(Rect(Point2i(border_size, border_size), src.size()));
int bcols, brows;
device::imgproc::nln_fast_get_buffer_size(src_hdr, search_window, block_window, bcols, brows);
cuda::imgproc::nln_fast_get_buffer_size(src_hdr, search_window, block_window, bcols, brows);
buffer.create(brows, bcols, CV_32S);
using namespace cv::gpu::device::imgproc;
using namespace cv::gpu::cuda::imgproc;
typedef void (*nlm_fast_t)(const PtrStepSzb&, PtrStepSzb, PtrStepi, int, int, float, cudaStream_t);
static const nlm_fast_t funcs[] = { nlm_fast_gpu<uchar>, nlm_fast_gpu<uchar2>, nlm_fast_gpu<uchar3>, 0};
@ -183,12 +183,12 @@ void cv::gpu::FastNonLocalMeansDenoising::labMethod( const GpuMat& src, GpuMat&
l.create(src.size(), CV_8U);
ab.create(src.size(), CV_8UC2);
device::imgproc::fnlm_split_channels(lab, l, ab, StreamAccessor::getStream(s));
cuda::imgproc::fnlm_split_channels(lab, l, ab, StreamAccessor::getStream(s));
simpleMethod(l, l, h_luminance, search_window, block_window, s);
simpleMethod(ab, ab, h_color, search_window, block_window, s);
device::imgproc::fnlm_merge_channels(l, ab, lab, StreamAccessor::getStream(s));
cuda::imgproc::fnlm_merge_channels(l, ab, lab, StreamAccessor::getStream(s));
cv::gpu::cvtColor(lab, dst, CV_Lab2BGR, 0, s);
}

6
modules/gpu/src/fast.cpp
View File

@ -108,7 +108,7 @@ void cv::gpu::FAST_GPU::operator ()(const GpuMat& img, const GpuMat& mask, GpuMa
keypoints.cols = getKeyPoints(keypoints);
}
namespace cv { namespace gpu { namespace device
namespace cv { namespace gpu { namespace cuda
{
namespace fast
{
@ -119,7 +119,7 @@ namespace cv { namespace gpu { namespace device
int cv::gpu::FAST_GPU::calcKeyPointsLocation(const GpuMat& img, const GpuMat& mask)
{
using namespace cv::gpu::device::fast;
using namespace cv::gpu::cuda::fast;
CV_Assert(img.type() == CV_8UC1);
CV_Assert(mask.empty() || (mask.type() == CV_8UC1 && mask.size() == img.size()));
@ -142,7 +142,7 @@ int cv::gpu::FAST_GPU::calcKeyPointsLocation(const GpuMat& img, const GpuMat& ma
int cv::gpu::FAST_GPU::getKeyPoints(GpuMat& keypoints)
{
using namespace cv::gpu::device::fast;
using namespace cv::gpu::cuda::fast;
if (count_ == 0)
return 0;

Some files were not shown because too many files have changed in this diff Show More