renamed gpuarithm -> cudaarithm

modules/gpuarithm/CMakeLists.txt → modules/cudaarithm/CMakeLists.txt

 if(ANDROID OR IOS)
-  ocv_module_disable(gpuarithm)
+  ocv_module_disable(cudaarithm)
 endif()
 
-set(the_description "GPU-accelerated Operations on Matrices")
+set(the_description "CUDA-accelerated Operations on Matrices")
 
 ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4127 /wd4324 /wd4512 -Wundef -Wmissing-declarations)
 
-ocv_add_module(gpuarithm opencv_core OPTIONAL opencv_cudalegacy)
+ocv_add_module(cudaarithm opencv_core OPTIONAL opencv_cudalegacy)
 
 ocv_module_include_directories()
 ocv_glob_module_sources()

modules/gpuarithm/include/opencv2/gpuarithm.hpp → modules/cudaarithm/include/opencv2/cudaarithm.hpp

@@ -40,11 +40,11 @@
 //
 //M*/
 
-#ifndef __OPENCV_GPUARITHM_HPP__
-#define __OPENCV_GPUARITHM_HPP__
+#ifndef __OPENCV_CUDAARITHM_HPP__
+#define __OPENCV_CUDAARITHM_HPP__
 
 #ifndef __cplusplus
-#  error gpuarithm.hpp header must be compiled as C++
+#  error cudaarithm.hpp header must be compiled as C++
 #endif
 
 #include "opencv2/core/cuda.hpp"
@@ -371,4 +371,4 @@ CV_EXPORTS Ptr<Convolution> createConvolution(Size user_block_size = Size());
 
 }} // namespace cv { namespace cuda {
 
-#endif /* __OPENCV_GPUARITHM_HPP__ */
+#endif /* __OPENCV_CUDAARITHM_HPP__ */

modules/gpuarithm/perf/perf_main.cpp → modules/cudaarithm/perf/perf_main.cpp

@@ -44,4 +44,4 @@
 
 using namespace perf;
 
-CV_PERF_TEST_CUDA_MAIN(gpuarithm)
+CV_PERF_TEST_CUDA_MAIN(cudaarithm)

modules/gpuarithm/perf/perf_precomp.hpp → modules/cudaarithm/perf/perf_precomp.hpp

@@ -54,7 +54,7 @@
 #include "opencv2/ts.hpp"
 #include "opencv2/ts/gpu_perf.hpp"
 
-#include "opencv2/gpuarithm.hpp"
+#include "opencv2/cudaarithm.hpp"
 #include "opencv2/core.hpp"
 #include "opencv2/imgproc.hpp"
 

modules/gpuarithm/src/precomp.hpp → modules/cudaarithm/src/precomp.hpp

@@ -47,7 +47,7 @@
 
 #include "cvconfig.h"
 
-#include "opencv2/gpuarithm.hpp"
+#include "opencv2/cudaarithm.hpp"
 #include "opencv2/core/utility.hpp"
 
 #include "opencv2/core/private.cuda.hpp"

modules/gpuarithm/test/test_precomp.hpp → modules/cudaarithm/test/test_precomp.hpp

@@ -56,7 +56,7 @@
 #include "opencv2/ts.hpp"
 #include "opencv2/ts/gpu_test.hpp"
 
-#include "opencv2/gpuarithm.hpp"
+#include "opencv2/cudaarithm.hpp"
 #include "opencv2/core.hpp"
 #include "opencv2/imgproc.hpp"
 

modules/gpu/CMakeLists.txt

@@ -6,4 +6,4 @@ set(the_description "GPU-accelerated Computer Vision")
 
 ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4127 /wd4100 /wd4324 /wd4512 /wd4515 -Wundef -Wmissing-declarations -Wshadow -Wunused-parameter)
 
-ocv_define_module(gpu opencv_calib3d opencv_objdetect opencv_gpuarithm opencv_gpuwarping OPTIONAL opencv_cudalegacy)
+ocv_define_module(gpu opencv_calib3d opencv_objdetect opencv_cudaarithm opencv_gpuwarping OPTIONAL opencv_cudalegacy)

modules/gpu/src/precomp.hpp

@@ -44,7 +44,7 @@
 #define __OPENCV_PRECOMP_H__
 
 #include "opencv2/gpu.hpp"
-#include "opencv2/gpuarithm.hpp"
+#include "opencv2/cudaarithm.hpp"
 #include "opencv2/gpuwarping.hpp"
 #include "opencv2/calib3d.hpp"
 #include "opencv2/objdetect.hpp"

modules/gpubgsegm/CMakeLists.txt

@@ -6,4 +6,4 @@ set(the_description "GPU-accelerated Background Segmentation")
 
 ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4127 /wd4324 /wd4512 -Wundef -Wmissing-declarations)
 
-ocv_define_module(gpubgsegm opencv_video OPTIONAL opencv_legacy opencv_imgproc opencv_gpuarithm opencv_gpufilters opencv_gpuimgproc)
+ocv_define_module(gpubgsegm opencv_video OPTIONAL opencv_legacy opencv_imgproc opencv_cudaarithm opencv_gpufilters opencv_gpuimgproc)

modules/gpubgsegm/src/fgd.cpp

@@ -45,7 +45,7 @@
 using namespace cv;
 using namespace cv::cuda;
 
-#if !defined(HAVE_CUDA) || defined(CUDA_DISABLER) || !defined(HAVE_OPENCV_IMGPROC) || !defined(HAVE_OPENCV_GPUARITHM) || !defined(HAVE_OPENCV_GPUIMGPROC)
+#if !defined(HAVE_CUDA) || defined(CUDA_DISABLER) || !defined(HAVE_OPENCV_IMGPROC) || !defined(HAVE_OPENCV_CUDAARITHM) || !defined(HAVE_OPENCV_GPUIMGPROC)
 
 cv::cuda::FGDParams::FGDParams() { throw_no_cuda(); }
 

modules/gpubgsegm/src/gmg.cpp

@@ -141,7 +141,7 @@ namespace
         GpuMat colors_;
         GpuMat weights_;
 
-#if defined(HAVE_OPENCV_GPUFILTERS) && defined(HAVE_OPENCV_GPUARITHM)
+#if defined(HAVE_OPENCV_GPUFILTERS) && defined(HAVE_OPENCV_CUDAARITHM)
         Ptr<cuda::Filter> boxFilter_;
         GpuMat buf_;
 #endif
@@ -214,7 +214,7 @@ namespace
         funcs[frame.depth()][frame.channels() - 1](frame, fgmask, colors_, weights_, nfeatures_, frameNum_,
                                                    learningRate_, updateBackgroundModel_, StreamAccessor::getStream(stream));
 
-#if defined(HAVE_OPENCV_GPUFILTERS) && defined(HAVE_OPENCV_GPUARITHM)
+#if defined(HAVE_OPENCV_GPUFILTERS) && defined(HAVE_OPENCV_CUDAARITHM)
         // medianBlur
         if (smoothingRadius_ > 0)
         {
@@ -259,7 +259,7 @@ namespace
 
         nfeatures_.setTo(Scalar::all(0));
 
-#if defined(HAVE_OPENCV_GPUFILTERS) && defined(HAVE_OPENCV_GPUARITHM)
+#if defined(HAVE_OPENCV_GPUFILTERS) && defined(HAVE_OPENCV_CUDAARITHM)
         if (smoothingRadius_ > 0)
             boxFilter_ = cuda::createBoxFilter(CV_8UC1, -1, Size(smoothingRadius_, smoothingRadius_));
 #endif

modules/gpubgsegm/src/precomp.hpp

@@ -51,8 +51,8 @@
 
 #include "opencv2/opencv_modules.hpp"
 
-#ifdef HAVE_OPENCV_GPUARITHM
-#  include "opencv2/gpuarithm.hpp"
+#ifdef HAVE_OPENCV_CUDAARITHM
+#  include "opencv2/cudaarithm.hpp"
 #endif
 
 #ifdef HAVE_OPENCV_GPUFILTERS

modules/gpufeatures2d/src/precomp.hpp

@@ -48,7 +48,7 @@
 #include <iterator>
 
 #include "opencv2/gpufeatures2d.hpp"
-#include "opencv2/gpuarithm.hpp"
+#include "opencv2/cudaarithm.hpp"
 #include "opencv2/gpuwarping.hpp"
 #include "opencv2/features2d.hpp"
 

modules/gpufilters/CMakeLists.txt

@@ -6,4 +6,4 @@ set(the_description "GPU-accelerated Image Filtering")
 
 ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4127 /wd4324 /wd4512 -Wundef -Wmissing-declarations)
 
-ocv_define_module(gpufilters opencv_imgproc opencv_gpuarithm)
+ocv_define_module(gpufilters opencv_imgproc opencv_cudaarithm)

modules/gpufilters/src/precomp.hpp

@@ -46,7 +46,7 @@
 #include <limits>
 
 #include "opencv2/gpufilters.hpp"
-#include "opencv2/gpuarithm.hpp"
+#include "opencv2/cudaarithm.hpp"
 #include "opencv2/imgproc.hpp"
 
 #include "opencv2/core/private.cuda.hpp"

modules/gpuimgproc/CMakeLists.txt

@@ -6,4 +6,4 @@ set(the_description "GPU-accelerated Image Processing")
 
 ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4127 /wd4100 /wd4324 /wd4512 /wd4515 -Wundef -Wmissing-declarations -Wshadow -Wunused-parameter)
 
-ocv_define_module(gpuimgproc opencv_imgproc OPTIONAL opencv_gpuarithm opencv_gpufilters)
+ocv_define_module(gpuimgproc opencv_imgproc OPTIONAL opencv_cudaarithm opencv_gpufilters)

modules/gpuimgproc/src/cuda/generalized_hough.cu

@@ -52,7 +52,7 @@
 
 #include "opencv2/opencv_modules.hpp"
 
-#ifdef HAVE_OPENCV_GPUARITHM
+#ifdef HAVE_OPENCV_CUDAARITHM
 
 namespace cv { namespace cuda { namespace device
 {
@@ -819,6 +819,6 @@ namespace cv { namespace cuda { namespace device
     }
 }}}
 
-#endif // HAVE_OPENCV_GPUARITHM
+#endif // HAVE_OPENCV_CUDAARITHM
 
 #endif /* CUDA_DISABLER */

modules/gpuimgproc/src/generalized_hough.cpp

@@ -45,7 +45,7 @@
 using namespace cv;
 using namespace cv::cuda;
 
-#if !defined (HAVE_CUDA) || defined (CUDA_DISABLER) || !defined(HAVE_OPENCV_GPUARITHM)
+#if !defined (HAVE_CUDA) || defined (CUDA_DISABLER) || !defined(HAVE_OPENCV_CUDAARITHM)
 
 Ptr<GeneralizedHoughBallard> cv::cuda::createGeneralizedHoughBallard() { throw_no_cuda(); return Ptr<GeneralizedHoughBallard>(); }
 

modules/gpuimgproc/src/gftt.cpp

@@ -45,7 +45,7 @@
 using namespace cv;
 using namespace cv::cuda;
 
-#if !defined (HAVE_CUDA) || defined (CUDA_DISABLER) || !defined(HAVE_OPENCV_GPUARITHM)
+#if !defined (HAVE_CUDA) || defined (CUDA_DISABLER) || !defined(HAVE_OPENCV_CUDAARITHM)
 
 Ptr<cuda::CornersDetector> cv::cuda::createGoodFeaturesToTrackDetector(int, int, double, double, int, bool, double) { throw_no_cuda(); return Ptr<cuda::CornersDetector>(); }
 

modules/gpuimgproc/src/histogram.cpp

@@ -202,7 +202,7 @@ namespace
         }
         else
         {
-#ifndef HAVE_OPENCV_GPUARITHM
+#ifndef HAVE_OPENCV_CUDAARITHM
             throw_no_cuda();
 #else
             cv::cuda::copyMakeBorder(src, srcExt_, 0, tilesY_ - (src.rows % tilesY_), 0, tilesX_ - (src.cols % tilesX_), cv::BORDER_REFLECT_101, cv::Scalar(), s);

modules/gpuimgproc/src/match_template.cpp

@@ -45,7 +45,7 @@
 using namespace cv;
 using namespace cv::cuda;
 
-#if !defined (HAVE_CUDA) || !defined (HAVE_OPENCV_GPUARITHM) || defined (CUDA_DISABLER)
+#if !defined (HAVE_CUDA) || !defined (HAVE_OPENCV_CUDAARITHM) || defined (CUDA_DISABLER)
 
 Ptr<cuda::TemplateMatching> cv::cuda::createTemplateMatching(int, int, Size) { throw_no_cuda(); return Ptr<cuda::TemplateMatching>(); }
 

modules/gpuimgproc/src/precomp.hpp

@@ -51,8 +51,8 @@
 
 #include "opencv2/opencv_modules.hpp"
 
-#ifdef HAVE_OPENCV_GPUARITHM
-#  include "opencv2/gpuarithm.hpp"
+#ifdef HAVE_OPENCV_CUDAARITHM
+#  include "opencv2/cudaarithm.hpp"
 #endif
 
 #ifdef HAVE_OPENCV_GPUFILTERS

modules/gpuoptflow/CMakeLists.txt

@@ -6,4 +6,4 @@ set(the_description "GPU-accelerated Optical Flow")
 
 ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4127 /wd4324 /wd4512 -Wundef -Wmissing-declarations)
 
-ocv_define_module(gpuoptflow opencv_video opencv_legacy opencv_gpuarithm opencv_gpuwarping opencv_gpuimgproc OPTIONAL opencv_cudalegacy)
+ocv_define_module(gpuoptflow opencv_video opencv_legacy opencv_cudaarithm opencv_gpuwarping opencv_gpuimgproc OPTIONAL opencv_cudalegacy)

modules/gpuoptflow/src/precomp.hpp

@@ -46,7 +46,7 @@
 #include <limits>
 
 #include "opencv2/gpuoptflow.hpp"
-#include "opencv2/gpuarithm.hpp"
+#include "opencv2/cudaarithm.hpp"
 #include "opencv2/gpuwarping.hpp"
 #include "opencv2/gpuimgproc.hpp"
 #include "opencv2/video.hpp"

modules/nonfree/CMakeLists.txt

@@ -4,4 +4,4 @@ endif()
 
 set(the_description "Functionality with possible limitations on the use")
 ocv_warnings_disable(CMAKE_CXX_FLAGS -Wundef)
-ocv_define_module(nonfree opencv_imgproc opencv_features2d opencv_calib3d OPTIONAL opencv_gpuarithm opencv_ocl)
+ocv_define_module(nonfree opencv_imgproc opencv_features2d opencv_calib3d OPTIONAL opencv_cudaarithm opencv_ocl)

modules/nonfree/perf/perf_gpu.cpp

@@ -53,7 +53,7 @@ using namespace perf;
 //////////////////////////////////////////////////////////////////////
 // SURF
 
-#ifdef HAVE_OPENCV_GPUARITHM
+#ifdef HAVE_OPENCV_CUDAARITHM
 
 DEF_PARAM_TEST_1(Image, string);
 
@@ -98,6 +98,6 @@ PERF_TEST_P(Image, GPU_SURF,
     }
 }
 
-#endif // HAVE_OPENCV_GPUARITHM
+#endif // HAVE_OPENCV_CUDAARITHM
 
 #endif // HAVE_CUDA

modules/nonfree/src/cuda/surf.cu

@@ -42,7 +42,7 @@
 
 #include "opencv2/opencv_modules.hpp"
 
-#ifdef HAVE_OPENCV_GPUARITHM
+#ifdef HAVE_OPENCV_CUDAARITHM
 
 #include "opencv2/core/cuda/common.hpp"
 #include "opencv2/core/cuda/limits.hpp"
@@ -957,4 +957,4 @@ namespace cv { namespace cuda { namespace device
     } // namespace surf
 }}} // namespace cv { namespace cuda { namespace cudev
 
-#endif // HAVE_OPENCV_GPUARITHM
+#endif // HAVE_OPENCV_CUDAARITHM

modules/nonfree/src/precomp.hpp

@@ -54,8 +54,8 @@
 
 #include "opencv2/opencv_modules.hpp"
 
-#ifdef HAVE_OPENCV_GPUARITHM
-#  include "opencv2/gpuarithm.hpp"
+#ifdef HAVE_OPENCV_CUDAARITHM
+#  include "opencv2/cudaarithm.hpp"
 #endif
 
 #ifdef HAVE_OPENCV_OCL

modules/nonfree/src/surf_gpu.cpp

@@ -45,7 +45,7 @@
 using namespace cv;
 using namespace cv::cuda;
 
-#if !defined (HAVE_CUDA) || !defined (HAVE_OPENCV_GPUARITHM)
+#if !defined (HAVE_CUDA) || !defined (HAVE_OPENCV_CUDAARITHM)
 
 cv::cuda::SURF_GPU::SURF_GPU() { throw_no_cuda(); }
 cv::cuda::SURF_GPU::SURF_GPU(double, int, int, bool, float, bool) { throw_no_cuda(); }

modules/nonfree/test/test_gpu.cpp

@@ -49,7 +49,7 @@ using namespace cvtest;
 /////////////////////////////////////////////////////////////////////////////////////////////////
 // SURF
 
-#ifdef HAVE_OPENCV_GPUARITHM
+#ifdef HAVE_OPENCV_CUDAARITHM
 
 namespace
 {
@@ -193,6 +193,6 @@ INSTANTIATE_TEST_CASE_P(GPU_Features2D, SURF, testing::Combine(
     testing::Values(SURF_Extended(false), SURF_Extended(true)),
     testing::Values(SURF_Upright(false), SURF_Upright(true))));
 
-#endif // HAVE_OPENCV_GPUARITHM
+#endif // HAVE_OPENCV_CUDAARITHM
 
 #endif // HAVE_CUDA

modules/photo/CMakeLists.txt

@@ -4,4 +4,4 @@ if(HAVE_CUDA)
   ocv_warnings_disable(CMAKE_CXX_FLAGS -Wundef -Wmissing-declarations)
 endif()
 
-ocv_define_module(photo opencv_imgproc OPTIONAL opencv_gpuarithm opencv_gpuimgproc)
+ocv_define_module(photo opencv_imgproc OPTIONAL opencv_cudaarithm opencv_gpuimgproc)

modules/photo/perf/perf_gpu.cpp

@@ -47,7 +47,7 @@
 
 #include "opencv2/opencv_modules.hpp"
 
-#if defined (HAVE_CUDA) && defined(HAVE_OPENCV_GPUARITHM) && defined(HAVE_OPENCV_GPUIMGPROC)
+#if defined (HAVE_CUDA) && defined(HAVE_OPENCV_CUDAARITHM) && defined(HAVE_OPENCV_GPUIMGPROC)
 
 using namespace std;
 using namespace testing;

modules/photo/src/denoising_gpu.cpp

@@ -47,8 +47,8 @@
 
 #include "opencv2/opencv_modules.hpp"
 
-#ifdef HAVE_OPENCV_GPUARITHM
-#  include "opencv2/gpuarithm.hpp"
+#ifdef HAVE_OPENCV_CUDAARITHM
+#  include "opencv2/cudaarithm.hpp"
 #endif
 
 #ifdef HAVE_OPENCV_GPUIMGPROC
@@ -58,7 +58,7 @@
 using namespace cv;
 using namespace cv::cuda;
 
-#if !defined (HAVE_CUDA) || !defined(HAVE_OPENCV_GPUARITHM) || !defined(HAVE_OPENCV_GPUIMGPROC)
+#if !defined (HAVE_CUDA) || !defined(HAVE_OPENCV_CUDAARITHM) || !defined(HAVE_OPENCV_GPUIMGPROC)
 
 void cv::cuda::nonLocalMeans(const GpuMat&, GpuMat&, float, int, int, int, Stream&) { throw_no_cuda(); }
 void cv::cuda::FastNonLocalMeansDenoising::simpleMethod(const GpuMat&, GpuMat&, float, int, int, Stream&) { throw_no_cuda(); }

modules/photo/test/test_denoising_gpu.cpp

@@ -48,7 +48,7 @@
 #include "opencv2/opencv_modules.hpp"
 #include "cvconfig.h"
 
-#if defined (HAVE_CUDA) && defined(HAVE_OPENCV_GPUARITHM) && defined(HAVE_OPENCV_GPUIMGPROC)
+#if defined (HAVE_CUDA) && defined(HAVE_OPENCV_CUDAARITHM) && defined(HAVE_OPENCV_GPUIMGPROC)
 
 using namespace cvtest;
 

modules/stitching/CMakeLists.txt

 set(the_description "Images stitching")
 ocv_define_module(stitching opencv_imgproc opencv_features2d opencv_calib3d opencv_objdetect
-                  OPTIONAL opencv_gpu opencv_gpuarithm opencv_gpufilters opencv_gpufeatures2d opencv_nonfree)
+                  OPTIONAL opencv_gpu opencv_cudaarithm opencv_gpufilters opencv_gpufeatures2d opencv_nonfree)

modules/stitching/src/blenders.cpp

@@ -188,7 +188,7 @@ MultiBandBlender::MultiBandBlender(int try_gpu, int num_bands, int weight_type)
 {
     setNumBands(num_bands);
 
-#if defined(HAVE_OPENCV_GPUARITHM) && defined(HAVE_OPENCV_GPUWARPING)
+#if defined(HAVE_OPENCV_CUDAARITHM) && defined(HAVE_OPENCV_GPUWARPING)
     can_use_gpu_ = try_gpu && cuda::getCudaEnabledDeviceCount();
 #else
     (void) try_gpu;
@@ -491,7 +491,7 @@ void createLaplacePyr(const Mat &img, int num_levels, std::vector<Mat> &pyr)
 
 void createLaplacePyrGpu(const Mat &img, int num_levels, std::vector<Mat> &pyr)
 {
-#if defined(HAVE_OPENCV_GPUARITHM) && defined(HAVE_OPENCV_GPUWARPING)
+#if defined(HAVE_OPENCV_CUDAARITHM) && defined(HAVE_OPENCV_GPUWARPING)
     pyr.resize(num_levels + 1);
 
     std::vector<cuda::GpuMat> gpu_pyr(num_levels + 1);
@@ -531,7 +531,7 @@ void restoreImageFromLaplacePyr(std::vector<Mat> &pyr)
 
 void restoreImageFromLaplacePyrGpu(std::vector<Mat> &pyr)
 {
-#if defined(HAVE_OPENCV_GPUARITHM) && defined(HAVE_OPENCV_GPUWARPING)
+#if defined(HAVE_OPENCV_CUDAARITHM) && defined(HAVE_OPENCV_GPUWARPING)
     if (pyr.empty())
         return;
 

modules/stitching/src/precomp.hpp

@@ -68,8 +68,8 @@
 #include "opencv2/features2d.hpp"
 #include "opencv2/calib3d.hpp"
 
-#ifdef HAVE_OPENCV_GPUARITHM
-#  include "opencv2/gpuarithm.hpp"
+#ifdef HAVE_OPENCV_CUDAARITHM
+#  include "opencv2/cudaarithm.hpp"
 #endif
 
 #ifdef HAVE_OPENCV_GPUWARPING

modules/superres/CMakeLists.txt

@@ -6,4 +6,4 @@ set(the_description "Super Resolution")
 ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4127 -Wundef)
 ocv_define_module(superres opencv_imgproc opencv_video
                   OPTIONAL opencv_highgui opencv_ocl
-                  opencv_gpuarithm opencv_gpufilters opencv_gpuwarping opencv_gpuimgproc opencv_gpuoptflow opencv_cudacodec)
+                  opencv_cudaarithm opencv_gpufilters opencv_gpuwarping opencv_gpuimgproc opencv_gpuoptflow opencv_cudacodec)

modules/superres/src/btv_l1_gpu.cpp

@@ -50,7 +50,7 @@ using namespace cv::cuda;
 using namespace cv::superres;
 using namespace cv::superres::detail;
 
-#if !defined(HAVE_CUDA) || !defined(HAVE_OPENCV_GPUARITHM) || !defined(HAVE_OPENCV_GPUWARPING) || !defined(HAVE_OPENCV_GPUFILTERS)
+#if !defined(HAVE_CUDA) || !defined(HAVE_OPENCV_CUDAARITHM) || !defined(HAVE_OPENCV_GPUWARPING) || !defined(HAVE_OPENCV_GPUFILTERS)
 
 Ptr<SuperResolution> cv::superres::createSuperResolution_BTVL1_GPU()
 {

modules/superres/src/cuda/btv_l1_gpu.cu

@@ -42,7 +42,7 @@
 
 #include "opencv2/opencv_modules.hpp"
 
-#if defined(HAVE_OPENCV_GPUARITHM) && defined(HAVE_OPENCV_GPUWARPING) && defined(HAVE_OPENCV_GPUFILTERS)
+#if defined(HAVE_OPENCV_CUDAARITHM) && defined(HAVE_OPENCV_GPUWARPING) && defined(HAVE_OPENCV_GPUFILTERS)
 
 #include "opencv2/core/cuda/common.hpp"
 #include "opencv2/core/cuda/transform.hpp"

modules/superres/src/precomp.hpp

@@ -57,8 +57,8 @@
 
 #include "opencv2/core/private.cuda.hpp"
 
-#ifdef HAVE_OPENCV_GPUARITHM
-#  include "opencv2/gpuarithm.hpp"
+#ifdef HAVE_OPENCV_CUDAARITHM
+#  include "opencv2/cudaarithm.hpp"
 #endif
 
 #ifdef HAVE_OPENCV_GPUWARPING

modules/superres/test/test_superres.cpp

@@ -268,7 +268,7 @@ TEST_F(SuperResolution, BTVL1)
     RunTest(cv::superres::createSuperResolution_BTVL1());
 }
 
-#if defined(HAVE_CUDA) && defined(HAVE_OPENCV_GPUARITHM) && defined(HAVE_OPENCV_GPUWARPING) && defined(HAVE_OPENCV_GPUFILTERS)
+#if defined(HAVE_CUDA) && defined(HAVE_OPENCV_CUDAARITHM) && defined(HAVE_OPENCV_GPUWARPING) && defined(HAVE_OPENCV_GPUFILTERS)
 
 TEST_F(SuperResolution, BTVL1_GPU)
 {

samples/cpp/CMakeLists.txt

@@ -22,8 +22,8 @@ if(BUILD_EXAMPLES AND OCV_DEPENDENCIES_FOUND)
   if(HAVE_opencv_gpuimgproc)
     ocv_include_directories("${OpenCV_SOURCE_DIR}/modules/gpuimgproc/include")
   endif()
-  if(HAVE_opencv_gpuarithm)
-    ocv_include_directories("${OpenCV_SOURCE_DIR}/modules/gpuarithm/include")
+  if(HAVE_opencv_cudaarithm)
+    ocv_include_directories("${OpenCV_SOURCE_DIR}/modules/cudaarithm/include")
   endif()
   if(HAVE_opencv_gpufilters)
     ocv_include_directories("${OpenCV_SOURCE_DIR}/modules/gpufilters/include")
@@ -53,7 +53,7 @@ if(BUILD_EXAMPLES AND OCV_DEPENDENCIES_FOUND)
     target_link_libraries(${the_target} ${OPENCV_LINKER_LIBS} ${OPENCV_CPP_SAMPLES_REQUIRED_DEPS})
 
     if("${srcs}" MATCHES "gpu/")
-      target_link_libraries(${the_target} opencv_gpuarithm opencv_gpufilters)
+      target_link_libraries(${the_target} opencv_cudaarithm opencv_gpufilters)
     endif()
 
     set_target_properties(${the_target} PROPERTIES
@@ -79,7 +79,7 @@ if(BUILD_EXAMPLES AND OCV_DEPENDENCIES_FOUND)
     ocv_list_filterout(cpp_samples Qt_sample)
   endif()
 
-  if(NOT HAVE_opencv_gpuarithm OR NOT HAVE_opencv_gpufilters)
+  if(NOT HAVE_opencv_cudaarithm OR NOT HAVE_opencv_gpufilters)
     ocv_list_filterout(cpp_samples "/gpu/")
   endif()
 

samples/cpp/tutorial_code/gpu/gpu-basics-similarity/gpu-basics-similarity.cpp

@@ -7,7 +7,7 @@
 #include <opencv2/highgui.hpp>// Read images
 
 // GPU structures and methods
-#include <opencv2/gpuarithm.hpp>
+#include <opencv2/cudaarithm.hpp>
 #include <opencv2/gpufilters.hpp>
 
 using namespace std;

samples/gpu/CMakeLists.txt

@@ -2,7 +2,7 @@ SET(OPENCV_GPU_SAMPLES_REQUIRED_DEPS opencv_core opencv_flann opencv_imgproc ope
                                      opencv_ml opencv_video opencv_objdetect opencv_features2d
                                      opencv_calib3d opencv_legacy opencv_contrib opencv_gpu
                                      opencv_nonfree opencv_softcascade opencv_superres
-                                     opencv_gpuarithm opencv_gpufilters opencv_gpuwarping opencv_gpuimgproc
+                                     opencv_cudaarithm opencv_gpufilters opencv_gpuwarping opencv_gpuimgproc
                                      opencv_gpufeatures2d opencv_gpuoptflow opencv_gpubgsegm
                                      opencv_gpustereo opencv_cudalegacy)
 

samples/gpu/brox_optical_flow.cpp

@@ -8,7 +8,7 @@
 #include "opencv2/highgui.hpp"
 #include "opencv2/imgproc.hpp"
 #include "opencv2/gpuoptflow.hpp"
-#include "opencv2/gpuarithm.hpp"
+#include "opencv2/cudaarithm.hpp"
 
 using namespace std;
 using namespace cv;

samples/gpu/driver_api_multi.cpp

@@ -9,7 +9,7 @@
 #include <iostream>
 #include "cvconfig.h"
 #include "opencv2/core/core.hpp"
-#include "opencv2/gpuarithm.hpp"
+#include "opencv2/cudaarithm.hpp"
 
 #ifdef HAVE_TBB
 #  include "tbb/tbb_stddef.h"

samples/gpu/multi.cpp

@@ -9,7 +9,7 @@
 #include <iostream>
 #include "cvconfig.h"
 #include "opencv2/core/core.hpp"
-#include "opencv2/gpuarithm.hpp"
+#include "opencv2/cudaarithm.hpp"
 
 #ifdef HAVE_TBB
 #  include "tbb/tbb_stddef.h"