next: drop CV_CXX11 conditions

define itself is still here for compatibility

modules/calib3d/test/test_affine3d_estimator.cpp

@@ -138,13 +138,8 @@ bool CV_Affine3D_EstTest::testNPoints()
     std::transform(fpts.ptr<Point3f>(), fpts.ptr<Point3f>() + n, tpts.ptr<Point3f>(), WrapAff(aff));
 
     /* adding noise*/
-#ifdef CV_CXX11
     std::transform(tpts.ptr<Point3f>() + m, tpts.ptr<Point3f>() + n, tpts.ptr<Point3f>() + m,
         [=] (const Point3f& pt) -> Point3f { return Noise(noise_level)(pt + shift_outl); });
-#else
-    std::transform(tpts.ptr<Point3f>() + m, tpts.ptr<Point3f>() + n, tpts.ptr<Point3f>() + m, std::bind2nd(std::plus<Point3f>(), shift_outl));
-    std::transform(tpts.ptr<Point3f>() + m, tpts.ptr<Point3f>() + n, tpts.ptr<Point3f>() + m, Noise(noise_level));
-#endif
 
     Mat aff_est;
     vector<uchar> outl;

modules/core/include/opencv2/core/cuda/functional.hpp

@@ -58,7 +58,6 @@
 namespace cv { namespace cuda { namespace device
 {
     // Function Objects
-#ifdef CV_CXX11
     template<typename Argument, typename Result> struct unary_function
     {
         typedef Argument argument_type;
@@ -70,10 +69,6 @@ namespace cv { namespace cuda { namespace device
         typedef Argument2 second_argument_type;
         typedef Result result_type;
     };
-#else
-    template<typename Argument, typename Result> struct unary_function : public std::unary_function<Argument, Result> {};
-    template<typename Argument1, typename Argument2, typename Result> struct binary_function : public std::binary_function<Argument1, Argument2, Result> {};
-#endif
 
     // Arithmetic Operations
     template <typename T> struct plus : binary_function<T, T, T>

modules/core/include/opencv2/core/cvdef.h

@@ -417,6 +417,9 @@ Cv64suf;
 #    undef CV_CXX11
 #  endif
 #endif
+#ifndef CV_CXX11
+#  error "OpenCV 4.x+ requires enabled C++11 support"
+#endif
 
 
 /****************************************************************************************\

modules/core/include/opencv2/core/mat.hpp

@@ -53,9 +53,7 @@
 
 #include "opencv2/core/bufferpool.hpp"
 
-#ifdef CV_CXX11
 #include <type_traits>
-#endif
 
 namespace cv
 {
@@ -984,7 +982,6 @@ public:
     */
     template<typename _Tp> explicit Mat(const std::vector<_Tp>& vec, bool copyData=false);
 
-#ifdef CV_CXX11
     /** @overload
     */
     template<typename _Tp, typename = typename std::enable_if<std::is_arithmetic<_Tp>::value>::type>
@@ -993,7 +990,6 @@ public:
     /** @overload
     */
     template<typename _Tp> explicit Mat(const std::initializer_list<int> sizes, const std::initializer_list<_Tp> list);
-#endif
 
 #ifdef CV_CXX_STD_ARRAY
     /** @overload
@@ -2210,10 +2206,8 @@ public:
     explicit Mat_(const Point3_<typename DataType<_Tp>::channel_type>& pt, bool copyData=true);
     explicit Mat_(const MatCommaInitializer_<_Tp>& commaInitializer);
 
-#ifdef CV_CXX11
     Mat_(std::initializer_list<_Tp> values);
     explicit Mat_(const std::initializer_list<int> sizes, const std::initializer_list<_Tp> values);
-#endif
 
 #ifdef CV_CXX_STD_ARRAY
     template <std::size_t _Nm> explicit Mat_(const std::array<_Tp, _Nm>& arr, bool copyData=false);

modules/core/include/opencv2/core/mat.inl.hpp

@@ -574,7 +574,6 @@ Mat::Mat(const std::vector<_Tp>& vec, bool copyData)
         Mat((int)vec.size(), 1, traits::Type<_Tp>::value, (uchar*)&vec[0]).copyTo(*this);
 }
 
-#ifdef CV_CXX11
 template<typename _Tp, typename> inline
 Mat::Mat(const std::initializer_list<_Tp> list)
     : Mat()
@@ -594,7 +593,6 @@ Mat::Mat(const std::initializer_list<int> sizes, const std::initializer_list<_Tp
     CV_Assert(size_total == list.size());
     Mat((int)sizes.size(), (int*)sizes.begin(), traits::Type<_Tp>::value, (uchar*)list.begin()).copyTo(*this);
 }
-#endif
 
 #ifdef CV_CXX_STD_ARRAY
 template<typename _Tp, std::size_t _Nm> inline
@@ -1634,7 +1632,6 @@ Mat_<_Tp>::Mat_(const std::vector<_Tp>& vec, bool copyData)
     : Mat(vec, copyData)
 {}
 
-#ifdef CV_CXX11
 template<typename _Tp> inline
 Mat_<_Tp>::Mat_(std::initializer_list<_Tp> list)
     : Mat(list)
@@ -1644,7 +1641,6 @@ template<typename _Tp> inline
 Mat_<_Tp>::Mat_(const std::initializer_list<int> sizes, std::initializer_list<_Tp> list)
     : Mat(sizes, list)
 {}
-#endif
 
 #ifdef CV_CXX_STD_ARRAY
 template<typename _Tp> template<std::size_t _Nm> inline

modules/core/include/opencv2/core/matx.hpp

@@ -53,9 +53,7 @@
 #include "opencv2/core/traits.hpp"
 #include "opencv2/core/saturate.hpp"
 
-#ifdef CV_CXX11
 #include <initializer_list>
-#endif
 
 namespace cv
 {
@@ -141,9 +139,7 @@ public:
          _Tp v12, _Tp v13, _Tp v14, _Tp v15); //!< 1x16, 4x4 or 16x1 matrix
     explicit Matx(const _Tp* vals); //!< initialize from a plain array
 
-#ifdef CV_CXX11
     Matx(std::initializer_list<_Tp>); //!< initialize from an initializer list
-#endif
 
     static Matx all(_Tp alpha);
     static Matx zeros();
@@ -361,9 +357,7 @@ public:
     Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8, _Tp v9, _Tp v10, _Tp v11, _Tp v12, _Tp v13); //!< 14-element vector constructor
     explicit Vec(const _Tp* values);
 
-#ifdef CV_CXX11
     Vec(std::initializer_list<_Tp>);
-#endif
 
     Vec(const Vec<_Tp, cn>& v);
 
@@ -665,7 +659,6 @@ Matx<_Tp, m, n>::Matx(const _Tp* values)
     for( int i = 0; i < channels; i++ ) val[i] = values[i];
 }
 
-#ifdef CV_CXX11
 template<typename _Tp, int m, int n> inline
 Matx<_Tp, m, n>::Matx(std::initializer_list<_Tp> list)
 {
@@ -676,7 +669,6 @@ Matx<_Tp, m, n>::Matx(std::initializer_list<_Tp> list)
         val[i++] = elem;
     }
 }
-#endif
 
 template<typename _Tp, int m, int n> inline
 Matx<_Tp, m, n> Matx<_Tp, m, n>::all(_Tp alpha)
@@ -1019,11 +1011,9 @@ template<typename _Tp, int cn> inline
 Vec<_Tp, cn>::Vec(const _Tp* values)
     : Matx<_Tp, cn, 1>(values) {}
 
-#ifdef CV_CXX11
 template<typename _Tp, int cn> inline
 Vec<_Tp, cn>::Vec(std::initializer_list<_Tp> list)
     : Matx<_Tp, cn, 1>(list) {}
-#endif
 
 template<typename _Tp, int cn> inline
 Vec<_Tp, cn>::Vec(const Vec<_Tp, cn>& m)

modules/core/include/opencv2/core/utility.hpp

@@ -56,9 +56,7 @@
 #include "opencv2/core.hpp"
 #include <ostream>
 
-#ifdef CV_CXX11
 #include <functional>
-#endif
 
 namespace cv
 {
@@ -531,7 +529,6 @@ public:
 */
 CV_EXPORTS void parallel_for_(const Range& range, const ParallelLoopBody& body, double nstripes=-1.);
 
-#ifdef CV_CXX11
 class ParallelLoopBodyLambdaWrapper : public ParallelLoopBody
 {
 private:
@@ -551,7 +548,6 @@ inline void parallel_for_(const Range& range, std::function<void(const Range&)>
 {
     parallel_for_(range, ParallelLoopBodyLambdaWrapper(functor), nstripes);
 }
-#endif
 
 /////////////////////////////// forEach method of cv::Mat ////////////////////////////
 template<typename _Tp, typename Functor> inline

modules/core/src/parallel_impl.cpp

@@ -21,27 +21,15 @@
 
 //#define CV_USE_GLOBAL_WORKERS_COND_VAR  // not effective on many-core systems (10+)
 
-#ifdef CV_CXX11
 #include <atomic>
-#else
-#include <unistd.h>  // _POSIX_PRIORITY_SCHEDULING
-#endif
 
 // Spin lock's OS-level yield
 #ifdef DECLARE_CV_YIELD
 DECLARE_CV_YIELD
 #endif
 #ifndef CV_YIELD
-# ifdef CV_CXX11
-#   include <thread>
-#   define CV_YIELD() std::this_thread::yield()
-# elif defined(_POSIX_PRIORITY_SCHEDULING)
-#   include <sched.h>
-#   define CV_YIELD() sched_yield()
-# else
-#   warning "Can't detect sched_yield() on the target platform. Specify CV_YIELD() definition via compiler flags."
-#   define CV_YIELD() /* no-op: works, but not effective */
-# endif
+# include <thread>
+# define CV_YIELD() std::this_thread::yield()
 #endif // CV_YIELD
 
 // Spin lock's CPU-level yield (required for Hyper-Threading)
@@ -290,15 +278,9 @@ public:
         is_completed(false)
     {
         CV_LOG_VERBOSE(NULL, 5, "ParallelJob::ParallelJob(" << (void*)this << ")");
-#ifdef CV_CXX11
         current_task.store(0, std::memory_order_relaxed);
         active_thread_count.store(0, std::memory_order_relaxed);
         completed_thread_count.store(0, std::memory_order_relaxed);
-#else
-        current_task = 0;
-        active_thread_count = 0;
-        completed_thread_count = 0;
-#endif
         dummy0_[0] = 0, dummy1_[0] = 0, dummy2_[0] = 0; // compiler warning
     }
 
@@ -319,11 +301,7 @@ public:
         for (;;)
         {
             int chunk_size = std::max(1, (task_count - current_task) / remaining_multiplier);
-#ifdef CV_CXX11
             int id = current_task.fetch_add(chunk_size, std::memory_order_seq_cst);
-#else
-            int id = (int)CV_XADD(&current_task, chunk_size);
-#endif
             if (id >= task_count)
                 break; // no more free tasks
 
@@ -349,7 +327,7 @@ public:
     const ParallelLoopBody& body;
     const Range range;
     const unsigned nstripes;
-#ifdef CV_CXX11
+
     std::atomic<int> current_task;  // next free part of job
     int64 dummy0_[8];  // avoid cache-line reusing for the same atomics
 
@@ -358,16 +336,6 @@ public:
 
     std::atomic<int> completed_thread_count;  // number of threads completed any activities on this job
     int64 dummy2_[8];  // avoid cache-line reusing for the same atomics
-#else
-    /*CV_DECL_ALIGNED(64)*/ volatile int current_task;  // next free part of job
-    int64 dummy0_[8];  // avoid cache-line reusing for the same atomics
-
-    /*CV_DECL_ALIGNED(64)*/ volatile int active_thread_count;  // number of threads worked on this job
-    int64 dummy1_[8];  // avoid cache-line reusing for the same atomics
-
-    /*CV_DECL_ALIGNED(64)*/ volatile int completed_thread_count;  // number of threads completed any activities on this job
-    int64 dummy2_[8];  // avoid cache-line reusing for the same atomics
-#endif
 
     volatile bool is_completed;  // std::atomic_flag ?
 
@@ -437,11 +405,7 @@ void WorkerThread::thread_body()
                 CV_LOG_VERBOSE(NULL, 5, "Thread: job size=" << j->range.size() << " done=" << j->current_task);
                 if (j->current_task < j->range.size())
                 {
-#ifdef CV_CXX11
                     int other = j->active_thread_count.fetch_add(1, std::memory_order_seq_cst);
-#else
-                    int other = CV_XADD(&j->active_thread_count, 1);
-#endif
                     CV_LOG_VERBOSE(NULL, 5, "Thread: processing new job (with " << other << " other threads)"); CV_UNUSED(other);
 #ifdef CV_PROFILE_THREADS
                     stat.threadExecuteStart = getTickCount();
@@ -450,13 +414,8 @@ void WorkerThread::thread_body()
 #else
                     j->execute(true);
 #endif
-#ifdef CV_CXX11
                     int completed = j->completed_thread_count.fetch_add(1, std::memory_order_seq_cst) + 1;
                     int active = j->active_thread_count.load(std::memory_order_acquire);
-#else
-                    int completed = (int)CV_XADD(&j->completed_thread_count, 1) + 1;
-                    int active = j->active_thread_count;
-#endif
                     if (CV_WORKER_ACTIVE_WAIT_THREADS_LIMIT > 0)
                     {
                         allow_active_wait = true;

modules/core/test/test_mat.cpp

@@ -1344,8 +1344,6 @@ TEST(Core_Matx, fromMat_)
     ASSERT_EQ( cvtest::norm(a, b, NORM_INF), 0.);
 }
 
-#ifdef CV_CXX11
-
 TEST(Core_Matx, from_initializer_list)
 {
     Mat_<double> a = (Mat_<double>(2,2) << 10, 11, 12, 13);
@@ -1360,8 +1358,6 @@ TEST(Core_Mat, regression_9507)
     EXPECT_EQ(25u, m2.total());
 }
 
-#endif // CXX11
-
 TEST(Core_InputArray, empty)
 {
     vector<vector<Point> > data;
@@ -1711,8 +1707,6 @@ TEST(Mat, regression_8680)
    ASSERT_EQ(mat.channels(), 2);
 }
 
-#ifdef CV_CXX11
-
 TEST(Mat_, range_based_for)
 {
     Mat_<uchar> img = Mat_<uchar>::zeros(3, 3);
@@ -1774,6 +1768,4 @@ TEST(Mat_, template_based_ptr)
     ASSERT_FLOAT_EQ(66.0f, *(mat.ptr<float>(idx)));
 }
 
-#endif
-
 }} // namespace

modules/cudafeatures2d/src/brute_force_matcher.cpp

@@ -564,12 +564,8 @@ namespace
 
             if (compactResult)
             {
-#ifdef CV_CXX11
                 std::vector< std::vector<DMatch> >::iterator new_end = std::remove_if(matches.begin(), matches.end(),
                     [](const std::vector<DMatch>& e)->bool { return e.empty(); });
-#else
-                std::vector< std::vector<DMatch> >::iterator new_end = std::remove_if(matches.begin(), matches.end(), std::mem_fun_ref(&std::vector<DMatch>::empty));
-#endif
                 matches.erase(new_end, matches.end());
             }
         }

modules/imgproc/src/featureselect.cpp

@@ -52,11 +52,7 @@
 namespace cv
 {
 
-#ifdef CV_CXX11
 struct greaterThanPtr
-#else
-struct greaterThanPtr : public std::binary_function<const float *, const float *, bool>
-#endif
 {
     bool operator () (const float * a, const float * b) const
     // Ensure a fully deterministic result of the sort

modules/imgproc/src/generalized_hough.cpp

@@ -385,11 +385,7 @@ namespace
         const double thetaScale = levels_ / 360.0;
 
         r_table_.resize(levels_ + 1);
-#ifdef CV_CXX11
         std::for_each(r_table_.begin(), r_table_.end(), [](std::vector<Point>& e)->void { e.clear(); });
-#else
-        std::for_each(r_table_.begin(), r_table_.end(), std::mem_fun_ref(&std::vector<Point>::clear));
-#endif
 
         for (int y = 0; y < templSize_.height; ++y)
         {
@@ -696,12 +692,7 @@ namespace
         getContourPoints(edges, dx, dy, points);
 
         features.resize(levels_ + 1);
-#ifdef CV_CXX11
         std::for_each(features.begin(), features.end(), [=](std::vector<Feature>& e) { e.clear(); e.reserve(maxBufferSize_); });
-#else
-        std::for_each(features.begin(), features.end(), std::mem_fun_ref(&std::vector<Feature>::clear));
-        std::for_each(features.begin(), features.end(), std::bind2nd(std::mem_fun_ref(&std::vector<Feature>::reserve), maxBufferSize_));
-#endif
 
         for (size_t i = 0; i < points.size(); ++i)
         {

modules/imgproc/test/test_goodfeaturetotrack.cpp

@@ -56,11 +56,7 @@ enum { MINEIGENVAL=0, HARRIS=1, EIGENVALSVECS=2 };
 
 /////////////////////ref//////////////////////
 
-#ifdef CV_CXX11
 struct greaterThanPtr
-#else
-struct greaterThanPtr : public std::binary_function<const float *, const float *, bool>
-#endif
 {
     bool operator () (const float * a, const float * b) const
     { return *a > *b; }

modules/objdetect/include/opencv2/objdetect/detection_based_tracker.hpp

@@ -46,10 +46,6 @@
 
 #include <opencv2/core.hpp>
 
-// After this condition removal update blacklist for bindings: modules/python/common.cmake
-#if defined(__linux__) || defined(LINUX) || defined(__APPLE__) || defined(__ANDROID__) || \
-  defined(CV_CXX11)
-
 #include <vector>
 
 namespace cv
@@ -222,6 +218,5 @@ class CV_EXPORTS DetectionBasedTracker
 //! @} objdetect
 
 } //end of cv namespace
-#endif
 
 #endif

modules/objdetect/perf/opencl/perf_hogdetect.cpp

@@ -53,11 +53,7 @@ namespace opencv_test {
 namespace ocl {
 ///////////// HOG////////////////////////
 
-#ifdef CV_CXX11
 struct RectLess
-#else
-struct RectLess : public std::binary_function<cv::Rect, cv::Rect, bool>
-#endif
 {
     bool operator()(const cv::Rect& a,
         const cv::Rect& b) const

modules/ts/include/opencv2/ts/ts_perf.hpp

@@ -706,11 +706,7 @@ namespace comparators
 {
 
 template<typename T>
-#ifdef CV_CXX11
 struct RectLess_
-#else
-struct RectLess_ : public std::binary_function<cv::Rect_<T>, cv::Rect_<T>, bool>
-#endif
 {
   bool operator()(const cv::Rect_<T>& r1, const cv::Rect_<T>& r2) const
   {
@@ -723,11 +719,7 @@ struct RectLess_ : public std::binary_function<cv::Rect_<T>, cv::Rect_<T>, bool>
 
 typedef RectLess_<int> RectLess;
 
-#ifdef CV_CXX11
 struct KeypointGreater
-#else
-struct KeypointGreater : public std::binary_function<cv::KeyPoint, cv::KeyPoint, bool>
-#endif
 {
     bool operator()(const cv::KeyPoint& kp1, const cv::KeyPoint& kp2) const
     {

modules/ts/src/cuda_test.cpp

@@ -462,11 +462,7 @@ namespace cvtest
             return false;
         }
 
-#ifdef CV_CXX11
         struct KeyPointLess
-#else
-        struct KeyPointLess : std::binary_function<cv::KeyPoint, cv::KeyPoint, bool>
-#endif
         {
             bool operator()(const cv::KeyPoint& kp1, const cv::KeyPoint& kp2) const
             {