generic-library/opencv
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

replaced GPU -> CUDA

Browse Source
This commit is contained in:
Vladislav Vinogradov
2013-07-24 13:55:18 +04:00
parent 3c34b24f1f
commit fd88654b45
172 changed files with 2434 additions and 2436 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
modules/cudaoptflow/include/opencv2/cudaoptflow.hpp
View File

@@ -182,10 +182,10 @@ private:
// see reference:
// [1] C. Zach, T. Pock and H. Bischof, "A Duality Based Approach for Realtime TV-L1 Optical Flow".
// [2] Javier Sanchez, Enric Meinhardt-Llopis and Gabriele Facciolo. "TV-L1 Optical Flow Estimation".
class CV_EXPORTS OpticalFlowDual_TVL1_GPU
class CV_EXPORTS OpticalFlowDual_TVL1_CUDA
{
public:
OpticalFlowDual_TVL1_GPU();
OpticalFlowDual_TVL1_CUDA();
void operator ()(const GpuMat& I0, const GpuMat& I1, GpuMat& flowx, GpuMat& flowy);

54
modules/cudaoptflow/perf/perf_optflow.cpp
View File

@@ -66,7 +66,7 @@ PERF_TEST_P(ImagePair, InterpolateFrames,
frame0.convertTo(frame0, CV_32FC1, 1.0 / 255.0);
frame1.convertTo(frame1, CV_32FC1, 1.0 / 255.0);
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
const cv::cuda::GpuMat d_frame0(frame0);
const cv::cuda::GpuMat d_frame1(frame1);
@@ -84,7 +84,7 @@ PERF_TEST_P(ImagePair, InterpolateFrames,
TEST_CYCLE() cv::cuda::interpolateFrames(d_frame0, d_frame1, d_fu, d_fv, d_bu, d_bv, 0.5f, newFrame, d_buf);
GPU_SANITY_CHECK(newFrame, 1e-4);
CUDA_SANITY_CHECK(newFrame, 1e-4);
}
else
{
@@ -107,7 +107,7 @@ PERF_TEST_P(ImagePair, CreateOpticalFlowNeedleMap,
frame0.convertTo(frame0, CV_32FC1, 1.0 / 255.0);
frame1.convertTo(frame1, CV_32FC1, 1.0 / 255.0);
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
const cv::cuda::GpuMat d_frame0(frame0);
const cv::cuda::GpuMat d_frame1(frame1);
@@ -123,8 +123,8 @@ PERF_TEST_P(ImagePair, CreateOpticalFlowNeedleMap,
TEST_CYCLE() cv::cuda::createOpticalFlowNeedleMap(u, v, vertex, colors);
GPU_SANITY_CHECK(vertex, 1e-6);
GPU_SANITY_CHECK(colors);
CUDA_SANITY_CHECK(vertex, 1e-6);
CUDA_SANITY_CHECK(colors);
}
else
{
@@ -149,7 +149,7 @@ PERF_TEST_P(ImagePair, BroxOpticalFlow,
frame0.convertTo(frame0, CV_32FC1, 1.0 / 255.0);
frame1.convertTo(frame1, CV_32FC1, 1.0 / 255.0);
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
const cv::cuda::GpuMat d_frame0(frame0);
const cv::cuda::GpuMat d_frame1(frame1);
@@ -161,8 +161,8 @@ PERF_TEST_P(ImagePair, BroxOpticalFlow,
TEST_CYCLE() d_flow(d_frame0, d_frame1, u, v);
GPU_SANITY_CHECK(u, 1e-1);
GPU_SANITY_CHECK(v, 1e-1);
CUDA_SANITY_CHECK(u, 1e-1);
CUDA_SANITY_CHECK(v, 1e-1);
}
else
{
@@ -207,7 +207,7 @@ PERF_TEST_P(ImagePair_Gray_NPts_WinSz_Levels_Iters, PyrLKOpticalFlowSparse,
cv::Mat pts;
cv::goodFeaturesToTrack(gray_frame, pts, points, 0.01, 0.0);
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
const cv::cuda::GpuMat d_pts(pts.reshape(2, 1));
@@ -223,8 +223,8 @@ PERF_TEST_P(ImagePair_Gray_NPts_WinSz_Levels_Iters, PyrLKOpticalFlowSparse,
TEST_CYCLE() d_pyrLK.sparse(d_frame0, d_frame1, d_pts, nextPts, status);
GPU_SANITY_CHECK(nextPts);
GPU_SANITY_CHECK(status);
CUDA_SANITY_CHECK(nextPts);
CUDA_SANITY_CHECK(status);
}
else
{
@@ -267,7 +267,7 @@ PERF_TEST_P(ImagePair_WinSz_Levels_Iters, PyrLKOpticalFlowDense,
const cv::Mat frame1 = readImage(imagePair.second, cv::IMREAD_GRAYSCALE);
ASSERT_FALSE(frame1.empty());
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
const cv::cuda::GpuMat d_frame0(frame0);
const cv::cuda::GpuMat d_frame1(frame1);
@@ -281,8 +281,8 @@ PERF_TEST_P(ImagePair_WinSz_Levels_Iters, PyrLKOpticalFlowDense,
TEST_CYCLE() d_pyrLK.dense(d_frame0, d_frame1, u, v);
GPU_SANITY_CHECK(u);
GPU_SANITY_CHECK(v);
CUDA_SANITY_CHECK(u);
CUDA_SANITY_CHECK(v);
}
else
{
@@ -312,7 +312,7 @@ PERF_TEST_P(ImagePair, FarnebackOpticalFlow,
const double polySigma = 1.1;
const int flags = 0;
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
const cv::cuda::GpuMat d_frame0(frame0);
const cv::cuda::GpuMat d_frame1(frame1);
@@ -330,8 +330,8 @@ PERF_TEST_P(ImagePair, FarnebackOpticalFlow,
TEST_CYCLE() d_farneback(d_frame0, d_frame1, u, v);
GPU_SANITY_CHECK(u, 1e-4);
GPU_SANITY_CHECK(v, 1e-4);
CUDA_SANITY_CHECK(u, 1e-4);
CUDA_SANITY_CHECK(v, 1e-4);
}
else
{
@@ -357,19 +357,19 @@ PERF_TEST_P(ImagePair, OpticalFlowDual_TVL1,
const cv::Mat frame1 = readImage(GetParam().second, cv::IMREAD_GRAYSCALE);
ASSERT_FALSE(frame1.empty());
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
const cv::cuda::GpuMat d_frame0(frame0);
const cv::cuda::GpuMat d_frame1(frame1);
cv::cuda::GpuMat u;
cv::cuda::GpuMat v;
cv::cuda::OpticalFlowDual_TVL1_GPU d_alg;
cv::cuda::OpticalFlowDual_TVL1_CUDA d_alg;
TEST_CYCLE() d_alg(d_frame0, d_frame1, u, v);
GPU_SANITY_CHECK(u, 1e-2);
GPU_SANITY_CHECK(v, 1e-2);
CUDA_SANITY_CHECK(u, 1e-2);
CUDA_SANITY_CHECK(v, 1e-2);
}
else
{
@@ -422,7 +422,7 @@ PERF_TEST_P(ImagePair, OpticalFlowBM,
const cv::Size shift_size(1, 1);
const cv::Size max_range(16, 16);
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
const cv::cuda::GpuMat d_frame0(frame0);
const cv::cuda::GpuMat d_frame1(frame1);
@@ -430,8 +430,8 @@ PERF_TEST_P(ImagePair, OpticalFlowBM,
TEST_CYCLE() cv::cuda::calcOpticalFlowBM(d_frame0, d_frame1, block_size, shift_size, max_range, false, u, v, buf);
GPU_SANITY_CHECK(u);
GPU_SANITY_CHECK(v);
CUDA_SANITY_CHECK(u);
CUDA_SANITY_CHECK(v);
}
else
{
@@ -459,7 +459,7 @@ PERF_TEST_P(ImagePair, FastOpticalFlowBM,
const cv::Size shift_size(1, 1);
const cv::Size max_range(16, 16);
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
const cv::cuda::GpuMat d_frame0(frame0);
const cv::cuda::GpuMat d_frame1(frame1);
@@ -469,8 +469,8 @@ PERF_TEST_P(ImagePair, FastOpticalFlowBM,
TEST_CYCLE() fastBM(d_frame0, d_frame1, u, v, max_range.width, block_size.width);
GPU_SANITY_CHECK(u, 2);
GPU_SANITY_CHECK(v, 2);
CUDA_SANITY_CHECK(u, 2);
CUDA_SANITY_CHECK(v, 2);
}
else
{

4
modules/cudaoptflow/src/farneback.cpp
View File

@@ -46,9 +46,9 @@
#define S(x) StreamAccessor::getStream(x)
// GPU resize() is fast, but it differs from the CPU analog. Disabling this flag
// CUDA resize() is fast, but it differs from the CPU analog. Disabling this flag
// leads to an inefficient code. It's for debug purposes only.
#define ENABLE_GPU_RESIZE 1
#define ENABLE_CUDA_RESIZE 1
using namespace cv;
using namespace cv::cuda;

16
modules/cudaoptflow/src/tvl1flow.cpp
View File

@@ -44,17 +44,17 @@
#if !defined HAVE_CUDA || defined(CUDA_DISABLER)
cv::cuda::OpticalFlowDual_TVL1_GPU::OpticalFlowDual_TVL1_GPU() { throw_no_cuda(); }
void cv::cuda::OpticalFlowDual_TVL1_GPU::operator ()(const GpuMat&, const GpuMat&, GpuMat&, GpuMat&) { throw_no_cuda(); }
void cv::cuda::OpticalFlowDual_TVL1_GPU::collectGarbage() {}
void cv::cuda::OpticalFlowDual_TVL1_GPU::procOneScale(const GpuMat&, const GpuMat&, GpuMat&, GpuMat&) { throw_no_cuda(); }
cv::cuda::OpticalFlowDual_TVL1_CUDA::OpticalFlowDual_TVL1_CUDA() { throw_no_cuda(); }
void cv::cuda::OpticalFlowDual_TVL1_CUDA::operator ()(const GpuMat&, const GpuMat&, GpuMat&, GpuMat&) { throw_no_cuda(); }
void cv::cuda::OpticalFlowDual_TVL1_CUDA::collectGarbage() {}
void cv::cuda::OpticalFlowDual_TVL1_CUDA::procOneScale(const GpuMat&, const GpuMat&, GpuMat&, GpuMat&) { throw_no_cuda(); }
#else
using namespace cv;
using namespace cv::cuda;
cv::cuda::OpticalFlowDual_TVL1_GPU::OpticalFlowDual_TVL1_GPU()
cv::cuda::OpticalFlowDual_TVL1_CUDA::OpticalFlowDual_TVL1_CUDA()
{
tau = 0.25;
lambda = 0.15;
@@ -67,7 +67,7 @@ cv::cuda::OpticalFlowDual_TVL1_GPU::OpticalFlowDual_TVL1_GPU()
useInitialFlow = false;
}
void cv::cuda::OpticalFlowDual_TVL1_GPU::operator ()(const GpuMat& I0, const GpuMat& I1, GpuMat& flowx, GpuMat& flowy)
void cv::cuda::OpticalFlowDual_TVL1_CUDA::operator ()(const GpuMat& I0, const GpuMat& I1, GpuMat& flowx, GpuMat& flowy)
{
CV_Assert( I0.type() == CV_8UC1 || I0.type() == CV_32FC1 );
CV_Assert( I0.size() == I1.size() );
@@ -177,7 +177,7 @@ namespace tvl1flow
void estimateDualVariables(PtrStepSzf u1, PtrStepSzf u2, PtrStepSzf p11, PtrStepSzf p12, PtrStepSzf p21, PtrStepSzf p22, float taut);
}
void cv::cuda::OpticalFlowDual_TVL1_GPU::procOneScale(const GpuMat& I0, const GpuMat& I1, GpuMat& u1, GpuMat& u2)
void cv::cuda::OpticalFlowDual_TVL1_CUDA::procOneScale(const GpuMat& I0, const GpuMat& I1, GpuMat& u1, GpuMat& u2)
{
using namespace tvl1flow;
@@ -230,7 +230,7 @@ void cv::cuda::OpticalFlowDual_TVL1_GPU::procOneScale(const GpuMat& I0, const Gp
}
}
void cv::cuda::OpticalFlowDual_TVL1_GPU::collectGarbage()
void cv::cuda::OpticalFlowDual_TVL1_CUDA::collectGarbage()
{
I0s.clear();
I1s.clear();

2
modules/cudaoptflow/test/test_main.cpp
View File

@@ -42,4 +42,4 @@
#include "test_precomp.hpp"
CV_GPU_TEST_MAIN("gpu")
CV_CUDA_TEST_MAIN("gpu")

28
modules/cudaoptflow/test/test_optflow.cpp
View File

@@ -64,7 +64,7 @@ struct BroxOpticalFlow : testing::TestWithParam<cv::cuda::DeviceInfo>
}
};
GPU_TEST_P(BroxOpticalFlow, Regression)
CUDA_TEST_P(BroxOpticalFlow, Regression)
{
cv::Mat frame0 = readImageType("opticalflow/frame0.png", CV_32FC1);
ASSERT_FALSE(frame0.empty());
@@ -122,7 +122,7 @@ GPU_TEST_P(BroxOpticalFlow, Regression)
#endif
}
GPU_TEST_P(BroxOpticalFlow, OpticalFlowNan)
CUDA_TEST_P(BroxOpticalFlow, OpticalFlowNan)
{
cv::Mat frame0 = readImageType("opticalflow/frame0.png", CV_32FC1);
ASSERT_FALSE(frame0.empty());
@@ -149,7 +149,7 @@ GPU_TEST_P(BroxOpticalFlow, OpticalFlowNan)
EXPECT_TRUE(cv::checkRange(h_v));
};
INSTANTIATE_TEST_CASE_P(GPU_OptFlow, BroxOpticalFlow, ALL_DEVICES);
INSTANTIATE_TEST_CASE_P(CUDA_OptFlow, BroxOpticalFlow, ALL_DEVICES);
//////////////////////////////////////////////////////
// PyrLKOpticalFlow
@@ -173,7 +173,7 @@ PARAM_TEST_CASE(PyrLKOpticalFlow, cv::cuda::DeviceInfo, UseGray)
}
};
GPU_TEST_P(PyrLKOpticalFlow, Sparse)
CUDA_TEST_P(PyrLKOpticalFlow, Sparse)
{
cv::Mat frame0 = readImage("opticalflow/frame0.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);
ASSERT_FALSE(frame0.empty());
@@ -241,7 +241,7 @@ GPU_TEST_P(PyrLKOpticalFlow, Sparse)
ASSERT_LE(bad_ratio, 0.01);
}
INSTANTIATE_TEST_CASE_P(GPU_OptFlow, PyrLKOpticalFlow, testing::Combine(
INSTANTIATE_TEST_CASE_P(CUDA_OptFlow, PyrLKOpticalFlow, testing::Combine(
ALL_DEVICES,
testing::Values(UseGray(true), UseGray(false))));
@@ -276,7 +276,7 @@ PARAM_TEST_CASE(FarnebackOpticalFlow, cv::cuda::DeviceInfo, PyrScale, PolyN, Far
}
};
GPU_TEST_P(FarnebackOpticalFlow, Accuracy)
CUDA_TEST_P(FarnebackOpticalFlow, Accuracy)
{
cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
ASSERT_FALSE(frame0.empty());
@@ -316,7 +316,7 @@ GPU_TEST_P(FarnebackOpticalFlow, Accuracy)
EXPECT_MAT_SIMILAR(flowxy[1], d_flowy, 0.1);
}
INSTANTIATE_TEST_CASE_P(GPU_OptFlow, FarnebackOpticalFlow, testing::Combine(
INSTANTIATE_TEST_CASE_P(CUDA_OptFlow, FarnebackOpticalFlow, testing::Combine(
ALL_DEVICES,
testing::Values(PyrScale(0.3), PyrScale(0.5), PyrScale(0.8)),
testing::Values(PolyN(5), PolyN(7)),
@@ -340,7 +340,7 @@ PARAM_TEST_CASE(OpticalFlowDual_TVL1, cv::cuda::DeviceInfo, UseRoi)
}
};
GPU_TEST_P(OpticalFlowDual_TVL1, Accuracy)
CUDA_TEST_P(OpticalFlowDual_TVL1, Accuracy)
{
cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
ASSERT_FALSE(frame0.empty());
@@ -348,7 +348,7 @@ GPU_TEST_P(OpticalFlowDual_TVL1, Accuracy)
cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
ASSERT_FALSE(frame1.empty());
cv::cuda::OpticalFlowDual_TVL1_GPU d_alg;
cv::cuda::OpticalFlowDual_TVL1_CUDA d_alg;
cv::cuda::GpuMat d_flowx = createMat(frame0.size(), CV_32FC1, useRoi);
cv::cuda::GpuMat d_flowy = createMat(frame0.size(), CV_32FC1, useRoi);
d_alg(loadMat(frame0, useRoi), loadMat(frame1, useRoi), d_flowx, d_flowy);
@@ -366,7 +366,7 @@ GPU_TEST_P(OpticalFlowDual_TVL1, Accuracy)
EXPECT_MAT_SIMILAR(gold[1], d_flowy, 4e-3);
}
INSTANTIATE_TEST_CASE_P(GPU_OptFlow, OpticalFlowDual_TVL1, testing::Combine(
INSTANTIATE_TEST_CASE_P(CUDA_OptFlow, OpticalFlowDual_TVL1, testing::Combine(
ALL_DEVICES,
WHOLE_SUBMAT));
@@ -398,7 +398,7 @@ struct OpticalFlowBM : testing::TestWithParam<cv::cuda::DeviceInfo>
{
};
GPU_TEST_P(OpticalFlowBM, Accuracy)
CUDA_TEST_P(OpticalFlowBM, Accuracy)
{
cv::cuda::DeviceInfo devInfo = GetParam();
cv::cuda::setDevice(devInfo.deviceID());
@@ -425,7 +425,7 @@ GPU_TEST_P(OpticalFlowBM, Accuracy)
EXPECT_MAT_NEAR(vely, d_vely, 0);
}
INSTANTIATE_TEST_CASE_P(GPU_OptFlow, OpticalFlowBM, ALL_DEVICES);
INSTANTIATE_TEST_CASE_P(CUDA_OptFlow, OpticalFlowBM, ALL_DEVICES);
//////////////////////////////////////////////////////
// FastOpticalFlowBM
@@ -501,7 +501,7 @@ struct FastOpticalFlowBM : testing::TestWithParam<cv::cuda::DeviceInfo>
{
};
GPU_TEST_P(FastOpticalFlowBM, Accuracy)
CUDA_TEST_P(FastOpticalFlowBM, Accuracy)
{
const double MAX_RMSE = 0.6;
@@ -543,6 +543,6 @@ GPU_TEST_P(FastOpticalFlowBM, Accuracy)
EXPECT_LE(err, MAX_RMSE);
}
INSTANTIATE_TEST_CASE_P(GPU_OptFlow, FastOpticalFlowBM, ALL_DEVICES);
INSTANTIATE_TEST_CASE_P(CUDA_OptFlow, FastOpticalFlowBM, ALL_DEVICES);
#endif // HAVE_CUDA