third_party/opencv
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

renamed cuda namespace to cudev

Browse Source
This commit is contained in:
Vladislav Vinogradov
2013-04-04 15:36:22 +04:00
parent 1bb141c465
commit 910ef57109
130 changed files with 592 additions and 594 deletions
Download Patch File Download Diff File Expand all files Collapse all files
modules/gpu/src/arithm.cpp
+3 -3
View File
@@ -444,7 +444,7 @@ void cv::gpu::magnitudeSqr(const GpuMat& src, GpuMat& dst, Stream& stream)
////////////////////////////////////////////////////////////////////////
// Polar <-> Cart
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
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::cuda::mathfunc;
using namespace ::cv::gpu::cudev::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::cuda::mathfunc;
using namespace ::cv::gpu::cudev::mathfunc;
CV_Assert((mag.empty() || mag.size() == angle.size()) && mag.type() == angle.type());
CV_Assert(mag.depth() == CV_32F);
modules/gpu/src/bgfg_gmg.cpp
+3 -3
View File
@@ -51,7 +51,7 @@ void cv::gpu::GMG_GPU::release() {}
#else
namespace cv { namespace gpu { namespace cuda {
namespace cv { namespace gpu { namespace cudev {
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::cuda::bgfg_gmg;
using namespace cv::gpu::cudev::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::cuda::bgfg_gmg;
using namespace cv::gpu::cudev::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);
modules/gpu/src/bgfg_mog.cpp
+6 -6
View File
@@ -58,7 +58,7 @@ void cv::gpu::MOG2_GPU::release() {}
#else
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
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::cuda::mog;
using namespace cv::gpu::cudev::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::cuda::mog;
using namespace cv::gpu::cudev::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::cuda::mog;
using namespace cv::gpu::cudev::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::cuda::mog;
using namespace cv::gpu::cudev::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::cuda::mog;
using namespace cv::gpu::cudev::mog;
backgroundImage.create(frameSize_, frameType_);
modules/gpu/src/bilateral_filter.cpp
+2 -2
View File
@@ -54,7 +54,7 @@ void cv::gpu::DisparityBilateralFilter::operator()(const GpuMat&, const GpuMat&,
#else /* !defined (HAVE_CUDA) */
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace disp_bilateral_filter
{
@@ -65,7 +65,7 @@ namespace cv { namespace gpu { namespace cuda
}
}}}
using namespace ::cv::gpu::cuda::disp_bilateral_filter;
using namespace ::cv::gpu::cudev::disp_bilateral_filter;
namespace
{
modules/gpu/src/blend.cpp
+2 -2
View File
@@ -51,7 +51,7 @@ void cv::gpu::blendLinear(const GpuMat&, const GpuMat&, const GpuMat&, const Gpu
#else
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace blend
{
@@ -62,7 +62,7 @@ namespace cv { namespace gpu { namespace cuda
}
}}}
using namespace ::cv::gpu::cuda::blend;
using namespace ::cv::gpu::cudev::blend;
void cv::gpu::blendLinear(const GpuMat& img1, const GpuMat& img2, const GpuMat& weights1, const GpuMat& weights2,
GpuMat& result, Stream& stream)
modules/gpu/src/brute_force_matcher.cpp
+7 -7
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 cuda
namespace cv { namespace gpu { namespace cudev
{
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::cuda::bf_match;
using namespace cv::gpu::cudev::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::cuda::bf_match;
using namespace cv::gpu::cudev::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::cuda::bf_knnmatch;
using namespace cv::gpu::cudev::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::cuda::bf_knnmatch;
using namespace cv::gpu::cudev::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::cuda::bf_radius_match;
using namespace cv::gpu::cudev::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::cuda::bf_radius_match;
using namespace cv::gpu::cudev::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,
modules/gpu/src/calib3d.cpp
+2 -2
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 cuda
namespace cv { namespace gpu { namespace cudev
{
namespace transform_points
{
@@ -78,7 +78,7 @@ namespace cv { namespace gpu { namespace cuda
}
}}}
using namespace ::cv::gpu::cuda;
using namespace ::cv::gpu::cudev;
namespace
{
modules/gpu/src/cascadeclassifier.cpp
+3 -3
View File
@@ -340,7 +340,7 @@ struct PyrLavel
cv::Size sWindow;
};
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace lbp
{
@@ -441,7 +441,7 @@ public:
acc += level.sFrame.width + 1;
}
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,
cudev::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;
cvCudaSafeCall( cudaMemcpy(&classified, dclassified.ptr(), sizeof(int), cudaMemcpyDeviceToHost) );
cuda::lbp::connectedConmonents(candidates, classified, objects, groupThreshold, grouping_eps, dclassified.ptr<unsigned int>());
cudev::lbp::connectedConmonents(candidates, classified, objects, groupThreshold, grouping_eps, dclassified.ptr<unsigned int>());
cvCudaSafeCall( cudaMemcpy(&classified, dclassified.ptr(), sizeof(int), cudaMemcpyDeviceToHost) );
cvCudaSafeCall( cudaDeviceSynchronize() );
modules/gpu/src/color.cpp
+81 -81
View File
@@ -57,7 +57,7 @@ void cv::gpu::gammaCorrection(const GpuMat&, GpuMat&, bool, Stream&) { throw_no_
#include "cvt_color_internal.h"
namespace cv { namespace gpu {
namespace cuda
namespace cudev
{
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::cuda;
using namespace ::cv::gpu::cudev;
namespace
{
@@ -77,7 +77,7 @@ namespace
void bgr_to_rgb(const GpuMat& src, GpuMat& dst, int, Stream& stream)
{
using namespace cv::gpu::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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);
cuda::bgr_to_bgr555(src, dst, StreamAccessor::getStream(stream));
cudev::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);
cuda::bgr_to_bgr565(src, dst, StreamAccessor::getStream(stream));
cudev::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);
cuda::rgb_to_bgr555(src, dst, StreamAccessor::getStream(stream));
cudev::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);
cuda::rgb_to_bgr565(src, dst, StreamAccessor::getStream(stream));
cudev::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);
cuda::bgra_to_bgr555(src, dst, StreamAccessor::getStream(stream));
cudev::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);
cuda::bgra_to_bgr565(src, dst, StreamAccessor::getStream(stream));
cudev::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);
cuda::rgba_to_bgr555(src, dst, StreamAccessor::getStream(stream));
cudev::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);
cuda::rgba_to_bgr565(src, dst, StreamAccessor::getStream(stream));
cudev::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);
cuda::bgr555_to_rgb(src, dst, StreamAccessor::getStream(stream));
cudev::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);
cuda::bgr565_to_rgb(src, dst, StreamAccessor::getStream(stream));
cudev::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);
cuda::bgr555_to_bgr(src, dst, StreamAccessor::getStream(stream));
cudev::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);
cuda::bgr565_to_bgr(src, dst, StreamAccessor::getStream(stream));
cudev::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);
cuda::bgr555_to_rgba(src, dst, StreamAccessor::getStream(stream));
cudev::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);
cuda::bgr565_to_rgba(src, dst, StreamAccessor::getStream(stream));
cudev::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);
cuda::bgr555_to_bgra(src, dst, StreamAccessor::getStream(stream));
cudev::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);
cuda::bgr565_to_bgra(src, dst, StreamAccessor::getStream(stream));
cudev::bgr565_to_bgra(src, dst, StreamAccessor::getStream(stream));
}
void gray_to_bgr(const GpuMat& src, GpuMat& dst, int, Stream& stream)
{
using namespace cv::gpu::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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);
cuda::gray_to_bgr555(src, dst, StreamAccessor::getStream(stream));
cudev::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);
cuda::gray_to_bgr565(src, dst, StreamAccessor::getStream(stream));
cudev::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);
cuda::bgr555_to_gray(src, dst, StreamAccessor::getStream(stream));
cudev::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);
cuda::bgr565_to_gray(src, dst, StreamAccessor::getStream(stream));
cudev::bgr565_to_gray(src, dst, StreamAccessor::getStream(stream));
}
void rgb_to_gray(const GpuMat& src, GpuMat& dst, int, Stream& stream)
{
using namespace cv::gpu::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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::cuda;
using namespace cv::gpu::cudev;
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)
cuda::MHCdemosaic<3>(srcWhole, make_int2(ofs.x, ofs.y), dst, firstRed, StreamAccessor::getStream(stream));
cudev::MHCdemosaic<3>(srcWhole, make_int2(ofs.x, ofs.y), dst, firstRed, StreamAccessor::getStream(stream));
else
cuda::MHCdemosaic<4>(srcWhole, make_int2(ofs.x, ofs.y), dst, firstRed, StreamAccessor::getStream(stream));
cudev::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);
cuda::MHCdemosaic<1>(srcWhole, make_int2(ofs.x, ofs.y), dst, firstRed, StreamAccessor::getStream(stream));
cudev::MHCdemosaic<1>(srcWhole, make_int2(ofs.x, ofs.y), dst, firstRed, StreamAccessor::getStream(stream));
break;
}
modules/gpu/src/cuda/NV12ToARGB.cu
+1 -1
View File
@@ -51,7 +51,7 @@
#include "opencv2/core/cuda/common.hpp"
namespace cv { namespace gpu { namespace cuda {
namespace cv { namespace gpu { namespace cudev {
namespace video_decoding
{
__constant__ uint constAlpha = ((uint)0xff << 24);
modules/gpu/src/cuda/bf_knnmatch.cu
+2 -2
View File
@@ -50,7 +50,7 @@
#include "opencv2/core/cuda/datamov_utils.hpp"
#include "opencv2/core/cuda/warp_shuffle.hpp"
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace bf_knnmatch
{
@@ -1249,7 +1249,7 @@ namespace cv { namespace gpu { namespace cuda
//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 cuda {
}}} // namespace cv { namespace gpu { namespace cudev {
#endif /* CUDA_DISABLER */
modules/gpu/src/cuda/bf_match.cu
+2 -2
View File
@@ -49,7 +49,7 @@
#include "opencv2/core/cuda/vec_distance.hpp"
#include "opencv2/core/cuda/datamov_utils.hpp"
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace bf_match
{
@@ -768,7 +768,7 @@ namespace cv { namespace gpu { namespace cuda
//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 cuda {
}}} // namespace cv { namespace gpu { namespace cudev {
#endif /* CUDA_DISABLER */
modules/gpu/src/cuda/bf_radius_match.cu
+2 -2
View File
@@ -48,7 +48,7 @@
#include "opencv2/core/cuda/vec_distance.hpp"
#include "opencv2/core/cuda/datamov_utils.hpp"
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace bf_radius_match
{
@@ -457,7 +457,7 @@ namespace cv { namespace gpu { namespace cuda
//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 cuda
}}} // namespace cv { namespace gpu { namespace cudev
#endif /* CUDA_DISABLER */
modules/gpu/src/cuda/bgfg_gmg.cu
+1 -1
View File
@@ -46,7 +46,7 @@
#include "opencv2/core/cuda/vec_traits.hpp"
#include "opencv2/core/cuda/limits.hpp"
namespace cv { namespace gpu { namespace cuda {
namespace cv { namespace gpu { namespace cudev {
namespace bgfg_gmg
{
__constant__ int c_width;
modules/gpu/src/cuda/bgfg_mog.cu
+1 -1
View File
@@ -47,7 +47,7 @@
#include "opencv2/core/cuda/vec_math.hpp"
#include "opencv2/core/cuda/limits.hpp"
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace mog
{
modules/gpu/src/cuda/bilateral_filter.cu
+2 -2
View File
@@ -55,7 +55,7 @@ typedef unsigned short ushort;
//////////////////////////////////////////////////////////////////////////////////
/// Bilateral filtering
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace imgproc
{
@@ -163,7 +163,7 @@ namespace cv { namespace gpu { namespace cuda
#define OCV_INSTANTIATE_BILATERAL_FILTER(T) \
template void cv::gpu::cuda::imgproc::bilateral_filter_gpu<T>(const PtrStepSzb&, PtrStepSzb, int, float, float, int, cudaStream_t);
template void cv::gpu::cudev::imgproc::bilateral_filter_gpu<T>(const PtrStepSzb&, PtrStepSzb, int, float, float, int, cudaStream_t);
OCV_INSTANTIATE_BILATERAL_FILTER(uchar)
//OCV_INSTANTIATE_BILATERAL_FILTER(uchar2)
modules/gpu/src/cuda/blend.cu
+2 -2
View File
@@ -44,7 +44,7 @@
#include "opencv2/core/cuda/common.hpp"
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace blend
{
@@ -115,7 +115,7 @@ namespace cv { namespace gpu { namespace cuda
cvCudaSafeCall(cudaDeviceSynchronize());
}
} // namespace blend
}}} // namespace cv { namespace gpu { namespace cuda
}}} // namespace cv { namespace gpu { namespace cudev
#endif /* CUDA_DISABLER */
modules/gpu/src/cuda/calib3d.cu
+4 -4
View File
@@ -47,7 +47,7 @@
#include "opencv2/core/cuda/functional.hpp"
#include "opencv2/core/cuda/reduce.hpp"
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
#define SOLVE_PNP_RANSAC_MAX_NUM_ITERS 200
@@ -79,7 +79,7 @@ namespace cv { namespace gpu { namespace cuda
cvCudaSafeCall(cudaMemcpyToSymbol(crot1, rot + 3, sizeof(float) * 3));
cvCudaSafeCall(cudaMemcpyToSymbol(crot2, rot + 6, sizeof(float) * 3));
cvCudaSafeCall(cudaMemcpyToSymbol(ctransl, transl, sizeof(float) * 3));
cv::gpu::cuda::transform(src, dst, TransformOp(), WithOutMask(), stream);
cv::gpu::cudev::transform(src, dst, TransformOp(), WithOutMask(), stream);
}
} // namespace transform_points
@@ -120,7 +120,7 @@ namespace cv { namespace gpu { namespace cuda
cvCudaSafeCall(cudaMemcpyToSymbol(ctransl, transl, sizeof(float) * 3));
cvCudaSafeCall(cudaMemcpyToSymbol(cproj0, proj, sizeof(float) * 3));
cvCudaSafeCall(cudaMemcpyToSymbol(cproj1, proj + 3, sizeof(float) * 3));
cv::gpu::cuda::transform(src, dst, ProjectOp(), WithOutMask(), stream);
cv::gpu::cudev::transform(src, dst, ProjectOp(), WithOutMask(), stream);
}
} // namespace project_points
@@ -187,7 +187,7 @@ namespace cv { namespace gpu { namespace cuda
cvCudaSafeCall( cudaDeviceSynchronize() );
}
} // namespace solvepnp_ransac
}}} // namespace cv { namespace gpu { namespace cuda
}}} // namespace cv { namespace gpu { namespace cudev
#endif /* CUDA_DISABLER */
modules/gpu/src/cuda/canny.cu
+3 -3
View File
@@ -51,7 +51,7 @@
#include "opencv2/core/cuda/utility.hpp"
using namespace cv::gpu;
using namespace cv::gpu::cuda;
using namespace cv::gpu::cudev;
namespace canny
{
@@ -77,7 +77,7 @@ namespace canny
};
}
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
template <> struct TransformFunctorTraits<canny::L1> : DefaultTransformFunctorTraits<canny::L1>
{
@@ -475,7 +475,7 @@ namespace canny
};
}
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
template <> struct TransformFunctorTraits<canny::GetEdges> : DefaultTransformFunctorTraits<canny::GetEdges>
{
modules/gpu/src/cuda/ccomponetns.cu
+1 -1
View File
@@ -50,7 +50,7 @@
#include <iostream>
#include <stdio.h>
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace ccl
{
modules/gpu/src/cuda/clahe.cu
+1 -1
View File
@@ -50,7 +50,7 @@
#include "opencv2/core/cuda/saturate_cast.hpp"
using namespace cv::gpu;
using namespace cv::gpu::cuda;
using namespace cv::gpu::cudev;
namespace clahe
{
modules/gpu/src/cuda/color.cu
+3 -3
View File
@@ -47,7 +47,7 @@
#include "opencv2/core/cuda/color.hpp"
#include "cvt_color_internal.h"
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
OPENCV_GPU_TRANSFORM_FUNCTOR_TRAITS(bgra_to_rgba_traits<uchar>::functor_type)
{
@@ -229,7 +229,7 @@ namespace cv { namespace gpu { namespace cuda
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::cuda::transform((PtrStepSz<src_t>)src, (PtrStepSz<dst_t>)dst, functor, WithOutMask(), stream); \
cv::gpu::cudev::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 cuda
#undef OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL
#undef OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F
#undef OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F_FULL
}}} // namespace cv { namespace gpu { namespace cuda
}}} // namespace cv { namespace gpu { namespace cudev
#endif /* CUDA_DISABLER */
modules/gpu/src/cuda/column_filter.h
+1 -1
View File
@@ -46,7 +46,7 @@
#include "opencv2/core/cuda/border_interpolate.hpp"
using namespace cv::gpu;
using namespace cv::gpu::cuda;
using namespace cv::gpu::cudev;
namespace column_filter
{
modules/gpu/src/cuda/copy_make_border.cu
+2 -2
View File
@@ -45,7 +45,7 @@
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/border_interpolate.hpp"
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace imgproc
{
@@ -126,6 +126,6 @@ namespace cv { namespace gpu { namespace cuda
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 cuda
}}} // namespace cv { namespace gpu { namespace cudev
#endif /* CUDA_DISABLER */
modules/gpu/src/cuda/debayer.cu
+1 -1
View File
@@ -49,7 +49,7 @@
#include "opencv2/core/cuda/color.hpp"
#include "opencv2/core/cuda/saturate_cast.hpp"
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
template <typename T> struct Bayer2BGR;
modules/gpu/src/cuda/disp_bilateral_filter.cu
+2 -2
View File
@@ -45,7 +45,7 @@
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/limits.hpp"
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace disp_bilateral_filter
{
@@ -218,6 +218,6 @@ namespace cv { namespace gpu { namespace cuda
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 cuda
}}} // namespace cv { namespace gpu { namespace cudev
#endif /* CUDA_DISABLER */
modules/gpu/src/cuda/element_operations.cu
+84 -84
View File
@@ -51,7 +51,7 @@
#include "opencv2/core/cuda/simd_functions.hpp"
using namespace cv::gpu;
using namespace cv::gpu::cuda;
using namespace cv::gpu::cudev;
namespace arithm
{
@@ -193,7 +193,7 @@ namespace arithm
};
}
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
template <> struct TransformFunctorTraits< arithm::VAdd4 > : arithm::ArithmFuncTraits<sizeof(uint), sizeof(uint)>
{
@@ -216,21 +216,21 @@ namespace arithm
{
void addMat_v4(PtrStepSz<uint> src1, PtrStepSz<uint> src2, PtrStepSz<uint> dst, cudaStream_t stream)
{
cuda::transform(src1, src2, dst, VAdd4(), WithOutMask(), stream);
cudev::transform(src1, src2, dst, VAdd4(), WithOutMask(), stream);
}
void addMat_v2(PtrStepSz<uint> src1, PtrStepSz<uint> src2, PtrStepSz<uint> dst, cudaStream_t stream)
{
cuda::transform(src1, src2, dst, VAdd2(), WithOutMask(), stream);
cudev::transform(src1, src2, dst, VAdd2(), WithOutMask(), stream);
}
template <typename T, typename D>
void addMat(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream)
{
if (mask.data)
cuda::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<D>) dst, AddMat<T, D>(), mask, stream);
cudev::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<D>) dst, AddMat<T, D>(), mask, stream);
else
cuda::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<D>) dst, AddMat<T, D>(), WithOutMask(), stream);
cudev::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<D>) dst, AddMat<T, D>(), WithOutMask(), stream);
}
template void addMat<uchar, uchar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
@@ -308,7 +308,7 @@ namespace arithm
};
}
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
template <typename T, typename S, typename D> struct TransformFunctorTraits< arithm::AddScalar<T, S, D> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(D)>
{
@@ -323,9 +323,9 @@ namespace arithm
AddScalar<T, S, D> op(static_cast<S>(val));
if (mask.data)
cuda::transform((PtrStepSz<T>) src1, (PtrStepSz<D>) dst, op, mask, stream);
cudev::transform((PtrStepSz<T>) src1, (PtrStepSz<D>) dst, op, mask, stream);
else
cuda::transform((PtrStepSz<T>) src1, (PtrStepSz<D>) dst, op, WithOutMask(), stream);
cudev::transform((PtrStepSz<T>) src1, (PtrStepSz<D>) dst, op, WithOutMask(), stream);
}
template void addScalar<uchar, float, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
@@ -428,7 +428,7 @@ namespace arithm
};
}
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
template <> struct TransformFunctorTraits< arithm::VSub4 > : arithm::ArithmFuncTraits<sizeof(uint), sizeof(uint)>
{
@@ -451,21 +451,21 @@ namespace arithm
{
void subMat_v4(PtrStepSz<uint> src1, PtrStepSz<uint> src2, PtrStepSz<uint> dst, cudaStream_t stream)
{
cuda::transform(src1, src2, dst, VSub4(), WithOutMask(), stream);
cudev::transform(src1, src2, dst, VSub4(), WithOutMask(), stream);
}
void subMat_v2(PtrStepSz<uint> src1, PtrStepSz<uint> src2, PtrStepSz<uint> dst, cudaStream_t stream)
{
cuda::transform(src1, src2, dst, VSub2(), WithOutMask(), stream);
cudev::transform(src1, src2, dst, VSub2(), WithOutMask(), stream);
}
template <typename T, typename D>
void subMat(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream)
{
if (mask.data)
cuda::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<D>) dst, SubMat<T, D>(), mask, stream);
cudev::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<D>) dst, SubMat<T, D>(), mask, stream);
else
cuda::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<D>) dst, SubMat<T, D>(), WithOutMask(), stream);
cudev::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<D>) dst, SubMat<T, D>(), WithOutMask(), stream);
}
template void subMat<uchar, uchar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
@@ -536,9 +536,9 @@ namespace arithm
AddScalar<T, S, D> op(-static_cast<S>(val));
if (mask.data)
cuda::transform((PtrStepSz<T>) src1, (PtrStepSz<D>) dst, op, mask, stream);
cudev::transform((PtrStepSz<T>) src1, (PtrStepSz<D>) dst, op, mask, stream);
else
cuda::transform((PtrStepSz<T>) src1, (PtrStepSz<D>) dst, op, WithOutMask(), stream);
cudev::transform((PtrStepSz<T>) src1, (PtrStepSz<D>) dst, op, WithOutMask(), stream);
}
template void subScalar<uchar, float, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
@@ -657,7 +657,7 @@ namespace arithm
};
}
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
template <> struct TransformFunctorTraits<arithm::Mul_8uc4_32f> : arithm::ArithmFuncTraits<sizeof(uint), sizeof(uint)>
{
@@ -676,12 +676,12 @@ namespace arithm
{
void mulMat_8uc4_32f(PtrStepSz<uint> src1, PtrStepSzf src2, PtrStepSz<uint> dst, cudaStream_t stream)
{
cuda::transform(src1, src2, dst, Mul_8uc4_32f(), WithOutMask(), stream);
cudev::transform(src1, src2, dst, Mul_8uc4_32f(), WithOutMask(), stream);
}
void mulMat_16sc4_32f(PtrStepSz<short4> src1, PtrStepSzf src2, PtrStepSz<short4> dst, cudaStream_t stream)
{
cuda::transform(src1, src2, dst, Mul_16sc4_32f(), WithOutMask(), stream);
cudev::transform(src1, src2, dst, Mul_16sc4_32f(), WithOutMask(), stream);
}
template <typename T, typename S, typename D>
@@ -690,12 +690,12 @@ namespace arithm
if (scale == 1)
{
Mul<T, D> op;
cuda::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<D>) dst, op, WithOutMask(), stream);
cudev::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<D>) dst, op, WithOutMask(), stream);
}
else
{
MulScale<T, S, D> op(static_cast<S>(scale));
cuda::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<D>) dst, op, WithOutMask(), stream);
cudev::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<D>) dst, op, WithOutMask(), stream);
}
}
@@ -774,7 +774,7 @@ namespace arithm
};
}
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
template <typename T, typename S, typename D> struct TransformFunctorTraits< arithm::MulScalar<T, S, D> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(D)>
{
@@ -787,7 +787,7 @@ namespace arithm
void mulScalar(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream)
{
MulScalar<T, S, D> op(static_cast<S>(val));
cuda::transform((PtrStepSz<T>) src1, (PtrStepSz<D>) dst, op, WithOutMask(), stream);
cudev::transform((PtrStepSz<T>) src1, (PtrStepSz<D>) dst, op, WithOutMask(), stream);
}
template void mulScalar<uchar, float, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
@@ -925,7 +925,7 @@ namespace arithm
};
}
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
template <> struct TransformFunctorTraits<arithm::Div_8uc4_32f> : arithm::ArithmFuncTraits<sizeof(uint), sizeof(uint)>
{
@@ -944,12 +944,12 @@ namespace arithm
{
void divMat_8uc4_32f(PtrStepSz<uint> src1, PtrStepSzf src2, PtrStepSz<uint> dst, cudaStream_t stream)
{
cuda::transform(src1, src2, dst, Div_8uc4_32f(), WithOutMask(), stream);
cudev::transform(src1, src2, dst, Div_8uc4_32f(), WithOutMask(), stream);
}
void divMat_16sc4_32f(PtrStepSz<short4> src1, PtrStepSzf src2, PtrStepSz<short4> dst, cudaStream_t stream)
{
cuda::transform(src1, src2, dst, Div_16sc4_32f(), WithOutMask(), stream);
cudev::transform(src1, src2, dst, Div_16sc4_32f(), WithOutMask(), stream);
}
template <typename T, typename S, typename D>
@@ -958,12 +958,12 @@ namespace arithm
if (scale == 1)
{
Div<T, D> op;
cuda::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<D>) dst, op, WithOutMask(), stream);
cudev::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<D>) dst, op, WithOutMask(), stream);
}
else
{
DivScale<T, S, D> op(static_cast<S>(scale));
cuda::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<D>) dst, op, WithOutMask(), stream);
cudev::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<D>) dst, op, WithOutMask(), stream);
}
}
@@ -1033,7 +1033,7 @@ namespace arithm
void divScalar(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream)
{
MulScalar<T, S, D> op(static_cast<S>(1.0 / val));
cuda::transform((PtrStepSz<T>) src1, (PtrStepSz<D>) dst, op, WithOutMask(), stream);
cudev::transform((PtrStepSz<T>) src1, (PtrStepSz<D>) dst, op, WithOutMask(), stream);
}
template void divScalar<uchar, float, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
@@ -1111,7 +1111,7 @@ namespace arithm
};
}
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
template <typename T, typename S, typename D> struct TransformFunctorTraits< arithm::DivInv<T, S, D> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(D)>
{
@@ -1124,7 +1124,7 @@ namespace arithm
void divInv(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream)
{
DivInv<T, S, D> op(static_cast<S>(val));
cuda::transform((PtrStepSz<T>) src1, (PtrStepSz<D>) dst, op, WithOutMask(), stream);
cudev::transform((PtrStepSz<T>) src1, (PtrStepSz<D>) dst, op, WithOutMask(), stream);
}
template void divInv<uchar, float, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
@@ -1240,7 +1240,7 @@ namespace arithm
};
}
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
template <> struct TransformFunctorTraits< arithm::VAbsDiff4 > : arithm::ArithmFuncTraits<sizeof(uint), sizeof(uint)>
{
@@ -1263,18 +1263,18 @@ namespace arithm
{
void absDiffMat_v4(PtrStepSz<uint> src1, PtrStepSz<uint> src2, PtrStepSz<uint> dst, cudaStream_t stream)
{
cuda::transform(src1, src2, dst, VAbsDiff4(), WithOutMask(), stream);
cudev::transform(src1, src2, dst, VAbsDiff4(), WithOutMask(), stream);
}
void absDiffMat_v2(PtrStepSz<uint> src1, PtrStepSz<uint> src2, PtrStepSz<uint> dst, cudaStream_t stream)
{
cuda::transform(src1, src2, dst, VAbsDiff2(), WithOutMask(), stream);
cudev::transform(src1, src2, dst, VAbsDiff2(), WithOutMask(), stream);
}
template <typename T>
void absDiffMat(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream)
{
cuda::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<T>) dst, AbsDiffMat<T>(), WithOutMask(), stream);
cudev::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<T>) dst, AbsDiffMat<T>(), WithOutMask(), stream);
}
template void absDiffMat<uchar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
@@ -1305,7 +1305,7 @@ namespace arithm
};
}
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
template <typename T, typename S> struct TransformFunctorTraits< arithm::AbsDiffScalar<T, S> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
{
@@ -1319,7 +1319,7 @@ namespace arithm
{
AbsDiffScalar<T, S> op(static_cast<S>(val));
cuda::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) dst, op, WithOutMask(), stream);
cudev::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) dst, op, WithOutMask(), stream);
}
template void absDiffScalar<uchar, float>(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
@@ -1334,7 +1334,7 @@ namespace arithm
//////////////////////////////////////////////////////////////////////////
// absMat
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
template <typename T> struct TransformFunctorTraits< abs_func<T> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
{
@@ -1346,7 +1346,7 @@ namespace arithm
template <typename T>
void absMat(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream)
{
cuda::transform((PtrStepSz<T>) src, (PtrStepSz<T>) dst, abs_func<T>(), WithOutMask(), stream);
cudev::transform((PtrStepSz<T>) src, (PtrStepSz<T>) dst, abs_func<T>(), WithOutMask(), stream);
}
template void absMat<uchar>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
@@ -1375,7 +1375,7 @@ namespace arithm
};
}
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
template <typename T> struct TransformFunctorTraits< arithm::Sqr<T> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
{
@@ -1387,7 +1387,7 @@ namespace arithm
template <typename T>
void sqrMat(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream)
{
cuda::transform((PtrStepSz<T>) src, (PtrStepSz<T>) dst, Sqr<T>(), WithOutMask(), stream);
cudev::transform((PtrStepSz<T>) src, (PtrStepSz<T>) dst, Sqr<T>(), WithOutMask(), stream);
}
template void sqrMat<uchar>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
@@ -1402,7 +1402,7 @@ namespace arithm
//////////////////////////////////////////////////////////////////////////
// sqrtMat
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
template <typename T> struct TransformFunctorTraits< sqrt_func<T> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
{
@@ -1414,7 +1414,7 @@ namespace arithm
template <typename T>
void sqrtMat(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream)
{
cuda::transform((PtrStepSz<T>) src, (PtrStepSz<T>) dst, sqrt_func<T>(), WithOutMask(), stream);
cudev::transform((PtrStepSz<T>) src, (PtrStepSz<T>) dst, sqrt_func<T>(), WithOutMask(), stream);
}
template void sqrtMat<uchar>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
@@ -1429,7 +1429,7 @@ namespace arithm
//////////////////////////////////////////////////////////////////////////
// logMat
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
template <typename T> struct TransformFunctorTraits< log_func<T> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
{
@@ -1441,7 +1441,7 @@ namespace arithm
template <typename T>
void logMat(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream)
{
cuda::transform((PtrStepSz<T>) src, (PtrStepSz<T>) dst, log_func<T>(), WithOutMask(), stream);
cudev::transform((PtrStepSz<T>) src, (PtrStepSz<T>) dst, log_func<T>(), WithOutMask(), stream);
}
template void logMat<uchar>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
@@ -1471,7 +1471,7 @@ namespace arithm
};
}
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
template <typename T> struct TransformFunctorTraits< arithm::Exp<T> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
{
@@ -1483,7 +1483,7 @@ namespace arithm
template <typename T>
void expMat(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream)
{
cuda::transform((PtrStepSz<T>) src, (PtrStepSz<T>) dst, Exp<T>(), WithOutMask(), stream);
cudev::transform((PtrStepSz<T>) src, (PtrStepSz<T>) dst, Exp<T>(), WithOutMask(), stream);
}
template void expMat<uchar>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
@@ -1554,7 +1554,7 @@ namespace arithm
};
}
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
template <> struct TransformFunctorTraits< arithm::VCmpEq4 > : arithm::ArithmFuncTraits<sizeof(uint), sizeof(uint)>
{
@@ -1580,26 +1580,26 @@ namespace arithm
{
void cmpMatEq_v4(PtrStepSz<uint> src1, PtrStepSz<uint> src2, PtrStepSz<uint> dst, cudaStream_t stream)
{
cuda::transform(src1, src2, dst, VCmpEq4(), WithOutMask(), stream);
cudev::transform(src1, src2, dst, VCmpEq4(), WithOutMask(), stream);
}
void cmpMatNe_v4(PtrStepSz<uint> src1, PtrStepSz<uint> src2, PtrStepSz<uint> dst, cudaStream_t stream)
{
cuda::transform(src1, src2, dst, VCmpNe4(), WithOutMask(), stream);
cudev::transform(src1, src2, dst, VCmpNe4(), WithOutMask(), stream);
}
void cmpMatLt_v4(PtrStepSz<uint> src1, PtrStepSz<uint> src2, PtrStepSz<uint> dst, cudaStream_t stream)
{
cuda::transform(src1, src2, dst, VCmpLt4(), WithOutMask(), stream);
cudev::transform(src1, src2, dst, VCmpLt4(), WithOutMask(), stream);
}
void cmpMatLe_v4(PtrStepSz<uint> src1, PtrStepSz<uint> src2, PtrStepSz<uint> dst, cudaStream_t stream)
{
cuda::transform(src1, src2, dst, VCmpLe4(), WithOutMask(), stream);
cudev::transform(src1, src2, dst, VCmpLe4(), WithOutMask(), stream);
}
template <template <typename> class Op, typename T>
void cmpMat(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream)
{
Cmp<Op<T>, T> op;
cuda::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, dst, op, WithOutMask(), stream);
cudev::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, dst, op, WithOutMask(), stream);
}
template <typename T> void cmpMatEq(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream)
@@ -1716,7 +1716,7 @@ namespace arithm
#undef TYPE_VEC
}
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
template <class Op, typename T> struct TransformFunctorTraits< arithm::CmpScalar<Op, T, 1> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(uchar)>
{
@@ -1735,7 +1735,7 @@ namespace arithm
src_t val1 = VecTraits<src_t>::make(sval);
CmpScalar<Op<T>, T, cn> op(val1);
cuda::transform((PtrStepSz<src_t>) src, (PtrStepSz<dst_t>) dst, op, WithOutMask(), stream);
cudev::transform((PtrStepSz<src_t>) src, (PtrStepSz<dst_t>) dst, op, WithOutMask(), stream);
}
template <typename T> void cmpScalarEq(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream)
@@ -1875,7 +1875,7 @@ namespace arithm
//////////////////////////////////////////////////////////////////////////////////////
// bitMat
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
template <typename T> struct TransformFunctorTraits< bit_not<T> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
{
@@ -1899,33 +1899,33 @@ namespace arithm
template <typename T> void bitMatNot(PtrStepSzb src, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream)
{
if (mask.data)
cuda::transform((PtrStepSz<T>) src, (PtrStepSz<T>) dst, bit_not<T>(), mask, stream);
cudev::transform((PtrStepSz<T>) src, (PtrStepSz<T>) dst, bit_not<T>(), mask, stream);
else
cuda::transform((PtrStepSz<T>) src, (PtrStepSz<T>) dst, bit_not<T>(), WithOutMask(), stream);
cudev::transform((PtrStepSz<T>) src, (PtrStepSz<T>) dst, bit_not<T>(), WithOutMask(), stream);
}
template <typename T> void bitMatAnd(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream)
{
if (mask.data)
cuda::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<T>) dst, bit_and<T>(), mask, stream);
cudev::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<T>) dst, bit_and<T>(), mask, stream);
else
cuda::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<T>) dst, bit_and<T>(), WithOutMask(), stream);
cudev::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<T>) dst, bit_and<T>(), WithOutMask(), stream);
}
template <typename T> void bitMatOr(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream)
{
if (mask.data)
cuda::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<T>) dst, bit_or<T>(), mask, stream);
cudev::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<T>) dst, bit_or<T>(), mask, stream);
else
cuda::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<T>) dst, bit_or<T>(), WithOutMask(), stream);
cudev::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<T>) dst, bit_or<T>(), WithOutMask(), stream);
}
template <typename T> void bitMatXor(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream)
{
if (mask.data)
cuda::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<T>) dst, bit_xor<T>(), mask, stream);
cudev::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<T>) dst, bit_xor<T>(), mask, stream);
else
cuda::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<T>) dst, bit_xor<T>(), WithOutMask(), stream);
cudev::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<T>) dst, bit_xor<T>(), WithOutMask(), stream);
}
template void bitMatNot<uchar>(PtrStepSzb src, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
@@ -1948,7 +1948,7 @@ namespace arithm
//////////////////////////////////////////////////////////////////////////////////////
// bitScalar
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
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)
{
cuda::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) dst, cv::gpu::cuda::bind2nd(bit_and<T>(), src2), WithOutMask(), stream);
cudev::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) dst, cv::gpu::cudev::bind2nd(bit_and<T>(), src2), WithOutMask(), stream);
}
template <typename T> void bitScalarOr(PtrStepSzb src1, uint src2, PtrStepSzb dst, cudaStream_t stream)
{
cuda::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) dst, cv::gpu::cuda::bind2nd(bit_or<T>(), src2), WithOutMask(), stream);
cudev::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) dst, cv::gpu::cudev::bind2nd(bit_or<T>(), src2), WithOutMask(), stream);
}
template <typename T> void bitScalarXor(PtrStepSzb src1, uint src2, PtrStepSzb dst, cudaStream_t stream)
{
cuda::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) dst, cv::gpu::cuda::bind2nd(bit_xor<T>(), src2), WithOutMask(), stream);
cudev::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) dst, cv::gpu::cudev::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 cuda
namespace cv { namespace gpu { namespace cudev
{
template <> struct TransformFunctorTraits< arithm::VMin4 > : arithm::ArithmFuncTraits<sizeof(uint), sizeof(uint)>
{
@@ -2053,17 +2053,17 @@ namespace arithm
{
void minMat_v4(PtrStepSz<uint> src1, PtrStepSz<uint> src2, PtrStepSz<uint> dst, cudaStream_t stream)
{
cuda::transform(src1, src2, dst, VMin4(), WithOutMask(), stream);
cudev::transform(src1, src2, dst, VMin4(), WithOutMask(), stream);
}
void minMat_v2(PtrStepSz<uint> src1, PtrStepSz<uint> src2, PtrStepSz<uint> dst, cudaStream_t stream)
{
cuda::transform(src1, src2, dst, VMin2(), WithOutMask(), stream);
cudev::transform(src1, src2, dst, VMin2(), WithOutMask(), stream);
}
template <typename T> void minMat(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream)
{
cuda::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<T>) dst, minimum<T>(), WithOutMask(), stream);
cudev::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<T>) dst, minimum<T>(), WithOutMask(), stream);
}
template void minMat<uchar >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
@@ -2076,7 +2076,7 @@ namespace arithm
template <typename T> void minScalar(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream)
{
cuda::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) dst, cv::gpu::cuda::bind2nd(minimum<T>(), src2), WithOutMask(), stream);
cudev::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) dst, cv::gpu::cudev::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 cuda
namespace cv { namespace gpu { namespace cudev
{
template <> struct TransformFunctorTraits< arithm::VMax4 > : arithm::ArithmFuncTraits<sizeof(uint), sizeof(uint)>
{
@@ -2145,17 +2145,17 @@ namespace arithm
{
void maxMat_v4(PtrStepSz<uint> src1, PtrStepSz<uint> src2, PtrStepSz<uint> dst, cudaStream_t stream)
{
cuda::transform(src1, src2, dst, VMax4(), WithOutMask(), stream);
cudev::transform(src1, src2, dst, VMax4(), WithOutMask(), stream);
}
void maxMat_v2(PtrStepSz<uint> src1, PtrStepSz<uint> src2, PtrStepSz<uint> dst, cudaStream_t stream)
{
cuda::transform(src1, src2, dst, VMax2(), WithOutMask(), stream);
cudev::transform(src1, src2, dst, VMax2(), WithOutMask(), stream);
}
template <typename T> void maxMat(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream)
{
cuda::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<T>) dst, maximum<T>(), WithOutMask(), stream);
cudev::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<T>) dst, maximum<T>(), WithOutMask(), stream);
}
template void maxMat<uchar >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
@@ -2168,7 +2168,7 @@ namespace arithm
template <typename T> void maxScalar(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream)
{
cuda::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) dst, cv::gpu::cuda::bind2nd(maximum<T>(), src2), WithOutMask(), stream);
cudev::transform((PtrStepSz<T>) src1, (PtrStepSz<T>) dst, cv::gpu::cudev::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 cuda
namespace cv { namespace gpu { namespace cudev
{
template <typename T> struct TransformFunctorTraits< thresh_binary_func<T> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
{
@@ -2212,7 +2212,7 @@ namespace arithm
void threshold_caller(PtrStepSz<T> src, PtrStepSz<T> dst, T thresh, T maxVal, cudaStream_t stream)
{
Op<T> op(thresh, maxVal);
cuda::transform(src, dst, op, WithOutMask(), stream);
cudev::transform(src, dst, op, WithOutMask(), stream);
}
template <typename T>
@@ -2297,7 +2297,7 @@ namespace arithm
};
}
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
template <typename T> struct TransformFunctorTraits< arithm::PowOp<T> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
{
@@ -2309,7 +2309,7 @@ namespace arithm
template<typename T>
void pow(PtrStepSzb src, double power, PtrStepSzb dst, cudaStream_t stream)
{
cuda::transform((PtrStepSz<T>) src, (PtrStepSz<T>) dst, PowOp<T>(power), WithOutMask(), stream);
cudev::transform((PtrStepSz<T>) src, (PtrStepSz<T>) dst, PowOp<T>(power), WithOutMask(), stream);
}
template void pow<uchar>(PtrStepSzb src, double power, PtrStepSzb dst, cudaStream_t stream);
@@ -2372,7 +2372,7 @@ namespace arithm
};
}
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
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> >
{
@@ -2393,7 +2393,7 @@ namespace arithm
{
AddWeighted<T1, T2, D> op(alpha, beta, gamma);
cuda::transform((PtrStepSz<T1>) src1, (PtrStepSz<T2>) src2, (PtrStepSz<D>) dst, op, WithOutMask(), stream);
cudev::transform((PtrStepSz<T1>) src1, (PtrStepSz<T2>) src2, (PtrStepSz<D>) dst, op, WithOutMask(), stream);
}
template void addWeighted<uchar, uchar, uchar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
modules/gpu/src/cuda/fast.cu
+1 -1
View File
@@ -45,7 +45,7 @@
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/utility.hpp"
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace fast
{
modules/gpu/src/cuda/fgd_bgfg.cu
+1 -1
View File
@@ -51,7 +51,7 @@
#include "fgd_bgfg_common.hpp"
using namespace cv::gpu;
using namespace cv::gpu::cuda;
using namespace cv::gpu::cudev;
namespace bgfg
{
modules/gpu/src/cuda/gftt.cu
+1 -1
View File
@@ -48,7 +48,7 @@
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/utility.hpp"
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace gfft
{
modules/gpu/src/cuda/global_motion.cu
+1 -1
View File
@@ -47,7 +47,7 @@
#include <thrust/functional.h>
#include "opencv2/core/cuda/common.hpp"
namespace cv { namespace gpu { namespace cuda { namespace globmotion {
namespace cv { namespace gpu { namespace cudev { namespace globmotion {
__constant__ float cml[9];
__constant__ float cmr[9];
modules/gpu/src/cuda/hist.cu
+3 -3
View File
@@ -48,7 +48,7 @@
#include "opencv2/core/cuda/transform.hpp"
using namespace cv::gpu;
using namespace cv::gpu::cuda;
using namespace cv::gpu::cudev;
namespace hist
{
@@ -127,7 +127,7 @@ namespace hist
};
}
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
template <> struct TransformFunctorTraits<hist::EqualizeHist> : DefaultTransformFunctorTraits<hist::EqualizeHist>
{
@@ -146,7 +146,7 @@ namespace hist
const float scale = 255.0f / (src.cols * src.rows);
cuda::transform(src, dst, EqualizeHist(scale), WithOutMask(), stream);
cudev::transform(src, dst, EqualizeHist(scale), WithOutMask(), stream);
}
}
modules/gpu/src/cuda/hog.cu
+2 -2
View File
@@ -47,7 +47,7 @@
#include "opencv2/core/cuda/functional.hpp"
#include "opencv2/core/cuda/warp_shuffle.hpp"
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
// Other values are not supported
#define CELL_WIDTH 8
@@ -808,7 +808,7 @@ namespace cv { namespace gpu { namespace cuda
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 cuda
}}} // namespace cv { namespace gpu { namespace cudev
#endif /* CUDA_DISABLER */
modules/gpu/src/cuda/hough.cu
+2 -2
View File
@@ -51,7 +51,7 @@
#include "opencv2/core/cuda/limits.hpp"
#include "opencv2/core/cuda/dynamic_smem.hpp"
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace hough
{
@@ -1424,7 +1424,7 @@ namespace cv { namespace gpu { namespace cuda
cvCudaSafeCall( cudaDeviceSynchronize() );
thrust::device_ptr<int> sizesPtr(sizes);
thrust::transform(sizesPtr, sizesPtr + levels + 1, sizesPtr, cuda::bind2nd(cuda::minimum<int>(), maxSize));
thrust::transform(sizesPtr, sizesPtr + levels + 1, sizesPtr, cudev::bind2nd(cudev::minimum<int>(), maxSize));
}
void GHT_Guil_Full_buildTemplFeatureList_gpu(const unsigned int* coordList, const float* thetaList, int pointsCount,
modules/gpu/src/cuda/imgproc.cu
+2 -2
View File
@@ -49,7 +49,7 @@
#include "opencv2/core/cuda/border_interpolate.hpp"
#include "internal_shared.hpp"
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace imgproc
{
@@ -1002,7 +1002,7 @@ namespace cv { namespace gpu { namespace cuda
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 cuda {
}}} // namespace cv { namespace gpu { namespace cudev {
#endif /* CUDA_DISABLER */
modules/gpu/src/cuda/integral_image.cu
+1 -1
View File
@@ -44,7 +44,7 @@
#include "opencv2/core/cuda/common.hpp"
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace imgproc
{
modules/gpu/src/cuda/lbp.cu
+1 -1
View File
@@ -46,7 +46,7 @@
#include "opencv2/core/cuda/vec_traits.hpp"
#include "opencv2/core/cuda/saturate_cast.hpp"
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace lbp
{
modules/gpu/src/cuda/lbp.hpp
+1 -1
View File
@@ -46,7 +46,7 @@
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/emulation.hpp"
namespace cv { namespace gpu { namespace cuda {
namespace cv { namespace gpu { namespace cudev {
namespace lbp {
modules/gpu/src/cuda/match_template.cu
+2 -2
View File
@@ -45,7 +45,7 @@
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/vec_math.hpp"
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace match_template
{
@@ -910,7 +910,7 @@ namespace cv { namespace gpu { namespace cuda
cvCudaSafeCall( cudaDeviceSynchronize() );
}
} //namespace match_template
}}} // namespace cv { namespace gpu { namespace cuda
}}} // namespace cv { namespace gpu { namespace cudev
#endif /* CUDA_DISABLER */
modules/gpu/src/cuda/mathfunc.cu
+2 -2
View File
@@ -44,7 +44,7 @@
#include "opencv2/core/cuda/common.hpp"
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace mathfunc
{
@@ -212,6 +212,6 @@ namespace cv { namespace gpu { namespace cuda
callers[mag.data == 0](mag, angle, x, y, angleInDegrees, stream);
}
} // namespace mathfunc
}}} // namespace cv { namespace gpu { namespace cuda
}}} // namespace cv { namespace gpu { namespace cudev
#endif /* CUDA_DISABLER */
modules/gpu/src/cuda/matrix_reductions.cu
+12 -12
View File
@@ -53,7 +53,7 @@
#include "opencv2/core/cuda/type_traits.hpp"
using namespace cv::gpu;
using namespace cv::gpu::cuda;
using namespace cv::gpu::cudev;
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::cuda::smem_tuple(smem, smem + BLOCK_SIZE);
return cv::gpu::cudev::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::cuda::smem_tuple(smem, smem + BLOCK_SIZE, smem + 2 * BLOCK_SIZE);
return cv::gpu::cudev::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::cuda::smem_tuple(smem, smem + BLOCK_SIZE, smem + 2 * BLOCK_SIZE, smem + 3 * BLOCK_SIZE);
return cv::gpu::cudev::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);
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>()));
cudev::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
}
}
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>()));
cudev::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;
cuda::reduce<BLOCK_SIZE>(smem_tuple(sminval, smaxval), thrust::tie(mymin, mymax), tid, thrust::make_tuple(minOp, maxOp));
cudev::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
}
}
cuda::reduce<BLOCK_SIZE>(smem_tuple(sminval, smaxval), thrust::tie(mymin, mymax), tid, thrust::make_tuple(minOp, maxOp));
cudev::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
}
}
cuda::reduce<BLOCK_SIZE>(scount, mycount, tid, plus<unsigned int>());
cudev::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;
cuda::reduce<BLOCK_SIZE>(scount, mycount, tid, plus<unsigned int>());
cudev::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];
cuda::reduce<16>(srow, myVal, threadIdx.x, op);
cudev::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]));
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));
cudev::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));
modules/gpu/src/cuda/nlm.cu
+6 -6
View File
@@ -57,7 +57,7 @@ typedef unsigned short ushort;
//////////////////////////////////////////////////////////////////////////////////
//// Non Local Means Denosing
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace imgproc
{
@@ -179,7 +179,7 @@ namespace cv { namespace gpu { namespace cuda
//////////////////////////////////////////////////////////////////////////////////
//// Non Local Means Denosing (fast approximate version)
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace imgproc
{
@@ -190,7 +190,7 @@ namespace cv { namespace gpu { namespace cuda
template <int BLOCK_SIZE>
static __device__ __forceinline__ thrust::tuple<volatile float*, volatile float*> smem_tuple(float* smem)
{
return cv::gpu::cuda::smem_tuple(smem, smem + BLOCK_SIZE);
return cv::gpu::cudev::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 cuda
template <int BLOCK_SIZE>
static __device__ __forceinline__ thrust::tuple<volatile float*, volatile float*, volatile float*> smem_tuple(float* smem)
{
return cv::gpu::cuda::smem_tuple(smem, smem + BLOCK_SIZE, smem + 2 * BLOCK_SIZE);
return cv::gpu::cudev::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 cuda
template <int BLOCK_SIZE>
static __device__ __forceinline__ thrust::tuple<volatile float*, volatile float*, volatile float*, volatile float*> smem_tuple(float* smem)
{
return cv::gpu::cuda::smem_tuple(smem, smem + BLOCK_SIZE, smem + 2 * BLOCK_SIZE, smem + 3 * BLOCK_SIZE);
return cv::gpu::cudev::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 cuda
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::cuda::smem_tuple(smem, smem + BLOCK_SIZE, smem + 2 * BLOCK_SIZE, smem + 3 * BLOCK_SIZE, smem + 4 * BLOCK_SIZE);
return cv::gpu::cudev::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)
modules/gpu/src/cuda/optflowbm.cu
+1 -1
View File
@@ -48,7 +48,7 @@
#include "opencv2/core/cuda/reduce.hpp"
using namespace cv::gpu;
using namespace cv::gpu::cuda;
using namespace cv::gpu::cudev;
namespace optflowbm
{
modules/gpu/src/cuda/optical_flow.cu
+1 -1
View File
@@ -44,7 +44,7 @@
#include "opencv2/core/cuda/common.hpp"
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace optical_flow
{
modules/gpu/src/cuda/optical_flow_farneback.cu
+2 -2
View File
@@ -55,7 +55,7 @@
#define BORDER_SIZE 5
#define MAX_KSIZE_HALF 100
namespace cv { namespace gpu { namespace cuda { namespace optflow_farneback
namespace cv { namespace gpu { namespace cudev { namespace optflow_farneback
{
__constant__ float c_g[8];
__constant__ float c_xg[8];
@@ -641,7 +641,7 @@ namespace cv { namespace gpu { namespace cuda { namespace optflow_farneback
callers[borderMode](src, ksizeHalf, dst, stream);
}
}}}} // namespace cv { namespace gpu { namespace cuda { namespace optflow_farneback
}}}} // namespace cv { namespace gpu { namespace cudev { namespace optflow_farneback
#endif /* CUDA_DISABLER */
modules/gpu/src/cuda/orb.cu
+1 -1
View File
@@ -49,7 +49,7 @@
#include "opencv2/core/cuda/reduce.hpp"
#include "opencv2/core/cuda/functional.hpp"
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace orb
{
modules/gpu/src/cuda/pyr_down.cu
+2 -2
View File
@@ -48,7 +48,7 @@
#include "opencv2/core/cuda/vec_math.hpp"
#include "opencv2/core/cuda/saturate_cast.hpp"
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace imgproc
{
@@ -222,7 +222,7 @@ namespace cv { namespace gpu { namespace cuda
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 cuda
}}} // namespace cv { namespace gpu { namespace cudev
#endif /* CUDA_DISABLER */
modules/gpu/src/cuda/pyr_up.cu
+2 -2
View File
@@ -48,7 +48,7 @@
#include "opencv2/core/cuda/vec_math.hpp"
#include "opencv2/core/cuda/saturate_cast.hpp"
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace imgproc
{
@@ -191,6 +191,6 @@ namespace cv { namespace gpu { namespace cuda
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 cuda
}}} // namespace cv { namespace gpu { namespace cudev
#endif /* CUDA_DISABLER */
modules/gpu/src/cuda/pyrlk.cu
+1 -1
View File
@@ -50,7 +50,7 @@
#include "opencv2/core/cuda/reduce.hpp"
using namespace cv::gpu;
using namespace cv::gpu::cuda;
using namespace cv::gpu::cudev;
namespace pyrlk
{
modules/gpu/src/cuda/remap.cu
+2 -2
View File
@@ -49,7 +49,7 @@
#include "opencv2/core/cuda/saturate_cast.hpp"
#include "opencv2/core/cuda/filters.hpp"
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace imgproc
{
@@ -268,7 +268,7 @@ namespace cv { namespace gpu { namespace cuda
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 cuda
}}} // namespace cv { namespace gpu { namespace cudev
#endif /* CUDA_DISABLER */
modules/gpu/src/cuda/resize.cu
+2 -2
View File
@@ -51,7 +51,7 @@
#include "opencv2/core/cuda/filters.hpp"
#include "opencv2/core/cuda/scan.hpp"
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace imgproc
{
@@ -296,7 +296,7 @@ namespace cv { namespace gpu { namespace cuda
};
} // namespace imgproc
}}} // namespace cv { namespace gpu { namespace cuda
}}} // namespace cv { namespace gpu { namespace cudev
#endif /* CUDA_DISABLER */
modules/gpu/src/cuda/rgb_to_yv12.cu
+1 -1
View File
@@ -45,7 +45,7 @@
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/vec_traits.hpp"
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace video_encoding
{
modules/gpu/src/cuda/row_filter.h
+1 -1
View File
@@ -46,7 +46,7 @@
#include "opencv2/core/cuda/border_interpolate.hpp"
using namespace cv::gpu;
using namespace cv::gpu::cuda;
using namespace cv::gpu::cudev;
namespace row_filter
{
modules/gpu/src/cuda/split_merge.cu
+2 -2
View File
@@ -44,7 +44,7 @@
#include "opencv2/core/cuda/common.hpp"
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace split_merge
{
@@ -505,7 +505,7 @@ namespace cv { namespace gpu { namespace cuda
split_func(src, dst, stream);
}
} // namespace split_merge
}}} // namespace cv { namespace gpu { namespace cuda
}}} // namespace cv { namespace gpu { namespace cudev
#endif /* CUDA_DISABLER */
modules/gpu/src/cuda/stereobm.cu
+2 -2
View File
@@ -44,7 +44,7 @@
#include "opencv2/core/cuda/common.hpp"
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace stereobm
{
@@ -534,7 +534,7 @@ namespace cv { namespace gpu { namespace cuda
cvCudaSafeCall( cudaUnbindTexture (texForTF) );
}
} // namespace stereobm
}}} // namespace cv { namespace gpu { namespace cuda
}}} // namespace cv { namespace gpu { namespace cudev
#endif /* CUDA_DISABLER */
modules/gpu/src/cuda/stereobp.cu
+3 -3
View File
@@ -46,7 +46,7 @@
#include "opencv2/core/cuda/saturate_cast.hpp"
#include "opencv2/core/cuda/limits.hpp"
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace stereobp
{
@@ -384,7 +384,7 @@ namespace cv { namespace gpu { namespace cuda
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 = cuda::numeric_limits<float>::max();
float minimum = cudev::numeric_limits<float>::max();
for(int i = 0; i < cndisp; ++i)
{
@@ -533,6 +533,6 @@ namespace cv { namespace gpu { namespace cuda
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 cuda
}}} // namespace cv { namespace gpu { namespace cudev
#endif /* CUDA_DISABLER */
modules/gpu/src/cuda/stereocsbp.cu
+3 -3
View File
@@ -48,7 +48,7 @@
#include "opencv2/core/cuda/reduce.hpp"
#include "opencv2/core/cuda/functional.hpp"
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace stereocsbp
{
@@ -146,7 +146,7 @@ namespace cv { namespace gpu { namespace cuda
for(int i = 0; i < nr_plane; i++)
{
T minimum = cuda::numeric_limits<T>::max();
T minimum = cudev::numeric_limits<T>::max();
int id = 0;
for(int d = 0; d < cndisp; d++)
{
@@ -859,6 +859,6 @@ namespace cv { namespace gpu { namespace cuda
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 cuda {
}}} // namespace cv { namespace gpu { namespace cudev {
#endif /* CUDA_DISABLER */
modules/gpu/src/cuda/tvl1flow.cu
+1 -1
View File
@@ -47,7 +47,7 @@
#include "opencv2/core/cuda/limits.hpp"
using namespace cv::gpu;
using namespace cv::gpu::cuda;
using namespace cv::gpu::cudev;
////////////////////////////////////////////////////////////
// centeredGradient
modules/gpu/src/cuda/warp.cu
+2 -2
View File
@@ -49,7 +49,7 @@
#include "opencv2/core/cuda/saturate_cast.hpp"
#include "opencv2/core/cuda/filters.hpp"
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace imgproc
{
@@ -383,7 +383,7 @@ namespace cv { namespace gpu { namespace cuda
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 cuda
}}} // namespace cv { namespace gpu { namespace cudev
#endif /* CUDA_DISABLER */
modules/gpu/src/cvt_color_internal.h
+1 -1
View File
@@ -43,7 +43,7 @@
#ifndef __cvt_color_internal_h__
#define __cvt_color_internal_h__
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
#define OPENCV_GPU_DECLARE_CVTCOLOR_ONE(name) \
void name(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
modules/gpu/src/denoising.cpp
+8 -8
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 cuda
namespace cv { namespace gpu { namespace cudev
{
namespace imgproc
{
@@ -73,7 +73,7 @@ namespace cv { namespace gpu { namespace cuda
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::cuda::imgproc::bilateral_filter_gpu;
using cv::gpu::cudev::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::cuda::imgproc::nlm_bruteforce_gpu;
using cv::gpu::cudev::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 cuda
namespace cv { namespace gpu { namespace cudev
{
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;
cuda::imgproc::nln_fast_get_buffer_size(src_hdr, search_window, block_window, bcols, brows);
cudev::imgproc::nln_fast_get_buffer_size(src_hdr, search_window, block_window, bcols, brows);
buffer.create(brows, bcols, CV_32S);
using namespace cv::gpu::cuda::imgproc;
using namespace cv::gpu::cudev::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);
cuda::imgproc::fnlm_split_channels(lab, l, ab, StreamAccessor::getStream(s));
cudev::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);
cuda::imgproc::fnlm_merge_channels(l, ab, lab, StreamAccessor::getStream(s));
cudev::imgproc::fnlm_merge_channels(l, ab, lab, StreamAccessor::getStream(s));
cv::gpu::cvtColor(lab, dst, CV_Lab2BGR, 0, s);
}
modules/gpu/src/fast.cpp
+3 -3
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 cuda
namespace cv { namespace gpu { namespace cudev
{
namespace fast
{
@@ -119,7 +119,7 @@ namespace cv { namespace gpu { namespace cuda
int cv::gpu::FAST_GPU::calcKeyPointsLocation(const GpuMat& img, const GpuMat& mask)
{
using namespace cv::gpu::cuda::fast;
using namespace cv::gpu::cudev::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::cuda::fast;
using namespace cv::gpu::cudev::fast;
if (count_ == 0)
return 0;
modules/gpu/src/filtering.cpp
+3 -3
View File
@@ -661,7 +661,7 @@ void cv::gpu::morphologyEx(const GpuMat& src, GpuMat& dst, int op, const Mat& ke
////////////////////////////////////////////////////////////////////////////////////////////////////
// Linear Filter
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace imgproc
{
@@ -723,7 +723,7 @@ namespace
virtual void operator()(const GpuMat& src, GpuMat& dst, Stream& stream = Stream::Null())
{
using namespace cv::gpu::cuda::imgproc;
using namespace cv::gpu::cudev::imgproc;
Point ofs;
Size wholeSize;
@@ -742,7 +742,7 @@ namespace
Ptr<BaseFilter_GPU> cv::gpu::getLinearFilter_GPU(int srcType, int dstType, const Mat& kernel, Point anchor, int brd_type)
{
using namespace cv::gpu::cuda::imgproc;
using namespace cv::gpu::cudev::imgproc;
int sdepth = CV_MAT_DEPTH(srcType);
int scn = CV_MAT_CN(srcType);
modules/gpu/src/gftt.cpp
+2 -2
View File
@@ -51,7 +51,7 @@ void cv::gpu::GoodFeaturesToTrackDetector_GPU::operator ()(const GpuMat&, GpuMat
#else /* !defined (HAVE_CUDA) */
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace gfft
{
@@ -62,7 +62,7 @@ namespace cv { namespace gpu { namespace cuda
void cv::gpu::GoodFeaturesToTrackDetector_GPU::operator ()(const GpuMat& image, GpuMat& corners, const GpuMat& mask)
{
using namespace cv::gpu::cuda::gfft;
using namespace cv::gpu::cudev::gfft;
CV_Assert(qualityLevel > 0 && minDistance >= 0 && maxCorners >= 0);
CV_Assert(mask.empty() || (mask.type() == CV_8UC1 && mask.size() == image.size()));
modules/gpu/src/global_motion.cpp
+3 -3
View File
@@ -53,7 +53,7 @@ void cv::gpu::calcWobbleSuppressionMaps(
#else
namespace cv { namespace gpu { namespace cuda { namespace globmotion {
namespace cv { namespace gpu { namespace cudev { namespace globmotion {
int compactPoints(int N, float *points0, float *points1, const uchar *mask);
@@ -70,7 +70,7 @@ void cv::gpu::compactPoints(GpuMat &points0, GpuMat &points1, const GpuMat &mask
CV_Assert(points0.cols == mask.cols && points1.cols == mask.cols);
int npoints = points0.cols;
int remaining = cv::gpu::cuda::globmotion::compactPoints(
int remaining = cv::gpu::cudev::globmotion::compactPoints(
npoints, (float*)points0.data, (float*)points1.data, mask.data);
points0 = points0.colRange(0, remaining);
@@ -88,7 +88,7 @@ void cv::gpu::calcWobbleSuppressionMaps(
mapx.create(size, CV_32F);
mapy.create(size, CV_32F);
cv::gpu::cuda::globmotion::calcWobbleSuppressionMaps(
cv::gpu::cudev::globmotion::calcWobbleSuppressionMaps(
left, idx, right, size.width, size.height,
ml.ptr<float>(), mr.ptr<float>(), mapx, mapy);
}
modules/gpu/src/graphcuts.cpp
+6 -6
View File
@@ -52,7 +52,7 @@ void cv::gpu::labelComponents(const GpuMat&, GpuMat&, int, Stream&) { throw_no_c
#else /* !defined (HAVE_CUDA) */
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace ccl
{
@@ -81,12 +81,12 @@ void cv::gpu::connectivityMask(const GpuMat& image, GpuMat& mask, const cv::Scal
static const func_t suppotLookup[8][4] =
{ // 1, 2, 3, 4
{ cuda::ccl::computeEdges<uchar>, 0, cuda::ccl::computeEdges<uchar3>, cuda::ccl::computeEdges<uchar4> },// CV_8U
{ cudev::ccl::computeEdges<uchar>, 0, cudev::ccl::computeEdges<uchar3>, cudev::ccl::computeEdges<uchar4> },// CV_8U
{ 0, 0, 0, 0 },// CV_16U
{ cuda::ccl::computeEdges<ushort>, 0, cuda::ccl::computeEdges<ushort3>, cuda::ccl::computeEdges<ushort4> },// CV_8S
{ cudev::ccl::computeEdges<ushort>, 0, cudev::ccl::computeEdges<ushort3>, cudev::ccl::computeEdges<ushort4> },// CV_8S
{ 0, 0, 0, 0 },// CV_16S
{ cuda::ccl::computeEdges<int>, 0, 0, 0 },// CV_32S
{ cuda::ccl::computeEdges<float>, 0, 0, 0 },// CV_32F
{ cudev::ccl::computeEdges<int>, 0, 0, 0 },// CV_32S
{ cudev::ccl::computeEdges<float>, 0, 0, 0 },// CV_32F
{ 0, 0, 0, 0 },// CV_64F
{ 0, 0, 0, 0 } // CV_USRTYPE1
};
@@ -112,7 +112,7 @@ void cv::gpu::labelComponents(const GpuMat& mask, GpuMat& components, int flags,
components.create(mask.size(), CV_32SC1);
cudaStream_t stream = StreamAccessor::getStream(s);
cuda::ccl::labelComponents(mask, components, flags, stream);
cudev::ccl::labelComponents(mask, components, flags, stream);
}
namespace
modules/gpu/src/hog.cpp
+2 -2
View File
@@ -62,7 +62,7 @@ void cv::gpu::HOGDescriptor::computeConfidenceMultiScale(const GpuMat&, std::vec
#else
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace hog
{
@@ -102,7 +102,7 @@ namespace cv { namespace gpu { namespace cuda
}
}}}
using namespace ::cv::gpu::cuda;
using namespace ::cv::gpu::cudev;
cv::gpu::HOGDescriptor::HOGDescriptor(Size win_size_, Size block_size_, Size block_stride_, Size cell_size_,
int nbins_, double win_sigma_, double threshold_L2hys_, bool gamma_correction_, int nlevels_)
modules/gpu/src/hough.cpp
+21 -21
View File
@@ -70,7 +70,7 @@ void cv::gpu::GeneralizedHough_GPU::release() {}
#include "opencv2/core/utility.hpp"
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace hough
{
@@ -81,7 +81,7 @@ namespace cv { namespace gpu { namespace cuda
//////////////////////////////////////////////////////////
// HoughLines
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace hough
{
@@ -98,7 +98,7 @@ void cv::gpu::HoughLines(const GpuMat& src, GpuMat& lines, float rho, float thet
void cv::gpu::HoughLines(const GpuMat& src, GpuMat& lines, HoughLinesBuf& buf, float rho, float theta, int threshold, bool doSort, int maxLines)
{
using namespace cv::gpu::cuda::hough;
using namespace cv::gpu::cudev::hough;
CV_Assert(src.type() == CV_8UC1);
CV_Assert(src.cols < std::numeric_limits<unsigned short>::max());
@@ -161,7 +161,7 @@ void cv::gpu::HoughLinesDownload(const GpuMat& d_lines, OutputArray h_lines_, Ou
//////////////////////////////////////////////////////////
// HoughLinesP
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace hough
{
@@ -171,7 +171,7 @@ namespace cv { namespace gpu { namespace cuda
void cv::gpu::HoughLinesP(const GpuMat& src, GpuMat& lines, HoughLinesBuf& buf, float rho, float theta, int minLineLength, int maxLineGap, int maxLines)
{
using namespace cv::gpu::cuda::hough;
using namespace cv::gpu::cudev::hough;
CV_Assert( src.type() == CV_8UC1 );
CV_Assert( src.cols < std::numeric_limits<unsigned short>::max() );
@@ -210,7 +210,7 @@ void cv::gpu::HoughLinesP(const GpuMat& src, GpuMat& lines, HoughLinesBuf& buf,
//////////////////////////////////////////////////////////
// HoughCircles
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace hough
{
@@ -230,7 +230,7 @@ void cv::gpu::HoughCircles(const GpuMat& src, GpuMat& circles, int method, float
void cv::gpu::HoughCircles(const GpuMat& src, GpuMat& circles, HoughCirclesBuf& buf, int method,
float dp, float minDist, int cannyThreshold, int votesThreshold, int minRadius, int maxRadius, int maxCircles)
{
using namespace cv::gpu::cuda::hough;
using namespace cv::gpu::cudev::hough;
CV_Assert(src.type() == CV_8UC1);
CV_Assert(src.cols < std::numeric_limits<unsigned short>::max());
@@ -371,7 +371,7 @@ void cv::gpu::HoughCirclesDownload(const GpuMat& d_circles, cv::OutputArray h_ci
//////////////////////////////////////////////////////////
// GeneralizedHough
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace hough
{
@@ -559,7 +559,7 @@ namespace
void GHT_Pos::buildEdgePointList(const GpuMat& edges, const GpuMat& dx, const GpuMat& dy)
{
using namespace cv::gpu::cuda::hough;
using namespace cv::gpu::cudev::hough;
typedef int (*func_t)(PtrStepSzb edges, PtrStepSzb dx, PtrStepSzb dy, unsigned int* coordList, float* thetaList);
static const func_t funcs[] =
@@ -747,7 +747,7 @@ namespace
void GHT_Ballard_Pos::processTempl()
{
using namespace cv::gpu::cuda::hough;
using namespace cv::gpu::cudev::hough;
CV_Assert(levels > 0);
@@ -773,7 +773,7 @@ namespace
void GHT_Ballard_Pos::calcHist()
{
using namespace cv::gpu::cuda::hough;
using namespace cv::gpu::cudev::hough;
CV_Assert(levels > 0 && r_table.rows == (levels + 1) && r_sizes.cols == (levels + 1));
CV_Assert(dp > 0.0);
@@ -796,7 +796,7 @@ namespace
void GHT_Ballard_Pos::findPosInHist()
{
using namespace cv::gpu::cuda::hough;
using namespace cv::gpu::cudev::hough;
CV_Assert(votesThreshold > 0);
@@ -851,7 +851,7 @@ namespace
void GHT_Ballard_PosScale::calcHist()
{
using namespace cv::gpu::cuda::hough;
using namespace cv::gpu::cudev::hough;
CV_Assert(levels > 0 && r_table.rows == (levels + 1) && r_sizes.cols == (levels + 1));
CV_Assert(dp > 0.0);
@@ -879,7 +879,7 @@ namespace
void GHT_Ballard_PosScale::findPosInHist()
{
using namespace cv::gpu::cuda::hough;
using namespace cv::gpu::cudev::hough;
CV_Assert(votesThreshold > 0);
@@ -939,7 +939,7 @@ namespace
void GHT_Ballard_PosRotation::calcHist()
{
using namespace cv::gpu::cuda::hough;
using namespace cv::gpu::cudev::hough;
CV_Assert(levels > 0 && r_table.rows == (levels + 1) && r_sizes.cols == (levels + 1));
CV_Assert(dp > 0.0);
@@ -967,7 +967,7 @@ namespace
void GHT_Ballard_PosRotation::findPosInHist()
{
using namespace cv::gpu::cuda::hough;
using namespace cv::gpu::cudev::hough;
CV_Assert(votesThreshold > 0);
@@ -1146,7 +1146,7 @@ namespace
void GHT_Guil_Full::processTempl()
{
using namespace cv::gpu::cuda::hough;
using namespace cv::gpu::cudev::hough;
buildFeatureList(templEdges, templDx, templDy, templFeatures,
GHT_Guil_Full_setTemplFeatures, GHT_Guil_Full_buildTemplFeatureList_gpu,
@@ -1159,7 +1159,7 @@ namespace
void GHT_Guil_Full::processImage()
{
using namespace cv::gpu::cuda::hough;
using namespace cv::gpu::cudev::hough;
CV_Assert(levels > 0);
CV_Assert(templFeatures.sizes.cols == levels + 1);
@@ -1271,7 +1271,7 @@ namespace
void GHT_Guil_Full::calcOrientation()
{
using namespace cv::gpu::cuda::hough;
using namespace cv::gpu::cudev::hough;
const double iAngleStep = 1.0 / angleStep;
const int angleRange = cvCeil((maxAngle - minAngle) * iAngleStep);
@@ -1295,7 +1295,7 @@ namespace
void GHT_Guil_Full::calcScale(double angle)
{
using namespace cv::gpu::cuda::hough;
using namespace cv::gpu::cudev::hough;
const double iScaleStep = 1.0 / scaleStep;
const int scaleRange = cvCeil((maxScale - minScale) * iScaleStep);
@@ -1319,7 +1319,7 @@ namespace
void GHT_Guil_Full::calcPosition(double angle, int angleVotes, double scale, int scaleVotes)
{
using namespace cv::gpu::cuda::hough;
using namespace cv::gpu::cudev::hough;
hist.setTo(Scalar::all(0));
GHT_Guil_Full_calcPHist_gpu(templFeatures.sizes.ptr<int>(), imageFeatures.sizes.ptr<int>(0),
modules/gpu/src/imgproc.cpp
+34 -34
View File
@@ -98,7 +98,7 @@ cv::Ptr<cv::gpu::CLAHE> cv::gpu::createCLAHE(double, cv::Size) { throw_no_cuda()
////////////////////////////////////////////////////////////////////////
// meanShiftFiltering_GPU
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace imgproc
{
@@ -108,7 +108,7 @@ namespace cv { namespace gpu { namespace cuda
void cv::gpu::meanShiftFiltering(const GpuMat& src, GpuMat& dst, int sp, int sr, TermCriteria criteria, Stream& stream)
{
using namespace ::cv::gpu::cuda::imgproc;
using namespace ::cv::gpu::cudev::imgproc;
if( src.empty() )
CV_Error( CV_StsBadArg, "The input image is empty" );
@@ -134,7 +134,7 @@ void cv::gpu::meanShiftFiltering(const GpuMat& src, GpuMat& dst, int sp, int sr,
////////////////////////////////////////////////////////////////////////
// meanShiftProc_GPU
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace imgproc
{
@@ -144,7 +144,7 @@ namespace cv { namespace gpu { namespace cuda
void cv::gpu::meanShiftProc(const GpuMat& src, GpuMat& dstr, GpuMat& dstsp, int sp, int sr, TermCriteria criteria, Stream& stream)
{
using namespace ::cv::gpu::cuda::imgproc;
using namespace ::cv::gpu::cudev::imgproc;
if( src.empty() )
CV_Error( CV_StsBadArg, "The input image is empty" );
@@ -171,7 +171,7 @@ void cv::gpu::meanShiftProc(const GpuMat& src, GpuMat& dstr, GpuMat& dstsp, int
////////////////////////////////////////////////////////////////////////
// drawColorDisp
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace imgproc
{
@@ -185,7 +185,7 @@ namespace
template <typename T>
void drawColorDisp_caller(const GpuMat& src, GpuMat& dst, int ndisp, const cudaStream_t& stream)
{
using namespace ::cv::gpu::cuda::imgproc;
using namespace ::cv::gpu::cudev::imgproc;
dst.create(src.size(), CV_8UC4);
@@ -207,7 +207,7 @@ void cv::gpu::drawColorDisp(const GpuMat& src, GpuMat& dst, int ndisp, Stream& s
////////////////////////////////////////////////////////////////////////
// reprojectImageTo3D
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace imgproc
{
@@ -218,7 +218,7 @@ namespace cv { namespace gpu { namespace cuda
void cv::gpu::reprojectImageTo3D(const GpuMat& disp, GpuMat& xyz, const Mat& Q, int dst_cn, Stream& stream)
{
using namespace cv::gpu::cuda::imgproc;
using namespace cv::gpu::cudev::imgproc;
typedef void (*func_t)(const PtrStepSzb disp, PtrStepSzb xyz, const float* q, cudaStream_t stream);
static const func_t funcs[2][4] =
@@ -239,7 +239,7 @@ void cv::gpu::reprojectImageTo3D(const GpuMat& disp, GpuMat& xyz, const Mat& Q,
////////////////////////////////////////////////////////////////////////
// copyMakeBorder
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace imgproc
{
@@ -251,7 +251,7 @@ namespace
{
template <typename T, int cn> void copyMakeBorder_caller(const PtrStepSzb& src, const PtrStepSzb& dst, int top, int left, int borderType, const Scalar& value, cudaStream_t stream)
{
using namespace ::cv::gpu::cuda::imgproc;
using namespace ::cv::gpu::cudev::imgproc;
Scalar_<T> val(saturate_cast<T>(value[0]), saturate_cast<T>(value[1]), saturate_cast<T>(value[2]), saturate_cast<T>(value[3]));
@@ -348,7 +348,7 @@ void cv::gpu::copyMakeBorder(const GpuMat& src, GpuMat& dst, int top, int bottom
//////////////////////////////////////////////////////////////////////////////
// buildWarpPlaneMaps
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace imgproc
{
@@ -362,7 +362,7 @@ void cv::gpu::buildWarpPlaneMaps(Size src_size, Rect dst_roi, const Mat &K, cons
float scale, GpuMat& map_x, GpuMat& map_y, Stream& stream)
{
(void)src_size;
using namespace ::cv::gpu::cuda::imgproc;
using namespace ::cv::gpu::cudev::imgproc;
CV_Assert(K.size() == Size(3,3) && K.type() == CV_32F);
CV_Assert(R.size() == Size(3,3) && R.type() == CV_32F);
@@ -375,14 +375,14 @@ void cv::gpu::buildWarpPlaneMaps(Size src_size, Rect dst_roi, const Mat &K, cons
map_x.create(dst_roi.size(), CV_32F);
map_y.create(dst_roi.size(), CV_32F);
cuda::imgproc::buildWarpPlaneMaps(dst_roi.tl().x, dst_roi.tl().y, map_x, map_y, K_Rinv.ptr<float>(), R_Kinv.ptr<float>(),
cudev::imgproc::buildWarpPlaneMaps(dst_roi.tl().x, dst_roi.tl().y, map_x, map_y, K_Rinv.ptr<float>(), R_Kinv.ptr<float>(),
T.ptr<float>(), scale, StreamAccessor::getStream(stream));
}
//////////////////////////////////////////////////////////////////////////////
// buildWarpCylyndricalMaps
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace imgproc
{
@@ -396,7 +396,7 @@ void cv::gpu::buildWarpCylindricalMaps(Size src_size, Rect dst_roi, const Mat &K
GpuMat& map_x, GpuMat& map_y, Stream& stream)
{
(void)src_size;
using namespace ::cv::gpu::cuda::imgproc;
using namespace ::cv::gpu::cudev::imgproc;
CV_Assert(K.size() == Size(3,3) && K.type() == CV_32F);
CV_Assert(R.size() == Size(3,3) && R.type() == CV_32F);
@@ -408,14 +408,14 @@ void cv::gpu::buildWarpCylindricalMaps(Size src_size, Rect dst_roi, const Mat &K
map_x.create(dst_roi.size(), CV_32F);
map_y.create(dst_roi.size(), CV_32F);
cuda::imgproc::buildWarpCylindricalMaps(dst_roi.tl().x, dst_roi.tl().y, map_x, map_y, K_Rinv.ptr<float>(), R_Kinv.ptr<float>(), scale, StreamAccessor::getStream(stream));
cudev::imgproc::buildWarpCylindricalMaps(dst_roi.tl().x, dst_roi.tl().y, map_x, map_y, K_Rinv.ptr<float>(), R_Kinv.ptr<float>(), scale, StreamAccessor::getStream(stream));
}
//////////////////////////////////////////////////////////////////////////////
// buildWarpSphericalMaps
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace imgproc
{
@@ -429,7 +429,7 @@ void cv::gpu::buildWarpSphericalMaps(Size src_size, Rect dst_roi, const Mat &K,
GpuMat& map_x, GpuMat& map_y, Stream& stream)
{
(void)src_size;
using namespace ::cv::gpu::cuda::imgproc;
using namespace ::cv::gpu::cudev::imgproc;
CV_Assert(K.size() == Size(3,3) && K.type() == CV_32F);
CV_Assert(R.size() == Size(3,3) && R.type() == CV_32F);
@@ -441,7 +441,7 @@ void cv::gpu::buildWarpSphericalMaps(Size src_size, Rect dst_roi, const Mat &K,
map_x.create(dst_roi.size(), CV_32F);
map_y.create(dst_roi.size(), CV_32F);
cuda::imgproc::buildWarpSphericalMaps(dst_roi.tl().x, dst_roi.tl().y, map_x, map_y, K_Rinv.ptr<float>(), R_Kinv.ptr<float>(), scale, StreamAccessor::getStream(stream));
cudev::imgproc::buildWarpSphericalMaps(dst_roi.tl().x, dst_roi.tl().y, map_x, map_y, K_Rinv.ptr<float>(), R_Kinv.ptr<float>(), scale, StreamAccessor::getStream(stream));
}
////////////////////////////////////////////////////////////////////////
@@ -532,7 +532,7 @@ void cv::gpu::integral(const GpuMat& src, GpuMat& sum, Stream& s)
integralBuffered(src, sum, buffer, s);
}
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace imgproc
{
@@ -556,7 +556,7 @@ void cv::gpu::integralBuffered(const GpuMat& src, GpuMat& sum, GpuMat& buffer, S
{
ensureSizeIsEnough(((src.rows + 7) / 8) * 8, ((src.cols + 63) / 64) * 64, CV_32SC1, buffer);
cv::gpu::cuda::imgproc::shfl_integral_gpu(src, buffer, stream);
cv::gpu::cudev::imgproc::shfl_integral_gpu(src, buffer, stream);
sum.create(src.rows + 1, src.cols + 1, CV_32SC1);
if (s)
@@ -631,7 +631,7 @@ void cv::gpu::sqrIntegral(const GpuMat& src, GpuMat& sqsum, Stream& s)
//////////////////////////////////////////////////////////////////////////////
// columnSum
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace imgproc
{
@@ -641,13 +641,13 @@ namespace cv { namespace gpu { namespace cuda
void cv::gpu::columnSum(const GpuMat& src, GpuMat& dst)
{
using namespace ::cv::gpu::cuda::imgproc;
using namespace ::cv::gpu::cudev::imgproc;
CV_Assert(src.type() == CV_32F);
dst.create(src.size(), CV_32F);
cuda::imgproc::columnSum_32F(src, dst);
cudev::imgproc::columnSum_32F(src, dst);
}
void cv::gpu::rectStdDev(const GpuMat& src, const GpuMat& sqr, GpuMat& dst, const Rect& rect, Stream& s)
@@ -1021,7 +1021,7 @@ void cv::gpu::equalizeHist(const GpuMat& src, GpuMat& dst, GpuMat& hist, GpuMat&
////////////////////////////////////////////////////////////////////////
// cornerHarris & minEgenVal
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace imgproc
{
@@ -1074,7 +1074,7 @@ void cv::gpu::cornerHarris(const GpuMat& src, GpuMat& dst, GpuMat& Dx, GpuMat& D
void cv::gpu::cornerHarris(const GpuMat& src, GpuMat& dst, GpuMat& Dx, GpuMat& Dy, GpuMat& buf, int blockSize, int ksize, double k, int borderType, Stream& stream)
{
using namespace cv::gpu::cuda::imgproc;
using namespace cv::gpu::cudev::imgproc;
CV_Assert(borderType == cv::BORDER_REFLECT101 || borderType == cv::BORDER_REPLICATE || borderType == cv::BORDER_REFLECT);
@@ -1102,7 +1102,7 @@ void cv::gpu::cornerMinEigenVal(const GpuMat& src, GpuMat& dst, GpuMat& Dx, GpuM
void cv::gpu::cornerMinEigenVal(const GpuMat& src, GpuMat& dst, GpuMat& Dx, GpuMat& Dy, GpuMat& buf, int blockSize, int ksize, int borderType, Stream& stream)
{
using namespace ::cv::gpu::cuda::imgproc;
using namespace ::cv::gpu::cudev::imgproc;
CV_Assert(borderType == cv::BORDER_REFLECT101 || borderType == cv::BORDER_REPLICATE || borderType == cv::BORDER_REFLECT);
@@ -1119,7 +1119,7 @@ void cv::gpu::cornerMinEigenVal(const GpuMat& src, GpuMat& dst, GpuMat& Dx, GpuM
//////////////////////////////////////////////////////////////////////////////
// mulSpectrums
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace imgproc
{
@@ -1132,11 +1132,11 @@ namespace cv { namespace gpu { namespace cuda
void cv::gpu::mulSpectrums(const GpuMat& a, const GpuMat& b, GpuMat& c, int flags, bool conjB, Stream& stream)
{
(void)flags;
using namespace ::cv::gpu::cuda::imgproc;
using namespace ::cv::gpu::cudev::imgproc;
typedef void (*Caller)(const PtrStep<cufftComplex>, const PtrStep<cufftComplex>, PtrStepSz<cufftComplex>, cudaStream_t stream);
static Caller callers[] = { cuda::imgproc::mulSpectrums, cuda::imgproc::mulSpectrums_CONJ };
static Caller callers[] = { cudev::imgproc::mulSpectrums, cudev::imgproc::mulSpectrums_CONJ };
CV_Assert(a.type() == b.type() && a.type() == CV_32FC2);
CV_Assert(a.size() == b.size());
@@ -1150,7 +1150,7 @@ void cv::gpu::mulSpectrums(const GpuMat& a, const GpuMat& b, GpuMat& c, int flag
//////////////////////////////////////////////////////////////////////////////
// mulAndScaleSpectrums
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace imgproc
{
@@ -1163,10 +1163,10 @@ namespace cv { namespace gpu { namespace cuda
void cv::gpu::mulAndScaleSpectrums(const GpuMat& a, const GpuMat& b, GpuMat& c, int flags, float scale, bool conjB, Stream& stream)
{
(void)flags;
using namespace ::cv::gpu::cuda::imgproc;
using namespace ::cv::gpu::cudev::imgproc;
typedef void (*Caller)(const PtrStep<cufftComplex>, const PtrStep<cufftComplex>, float scale, PtrStepSz<cufftComplex>, cudaStream_t stream);
static Caller callers[] = { cuda::imgproc::mulAndScaleSpectrums, cuda::imgproc::mulAndScaleSpectrums_CONJ };
static Caller callers[] = { cudev::imgproc::mulAndScaleSpectrums, cudev::imgproc::mulAndScaleSpectrums_CONJ };
CV_Assert(a.type() == b.type() && a.type() == CV_32FC2);
CV_Assert(a.size() == b.size());
@@ -1335,7 +1335,7 @@ void cv::gpu::convolve(const GpuMat& image, const GpuMat& templ, GpuMat& result,
void cv::gpu::convolve(const GpuMat& image, const GpuMat& templ, GpuMat& result, bool ccorr, ConvolveBuf& buf, Stream& stream)
{
using namespace ::cv::gpu::cuda::imgproc;
using namespace ::cv::gpu::cudev::imgproc;
#ifndef HAVE_CUFFT
throw_no_cuda();
modules/gpu/src/match_template.cpp
+2 -2
View File
@@ -51,7 +51,7 @@ void cv::gpu::matchTemplate(const GpuMat&, const GpuMat&, GpuMat&, int, Stream&)
#else
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace match_template
{
@@ -137,7 +137,7 @@ namespace cv { namespace gpu { namespace cuda
}
}}}
using namespace ::cv::gpu::cuda::match_template;
using namespace ::cv::gpu::cudev::match_template;
namespace
{
modules/gpu/src/nvidia/NCVBroxOpticalFlow.cu
+2 -2
View File
@@ -1141,8 +1141,8 @@ NCVStatus NCVBroxOpticalFlow(const NCVBroxOpticalFlowDescriptor desc,
ScaleVector(ptrVNew->ptr(), ptrVNew->ptr(), 1.0f/scale_factor, ns * nh, stream);
ncvAssertCUDALastErrorReturn((int)NCV_CUDA_ERROR);
cv::gpu::cuda::swap<FloatVector*>(ptrU, ptrUNew);
cv::gpu::cuda::swap<FloatVector*>(ptrV, ptrVNew);
cv::gpu::cudev::swap<FloatVector*>(ptrU, ptrUNew);
cv::gpu::cudev::swap<FloatVector*>(ptrV, ptrVNew);
}
scale /= scale_factor;
}
modules/gpu/src/nvidia/NCVHaarObjectDetection.cu
+2 -2
View File
@@ -85,13 +85,13 @@ NCV_CT_ASSERT(K_WARP_SIZE == 32); //this is required for the manual unroll of th
__device__ Ncv32u warpScanInclusive(Ncv32u idata, volatile Ncv32u *s_Data)
{
#if __CUDA_ARCH__ >= 300
const unsigned int laneId = cv::gpu::cuda::Warp::laneId();
const unsigned int laneId = cv::gpu::cudev::Warp::laneId();
// scan on shuffl functions
#pragma unroll
for (int i = 1; i <= (K_WARP_SIZE / 2); i *= 2)
{
const Ncv32u n = cv::gpu::cuda::shfl_up(idata, i);
const Ncv32u n = cv::gpu::cudev::shfl_up(idata, i);
if (laneId >= i)
idata += n;
}
modules/gpu/src/nvidia/NPP_staging/NPP_staging.cu
+2 -2
View File
@@ -95,13 +95,13 @@ template <class T>
inline __device__ T warpScanInclusive(T idata, volatile T *s_Data)
{
#if __CUDA_ARCH__ >= 300
const unsigned int laneId = cv::gpu::cuda::Warp::laneId();
const unsigned int laneId = cv::gpu::cudev::Warp::laneId();
// scan on shuffl functions
#pragma unroll
for (int i = 1; i <= (K_WARP_SIZE / 2); i *= 2)
{
const T n = cv::gpu::cuda::shfl_up(idata, i);
const T n = cv::gpu::cudev::shfl_up(idata, i);
if (laneId >= i)
idata += n;
}
modules/gpu/src/nvidia/core/NCVPyramid.cu
+2 -2
View File
@@ -204,7 +204,7 @@ __global__ void kernelDownsampleX2(T *d_src,
}
}
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace pyramid
{
@@ -279,7 +279,7 @@ __global__ void kernelInterpolateFrom1(T *d_srcTop,
d_dst_line[j] = outPix;
}
}
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace pyramid
{
modules/gpu/src/optical_flow.cpp
+2 -2
View File
@@ -188,7 +188,7 @@ void cv::gpu::interpolateFrames(const GpuMat& frame0, const GpuMat& frame1, cons
cvCudaSafeCall( cudaDeviceSynchronize() );
}
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace optical_flow
{
@@ -199,7 +199,7 @@ namespace cv { namespace gpu { namespace cuda
void cv::gpu::createOpticalFlowNeedleMap(const GpuMat& u, const GpuMat& v, GpuMat& vertex, GpuMat& colors)
{
using namespace cv::gpu::cuda::optical_flow;
using namespace cv::gpu::cudev::optical_flow;
CV_Assert(u.type() == CV_32FC1);
CV_Assert(v.type() == u.type() && v.size() == u.size());
modules/gpu/src/optical_flow_farneback.cpp
+19 -19
View File
@@ -59,7 +59,7 @@ void cv::gpu::FarnebackOpticalFlow::operator ()(const GpuMat&, const GpuMat&, Gp
#else
namespace cv { namespace gpu { namespace cuda { namespace optflow_farneback
namespace cv { namespace gpu { namespace cudev { namespace optflow_farneback
{
void setPolynomialExpansionConsts(
int polyN, const float *g, const float *xg, const float *xxg,
@@ -93,7 +93,7 @@ namespace cv { namespace gpu { namespace cuda { namespace optflow_farneback
void gaussianBlur5Gpu_CC11(
const PtrStepSzf src, int ksizeHalf, PtrStepSzf dst, int borderType, cudaStream_t stream);
}}}} // namespace cv { namespace gpu { namespace cuda { namespace optflow_farneback
}}}} // namespace cv { namespace gpu { namespace cudev { namespace optflow_farneback
void cv::gpu::FarnebackOpticalFlow::prepareGaussian(
@@ -163,7 +163,7 @@ void cv::gpu::FarnebackOpticalFlow::setPolynomialExpansionConsts(int n, double s
double ig11, ig03, ig33, ig55;
prepareGaussian(n, sigma, g, xg, xxg, ig11, ig03, ig33, ig55);
cuda::optflow_farneback::setPolynomialExpansionConsts(n, g, xg, xxg, static_cast<float>(ig11), static_cast<float>(ig03), static_cast<float>(ig33), static_cast<float>(ig55));
cudev::optflow_farneback::setPolynomialExpansionConsts(n, g, xg, xxg, static_cast<float>(ig11), static_cast<float>(ig03), static_cast<float>(ig33), static_cast<float>(ig55));
}
@@ -172,17 +172,17 @@ void cv::gpu::FarnebackOpticalFlow::updateFlow_boxFilter(
GpuMat& M, GpuMat &bufM, int blockSize, bool updateMatrices, Stream streams[])
{
if (deviceSupports(FEATURE_SET_COMPUTE_12))
cuda::optflow_farneback::boxFilter5Gpu(M, blockSize/2, bufM, S(streams[0]));
cudev::optflow_farneback::boxFilter5Gpu(M, blockSize/2, bufM, S(streams[0]));
else
cuda::optflow_farneback::boxFilter5Gpu_CC11(M, blockSize/2, bufM, S(streams[0]));
cudev::optflow_farneback::boxFilter5Gpu_CC11(M, blockSize/2, bufM, S(streams[0]));
swap(M, bufM);
for (int i = 1; i < 5; ++i)
streams[i].waitForCompletion();
cuda::optflow_farneback::updateFlowGpu(M, flowx, flowy, S(streams[0]));
cudev::optflow_farneback::updateFlowGpu(M, flowx, flowy, S(streams[0]));
if (updateMatrices)
cuda::optflow_farneback::updateMatricesGpu(flowx, flowy, R0, R1, M, S(streams[0]));
cudev::optflow_farneback::updateMatricesGpu(flowx, flowy, R0, R1, M, S(streams[0]));
}
@@ -191,17 +191,17 @@ void cv::gpu::FarnebackOpticalFlow::updateFlow_gaussianBlur(
GpuMat& M, GpuMat &bufM, int blockSize, bool updateMatrices, Stream streams[])
{
if (deviceSupports(FEATURE_SET_COMPUTE_12))
cuda::optflow_farneback::gaussianBlur5Gpu(
cudev::optflow_farneback::gaussianBlur5Gpu(
M, blockSize/2, bufM, BORDER_REPLICATE_GPU, S(streams[0]));
else
cuda::optflow_farneback::gaussianBlur5Gpu_CC11(
cudev::optflow_farneback::gaussianBlur5Gpu_CC11(
M, blockSize/2, bufM, BORDER_REPLICATE_GPU, S(streams[0]));
swap(M, bufM);
cuda::optflow_farneback::updateFlowGpu(M, flowx, flowy, S(streams[0]));
cudev::optflow_farneback::updateFlowGpu(M, flowx, flowy, S(streams[0]));
if (updateMatrices)
cuda::optflow_farneback::updateMatricesGpu(flowx, flowy, R0, R1, M, S(streams[0]));
cudev::optflow_farneback::updateMatricesGpu(flowx, flowy, R0, R1, M, S(streams[0]));
}
@@ -253,7 +253,7 @@ void cv::gpu::FarnebackOpticalFlow::operator ()(
}
setPolynomialExpansionConsts(polyN, polySigma);
cuda::optflow_farneback::setUpdateMatricesConsts();
cudev::optflow_farneback::setUpdateMatricesConsts();
for (int k = numLevelsCropped; k >= 0; k--)
{
@@ -344,8 +344,8 @@ void cv::gpu::FarnebackOpticalFlow::operator ()(
if (fastPyramids)
{
cuda::optflow_farneback::polynomialExpansionGpu(pyramid0_[k], polyN, R[0], S(streams[0]));
cuda::optflow_farneback::polynomialExpansionGpu(pyramid1_[k], polyN, R[1], S(streams[1]));
cudev::optflow_farneback::polynomialExpansionGpu(pyramid0_[k], polyN, R[0], S(streams[0]));
cudev::optflow_farneback::polynomialExpansionGpu(pyramid1_[k], polyN, R[1], S(streams[1]));
}
else
{
@@ -361,11 +361,11 @@ void cv::gpu::FarnebackOpticalFlow::operator ()(
};
Mat g = getGaussianKernel(smoothSize, sigma, CV_32F);
cuda::optflow_farneback::setGaussianBlurKernel(g.ptr<float>(smoothSize/2), smoothSize/2);
cudev::optflow_farneback::setGaussianBlurKernel(g.ptr<float>(smoothSize/2), smoothSize/2);
for (int i = 0; i < 2; i++)
{
cuda::optflow_farneback::gaussianBlurGpu(
cudev::optflow_farneback::gaussianBlurGpu(
frames_[i], smoothSize/2, blurredFrame[i], BORDER_REFLECT101_GPU, S(streams[i]));
#if ENABLE_GPU_RESIZE
resize(blurredFrame[i], pyrLevel[i], Size(width, height), INTER_LINEAR, streams[i]);
@@ -375,17 +375,17 @@ void cv::gpu::FarnebackOpticalFlow::operator ()(
resize(tmp1, tmp2, Size(width, height), INTER_LINEAR);
I[i].upload(tmp2);
#endif
cuda::optflow_farneback::polynomialExpansionGpu(pyrLevel[i], polyN, R[i], S(streams[i]));
cudev::optflow_farneback::polynomialExpansionGpu(pyrLevel[i], polyN, R[i], S(streams[i]));
}
}
streams[1].waitForCompletion();
cuda::optflow_farneback::updateMatricesGpu(curFlowX, curFlowY, R[0], R[1], M, S(streams[0]));
cudev::optflow_farneback::updateMatricesGpu(curFlowX, curFlowY, R[0], R[1], M, S(streams[0]));
if (flags & OPTFLOW_FARNEBACK_GAUSSIAN)
{
Mat g = getGaussianKernel(winSize, winSize/2*0.3f, CV_32F);
cuda::optflow_farneback::setGaussianBlurKernel(g.ptr<float>(winSize/2), winSize/2);
cudev::optflow_farneback::setGaussianBlurKernel(g.ptr<float>(winSize/2), winSize/2);
}
for (int i = 0; i < numIters; i++)
{
modules/gpu/src/orb.cpp
+6 -6
View File
@@ -62,7 +62,7 @@ void cv::gpu::ORB_GPU::mergeKeyPoints(GpuMat&) { throw_no_cuda(); }
#else /* !defined (HAVE_CUDA) */
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace orb
{
@@ -431,7 +431,7 @@ cv::gpu::ORB_GPU::ORB_GPU(int nFeatures, float scaleFactor, int nLevels, int edg
++v_0;
}
CV_Assert(u_max.size() < 32);
cv::gpu::cuda::orb::loadUMax(&u_max[0], static_cast<int>(u_max.size()));
cv::gpu::cudev::orb::loadUMax(&u_max[0], static_cast<int>(u_max.size()));
// Calc pattern
const int npoints = 512;
@@ -543,7 +543,7 @@ namespace
//takes keypoints and culls them by the response
void cull(GpuMat& keypoints, int& count, int n_points)
{
using namespace cv::gpu::cuda::orb;
using namespace cv::gpu::cudev::orb;
//this is only necessary if the keypoints size is greater than the number of desired points.
if (count > n_points)
@@ -561,7 +561,7 @@ namespace
void cv::gpu::ORB_GPU::computeKeyPointsPyramid()
{
using namespace cv::gpu::cuda::orb;
using namespace cv::gpu::cudev::orb;
int half_patch_size = patchSize_ / 2;
@@ -604,7 +604,7 @@ void cv::gpu::ORB_GPU::computeKeyPointsPyramid()
void cv::gpu::ORB_GPU::computeDescriptors(GpuMat& descriptors)
{
using namespace cv::gpu::cuda::orb;
using namespace cv::gpu::cudev::orb;
int nAllkeypoints = 0;
@@ -644,7 +644,7 @@ void cv::gpu::ORB_GPU::computeDescriptors(GpuMat& descriptors)
void cv::gpu::ORB_GPU::mergeKeyPoints(GpuMat& keypoints)
{
using namespace cv::gpu::cuda::orb;
using namespace cv::gpu::cudev::orb;
int nAllkeypoints = 0;
modules/gpu/src/pyramids.cpp
+7 -7
View File
@@ -54,7 +54,7 @@ void cv::gpu::ImagePyramid::getLayer(GpuMat&, Size, Stream&) const { throw_no_cu
//////////////////////////////////////////////////////////////////////////////
// pyrDown
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace imgproc
{
@@ -64,7 +64,7 @@ namespace cv { namespace gpu { namespace cuda
void cv::gpu::pyrDown(const GpuMat& src, GpuMat& dst, Stream& stream)
{
using namespace cv::gpu::cuda::imgproc;
using namespace cv::gpu::cudev::imgproc;
typedef void (*func_t)(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
@@ -92,7 +92,7 @@ void cv::gpu::pyrDown(const GpuMat& src, GpuMat& dst, Stream& stream)
//////////////////////////////////////////////////////////////////////////////
// pyrUp
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace imgproc
{
@@ -102,7 +102,7 @@ namespace cv { namespace gpu { namespace cuda
void cv::gpu::pyrUp(const GpuMat& src, GpuMat& dst, Stream& stream)
{
using namespace cv::gpu::cuda::imgproc;
using namespace cv::gpu::cudev::imgproc;
typedef void (*func_t)(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
@@ -130,7 +130,7 @@ void cv::gpu::pyrUp(const GpuMat& src, GpuMat& dst, Stream& stream)
//////////////////////////////////////////////////////////////////////////////
// ImagePyramid
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace pyramid
{
@@ -141,7 +141,7 @@ namespace cv { namespace gpu { namespace cuda
void cv::gpu::ImagePyramid::build(const GpuMat& img, int numLayers, Stream& stream)
{
using namespace cv::gpu::cuda::pyramid;
using namespace cv::gpu::cudev::pyramid;
typedef void (*func_t)(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
@@ -189,7 +189,7 @@ void cv::gpu::ImagePyramid::build(const GpuMat& img, int numLayers, Stream& stre
void cv::gpu::ImagePyramid::getLayer(GpuMat& outImg, Size outRoi, Stream& stream) const
{
using namespace cv::gpu::cuda::pyramid;
using namespace cv::gpu::cudev::pyramid;
typedef void (*func_t)(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
modules/gpu/src/remap.cpp
+2 -2
View File
@@ -48,7 +48,7 @@ void cv::gpu::remap(const GpuMat&, GpuMat&, const GpuMat&, const GpuMat&, int, i
#else // HAVE_CUDA
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace imgproc
{
@@ -60,7 +60,7 @@ namespace cv { namespace gpu { namespace cuda
void cv::gpu::remap(const GpuMat& src, GpuMat& dst, const GpuMat& xmap, const GpuMat& ymap, int interpolation, int borderMode, Scalar borderValue, Stream& stream)
{
using namespace cv::gpu::cuda::imgproc;
using namespace cv::gpu::cudev::imgproc;
typedef void (*func_t)(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);
modules/gpu/src/resize.cpp
+2 -2
View File
@@ -59,7 +59,7 @@ void cv::gpu::resize(const GpuMat& src, GpuMat& dst, Size dsize, double fx, doub
#else // HAVE_CUDA
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace imgproc
{
@@ -137,7 +137,7 @@ void cv::gpu::resize(const GpuMat& src, GpuMat& dst, Size dsize, double fx, doub
}
else
{
using namespace ::cv::gpu::cuda::imgproc;
using namespace ::cv::gpu::cudev::imgproc;
typedef void (*func_t)(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float fx, float fy, PtrStepSzb dst, int interpolation, cudaStream_t stream);
modules/gpu/src/split_merge.cpp
+3 -3
View File
@@ -54,7 +54,7 @@ void cv::gpu::split(const GpuMat& /*src*/, std::vector<GpuMat>& /*dst*/, Stream&
#else /* !defined (HAVE_CUDA) */
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace split_merge
{
@@ -67,7 +67,7 @@ namespace
{
void merge(const GpuMat* src, size_t n, GpuMat& dst, const cudaStream_t& stream)
{
using namespace ::cv::gpu::cuda::split_merge;
using namespace ::cv::gpu::cudev::split_merge;
CV_Assert(src);
CV_Assert(n > 0);
@@ -112,7 +112,7 @@ namespace
void split(const GpuMat& src, GpuMat* dst, const cudaStream_t& stream)
{
using namespace ::cv::gpu::cuda::split_merge;
using namespace ::cv::gpu::cudev::split_merge;
CV_Assert(dst);
modules/gpu/src/stereobm.cpp
+2 -2
View File
@@ -55,7 +55,7 @@ void cv::gpu::StereoBM_GPU::operator() ( const GpuMat&, const GpuMat&, GpuMat&,
#else /* !defined (HAVE_CUDA) */
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace stereobm
{
@@ -101,7 +101,7 @@ namespace
{
void stereo_bm_gpu_operator( GpuMat& minSSD, GpuMat& leBuf, GpuMat& riBuf, int preset, int ndisp, int winSize, float avergeTexThreshold, const GpuMat& left, const GpuMat& right, GpuMat& disparity, cudaStream_t stream)
{
using namespace ::cv::gpu::cuda::stereobm;
using namespace ::cv::gpu::cudev::stereobm;
CV_Assert(left.rows == right.rows && left.cols == right.cols);
CV_Assert(left.type() == CV_8UC1);
modules/gpu/src/stereobp.cpp
+2 -2
View File
@@ -58,7 +58,7 @@ void cv::gpu::StereoBeliefPropagation::operator()(const GpuMat&, GpuMat&, Stream
#else /* !defined (HAVE_CUDA) */
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace stereobp
{
@@ -78,7 +78,7 @@ namespace cv { namespace gpu { namespace cuda
}
}}}
using namespace ::cv::gpu::cuda::stereobp;
using namespace ::cv::gpu::cudev::stereobp;
namespace
{
modules/gpu/src/stereocsbp.cpp
+2 -2
View File
@@ -57,7 +57,7 @@ void cv::gpu::StereoConstantSpaceBP::operator()(const GpuMat&, const GpuMat&, Gp
#else /* !defined (HAVE_CUDA) */
#include "opencv2/core/utility.hpp"
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace stereocsbp
{
@@ -89,7 +89,7 @@ namespace cv { namespace gpu { namespace cuda
}
}}}
using namespace ::cv::gpu::cuda::stereocsbp;
using namespace ::cv::gpu::cudev::stereocsbp;
namespace
{
modules/gpu/src/video_reader.cpp
+2 -2
View File
@@ -126,7 +126,7 @@ cv::gpu::VideoReader_GPU::Impl::~Impl()
videoSource_->stop();
}
namespace cv { namespace gpu { namespace cuda {
namespace cv { namespace gpu { namespace cudev {
namespace video_decoding
{
void loadHueCSC(float hueCSC[9]);
@@ -187,7 +187,7 @@ namespace
void cudaPostProcessFrame(const cv::gpu::GpuMat& decodedFrame, cv::gpu::GpuMat& interopFrame, int width, int height)
{
using namespace cv::gpu::cuda::video_decoding;
using namespace cv::gpu::cudev::video_decoding;
static bool updateCSC = true;
static float hueColorSpaceMat[9];
modules/gpu/src/video_writer.cpp
+1 -1
View File
@@ -674,7 +674,7 @@ void cv::gpu::VideoWriter_GPU::Impl::write(const cv::gpu::GpuMat& frame, bool la
CV_Assert( res == CUDA_SUCCESS );
if (inputFormat_ == SF_BGR)
cv::gpu::cuda::video_encoding::YV12_gpu(frame, frame.channels(), videoFrame_);
cv::gpu::cudev::video_encoding::YV12_gpu(frame, frame.channels(), videoFrame_);
else
{
switch (surfaceFormat_)
modules/gpu/src/warp.cpp
+5 -5
View File
@@ -53,7 +53,7 @@ void cv::gpu::buildWarpPerspectiveMaps(const Mat&, bool, Size, GpuMat&, GpuMat&,
#else // HAVE_CUDA
namespace cv { namespace gpu { namespace cuda
namespace cv { namespace gpu { namespace cudev
{
namespace imgproc
{
@@ -73,7 +73,7 @@ namespace cv { namespace gpu { namespace cuda
void cv::gpu::buildWarpAffineMaps(const Mat& M, bool inverse, Size dsize, GpuMat& xmap, GpuMat& ymap, Stream& stream)
{
using namespace cv::gpu::cuda::imgproc;
using namespace cv::gpu::cudev::imgproc;
CV_Assert(M.rows == 2 && M.cols == 3);
@@ -97,7 +97,7 @@ void cv::gpu::buildWarpAffineMaps(const Mat& M, bool inverse, Size dsize, GpuMat
void cv::gpu::buildWarpPerspectiveMaps(const Mat& M, bool inverse, Size dsize, GpuMat& xmap, GpuMat& ymap, Stream& stream)
{
using namespace cv::gpu::cuda::imgproc;
using namespace cv::gpu::cudev::imgproc;
CV_Assert(M.rows == 3 && M.cols == 3);
@@ -272,7 +272,7 @@ void cv::gpu::warpAffine(const GpuMat& src, GpuMat& dst, const Mat& M, Size dsiz
}
else
{
using namespace cv::gpu::cuda::imgproc;
using namespace cv::gpu::cudev::imgproc;
typedef void (*func_t)(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation,
int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
@@ -410,7 +410,7 @@ void cv::gpu::warpPerspective(const GpuMat& src, GpuMat& dst, const Mat& M, Size
}
else
{
using namespace cv::gpu::cuda::imgproc;
using namespace cv::gpu::cudev::imgproc;
typedef void (*func_t)(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation,
int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);