-Wenum-compare-switch
-Wsuggest-override -Winconsistent-missing-override
-Wimplicit-fallthrough
+ -Warray-bounds # GCC 9+
)
endif()
if(CV_ICC)
endmacro()
set(OCV_COMPILER_FAIL_REGEX
+ "argument '.*' is not valid" # GCC 9+
"command line option .* is valid for .* but not for C\\+\\+" # GNU
"command line option .* is valid for .* but not for C" # GNU
"unrecognized .*option" # GNU
//M*/
#include "precomp.hpp"
-#include "upnp.h"
+//#include "upnp.h"
#include "dls.h"
#include "epnp.h"
#include "p3p.h"
#include "upnp.h"
#include <limits>
+#if 0 // fix buffer overflow first (FIXIT mark in .cpp file)
+
using namespace std;
using namespace cv;
const double * v = ut + 12 * (9 + i);
for(int j = 0; j < 4; ++j)
for(int k = 0; k < 3; ++k)
- ccs[j][k] += betas[i] * v[3 * j + k];
+ ccs[j][k] += betas[i] * v[3 * j + k]; // FIXIT: array subscript 144 is outside array bounds of 'double [144]' [-Warray-bounds]
+ // line 109: double ut[12 * 12]
+ // line 359: double u[12*12]
}
for (int i = 0; i < 4; ++i) ccs[i][2] *= fu;
pX[i] = (pb[i] - sum) / A2[i];
}
}
+
+#endif
#include "opencv2/core/core_c.h"
#include <iostream>
+#if 0 // fix buffer overflow first (FIXIT mark in .cpp file)
+
class upnp
{
public:
double * A1, * A2;
};
+#endif
+
#endif // OPENCV_CALIB3D_UPNP_H_
*/
FileNode(const FileNode& node);
+ FileNode& operator=(const FileNode& node);
+
/** @brief Returns element of a mapping node or a sequence node.
@param nodename Name of an element in the mapping node.
@returns Returns the element with the given identifier.
*/
FileNodeIterator(const FileNodeIterator& it);
+ FileNodeIterator& operator=(const FileNodeIterator& it);
+
//! returns the currently observed element
FileNode operator *() const;
//! accesses the currently observed element methods
inline FileNode::FileNode() : fs(0), node(0) {}
inline FileNode::FileNode(const CvFileStorage* _fs, const CvFileNode* _node) : fs(_fs), node(_node) {}
inline FileNode::FileNode(const FileNode& _node) : fs(_node.fs), node(_node.node) {}
+inline FileNode& FileNode::operator=(const FileNode& _node) { fs = _node.fs; node = _node.node; return *this; }
inline bool FileNode::empty() const { return node == 0; }
inline bool FileNode::isNone() const { return type() == NONE; }
inline bool FileNode::isSeq() const { return type() == SEQ; }
remaining = it.remaining;
}
+FileNodeIterator& FileNodeIterator::operator=(const FileNodeIterator& it)
+{
+ fs = it.fs;
+ container = it.container;
+ reader = it.reader;
+ remaining = it.remaining;
+ return *this;
+}
+
FileNodeIterator& FileNodeIterator::operator ++()
{
if( remaining > 0 )
cvInitSystem(0,NULL);
if (!thread_started)
{
- if (!g_thread_supported ()) {
+#if !GLIB_CHECK_VERSION(2, 32, 0) // https://github.com/GNOME/glib/blame/b4d58a7105bb9d75907233968bb534b38f9a6e43/glib/deprecated/gthread.h#L274
+ if (!g_thread_supported ())
+ {
/* the GThread system wasn't inited, so init it */
g_thread_init(NULL);
}
+#endif
(void)getWindowMutex(); // force mutex initialization
public:
typedef fixedpoint64 WT;
CV_ALWAYS_INLINE fixedpoint64() { val = 0; }
+ CV_ALWAYS_INLINE fixedpoint64(const fixedpoint64& v) { val = v.val; }
CV_ALWAYS_INLINE fixedpoint64(const int8_t& _val) { val = ((int64_t)_val) << fixedShift; }
CV_ALWAYS_INLINE fixedpoint64(const uint8_t& _val) { val = ((int64_t)_val) << fixedShift; }
CV_ALWAYS_INLINE fixedpoint64(const int16_t& _val) { val = ((int64_t)_val) << fixedShift; }
public:
typedef ufixedpoint64 WT;
CV_ALWAYS_INLINE ufixedpoint64() { val = 0; }
+ CV_ALWAYS_INLINE ufixedpoint64(const ufixedpoint64& v) { val = v.val; }
CV_ALWAYS_INLINE ufixedpoint64(const uint8_t& _val) { val = ((uint64_t)_val) << fixedShift; }
CV_ALWAYS_INLINE ufixedpoint64(const uint16_t& _val) { val = ((uint64_t)_val) << fixedShift; }
CV_ALWAYS_INLINE ufixedpoint64(const uint32_t& _val) { val = ((uint64_t)_val) << fixedShift; }
public:
typedef fixedpoint64 WT;
CV_ALWAYS_INLINE fixedpoint32() { val = 0; }
+ CV_ALWAYS_INLINE fixedpoint32(const fixedpoint32& v) { val = v.val; }
CV_ALWAYS_INLINE fixedpoint32(const int8_t& _val) { val = ((int32_t)_val) << fixedShift; }
CV_ALWAYS_INLINE fixedpoint32(const uint8_t& _val) { val = ((int32_t)_val) << fixedShift; }
CV_ALWAYS_INLINE fixedpoint32(const int16_t& _val) { val = ((int32_t)_val) << fixedShift; }
public:
typedef ufixedpoint64 WT;
CV_ALWAYS_INLINE ufixedpoint32() { val = 0; }
+ CV_ALWAYS_INLINE ufixedpoint32(const ufixedpoint32& v) { val = v.val; }
CV_ALWAYS_INLINE ufixedpoint32(const uint8_t& _val) { val = ((uint32_t)_val) << fixedShift; }
CV_ALWAYS_INLINE ufixedpoint32(const uint16_t& _val) { val = ((uint32_t)_val) << fixedShift; }
CV_ALWAYS_INLINE ufixedpoint32(const cv::softdouble& _val) { val = _val.getSign() ? 0 : (uint32_t)cvRound(_val * cv::softdouble((1 << fixedShift))); }
public:
typedef fixedpoint32 WT;
CV_ALWAYS_INLINE fixedpoint16() { val = 0; }
+ CV_ALWAYS_INLINE fixedpoint16(const fixedpoint16& v) { val = v.val; }
CV_ALWAYS_INLINE fixedpoint16(const int8_t& _val) { val = ((int16_t)_val) << fixedShift; }
CV_ALWAYS_INLINE fixedpoint16(const cv::softdouble& _val) { val = (int16_t)cvRound(_val * cv::softdouble((1 << fixedShift))); }
CV_ALWAYS_INLINE fixedpoint16& operator = (const int8_t& _val) { val = ((int16_t)_val) << fixedShift; return *this; }
public:
typedef ufixedpoint32 WT;
CV_ALWAYS_INLINE ufixedpoint16() { val = 0; }
+ CV_ALWAYS_INLINE ufixedpoint16(const ufixedpoint16& v) { val = v.val; }
CV_ALWAYS_INLINE ufixedpoint16(const uint8_t& _val) { val = ((uint16_t)_val) << fixedShift; }
CV_ALWAYS_INLINE ufixedpoint16(const cv::softdouble& _val) { val = _val.getSign() ? 0 : (uint16_t)cvRound(_val * cv::softdouble((int32_t)(1 << fixedShift))); }
CV_ALWAYS_INLINE ufixedpoint16& operator = (const uint8_t& _val) { val = ((uint16_t)_val) << fixedShift; return *this; }