From 752e5fdc262c6377302cf63b24d60fe1472c9d4c Mon Sep 17 00:00:00 2001 From: Andrey Senyaev Date: Tue, 20 Sep 2022 13:36:59 +0300 Subject: [PATCH] Disabled compiling warnings in case of symbols in cmake for 5.x --- 3rdparty/clapack/CMakeLists.txt | 2 +- 3rdparty/openexr/CMakeLists.txt | 1 + 3rdparty/openjpeg/openjp2/CMakeLists.txt | 2 + cmake/OpenCVCompilerOptions.cmake | 1 + modules/3d/src/usac.hpp | 10 ++--- modules/calib/src/calibration_handeye.cpp | 2 +- modules/core/include/opencv2/core/cuda.hpp | 8 ++++ .../core/include/opencv2/core/cuda.inl.hpp | 40 +++++++++++++++++++ modules/core/include/opencv2/core/matx.hpp | 8 ++++ modules/core/include/opencv2/core/opengl.hpp | 8 ++++ .../opencv2/core/utils/filesystem.private.hpp | 2 +- modules/features2d/src/affine_feature.cpp | 2 +- modules/objdetect/test/test_qrcode_encode.cpp | 6 +-- .../opencv2/stitching/detail/warpers.hpp | 24 +++++++++++ 14 files changed, 104 insertions(+), 12 deletions(-) diff --git a/3rdparty/clapack/CMakeLists.txt b/3rdparty/clapack/CMakeLists.txt index fc28713b0a..5357c94f85 100644 --- a/3rdparty/clapack/CMakeLists.txt +++ b/3rdparty/clapack/CMakeLists.txt @@ -24,7 +24,7 @@ add_library(${the_target} STATIC ${lapack_srcs} ${runtime_srcs} ${lib_hdrs}) ocv_warnings_disable(CMAKE_C_FLAGS -Wno-parentheses -Wno-uninitialized -Wno-array-bounds -Wno-implicit-function-declaration -Wno-unused -Wunused-parameter) # gcc/clang warnings -ocv_warnings_disable(CMAKE_C_FLAGS /wd4244 /wd4554 /wd4723) # visual studio warnings +ocv_warnings_disable(CMAKE_C_FLAGS /wd4244 /wd4554 /wd4723 /wd4819) # visual studio warnings set_target_properties(${the_target} PROPERTIES OUTPUT_NAME ${the_target} diff --git a/3rdparty/openexr/CMakeLists.txt b/3rdparty/openexr/CMakeLists.txt index 8d10e7d968..aeb5a55f31 100644 --- a/3rdparty/openexr/CMakeLists.txt +++ b/3rdparty/openexr/CMakeLists.txt @@ -120,6 +120,7 @@ ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4334) # vs2005 Win64 ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4244) # vs2008 ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4267) # vs2008 Win64 ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4456) # vs2015 +ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4819) # vs2019 Win64 if(MSVC AND CV_ICC) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Qrestrict") diff --git a/3rdparty/openjpeg/openjp2/CMakeLists.txt b/3rdparty/openjpeg/openjp2/CMakeLists.txt index 321d318642..4bd6c52f93 100644 --- a/3rdparty/openjpeg/openjp2/CMakeLists.txt +++ b/3rdparty/openjpeg/openjp2/CMakeLists.txt @@ -39,6 +39,8 @@ ocv_warnings_disable(CMAKE_C_FLAGS -Wunused-function # v2.4.0: Clang ) +ocv_warnings_disable(CMAKE_C_FLAGS /wd4819) # vs2019 Win64 + add_library(${OPENJPEG_LIBRARY_NAME} STATIC ${OPENJPEG_SRCS}) target_compile_definitions(${OPENJPEG_LIBRARY_NAME} PUBLIC OPJ_STATIC) diff --git a/cmake/OpenCVCompilerOptions.cmake b/cmake/OpenCVCompilerOptions.cmake index 4f5c353980..9e10673ae8 100644 --- a/cmake/OpenCVCompilerOptions.cmake +++ b/cmake/OpenCVCompilerOptions.cmake @@ -437,6 +437,7 @@ if(MSVC) ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4275) # non dll-interface class 'std::exception' used as base for dll-interface class 'cv::Exception' ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4512) # Assignment operator could not be generated ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4589) # Constructor of abstract class 'cv::ORB' ignores initializer for virtual base class 'cv::Algorithm' + ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4819) # Symbols like delta or epsilon cannot be represented endif() if(CV_ICC AND NOT ENABLE_NOISY_WARNINGS) diff --git a/modules/3d/src/usac.hpp b/modules/3d/src/usac.hpp index d1223721c7..f88233f024 100644 --- a/modules/3d/src/usac.hpp +++ b/modules/3d/src/usac.hpp @@ -495,14 +495,14 @@ struct SPRT_history { /* * delta: * The probability of a data point being consistent - * with a ‘bad’ model is modeled as a probability of + * with a 'bad' model is modeled as a probability of * a random event with Bernoulli distribution with parameter - * δ : p(1|Hb) = δ. + * delta : p(1|Hb) = delta. * epsilon: - * The probability p(1|Hg) = ε - * that any randomly chosen data point is consistent with a ‘good’ model - * is approximated by the fraction of inliers ε among the data + * The probability p(1|Hg) = epsilon + * that any randomly chosen data point is consistent with a 'good' model + * is approximated by the fraction of inliers epsilon among the data * points * A is the decision threshold, the only parameter of the Adapted SPRT diff --git a/modules/calib/src/calibration_handeye.cpp b/modules/calib/src/calibration_handeye.cpp index 8e10f2a2ff..813f3f3db7 100644 --- a/modules/calib/src/calibration_handeye.cpp +++ b/modules/calib/src/calibration_handeye.cpp @@ -838,7 +838,7 @@ static void calibrateRobotWorldHandEyeShah(const std::vector>& cRw, //Reference: //A. Li, L. Wang, and D. Wu, "Simultaneous robot-world and hand-eye calibration using dual-quaternions and kronecker product" -//International Journal of Physical Sciences, vol. 5, pp. 1530–1536, 2010. +//International Journal of Physical Sciences, vol. 5, pp. 1530-1536, 2010. //Matlab code: http://math.loyola.edu/~mili/Calibration/ static void calibrateRobotWorldHandEyeLi(const std::vector>& cRw, const std::vector>& ctw, const std::vector>& gRb, const std::vector>& gtb, diff --git a/modules/core/include/opencv2/core/cuda.hpp b/modules/core/include/opencv2/core/cuda.hpp index 719003f21f..08118dd03b 100644 --- a/modules/core/include/opencv2/core/cuda.hpp +++ b/modules/core/include/opencv2/core/cuda.hpp @@ -694,8 +694,16 @@ public: //! Allocates a new GpuMat of given size and type. CV_WRAP GpuMat getBuffer(int rows, int cols, int type); +// WARNING: unreachable code using Ninja +#if defined _MSC_VER && _MSC_VER >= 1920 +#pragma warning(push) +#pragma warning(disable: 4702) +#endif //! Allocates a new GpuMat of given size and type. CV_WRAP GpuMat getBuffer(Size size, int type) { return getBuffer(size.height, size.width, type); } +#if defined _MSC_VER && _MSC_VER >= 1920 +#pragma warning(pop) +#endif //! Returns the allocator associated with the stream. CV_WRAP Ptr getAllocator() const { return allocator_; } diff --git a/modules/core/include/opencv2/core/cuda.inl.hpp b/modules/core/include/opencv2/core/cuda.inl.hpp index 3f2a0c7240..9390b3a529 100644 --- a/modules/core/include/opencv2/core/cuda.inl.hpp +++ b/modules/core/include/opencv2/core/cuda.inl.hpp @@ -75,6 +75,11 @@ GpuMat::GpuMat(Size size_, int type_, Allocator* allocator_) create(size_.height, size_.width, type_); } +// WARNING: unreachable code using Ninja +#if defined _MSC_VER && _MSC_VER >= 1920 +#pragma warning(push) +#pragma warning(disable: 4702) +#endif inline GpuMat::GpuMat(int rows_, int cols_, int type_, Scalar s_, Allocator* allocator_) : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0), allocator(allocator_) @@ -96,6 +101,9 @@ GpuMat::GpuMat(Size size_, int type_, Scalar s_, Allocator* allocator_) setTo(s_); } } +#if defined _MSC_VER && _MSC_VER >= 1920 +#pragma warning(pop) +#endif inline GpuMat::GpuMat(const GpuMat& m) @@ -158,11 +166,19 @@ GpuMat GpuMat::clone() const return m; } +// WARNING: unreachable code using Ninja +#if defined _MSC_VER && _MSC_VER >= 1920 +#pragma warning(push) +#pragma warning(disable: 4702) +#endif inline void GpuMat::copyTo(OutputArray dst, InputArray mask) const { copyTo(dst, mask, Stream::Null()); } +#if defined _MSC_VER && _MSC_VER >= 1920 +#pragma warning(pop) +#endif inline GpuMat& GpuMat::setTo(Scalar s) @@ -176,6 +192,11 @@ GpuMat& GpuMat::setTo(Scalar s, InputArray mask) return setTo(s, mask, Stream::Null()); } +// WARNING: unreachable code using Ninja +#if defined _MSC_VER && _MSC_VER >= 1920 +#pragma warning(push) +#pragma warning(disable: 4702) +#endif inline void GpuMat::convertTo(OutputArray dst, int rtype) const { @@ -187,6 +208,9 @@ void GpuMat::convertTo(OutputArray dst, int rtype, double alpha, double beta) co { convertTo(dst, rtype, alpha, beta, Stream::Null()); } +#if defined _MSC_VER && _MSC_VER >= 1920 +#pragma warning(pop) +#endif inline void GpuMat::convertTo(OutputArray dst, int rtype, double alpha, Stream& stream) const @@ -646,6 +670,11 @@ Event::Event(const Ptr& impl) // Initialization & Info //=================================================================================== +// WARNING: unreachable code using Ninja +#if defined _MSC_VER && _MSC_VER >= 1920 +#pragma warning(push) +#pragma warning(disable: 4702) +#endif inline bool TargetArchs::has(int major, int minor) { @@ -663,6 +692,9 @@ DeviceInfo::DeviceInfo() { device_id_ = getDevice(); } +#if defined _MSC_VER && _MSC_VER >= 1920 +#pragma warning(pop) +#endif inline DeviceInfo::DeviceInfo(int device_id) @@ -671,6 +703,11 @@ DeviceInfo::DeviceInfo(int device_id) device_id_ = device_id; } +// WARNING: unreachable code using Ninja +#if defined _MSC_VER && _MSC_VER >= 1920 +#pragma warning(push) +#pragma warning(disable: 4702) +#endif inline int DeviceInfo::deviceID() const { @@ -699,6 +736,9 @@ bool DeviceInfo::supports(FeatureSet feature_set) const int version = majorVersion() * 10 + minorVersion(); return version >= feature_set; } +#if defined _MSC_VER && _MSC_VER >= 1920 +#pragma warning(pop) +#endif }} // namespace cv { namespace cuda { diff --git a/modules/core/include/opencv2/core/matx.hpp b/modules/core/include/opencv2/core/matx.hpp index 2fbe8410cf..68cb4de5bb 100644 --- a/modules/core/include/opencv2/core/matx.hpp +++ b/modules/core/include/opencv2/core/matx.hpp @@ -685,11 +685,19 @@ Matx<_Tp,m,n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp for(int i = 16; i < channels; i++) val[i] = _Tp(0); } +// WARNING: unreachable code using Ninja +#if defined _MSC_VER && _MSC_VER >= 1920 +#pragma warning(push) +#pragma warning(disable: 4702) +#endif template inline Matx<_Tp, m, n>::Matx(const _Tp* values) { for( int i = 0; i < channels; i++ ) val[i] = values[i]; } +#if defined _MSC_VER && _MSC_VER >= 1920 +#pragma warning(pop) +#endif template inline Matx<_Tp, m, n>::Matx(std::initializer_list<_Tp> list) diff --git a/modules/core/include/opencv2/core/opengl.hpp b/modules/core/include/opencv2/core/opengl.hpp index a311ce2525..fceb85bd06 100644 --- a/modules/core/include/opencv2/core/opengl.hpp +++ b/modules/core/include/opencv2/core/opengl.hpp @@ -703,10 +703,18 @@ cv::ogl::Texture2D::Format cv::ogl::Texture2D::format() const /////// +// WARNING: unreachable code using Ninja +#if defined _MSC_VER && _MSC_VER >= 1920 +#pragma warning(push) +#pragma warning(disable: 4702) +#endif inline cv::ogl::Arrays::Arrays() : size_(0) { } +#if defined _MSC_VER && _MSC_VER >= 1920 +#pragma warning(pop) +#endif inline int cv::ogl::Arrays::size() const diff --git a/modules/core/include/opencv2/core/utils/filesystem.private.hpp b/modules/core/include/opencv2/core/utils/filesystem.private.hpp index 72b2bb9479..c32be15c61 100644 --- a/modules/core/include/opencv2/core/utils/filesystem.private.hpp +++ b/modules/core/include/opencv2/core/utils/filesystem.private.hpp @@ -36,7 +36,7 @@ namespace cv { namespace utils { namespace fs { * Provides interprocess synchronization mechanism. * Platform dependent. * - * Supports multiple readers / single writer access pattern (RW / readers–writer / shared-exclusive lock). + * Supports multiple readers / single writer access pattern (RW / readers-writer / shared-exclusive lock). * * File must exist. * File can't be re-used (for example, I/O operations via std::fstream is not safe) diff --git a/modules/features2d/src/affine_feature.cpp b/modules/features2d/src/affine_feature.cpp index 41518d945d..40e03e92ba 100644 --- a/modules/features2d/src/affine_feature.cpp +++ b/modules/features2d/src/affine_feature.cpp @@ -41,7 +41,7 @@ /* Guoshen Yu, Jean-Michel Morel, ASIFT: An Algorithm for Fully Affine - Invariant Comparison, Image Processing On Line, 1 (2011), pp. 11–38. + Invariant Comparison, Image Processing On Line, 1 (2011), pp. 11-38. https://doi.org/10.5201/ipol.2011.my-asift */ diff --git a/modules/objdetect/test/test_qrcode_encode.cpp b/modules/objdetect/test/test_qrcode_encode.cpp index e2d6b5fc62..213b9c4627 100644 --- a/modules/objdetect/test/test_qrcode_encode.cpp +++ b/modules/objdetect/test/test_qrcode_encode.cpp @@ -318,9 +318,9 @@ TEST(Objdetect_QRCode_Encode_Kanji, regression) Mat qrcode; const int testing_versions = 3; - std::string input_infos[testing_versions] = {"\x82\xb1\x82\xf1\x82\xc9\x82\xbf\x82\xcd\x90\xa2\x8a\x45", // こんにちは世界 - "\x82\xa8\x95\xa0\x82\xaa\x8b\xf3\x82\xa2\x82\xc4\x82\xa2\x82\xdc\x82\xb7", // お腹が空いています - "\x82\xb1\x82\xf1\x82\xc9\x82\xbf\x82\xcd\x81\x41\x8e\x84\x82\xcd\x8f\xad\x82\xb5\x93\xfa\x96\x7b\x8c\xea\x82\xf0\x98\x62\x82\xb5\x82\xdc\x82\xb7" // こんにちは、私は少し日本語を話します + std::string input_infos[testing_versions] = {"\x82\xb1\x82\xf1\x82\xc9\x82\xbf\x82\xcd\x90\xa2\x8a\x45", // "Hello World" in Japanese + "\x82\xa8\x95\xa0\x82\xaa\x8b\xf3\x82\xa2\x82\xc4\x82\xa2\x82\xdc\x82\xb7", // "I am hungry" in Japanese + "\x82\xb1\x82\xf1\x82\xc9\x82\xbf\x82\xcd\x81\x41\x8e\x84\x82\xcd\x8f\xad\x82\xb5\x93\xfa\x96\x7b\x8c\xea\x82\xf0\x98\x62\x82\xb5\x82\xdc\x82\xb7" // "Hello, I speak a little Japanese" in Japanese }; for (int i = 0; i < testing_versions; i++) diff --git a/modules/stitching/include/opencv2/stitching/detail/warpers.hpp b/modules/stitching/include/opencv2/stitching/detail/warpers.hpp index ff005e8da2..d0d7869d45 100644 --- a/modules/stitching/include/opencv2/stitching/detail/warpers.hpp +++ b/modules/stitching/include/opencv2/stitching/detail/warpers.hpp @@ -503,6 +503,11 @@ class CV_EXPORTS PlaneWarperGpu : public PlaneWarper public: PlaneWarperGpu(float scale = 1.f) : PlaneWarper(scale) {} +// WARNING: unreachable code using Ninja +#if defined _MSC_VER && _MSC_VER >= 1920 +#pragma warning(push) +#pragma warning(disable: 4702) +#endif Rect buildMaps(Size src_size, InputArray K, InputArray R, OutputArray xmap, OutputArray ymap) CV_OVERRIDE { Rect result = buildMaps(src_size, K, R, d_xmap_, d_ymap_); @@ -536,6 +541,9 @@ public: d_dst_.download(dst); return result; } +#if defined _MSC_VER && _MSC_VER >= 1920 +#pragma warning(pop) +#endif Rect buildMaps(Size src_size, InputArray K, InputArray R, cuda::GpuMat & xmap, cuda::GpuMat & ymap); @@ -557,6 +565,11 @@ class CV_EXPORTS SphericalWarperGpu : public SphericalWarper public: SphericalWarperGpu(float scale) : SphericalWarper(scale) {} +// WARNING: unreachable code using Ninja +#if defined _MSC_VER && _MSC_VER >= 1920 +#pragma warning(push) +#pragma warning(disable: 4702) +#endif Rect buildMaps(Size src_size, InputArray K, InputArray R, OutputArray xmap, OutputArray ymap) CV_OVERRIDE { Rect result = buildMaps(src_size, K, R, d_xmap_, d_ymap_); @@ -573,6 +586,9 @@ public: d_dst_.download(dst); return result; } +#if defined _MSC_VER && _MSC_VER >= 1920 +#pragma warning(pop) +#endif Rect buildMaps(Size src_size, InputArray K, InputArray R, cuda::GpuMat & xmap, cuda::GpuMat & ymap); @@ -589,6 +605,11 @@ class CV_EXPORTS CylindricalWarperGpu : public CylindricalWarper public: CylindricalWarperGpu(float scale) : CylindricalWarper(scale) {} +// WARNING: unreachable code using Ninja +#if defined _MSC_VER && _MSC_VER >= 1920 +#pragma warning(push) +#pragma warning(disable: 4702) +#endif Rect buildMaps(Size src_size, InputArray K, InputArray R, OutputArray xmap, OutputArray ymap) CV_OVERRIDE { Rect result = buildMaps(src_size, K, R, d_xmap_, d_ymap_); @@ -605,6 +626,9 @@ public: d_dst_.download(dst); return result; } +#if defined _MSC_VER && _MSC_VER >= 1920 +#pragma warning(pop) +#endif Rect buildMaps(Size src_size, InputArray K, InputArray R, cuda::GpuMat & xmap, cuda::GpuMat & ymap);