renamed gpufilters -> cudafilters

modules/cudafilters/CMakeLists.txt

@@ -0,0 +1,9 @@
+if(ANDROID OR IOS)
+  ocv_module_disable(cudafilters)
+endif()
+
+set(the_description "CUDA-accelerated Image Filtering")
+
+ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4127 /wd4324 /wd4512 -Wundef -Wmissing-declarations)
+
+ocv_define_module(cudafilters opencv_imgproc opencv_cudaarithm)

modules/cudafilters/include/opencv2/cudafilters.hpp

@@ -40,11 +40,11 @@
 //
 //M*/
 
-#ifndef __OPENCV_GPUFILTERS_HPP__
-#define __OPENCV_GPUFILTERS_HPP__
+#ifndef __OPENCV_CUDAFILTERS_HPP__
+#define __OPENCV_CUDAFILTERS_HPP__
 
 #ifndef __cplusplus
-#  error gpufilters.hpp header must be compiled as C++
+#  error cudafilters.hpp header must be compiled as C++
 #endif
 
 #include "opencv2/core/cuda.hpp"
@@ -146,4 +146,4 @@ CV_EXPORTS Ptr<Filter> createColumnSumFilter(int srcType, int dstType, int ksize
 
 }} // namespace cv { namespace cuda {
 
-#endif /* __OPENCV_GPUFILTERS_HPP__ */
+#endif /* __OPENCV_CUDAFILTERS_HPP__ */

modules/cudafilters/perf/perf_main.cpp

@@ -44,4 +44,4 @@
 
 using namespace perf;
 
-CV_PERF_TEST_CUDA_MAIN(gpufilters)
+CV_PERF_TEST_CUDA_MAIN(cudafilters)

modules/cudafilters/perf/perf_precomp.hpp

@@ -54,7 +54,7 @@
 #include "opencv2/ts.hpp"
 #include "opencv2/ts/gpu_perf.hpp"
 
-#include "opencv2/gpufilters.hpp"
+#include "opencv2/cudafilters.hpp"
 #include "opencv2/imgproc.hpp"
 
 #ifdef GTEST_CREATE_SHARED_LIBRARY

modules/cudafilters/src/precomp.hpp

@@ -45,7 +45,7 @@
 
 #include <limits>
 
-#include "opencv2/gpufilters.hpp"
+#include "opencv2/cudafilters.hpp"
 #include "opencv2/cudaarithm.hpp"
 #include "opencv2/imgproc.hpp"
 

modules/cudafilters/test/test_precomp.hpp

@@ -54,7 +54,7 @@
 #include "opencv2/ts.hpp"
 #include "opencv2/ts/gpu_test.hpp"
 
-#include "opencv2/gpufilters.hpp"
+#include "opencv2/cudafilters.hpp"
 #include "opencv2/imgproc.hpp"
 
 #include "cvconfig.h"

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_cudaarithm opencv_gpufilters opencv_gpuimgproc)
+ocv_define_module(gpubgsegm opencv_video OPTIONAL opencv_legacy opencv_imgproc opencv_cudaarithm opencv_cudafilters opencv_gpuimgproc)

modules/gpubgsegm/src/fgd.cpp

@@ -309,7 +309,7 @@ namespace
 /////////////////////////////////////////////////////////////////////////
 // smoothForeground
 
-#ifdef HAVE_OPENCV_GPUFILTERS
+#ifdef HAVE_OPENCV_CUDAFILTERS
 
 namespace
 {
@@ -610,7 +610,7 @@ namespace
         GpuMat buf_;
         GpuMat filterBrd_;
 
-#ifdef HAVE_OPENCV_GPUFILTERS
+#ifdef HAVE_OPENCV_CUDAFILTERS
         Ptr<cuda::Filter> dilateFilter_;
         Ptr<cuda::Filter> erodeFilter_;
 #endif
@@ -651,7 +651,7 @@ namespace
 
         int FG_pixels_count = bgfgClassification(prevFrame_, curFrame, Ftd_, Fbd_, foreground_, countBuf_, params_, 4);
 
-#ifdef HAVE_OPENCV_GPUFILTERS
+#ifdef HAVE_OPENCV_CUDAFILTERS
         if (params_.perform_morphing > 0)
             smoothForeground(foreground_, filterBrd_, buf_, erodeFilter_, dilateFilter_, params_);
 #endif
@@ -710,7 +710,7 @@ namespace
         stat_.create(firstFrame.size(), params_);
         fgd::setBGPixelStat(stat_);
 
-#ifdef HAVE_OPENCV_GPUFILTERS
+#ifdef HAVE_OPENCV_CUDAFILTERS
         if (params_.perform_morphing > 0)
         {
             Mat kernel = getStructuringElement(MORPH_RECT, Size(1 + params_.perform_morphing * 2, 1 + params_.perform_morphing * 2));

modules/gpubgsegm/src/gmg.cpp

@@ -141,7 +141,7 @@ namespace
         GpuMat colors_;
         GpuMat weights_;
 
-#if defined(HAVE_OPENCV_GPUFILTERS) && defined(HAVE_OPENCV_CUDAARITHM)
+#if defined(HAVE_OPENCV_CUDAFILTERS) && 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_CUDAARITHM)
+#if defined(HAVE_OPENCV_CUDAFILTERS) && 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_CUDAARITHM)
+#if defined(HAVE_OPENCV_CUDAFILTERS) && defined(HAVE_OPENCV_CUDAARITHM)
         if (smoothingRadius_ > 0)
             boxFilter_ = cuda::createBoxFilter(CV_8UC1, -1, Size(smoothingRadius_, smoothingRadius_));
 #endif

modules/gpubgsegm/src/precomp.hpp

@@ -55,8 +55,8 @@
 #  include "opencv2/cudaarithm.hpp"
 #endif
 
-#ifdef HAVE_OPENCV_GPUFILTERS
-#  include "opencv2/gpufilters.hpp"
+#ifdef HAVE_OPENCV_CUDAFILTERS
+#  include "opencv2/cudafilters.hpp"
 #endif
 
 #ifdef HAVE_OPENCV_GPUIMGPROC

modules/gpufeatures2d/CMakeLists.txt

@@ -6,4 +6,4 @@ set(the_description "GPU-accelerated Feature Detection and Description")
 
 ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4127 /wd4100 /wd4324 /wd4512 /wd4515 -Wundef -Wmissing-declarations -Wshadow -Wunused-parameter)
 
-ocv_define_module(gpufeatures2d opencv_features2d opencv_gpufilters opencv_cudawarping)
+ocv_define_module(gpufeatures2d opencv_features2d opencv_cudafilters opencv_cudawarping)

modules/gpufeatures2d/include/opencv2/gpufeatures2d.hpp

@@ -48,7 +48,7 @@
 #endif
 
 #include "opencv2/core/cuda.hpp"
-#include "opencv2/gpufilters.hpp"
+#include "opencv2/cudafilters.hpp"
 
 namespace cv { namespace cuda {
 

modules/gpufilters/CMakeLists.txt

@@ -1,9 +0,0 @@
-if(ANDROID OR IOS)
-  ocv_module_disable(gpufilters)
-endif()
-
-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_cudaarithm)

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_cudaarithm opencv_gpufilters)
+ocv_define_module(gpuimgproc opencv_imgproc OPTIONAL opencv_cudaarithm opencv_cudafilters)

modules/gpuimgproc/src/canny.cpp

@@ -122,7 +122,7 @@ namespace
         GpuMat mag_;
         GpuMat map_;
         GpuMat st1_, st2_;
-#ifdef HAVE_OPENCV_GPUFILTERS
+#ifdef HAVE_OPENCV_CUDAFILTERS
         Ptr<Filter> filterDX_, filterDY_;
 #endif
         int old_apperture_size_;
@@ -154,7 +154,7 @@ namespace
         }
         else
         {
-#ifndef HAVE_OPENCV_GPUFILTERS
+#ifndef HAVE_OPENCV_CUDAFILTERS
             throw_no_cuda();
 #else
             filterDX_->apply(image, dx_);
@@ -197,7 +197,7 @@ namespace
         ensureSizeIsEnough(image_size, CV_32SC1, dx_);
         ensureSizeIsEnough(image_size, CV_32SC1, dy_);
 
-#ifdef HAVE_OPENCV_GPUFILTERS
+#ifdef HAVE_OPENCV_CUDAFILTERS
         if (apperture_size_ != 3 && apperture_size_ != old_apperture_size_)
         {
             filterDX_ = cuda::createDerivFilter(CV_8UC1, CV_32S, 1, 0, apperture_size_, false, 1, BORDER_REPLICATE);

modules/gpuimgproc/src/corners.cpp

@@ -45,7 +45,7 @@
 using namespace cv;
 using namespace cv::cuda;
 
-#if !defined (HAVE_CUDA) || defined (CUDA_DISABLER) || !defined(HAVE_OPENCV_GPUFILTERS)
+#if !defined (HAVE_CUDA) || defined (CUDA_DISABLER) || !defined(HAVE_OPENCV_CUDAFILTERS)
 
 Ptr<cuda::CornernessCriteria> cv::cuda::createHarrisCorner(int, int, int, double, int) { throw_no_cuda(); return Ptr<cuda::CornernessCriteria>(); }
 Ptr<cuda::CornernessCriteria> cv::cuda::createMinEigenValCorner(int, int, int, int) { throw_no_cuda(); return Ptr<cuda::CornernessCriteria>(); }

modules/gpuimgproc/src/cuda/corners.cu

@@ -50,7 +50,7 @@
 
 #include "opencv2/opencv_modules.hpp"
 
-#ifdef HAVE_OPENCV_GPUFILTERS
+#ifdef HAVE_OPENCV_CUDAFILTERS
 
 namespace cv { namespace cuda { namespace device
 {
@@ -275,6 +275,6 @@ namespace cv { namespace cuda { namespace device
     }
 }}}
 
-#endif // HAVE_OPENCV_GPUFILTERS
+#endif // HAVE_OPENCV_CUDAFILTERS
 
 #endif // CUDA_DISABLER

modules/gpuimgproc/src/cuda/hough_circles.cu

@@ -48,7 +48,7 @@
 
 #include "opencv2/opencv_modules.hpp"
 
-#ifdef HAVE_OPENCV_GPUFILTERS
+#ifdef HAVE_OPENCV_CUDAFILTERS
 
 namespace cv { namespace cuda { namespace device
 {
@@ -255,6 +255,6 @@ namespace cv { namespace cuda { namespace device
     }
 }}}
 
-#endif // HAVE_OPENCV_GPUFILTERS
+#endif // HAVE_OPENCV_CUDAFILTERS
 
 #endif /* CUDA_DISABLER */

modules/gpuimgproc/src/generalized_hough.cpp

@@ -140,14 +140,14 @@ namespace
         int posCount_;
 
     private:
-#ifdef HAVE_OPENCV_GPUFILTERS
+#ifdef HAVE_OPENCV_CUDAFILTERS
         void calcEdges(InputArray src, GpuMat& edges, GpuMat& dx, GpuMat& dy);
 #endif
 
         void filterMinDist();
         void convertTo(OutputArray positions, OutputArray votes);
 
-#ifdef HAVE_OPENCV_GPUFILTERS
+#ifdef HAVE_OPENCV_CUDAFILTERS
         Ptr<cuda::CannyEdgeDetector> canny_;
         Ptr<cuda::Filter> filterDx_;
         Ptr<cuda::Filter> filterDy_;
@@ -169,14 +169,14 @@ namespace
 
         maxBufferSize_ = 10000;
 
-#ifdef HAVE_OPENCV_GPUFILTERS
+#ifdef HAVE_OPENCV_CUDAFILTERS
         canny_ = cuda::createCannyEdgeDetector(cannyLowThresh_, cannyHighThresh_);
         filterDx_ = cuda::createSobelFilter(CV_8UC1, CV_32S, 1, 0);
         filterDy_ = cuda::createSobelFilter(CV_8UC1, CV_32S, 0, 1);
 #endif
     }
 
-#ifdef HAVE_OPENCV_GPUFILTERS
+#ifdef HAVE_OPENCV_CUDAFILTERS
     void GeneralizedHoughBase::calcEdges(InputArray _src, GpuMat& edges, GpuMat& dx, GpuMat& dy)
     {
         GpuMat src = _src.getGpuMat();
@@ -200,7 +200,7 @@ namespace
 
     void GeneralizedHoughBase::setTemplateImpl(InputArray templ, Point templCenter)
     {
-#ifndef HAVE_OPENCV_GPUFILTERS
+#ifndef HAVE_OPENCV_CUDAFILTERS
         (void) templ;
         (void) templCenter;
         throw_no_cuda();
@@ -238,7 +238,7 @@ namespace
 
     void GeneralizedHoughBase::detectImpl(InputArray image, OutputArray positions, OutputArray votes)
     {
-#ifndef HAVE_OPENCV_GPUFILTERS
+#ifndef HAVE_OPENCV_CUDAFILTERS
         (void) templ;
         (void) templCenter;
         throw_no_cuda();

modules/gpuimgproc/src/hough_circles.cpp

@@ -45,7 +45,7 @@
 using namespace cv;
 using namespace cv::cuda;
 
-#if !defined (HAVE_CUDA) || defined (CUDA_DISABLER) || !defined(HAVE_OPENCV_GPUFILTERS)
+#if !defined (HAVE_CUDA) || defined (CUDA_DISABLER) || !defined(HAVE_OPENCV_CUDAFILTERS)
 
 Ptr<cuda::HoughCirclesDetector> cv::cuda::createHoughCirclesDetector(float, float, int, int, int, int, int) { throw_no_cuda(); return Ptr<HoughCirclesDetector>(); }
 

modules/gpuimgproc/src/precomp.hpp

@@ -55,8 +55,8 @@
 #  include "opencv2/cudaarithm.hpp"
 #endif
 
-#ifdef HAVE_OPENCV_GPUFILTERS
-#  include "opencv2/gpufilters.hpp"
+#ifdef HAVE_OPENCV_CUDAFILTERS
+#  include "opencv2/cudafilters.hpp"
 #endif
 
 #endif /* __OPENCV_PRECOMP_H__ */

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_cudaarithm opencv_gpufilters opencv_gpufeatures2d opencv_nonfree)
+                  OPTIONAL opencv_gpu opencv_cudaarithm opencv_cudafilters opencv_gpufeatures2d opencv_nonfree)

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_cudaarithm opencv_gpufilters opencv_cudawarping opencv_gpuimgproc opencv_gpuoptflow opencv_cudacodec)
+                  opencv_cudaarithm opencv_cudafilters opencv_cudawarping 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_CUDAARITHM) || !defined(HAVE_OPENCV_CUDAWARPING) || !defined(HAVE_OPENCV_GPUFILTERS)
+#if !defined(HAVE_CUDA) || !defined(HAVE_OPENCV_CUDAARITHM) || !defined(HAVE_OPENCV_CUDAWARPING) || !defined(HAVE_OPENCV_CUDAFILTERS)
 
 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_CUDAARITHM) && defined(HAVE_OPENCV_CUDAWARPING) && defined(HAVE_OPENCV_GPUFILTERS)
+#if defined(HAVE_OPENCV_CUDAARITHM) && defined(HAVE_OPENCV_CUDAWARPING) && defined(HAVE_OPENCV_CUDAFILTERS)
 
 #include "opencv2/core/cuda/common.hpp"
 #include "opencv2/core/cuda/transform.hpp"

modules/superres/src/precomp.hpp

@@ -65,8 +65,8 @@
 #  include "opencv2/cudawarping.hpp"
 #endif
 
-#ifdef HAVE_OPENCV_GPUFILTERS
-#  include "opencv2/gpufilters.hpp"
+#ifdef HAVE_OPENCV_CUDAFILTERS
+#  include "opencv2/cudafilters.hpp"
 #endif
 
 #ifdef HAVE_OPENCV_GPUIMGPROC

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_CUDAARITHM) && defined(HAVE_OPENCV_CUDAWARPING) && defined(HAVE_OPENCV_GPUFILTERS)
+#if defined(HAVE_CUDA) && defined(HAVE_OPENCV_CUDAARITHM) && defined(HAVE_OPENCV_CUDAWARPING) && defined(HAVE_OPENCV_CUDAFILTERS)
 
 TEST_F(SuperResolution, BTVL1_GPU)
 {

samples/cpp/CMakeLists.txt

@@ -25,8 +25,8 @@ if(BUILD_EXAMPLES AND OCV_DEPENDENCIES_FOUND)
   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")
+  if(HAVE_opencv_cudafilters)
+    ocv_include_directories("${OpenCV_SOURCE_DIR}/modules/cudafilters/include")
   endif()
 
   if(CMAKE_COMPILER_IS_GNUCXX AND NOT ENABLE_NOISY_WARNINGS)
@@ -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_cudaarithm opencv_gpufilters)
+      target_link_libraries(${the_target} opencv_cudaarithm opencv_cudafilters)
     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_cudaarithm OR NOT HAVE_opencv_gpufilters)
+  if(NOT HAVE_opencv_cudaarithm OR NOT HAVE_opencv_cudafilters)
     ocv_list_filterout(cpp_samples "/gpu/")
   endif()
 

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

@@ -8,7 +8,7 @@
 
 // GPU structures and methods
 #include <opencv2/cudaarithm.hpp>
-#include <opencv2/gpufilters.hpp>
+#include <opencv2/cudafilters.hpp>
 
 using namespace std;
 using namespace cv;

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_cudaarithm opencv_gpufilters opencv_cudawarping opencv_gpuimgproc
+                                     opencv_cudaarithm opencv_cudafilters opencv_cudawarping opencv_gpuimgproc
                                      opencv_gpufeatures2d opencv_gpuoptflow opencv_gpubgsegm
                                      opencv_cudastereo opencv_cudalegacy)
 

samples/gpu/morphology.cpp

@@ -2,7 +2,7 @@
 
 #include "opencv2/imgproc.hpp"
 #include "opencv2/highgui.hpp"
-#include "opencv2/gpufilters.hpp"
+#include "opencv2/cudafilters.hpp"
 #include "opencv2/gpuimgproc.hpp"
 
 using namespace std;

samples/gpu/performance/tests.cpp

@@ -8,7 +8,7 @@
 #include "opencv2/cudaarithm.hpp"
 #include "opencv2/cudawarping.hpp"
 #include "opencv2/gpufeatures2d.hpp"
-#include "opencv2/gpufilters.hpp"
+#include "opencv2/cudafilters.hpp"
 #include "opencv2/gpuoptflow.hpp"
 #include "opencv2/gpubgsegm.hpp"