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

12
samples/gpu/CMakeLists.txt
View File

@@ -1,4 +1,4 @@
SET(OPENCV_GPU_SAMPLES_REQUIRED_DEPS opencv_core opencv_flann opencv_imgproc opencv_highgui
SET(OPENCV_CUDA_SAMPLES_REQUIRED_DEPS opencv_core opencv_flann opencv_imgproc opencv_highgui
opencv_ml opencv_video opencv_objdetect opencv_features2d
opencv_calib3d opencv_legacy opencv_contrib opencv_cuda
opencv_nonfree opencv_softcascade opencv_superres
@@ -6,7 +6,7 @@ SET(OPENCV_GPU_SAMPLES_REQUIRED_DEPS opencv_core opencv_flann opencv_imgproc ope
opencv_cudafeatures2d opencv_cudaoptflow opencv_cudabgsegm
opencv_cudastereo opencv_cudalegacy)
ocv_check_dependencies(${OPENCV_GPU_SAMPLES_REQUIRED_DEPS})
ocv_check_dependencies(${OPENCV_CUDA_SAMPLES_REQUIRED_DEPS})
if(BUILD_EXAMPLES AND OCV_DEPENDENCIES_FOUND)
set(project "gpu")
@@ -14,7 +14,7 @@ if(BUILD_EXAMPLES AND OCV_DEPENDENCIES_FOUND)
project("${project}_samples")
ocv_include_modules(${OPENCV_GPU_SAMPLES_REQUIRED_DEPS})
ocv_include_modules(${OPENCV_CUDA_SAMPLES_REQUIRED_DEPS})
ocv_include_directories(
"${OpenCV_SOURCE_DIR}/modules/gpu/src/nvidia"
"${OpenCV_SOURCE_DIR}/modules/gpu/src/nvidia/core"
@@ -43,11 +43,11 @@ if(BUILD_EXAMPLES AND OCV_DEPENDENCIES_FOUND)
# ---------------------------------------------
# Define executable targets
# ---------------------------------------------
MACRO(OPENCV_DEFINE_GPU_EXAMPLE name srcs)
MACRO(OPENCV_DEFINE_CUDA_EXAMPLE name srcs)
set(the_target "example_${project}_${name}")
add_executable(${the_target} ${srcs})
target_link_libraries(${the_target} ${OPENCV_LINKER_LIBS} ${OPENCV_GPU_SAMPLES_REQUIRED_DEPS})
target_link_libraries(${the_target} ${OPENCV_LINKER_LIBS} ${OPENCV_CUDA_SAMPLES_REQUIRED_DEPS})
if(HAVE_CUDA)
target_link_libraries(${the_target} ${CUDA_CUDA_LIBRARY})
@@ -85,7 +85,7 @@ if(BUILD_EXAMPLES AND OCV_DEPENDENCIES_FOUND)
foreach(sample_filename ${all_samples})
get_filename_component(sample ${sample_filename} NAME_WE)
file(GLOB sample_srcs RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${sample}.*)
OPENCV_DEFINE_GPU_EXAMPLE(${sample} ${sample_srcs})
OPENCV_DEFINE_CUDA_EXAMPLE(${sample} ${sample_srcs})
endforeach()
include("performance/CMakeLists.txt")

4
samples/gpu/cascadeclassifier.cpp
View File

@@ -130,7 +130,7 @@ int main(int argc, const char *argv[])
if (getCudaEnabledDeviceCount() == 0)
{
return cerr << "No GPU found or the library is compiled without GPU support" << endl, -1;
return cerr << "No GPU found or the library is compiled without CUDA support" << endl, -1;
}
cv::cuda::printShortCudaDeviceInfo(cv::cuda::getDevice());
@@ -172,7 +172,7 @@ int main(int argc, const char *argv[])
}
}
CascadeClassifier_GPU cascade_gpu;
CascadeClassifier_CUDA cascade_gpu;
if (!cascade_gpu.load(cascadeName))
{
return cerr << "ERROR: Could not load cascade classifier \"" << cascadeName << "\"" << endl, help(), -1;

2
samples/gpu/cascadeclassifier_nvidia_api.cpp
View File

@@ -160,7 +160,7 @@ int main(int argc, const char** argv)
cout << "Syntax: exename <cascade_file> <image_or_video_or_cameraid>" << endl;
cout << "=========================================" << endl;
ncvAssertPrintReturn(cv::cuda::getCudaEnabledDeviceCount() != 0, "No GPU found or the library is compiled without GPU support", -1);
ncvAssertPrintReturn(cv::cuda::getCudaEnabledDeviceCount() != 0, "No GPU found or the library is compiled without CUDA support", -1);
ncvAssertPrintReturn(argc == 3, "Invalid number of arguments", -1);
cv::cuda::printShortCudaDeviceInfo(cv::cuda::getDevice());

2
samples/gpu/driver_api_multi.cpp
View File

@@ -85,7 +85,7 @@ int main()
DeviceInfo dev_info(i);
if (!dev_info.isCompatible())
{
std::cout << "GPU module isn't built for GPU #" << i << " ("
std::cout << "CUDA module isn't built for GPU #" << i << " ("
<< dev_info.name() << ", CC " << dev_info.majorVersion()
<< dev_info.minorVersion() << "\n";
return -1;

2
samples/gpu/multi.cpp
View File

@@ -61,7 +61,7 @@ int main()
DeviceInfo dev_info(i);
if (!dev_info.isCompatible())
{
std::cout << "GPU module isn't built for GPU #" << i << " ("
std::cout << "CUDA module isn't built for GPU #" << i << " ("
<< dev_info.name() << ", CC " << dev_info.majorVersion()
<< dev_info.minorVersion() << "\n";
return -1;

2
samples/gpu/optical_flow.cpp
View File

@@ -170,7 +170,7 @@ int main(int argc, const char* argv[])
BroxOpticalFlow brox(0.197f, 50.0f, 0.8f, 10, 77, 10);
PyrLKOpticalFlow lk; lk.winSize = Size(7, 7);
FarnebackOpticalFlow farn;
OpticalFlowDual_TVL1_GPU tvl1;
OpticalFlowDual_TVL1_CUDA tvl1;
FastOpticalFlowBM fastBM;
{

8
samples/gpu/performance/CMakeLists.txt
View File

@@ -8,7 +8,7 @@ if(HAVE_opencv_nonfree)
endif()
add_executable(${the_target} ${sources} ${headers})
target_link_libraries(${the_target} ${OPENCV_LINKER_LIBS} ${OPENCV_GPU_SAMPLES_REQUIRED_DEPS})
target_link_libraries(${the_target} ${OPENCV_LINKER_LIBS} ${OPENCV_CUDA_SAMPLES_REQUIRED_DEPS})
if(HAVE_opencv_nonfree)
target_link_libraries(${the_target} opencv_nonfree)
@@ -16,7 +16,7 @@ endif()
set_target_properties(${the_target} PROPERTIES
OUTPUT_NAME "performance_gpu"
PROJECT_LABEL "(EXAMPLE_GPU) performance")
PROJECT_LABEL "(EXAMPLE_CUDA) performance")
if(ENABLE_SOLUTION_FOLDERS)
set_target_properties(${the_target} PROPERTIES FOLDER "samples//gpu")
@@ -27,8 +27,8 @@ if(WIN32)
endif()
if(INSTALL_C_EXAMPLES AND NOT WIN32)
file(GLOB GPU_FILES performance/*.cpp performance/*.h)
install(FILES ${GPU_FILES}
file(GLOB CUDA_FILES performance/*.cpp performance/*.h)
install(FILES ${CUDA_FILES}
DESTINATION share/OpenCV/samples/gpu/performance
PERMISSIONS OWNER_READ GROUP_READ WORLD_READ)
endif()

4
samples/gpu/performance/performance.cpp
View File

@@ -158,7 +158,7 @@ int main(int argc, const char* argv[])
int num_devices = getCudaEnabledDeviceCount();
if (num_devices == 0)
{
cerr << "No GPU found or the library was compiled without GPU support";
cerr << "No GPU found or the library was compiled without CUDA support";
return -1;
}
@@ -191,7 +191,7 @@ int main(int argc, const char* argv[])
DeviceInfo dev_info(device);
if (!dev_info.isCompatible())
{
cerr << "GPU module isn't built for GPU #" << device << " " << dev_info.name() << ", CC " << dev_info.majorVersion() << '.' << dev_info.minorVersion() << endl;
cerr << "CUDA module isn't built for GPU #" << device << " " << dev_info.name() << ", CC " << dev_info.majorVersion() << '.' << dev_info.minorVersion() << endl;
return -1;
}
setDevice(device);

10
samples/gpu/performance/performance.h
View File

@@ -1,5 +1,5 @@
#ifndef OPENCV_GPU_SAMPLE_PERFORMANCE_H_
#define OPENCV_GPU_SAMPLE_PERFORMANCE_H_
#ifndef OPENCV_CUDA_SAMPLE_PERFORMANCE_H_
#define OPENCV_CUDA_SAMPLE_PERFORMANCE_H_
#include <iostream>
#include <cstdio>
@@ -172,10 +172,10 @@ private:
TestSystem::instance().cpuOff(); \
} TestSystem::instance().cpuComplete()
#define GPU_ON \
#define CUDA_ON \
while (!TestSystem::instance().stop()) { \
TestSystem::instance().gpuOn()
#define GPU_OFF \
#define CUDA_OFF \
TestSystem::instance().gpuOff(); \
} TestSystem::instance().gpuComplete()
@@ -186,4 +186,4 @@ void gen(cv::Mat& mat, int rows, int cols, int type, cv::Scalar low,
// Returns abs path taking into account test system working dir
std::string abspath(const std::string& relpath);
#endif // OPENCV_GPU_SAMPLE_PERFORMANCE_H_
#endif // OPENCV_CUDA_SAMPLE_PERFORMANCE_H_

190
samples/gpu/performance/tests.cpp
View File

@@ -49,9 +49,9 @@ TEST(matchTemplate)
d_templ.upload(templ);
alg->match(d_src, d_templ, d_dst);
GPU_ON;
CUDA_ON;
alg->match(d_src, d_templ, d_dst);
GPU_OFF;
CUDA_OFF;
}
}
@@ -76,9 +76,9 @@ TEST(minMaxLoc)
d_src.upload(src);
GPU_ON;
CUDA_ON;
cuda::minMaxLoc(d_src, &min_val, &max_val, &min_loc, &max_loc);
GPU_OFF;
CUDA_OFF;
}
}
@@ -122,9 +122,9 @@ TEST(remap)
cuda::remap(d_src, d_dst, d_xmap, d_ymap, interpolation, borderMode);
GPU_ON;
CUDA_ON;
cuda::remap(d_src, d_dst, d_xmap, d_ymap, interpolation, borderMode);
GPU_OFF;
CUDA_OFF;
}
}
@@ -150,9 +150,9 @@ TEST(dft)
cuda::dft(d_src, d_dst, Size(size, size));
GPU_ON;
CUDA_ON;
cuda::dft(d_src, d_dst, Size(size, size));
GPU_OFF;
CUDA_OFF;
}
}
@@ -180,9 +180,9 @@ TEST(cornerHarris)
harris->compute(d_src, d_dst);
GPU_ON;
CUDA_ON;
harris->compute(d_src, d_dst);
GPU_OFF;
CUDA_OFF;
}
}
@@ -208,9 +208,9 @@ TEST(integral)
cuda::integralBuffered(d_src, d_sum, d_buf);
GPU_ON;
CUDA_ON;
cuda::integralBuffered(d_src, d_sum, d_buf);
GPU_OFF;
CUDA_OFF;
}
}
@@ -236,9 +236,9 @@ TEST(norm)
cuda::norm(d_src, NORM_INF, d_buf);
GPU_ON;
CUDA_ON;
cuda::norm(d_src, NORM_INF, d_buf);
GPU_OFF;
CUDA_OFF;
}
}
@@ -268,9 +268,9 @@ TEST(meanShift)
cuda::meanShiftFiltering(d_src, d_dst, sp, sr);
GPU_ON;
CUDA_ON;
cuda::meanShiftFiltering(d_src, d_dst, sp, sr);
GPU_OFF;
CUDA_OFF;
}
}
@@ -291,16 +291,16 @@ TEST(SURF)
surf(src, Mat(), keypoints, descriptors);
CPU_OFF;
cuda::SURF_GPU d_surf;
cuda::SURF_CUDA d_surf;
cuda::GpuMat d_src(src);
cuda::GpuMat d_keypoints;
cuda::GpuMat d_descriptors;
d_surf(d_src, cuda::GpuMat(), d_keypoints, d_descriptors);
GPU_ON;
CUDA_ON;
d_surf(d_src, cuda::GpuMat(), d_keypoints, d_descriptors);
GPU_OFF;
CUDA_OFF;
}
#endif
@@ -319,15 +319,15 @@ TEST(FAST)
FAST(src, keypoints, 20);
CPU_OFF;
cuda::FAST_GPU d_FAST(20);
cuda::FAST_CUDA d_FAST(20);
cuda::GpuMat d_src(src);
cuda::GpuMat d_keypoints;
d_FAST(d_src, cuda::GpuMat(), d_keypoints);
GPU_ON;
CUDA_ON;
d_FAST(d_src, cuda::GpuMat(), d_keypoints);
GPU_OFF;
CUDA_OFF;
}
@@ -346,16 +346,16 @@ TEST(ORB)
orb(src, Mat(), keypoints, descriptors);
CPU_OFF;
cuda::ORB_GPU d_orb;
cuda::ORB_CUDA d_orb;
cuda::GpuMat d_src(src);
cuda::GpuMat d_keypoints;
cuda::GpuMat d_descriptors;
d_orb(d_src, cuda::GpuMat(), d_keypoints, d_descriptors);
GPU_ON;
CUDA_ON;
d_orb(d_src, cuda::GpuMat(), d_keypoints, d_descriptors);
GPU_OFF;
CUDA_OFF;
}
@@ -373,9 +373,9 @@ TEST(BruteForceMatcher)
Mat train;
gen(train, 3000, desc_len, CV_32F, 0, 1);
// Init GPU matcher
// Init CUDA matcher
cuda::BFMatcher_GPU d_matcher(NORM_L2);
cuda::BFMatcher_CUDA d_matcher(NORM_L2);
cuda::GpuMat d_query(query);
cuda::GpuMat d_train(train);
@@ -394,9 +394,9 @@ TEST(BruteForceMatcher)
d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance);
GPU_ON;
CUDA_ON;
d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance);
GPU_OFF;
CUDA_OFF;
SUBTEST << "knnMatch";
@@ -408,9 +408,9 @@ TEST(BruteForceMatcher)
d_matcher.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, 2);
GPU_ON;
CUDA_ON;
d_matcher.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, 2);
GPU_OFF;
CUDA_OFF;
SUBTEST << "radiusMatch";
@@ -426,9 +426,9 @@ TEST(BruteForceMatcher)
d_matcher.radiusMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_nMatches, max_distance);
GPU_ON;
CUDA_ON;
d_matcher.radiusMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_nMatches, max_distance);
GPU_OFF;
CUDA_OFF;
}
@@ -455,9 +455,9 @@ TEST(magnitude)
cuda::magnitude(d_x, d_y, d_mag);
GPU_ON;
CUDA_ON;
cuda::magnitude(d_x, d_y, d_mag);
GPU_OFF;
CUDA_OFF;
}
}
@@ -485,9 +485,9 @@ TEST(add)
cuda::add(d_src1, d_src2, d_dst);
GPU_ON;
CUDA_ON;
cuda::add(d_src1, d_src2, d_dst);
GPU_OFF;
CUDA_OFF;
}
}
@@ -513,9 +513,9 @@ TEST(log)
cuda::log(d_src, d_dst);
GPU_ON;
CUDA_ON;
cuda::log(d_src, d_dst);
GPU_OFF;
CUDA_OFF;
}
}
@@ -543,9 +543,9 @@ TEST(mulSpectrums)
cuda::mulSpectrums(d_src1, d_src2, d_dst, 0, true);
GPU_ON;
CUDA_ON;
cuda::mulSpectrums(d_src1, d_src2, d_dst, 0, true);
GPU_OFF;
CUDA_OFF;
}
}
@@ -571,9 +571,9 @@ TEST(resize)
cuda::resize(d_src, d_dst, Size(), 2.0, 2.0);
GPU_ON;
CUDA_ON;
cuda::resize(d_src, d_dst, Size(), 2.0, 2.0);
GPU_OFF;
CUDA_OFF;
}
for (int size = 1000; size <= 3000; size += 1000)
@@ -592,9 +592,9 @@ TEST(resize)
cuda::resize(d_src, d_dst, Size(), 0.5, 0.5);
GPU_ON;
CUDA_ON;
cuda::resize(d_src, d_dst, Size(), 0.5, 0.5);
GPU_OFF;
CUDA_OFF;
}
}
@@ -617,9 +617,9 @@ TEST(cvtColor)
cuda::cvtColor(d_src, d_dst, COLOR_GRAY2BGRA, 4);
GPU_ON;
CUDA_ON;
cuda::cvtColor(d_src, d_dst, COLOR_GRAY2BGRA, 4);
GPU_OFF;
CUDA_OFF;
cv::swap(src, dst);
d_src.swap(d_dst);
@@ -634,9 +634,9 @@ TEST(cvtColor)
cuda::cvtColor(d_src, d_dst, COLOR_BGR2YCrCb, 4);
GPU_ON;
CUDA_ON;
cuda::cvtColor(d_src, d_dst, COLOR_BGR2YCrCb, 4);
GPU_OFF;
CUDA_OFF;
cv::swap(src, dst);
d_src.swap(d_dst);
@@ -651,9 +651,9 @@ TEST(cvtColor)
cuda::cvtColor(d_src, d_dst, COLOR_YCrCb2BGR, 4);
GPU_ON;
CUDA_ON;
cuda::cvtColor(d_src, d_dst, COLOR_YCrCb2BGR, 4);
GPU_OFF;
CUDA_OFF;
cv::swap(src, dst);
d_src.swap(d_dst);
@@ -668,9 +668,9 @@ TEST(cvtColor)
cuda::cvtColor(d_src, d_dst, COLOR_BGR2XYZ, 4);
GPU_ON;
CUDA_ON;
cuda::cvtColor(d_src, d_dst, COLOR_BGR2XYZ, 4);
GPU_OFF;
CUDA_OFF;
cv::swap(src, dst);
d_src.swap(d_dst);
@@ -685,9 +685,9 @@ TEST(cvtColor)
cuda::cvtColor(d_src, d_dst, COLOR_XYZ2BGR, 4);
GPU_ON;
CUDA_ON;
cuda::cvtColor(d_src, d_dst, COLOR_XYZ2BGR, 4);
GPU_OFF;
CUDA_OFF;
cv::swap(src, dst);
d_src.swap(d_dst);
@@ -702,9 +702,9 @@ TEST(cvtColor)
cuda::cvtColor(d_src, d_dst, COLOR_BGR2HSV, 4);
GPU_ON;
CUDA_ON;
cuda::cvtColor(d_src, d_dst, COLOR_BGR2HSV, 4);
GPU_OFF;
CUDA_OFF;
cv::swap(src, dst);
d_src.swap(d_dst);
@@ -719,9 +719,9 @@ TEST(cvtColor)
cuda::cvtColor(d_src, d_dst, COLOR_HSV2BGR, 4);
GPU_ON;
CUDA_ON;
cuda::cvtColor(d_src, d_dst, COLOR_HSV2BGR, 4);
GPU_OFF;
CUDA_OFF;
cv::swap(src, dst);
d_src.swap(d_dst);
@@ -752,9 +752,9 @@ TEST(erode)
erode->apply(d_src, d_dst);
GPU_ON;
CUDA_ON;
erode->apply(d_src, d_dst);
GPU_OFF;
CUDA_OFF;
}
}
@@ -779,9 +779,9 @@ TEST(threshold)
cuda::threshold(d_src, d_dst, 50.0, 0.0, THRESH_BINARY);
GPU_ON;
CUDA_ON;
cuda::threshold(d_src, d_dst, 50.0, 0.0, THRESH_BINARY);
GPU_OFF;
CUDA_OFF;
}
for (int size = 2000; size <= 4000; size += 1000)
@@ -800,9 +800,9 @@ TEST(threshold)
cuda::threshold(d_src, d_dst, 50.0, 0.0, THRESH_TRUNC);
GPU_ON;
CUDA_ON;
cuda::threshold(d_src, d_dst, 50.0, 0.0, THRESH_TRUNC);
GPU_OFF;
CUDA_OFF;
}
}
@@ -827,9 +827,9 @@ TEST(pow)
cuda::pow(d_src, -2.0, d_dst);
GPU_ON;
CUDA_ON;
cuda::pow(d_src, -2.0, d_dst);
GPU_OFF;
CUDA_OFF;
}
}
@@ -864,9 +864,9 @@ TEST(projectPoints)
cuda::projectPoints(d_src, rvec, tvec, camera_mat, Mat(), d_dst);
GPU_ON;
CUDA_ON;
cuda::projectPoints(d_src, rvec, tvec, camera_mat, Mat(), d_dst);
GPU_OFF;
CUDA_OFF;
}
}
@@ -906,10 +906,10 @@ TEST(solvePnPRansac)
max_dist, int(num_points * 0.05), inliers_cpu);
CPU_OFF;
GPU_ON;
CUDA_ON;
cuda::solvePnPRansac(object, image, camera_mat, Mat::zeros(1, 8, CV_32F), rvec, tvec, false, num_iters,
max_dist, int(num_points * 0.05), &inliers_gpu);
GPU_OFF;
CUDA_OFF;
}
}
@@ -937,9 +937,9 @@ TEST(GaussianBlur)
gauss->apply(d_src, d_dst);
GPU_ON;
CUDA_ON;
gauss->apply(d_src, d_dst);
GPU_OFF;
CUDA_OFF;
}
}
@@ -970,9 +970,9 @@ TEST(filter2D)
Ptr<cuda::Filter> filter2D = cuda::createLinearFilter(d_src.type(), -1, kernel);
filter2D->apply(d_src, d_dst);
GPU_ON;
CUDA_ON;
filter2D->apply(d_src, d_dst);
GPU_OFF;
CUDA_OFF;
}
}
}
@@ -997,9 +997,9 @@ TEST(pyrDown)
cuda::pyrDown(d_src, d_dst);
GPU_ON;
CUDA_ON;
cuda::pyrDown(d_src, d_dst);
GPU_OFF;
CUDA_OFF;
}
}
@@ -1024,9 +1024,9 @@ TEST(pyrUp)
cuda::pyrUp(d_src, d_dst);
GPU_ON;
CUDA_ON;
cuda::pyrUp(d_src, d_dst);
GPU_OFF;
CUDA_OFF;
}
}
@@ -1053,9 +1053,9 @@ TEST(equalizeHist)
cuda::equalizeHist(d_src, d_dst, d_buf);
GPU_ON;
CUDA_ON;
cuda::equalizeHist(d_src, d_dst, d_buf);
GPU_OFF;
CUDA_OFF;
}
}
@@ -1079,9 +1079,9 @@ TEST(Canny)
canny->detect(d_img, d_edges);
GPU_ON;
CUDA_ON;
canny->detect(d_img, d_edges);
GPU_OFF;
CUDA_OFF;
}
@@ -1109,9 +1109,9 @@ TEST(reduce)
cuda::reduce(d_src, d_dst0, 0, REDUCE_MIN);
GPU_ON;
CUDA_ON;
cuda::reduce(d_src, d_dst0, 0, REDUCE_MIN);
GPU_OFF;
CUDA_OFF;
SUBTEST << size << 'x' << size << ", dim = 1";
@@ -1123,9 +1123,9 @@ TEST(reduce)
cuda::reduce(d_src, d_dst1, 1, REDUCE_MIN);
GPU_ON;
CUDA_ON;
cuda::reduce(d_src, d_dst1, 1, REDUCE_MIN);
GPU_OFF;
CUDA_OFF;
}
}
@@ -1155,9 +1155,9 @@ TEST(gemm)
cuda::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst);
GPU_ON;
CUDA_ON;
cuda::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst);
GPU_OFF;
CUDA_OFF;
}
}
@@ -1181,9 +1181,9 @@ TEST(GoodFeaturesToTrack)
detector->detect(d_src, d_pts);
GPU_ON;
CUDA_ON;
detector->detect(d_src, d_pts);
GPU_OFF;
CUDA_OFF;
}
TEST(PyrLKOpticalFlow)
@@ -1230,9 +1230,9 @@ TEST(PyrLKOpticalFlow)
d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status, &d_err);
GPU_ON;
CUDA_ON;
d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status, &d_err);
GPU_OFF;
CUDA_OFF;
}
}
@@ -1255,9 +1255,9 @@ TEST(FarnebackOpticalFlow)
calc.flags |= useGaussianBlur ? OPTFLOW_FARNEBACK_GAUSSIAN : 0;
cuda::GpuMat d_frame0(frame0), d_frame1(frame1), d_flowx, d_flowy;
GPU_ON;
CUDA_ON;
calc(d_frame0, d_frame1, d_flowx, d_flowy);
GPU_OFF;
CUDA_OFF;
Mat flow;
CPU_ON;

2
samples/gpu/stereo_multi.cpp
View File

@@ -80,7 +80,7 @@ int main(int argc, char** argv)
DeviceInfo dev_info(i);
if (!dev_info.isCompatible())
{
std::cout << "GPU module isn't built for GPU #" << i << " ("
std::cout << "CUDA module isn't built for GPU #" << i << " ("
<< dev_info.name() << ", CC " << dev_info.majorVersion()
<< dev_info.minorVersion() << "\n";
return -1;

12
samples/gpu/super_resolution.cpp
View File

@@ -32,7 +32,7 @@ static Ptr<DenseOpticalFlowExt> createOptFlow(const string& name, bool useGpu)
if (name == "farneback")
{
if (useGpu)
return createOptFlow_Farneback_GPU();
return createOptFlow_Farneback_CUDA();
else
return createOptFlow_Farneback();
}
@@ -41,14 +41,14 @@ static Ptr<DenseOpticalFlowExt> createOptFlow(const string& name, bool useGpu)
else if (name == "tvl1")
{
if (useGpu)
return createOptFlow_DualTVL1_GPU();
return createOptFlow_DualTVL1_CUDA();
else
return createOptFlow_DualTVL1();
}
else if (name == "brox")
return createOptFlow_Brox_GPU();
return createOptFlow_Brox_CUDA();
else if (name == "pyrlk")
return createOptFlow_PyrLK_GPU();
return createOptFlow_PyrLK_CUDA();
else
{
cerr << "Incorrect Optical Flow algorithm - " << name << endl;
@@ -167,7 +167,7 @@ int main(int argc, const char* argv[])
#endif
{
if (useCuda)
superRes = createSuperResolution_BTVL1_GPU();
superRes = createSuperResolution_BTVL1_CUDA();
else
superRes = createSuperResolution_BTVL1();
@@ -188,7 +188,7 @@ int main(int argc, const char* argv[])
// Try to use gpu Video Decoding
try
{
frameSource = createFrameSource_Video_GPU(inputVideoName);
frameSource = createFrameSource_Video_CUDA(inputVideoName);
Mat frame;
frameSource->nextFrame(frame);
}

8
samples/gpu/surf_keypoint_matcher.cpp
View File

@@ -16,7 +16,7 @@ using namespace cv::cuda;
static void help()
{
cout << "\nThis program demonstrates using SURF_GPU features detector, descriptor extractor and BruteForceMatcher_GPU" << endl;
cout << "\nThis program demonstrates using SURF_CUDA features detector, descriptor extractor and BruteForceMatcher_CUDA" << endl;
cout << "\nUsage:\n\tmatcher_simple_gpu --left <image1> --right <image2>" << endl;
}
@@ -50,7 +50,7 @@ int main(int argc, char* argv[])
cv::cuda::printShortCudaDeviceInfo(cv::cuda::getDevice());
SURF_GPU surf;
SURF_CUDA surf;
// detecting keypoints & computing descriptors
GpuMat keypoints1GPU, keypoints2GPU;
@@ -62,7 +62,7 @@ int main(int argc, char* argv[])
cout << "FOUND " << keypoints2GPU.cols << " keypoints on second image" << endl;
// matching descriptors
BFMatcher_GPU matcher(NORM_L2);
BFMatcher_CUDA matcher(NORM_L2);
GpuMat trainIdx, distance;
matcher.matchSingle(descriptors1GPU, descriptors2GPU, trainIdx, distance);
@@ -74,7 +74,7 @@ int main(int argc, char* argv[])
surf.downloadKeypoints(keypoints2GPU, keypoints2);
surf.downloadDescriptors(descriptors1GPU, descriptors1);
surf.downloadDescriptors(descriptors2GPU, descriptors2);
BFMatcher_GPU::matchDownload(trainIdx, distance, matches);
BFMatcher_CUDA::matchDownload(trainIdx, distance, matches);
// drawing the results
Mat img_matches;

2
samples/gpu/video_reader.cpp
View File

@@ -78,7 +78,7 @@ int main(int argc, const char* argv[])
int main()
{
std::cout << "OpenCV was built without GPU Video decoding support\n" << std::endl;
std::cout << "OpenCV was built without CUDA Video decoding support\n" << std::endl;
return 0;
}

4
samples/gpu/video_writer.cpp
View File

@@ -66,7 +66,7 @@ int main(int argc, const char* argv[])
if (d_writer.empty())
{
std::cout << "Open GPU Writer" << std::endl;
std::cout << "Open CUDA Writer" << std::endl;
d_writer = cv::cudacodec::createVideoWriter("output_gpu.avi", frame.size(), FPS);
}
@@ -104,7 +104,7 @@ int main(int argc, const char* argv[])
int main()
{
std::cout << "OpenCV was built without GPU Video encoding support\n" << std::endl;
std::cout << "OpenCV was built without CUDA Video encoding support\n" << std::endl;
return 0;
}