renamed gpuarithm -> cudaarithm

11 years ago · dcd600cc47
parent 6d216d78d9
commit dcd600cc47
101 changed files with 72 additions and 72 deletions
--- a/modules/cudaarithm/CMakeLists.txt
+++ b/modules/cudaarithm/CMakeLists.txt
@ -1,12 +1,12 @@
 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()
--- a/modules/cudaarithm/doc/arithm.rst
+++ b/modules/cudaarithm/doc/arithm.rst
--- a/modules/cudaarithm/doc/core.rst
+++ b/modules/cudaarithm/doc/core.rst
--- a/modules/cudaarithm/doc/cudaarithm.rst
+++ b/modules/cudaarithm/doc/cudaarithm.rst
--- a/modules/cudaarithm/doc/element_operations.rst
+++ b/modules/cudaarithm/doc/element_operations.rst
--- a/modules/cudaarithm/doc/reductions.rst
+++ b/modules/cudaarithm/doc/reductions.rst
--- a/modules/cudaarithm/include/opencv2/cudaarithm.hpp
+++ b/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__ */
--- a/modules/cudaarithm/perf/perf_arithm.cpp
+++ b/modules/cudaarithm/perf/perf_arithm.cpp
--- a/modules/cudaarithm/perf/perf_core.cpp
+++ b/modules/cudaarithm/perf/perf_core.cpp
--- a/modules/cudaarithm/perf/perf_element_operations.cpp
+++ b/modules/cudaarithm/perf/perf_element_operations.cpp
--- a/modules/cudaarithm/perf/perf_main.cpp
+++ b/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)
--- a/modules/cudaarithm/perf/perf_precomp.cpp
+++ b/modules/cudaarithm/perf/perf_precomp.cpp
--- a/modules/cudaarithm/perf/perf_precomp.hpp
+++ b/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"

--- a/modules/cudaarithm/perf/perf_reductions.cpp
+++ b/modules/cudaarithm/perf/perf_reductions.cpp
--- a/modules/cudaarithm/src/arithm.cpp
+++ b/modules/cudaarithm/src/arithm.cpp
--- a/modules/cudaarithm/src/core.cpp
+++ b/modules/cudaarithm/src/core.cpp
--- a/modules/cudaarithm/src/cuda/absdiff_mat.cu
+++ b/modules/cudaarithm/src/cuda/absdiff_mat.cu
--- a/modules/cudaarithm/src/cuda/absdiff_scalar.cu
+++ b/modules/cudaarithm/src/cuda/absdiff_scalar.cu
--- a/modules/cudaarithm/src/cuda/add_mat.cu
+++ b/modules/cudaarithm/src/cuda/add_mat.cu
--- a/modules/cudaarithm/src/cuda/add_scalar.cu
+++ b/modules/cudaarithm/src/cuda/add_scalar.cu
--- a/modules/cudaarithm/src/cuda/add_weighted.cu
+++ b/modules/cudaarithm/src/cuda/add_weighted.cu
--- a/modules/cudaarithm/src/cuda/arithm_func_traits.hpp
+++ b/modules/cudaarithm/src/cuda/arithm_func_traits.hpp
--- a/modules/cudaarithm/src/cuda/bitwise_mat.cu
+++ b/modules/cudaarithm/src/cuda/bitwise_mat.cu
--- a/modules/cudaarithm/src/cuda/bitwise_scalar.cu
+++ b/modules/cudaarithm/src/cuda/bitwise_scalar.cu
--- a/modules/cudaarithm/src/cuda/cmp_mat.cu
+++ b/modules/cudaarithm/src/cuda/cmp_mat.cu
--- a/modules/cudaarithm/src/cuda/cmp_scalar.cu
+++ b/modules/cudaarithm/src/cuda/cmp_scalar.cu
--- a/modules/cudaarithm/src/cuda/copy_make_border.cu
+++ b/modules/cudaarithm/src/cuda/copy_make_border.cu
--- a/modules/cudaarithm/src/cuda/countnonzero.cu
+++ b/modules/cudaarithm/src/cuda/countnonzero.cu
--- a/modules/cudaarithm/src/cuda/div_mat.cu
+++ b/modules/cudaarithm/src/cuda/div_mat.cu
--- a/modules/cudaarithm/src/cuda/div_scalar.cu
+++ b/modules/cudaarithm/src/cuda/div_scalar.cu
--- a/modules/cudaarithm/src/cuda/integral.cu
+++ b/modules/cudaarithm/src/cuda/integral.cu
--- a/modules/cudaarithm/src/cuda/math.cu
+++ b/modules/cudaarithm/src/cuda/math.cu
--- a/modules/cudaarithm/src/cuda/minmax.cu
+++ b/modules/cudaarithm/src/cuda/minmax.cu
--- a/modules/cudaarithm/src/cuda/minmax_mat.cu
+++ b/modules/cudaarithm/src/cuda/minmax_mat.cu
--- a/modules/cudaarithm/src/cuda/minmaxloc.cu
+++ b/modules/cudaarithm/src/cuda/minmaxloc.cu
--- a/modules/cudaarithm/src/cuda/mul_mat.cu
+++ b/modules/cudaarithm/src/cuda/mul_mat.cu
--- a/modules/cudaarithm/src/cuda/mul_scalar.cu
+++ b/modules/cudaarithm/src/cuda/mul_scalar.cu
--- a/modules/cudaarithm/src/cuda/mul_spectrums.cu
+++ b/modules/cudaarithm/src/cuda/mul_spectrums.cu
--- a/modules/cudaarithm/src/cuda/polar_cart.cu
+++ b/modules/cudaarithm/src/cuda/polar_cart.cu
--- a/modules/cudaarithm/src/cuda/reduce.cu
+++ b/modules/cudaarithm/src/cuda/reduce.cu
--- a/modules/cudaarithm/src/cuda/split_merge.cu
+++ b/modules/cudaarithm/src/cuda/split_merge.cu
--- a/modules/cudaarithm/src/cuda/sub_mat.cu
+++ b/modules/cudaarithm/src/cuda/sub_mat.cu
--- a/modules/cudaarithm/src/cuda/sub_scalar.cu
+++ b/modules/cudaarithm/src/cuda/sub_scalar.cu
--- a/modules/cudaarithm/src/cuda/sum.cu
+++ b/modules/cudaarithm/src/cuda/sum.cu
--- a/modules/cudaarithm/src/cuda/threshold.cu
+++ b/modules/cudaarithm/src/cuda/threshold.cu
--- a/modules/cudaarithm/src/cuda/transpose.cu
+++ b/modules/cudaarithm/src/cuda/transpose.cu
--- a/modules/cudaarithm/src/cuda/unroll_detail.hpp
+++ b/modules/cudaarithm/src/cuda/unroll_detail.hpp
--- a/modules/cudaarithm/src/element_operations.cpp
+++ b/modules/cudaarithm/src/element_operations.cpp
--- a/modules/cudaarithm/src/precomp.cpp
+++ b/modules/cudaarithm/src/precomp.cpp
--- a/modules/cudaarithm/src/precomp.hpp
+++ b/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"
--- a/modules/cudaarithm/src/reductions.cpp
+++ b/modules/cudaarithm/src/reductions.cpp
--- a/modules/cudaarithm/test/test_arithm.cpp
+++ b/modules/cudaarithm/test/test_arithm.cpp
--- a/modules/cudaarithm/test/test_core.cpp
+++ b/modules/cudaarithm/test/test_core.cpp
--- a/modules/cudaarithm/test/test_element_operations.cpp
+++ b/modules/cudaarithm/test/test_element_operations.cpp
--- a/modules/cudaarithm/test/test_main.cpp
+++ b/modules/cudaarithm/test/test_main.cpp
--- a/modules/cudaarithm/test/test_precomp.cpp
+++ b/modules/cudaarithm/test/test_precomp.cpp
--- a/modules/cudaarithm/test/test_precomp.hpp
+++ b/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"

--- a/modules/cudaarithm/test/test_reductions.cpp
+++ b/modules/cudaarithm/test/test_reductions.cpp
--- a/modules/gpu/CMakeLists.txt
+++ b/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)
--- a/modules/gpu/src/precomp.hpp
+++ b/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"
--- a/modules/gpubgsegm/CMakeLists.txt
+++ b/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)
--- a/modules/gpubgsegm/src/fgd.cpp
+++ b/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(); }

--- a/modules/gpubgsegm/src/gmg.cpp
+++ b/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
--- a/modules/gpubgsegm/src/precomp.hpp
+++ b/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
--- a/modules/gpufeatures2d/src/precomp.hpp
+++ b/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"

--- a/modules/gpufilters/CMakeLists.txt
+++ b/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)
--- a/modules/gpufilters/src/precomp.hpp
+++ b/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"
--- a/modules/gpuimgproc/CMakeLists.txt
+++ b/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)
--- a/modules/gpuimgproc/src/cuda/generalized_hough.cu
+++ b/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 */
--- a/modules/gpuimgproc/src/generalized_hough.cpp
+++ b/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>(); }

--- a/modules/gpuimgproc/src/gftt.cpp
+++ b/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>(); }

--- a/modules/gpuimgproc/src/histogram.cpp
+++ b/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);
--- a/modules/gpuimgproc/src/match_template.cpp
+++ b/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>(); }

--- a/modules/gpuimgproc/src/precomp.hpp
+++ b/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
--- a/modules/gpuoptflow/CMakeLists.txt
+++ b/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)
--- a/modules/gpuoptflow/src/precomp.hpp
+++ b/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"
--- a/modules/nonfree/CMakeLists.txt
+++ b/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)
--- a/modules/nonfree/perf/perf_gpu.cpp
+++ b/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
--- a/modules/nonfree/src/cuda/surf.cu
+++ b/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
--- a/modules/nonfree/src/precomp.hpp
+++ b/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
--- a/modules/nonfree/src/surf_gpu.cpp
+++ b/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(); }
--- a/modules/nonfree/test/test_gpu.cpp
+++ b/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
--- a/modules/photo/CMakeLists.txt
+++ b/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)
--- a/modules/photo/perf/perf_gpu.cpp
+++ b/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;
--- a/modules/photo/src/denoising_gpu.cpp
+++ b/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(); }
--- a/modules/photo/test/test_denoising_gpu.cpp
+++ b/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;

--- a/modules/stitching/CMakeLists.txt
+++ b/modules/stitching/CMakeLists.txt
@ -1,3 +1,3 @@
 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)
--- a/modules/stitching/src/blenders.cpp
+++ b/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;

--- a/modules/stitching/src/precomp.hpp
+++ b/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
--- a/modules/superres/CMakeLists.txt
+++ b/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)
--- a/modules/superres/src/btv_l1_gpu.cpp
+++ b/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()
 {
--- a/modules/superres/src/cuda/btv_l1_gpu.cu
+++ b/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"
--- a/modules/superres/src/precomp.hpp
+++ b/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
--- a/modules/superres/test/test_superres.cpp
+++ b/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)
 {
--- a/samples/cpp/CMakeLists.txt
+++ b/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()

--- a/samples/cpp/tutorial_code/gpu/gpu-basics-similarity/gpu-basics-similarity.cpp
+++ b/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;
--- a/samples/gpu/CMakeLists.txt
+++ b/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)

--- a/samples/gpu/brox_optical_flow.cpp
+++ b/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;
--- a/samples/gpu/driver_api_multi.cpp
+++ b/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"
--- a/samples/gpu/multi.cpp
+++ b/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"
--- a/Show More
+++ b/Show More