Merge remote-tracking branch 'upstream/3.4' into merge-3.4

alalek · alalek · commit 583bd1a6e20c · 2022-06-04T19:10:35.000Z
diff --git a/doc/js_tutorials/js_setup/js_usage/js_usage.markdown b/doc/js_tutorials/js_setup/js_usage/js_usage.markdown
@@ -122,11 +122,14 @@ imgElement.onload = function() {
   mat.delete();
 };
 
-function onOpenCvReady() {
-  document.getElementById('status').innerHTML = 'OpenCV.js is ready.';
-}
+var Module = {
+  // https://emscripten.org/docs/api_reference/module.html#Module.onRuntimeInitialized
+  onRuntimeInitialized() {
+    document.getElementById('status').innerHTML = 'OpenCV.js is ready.';
+  }
+};
 </script>
-<script async src="opencv.js" onload="onOpenCvReady();" type="text/javascript"></script>
+<script async src="opencv.js" type="text/javascript"></script>
 </body>
 </html>
 @endcode
diff --git a/doc/opencv.bib b/doc/opencv.bib
@@ -1348,3 +1348,13 @@ @article{umeyama1991least
   year={1991},
   publisher={IEEE Computer Society}
 }
+@article{Kannala2006,
+  author = {Kannala, Juho and Brandt, Sami},
+  year = {2006},
+  month = {09},
+  pages = {1335-40},
+  title = {A Generic Camera Model and Calibration Method for Conventional, Wide-Angle, and Fish-Eye Lenses},
+  volume = {28},
+  journal = {IEEE transactions on pattern analysis and machine intelligence},
+  doi = {10.1109/TPAMI.2006.153}
+}
diff --git a/modules/calib3d/include/opencv2/calib3d.hpp b/modules/calib3d/include/opencv2/calib3d.hpp
@@ -430,6 +430,9 @@ R & t \\
     \f[u = f_x (x' + \alpha y') + c_x \\
     v = f_y y' + c_y\f]
 
+    Summary:
+    Generic camera model @cite Kannala2006 with perspective projection and without distortion correction
+
     @defgroup calib3d_c C API
 
   @}
@@ -3883,7 +3886,7 @@ namespace fisheye
     CV_EXPORTS_W void estimateNewCameraMatrixForUndistortRectify(InputArray K, InputArray D, const Size &image_size, InputArray R,
         OutputArray P, double balance = 0.0, const Size& new_size = Size(), double fov_scale = 1.0);
 
-    /** @brief Performs camera calibaration
+    /** @brief Performs camera calibration
 
     @param objectPoints vector of vectors of calibration pattern points in the calibration pattern
     coordinate space.
diff --git a/modules/core/src/precomp.hpp b/modules/core/src/precomp.hpp
@@ -365,6 +365,7 @@ extern CV_EXPORTS
 bool __termination;  // skip some cleanups, because process is terminating
                      // (for example, if ExitProcess() was already called)
 
+CV_EXPORTS
 cv::Mutex& getInitializationMutex();
 
 /// @brief Returns timestamp in nanoseconds since program launch
diff --git a/modules/dnn/src/darknet/darknet_importer.cpp b/modules/dnn/src/darknet/darknet_importer.cpp
@@ -207,7 +207,7 @@ Net readNetFromDarknet(const String &cfgFile, const String &darknetModel /*= Str
     std::ifstream cfgStream(cfgFile.c_str());
     if (!cfgStream.is_open())
     {
-        CV_Error(cv::Error::StsParseError, "Failed to parse NetParameter file: " + std::string(cfgFile));
+        CV_Error(cv::Error::StsParseError, "Failed to open NetParameter file: " + std::string(cfgFile));
     }
     if (darknetModel != String())
     {
diff --git a/modules/dnn/src/tensorflow/tf_graph_simplifier.cpp b/modules/dnn/src/tensorflow/tf_graph_simplifier.cpp
@@ -990,6 +990,7 @@ void sortByExecutionOrder(tensorflow::GraphDef& net)
         nodesMap.insert(std::make_pair(node.name(), i));
     }
 
+    CV_CheckEQ(nodesMap.size(), (size_t)net.node_size(), "Node names must be unique");
     // Indices of nodes which use specific node as input.
     std::vector<std::vector<int> > edges(nodesMap.size());
     std::vector<int> numRefsToAdd(nodesMap.size(), 0);
@@ -1007,7 +1008,7 @@ void sortByExecutionOrder(tensorflow::GraphDef& net)
             nodesMapIt = nodesMap.find(inpName);
             if (nodesMapIt != nodesMap.end())
             {
-                edges[nodesMapIt->second].push_back(i);
+                edges.at(nodesMapIt->second).push_back(i);
                 numInputsInGraph += 1;
             }
         }
@@ -1019,11 +1020,11 @@ void sortByExecutionOrder(tensorflow::GraphDef& net)
             {
                 int numControlEdges = 0;
                 for (int j = 0; j < numInputsInGraph; ++j)
-                    numControlEdges += node.input(j)[0] == '^';
-                numRefsToAdd[i] = numControlEdges + 1;
+                    numControlEdges += node.input(j).at(0) == '^';
+                numRefsToAdd.at(i) = numControlEdges + 1;
             }
             else
-                numRefsToAdd[i] = numInputsInGraph;
+                numRefsToAdd.at(i) = numInputsInGraph;
         }
     }
 
@@ -1035,17 +1036,16 @@ void sortByExecutionOrder(tensorflow::GraphDef& net)
         nodesToAdd.pop_back();
 
         permIds.push_back(nodeToAdd);
-        CV_Assert(nodeToAdd < edges.size());
-        for (int i = 0; i < edges[nodeToAdd].size(); ++i)
+        for (int i = 0; i < edges.at(nodeToAdd).size(); ++i)
         {
-            int consumerId = edges[nodeToAdd][i];
-            if (numRefsToAdd[consumerId] > 0)
+            int consumerId = edges.at(nodeToAdd).at(i);
+            if (numRefsToAdd.at(consumerId) > 0)
             {
-                if (numRefsToAdd[consumerId] == 1)
+                if (numRefsToAdd.at(consumerId) == 1)
                     nodesToAdd.push_back(consumerId);
                 else
-                    CV_Assert(numRefsToAdd[consumerId] >= 0);
-                numRefsToAdd[consumerId] -= 1;
+                    CV_Assert(numRefsToAdd.at(consumerId) >= 0);
+                numRefsToAdd.at(consumerId) -= 1;
             }
         }
     }
diff --git a/modules/dnn/test/test_tf_importer.cpp b/modules/dnn/test/test_tf_importer.cpp
@@ -1719,13 +1719,6 @@ TEST_P(Test_TensorFlow_layers, tf2_permute_nhwc_ncwh)
     runTensorFlowNet("tf2_permute_nhwc_ncwh");
 }
 
-// issue #21852
-TEST_P(Test_TensorFlow_layers, tf_graph_simplifier_buffer_overflow)
-{
-    // This just shouldn't segfault, otherwise it's fine
-    EXPECT_ANY_THROW(readNetFromTensorflow(path("tf_graph_simplifier_buffer_overflow_net.pb")));
-}
-
 TEST_P(Test_TensorFlow_layers, squeeze)
 {
 #if defined(INF_ENGINE_RELEASE)
@@ -1899,4 +1892,25 @@ TEST_P(Test_TensorFlow_nets, EfficientDet)
     expectNoFallbacksFromIE(net);
 }
 
+TEST(Test_TensorFlow_Importer, tf_graph_simplifier_buffer_overflow_21852)
+{
+    uint8_t payload[] = {0x08, 0x08, 0x0a, 0x00, 0x0a, 0x00};
+    EXPECT_ANY_THROW(readNetFromTensorflow(reinterpret_cast<const char*>(payload), sizeof(payload) / sizeof(payload[0])));
+}
+
+// can be triggered with -fsanitize=address
+TEST(Test_TensorFlow_Importer, tf_graph_simplifier_buffer_overflow_21947)
+{
+    uint8_t payload[] = {0x0a, 0x00, 0x0a, 0x00, 0x0a, 0x00, 0x0a, 0x00, 0x0a, 0x00, 0x0a, 0x00,
+                                0xba, 0x0a, 0x00, 0x0a, 0x00, 0x0a, 0x00, 0x0a, 0x00, 0x0a, 0x00,
+                                0x0a, 0xbd, 0x00, 0x1a, 0x00, 0x0a, 0x00, 0x0a, 0x00, 0xba,
+                                0x0a, 0x00, 0x0a, 0x00, 0x0a, 0x00, 0x0a, 0x00, 0x0a, 0x00, 0x0a, 0x00,
+                                0x0a, 0x00, 0x0a, 0x00, 0x0a, 0x00, 0x0a, 0x00, 0xba, 0x0a, 0x00,
+                                0x0a, 0x00, 0x0a, 0x00, 0x0a, 0x00, 0x0a, 0x00, 0x0a, 0x00, 0xba,
+                                0x0a, 0x00, 0x0a, 0x00, 0x0a, 0x00, 0x0a, 0x00, 0x0a, 0x00, 0x0a, 0x00,
+                                0x0a, 0x00, 0x0a, 0x00, 0x0a, 0x00, 0x2a, 0x00, 0xba, 0x0a, 0x00,
+                                0x0a, 0x00, 0x5d, 0x00, 0x0a, 0x00, 0x0a, 0x00, 0x0a, 0x00, 0x0a, 0x40};
+    EXPECT_ANY_THROW(readNetFromTensorflow(reinterpret_cast<const char*>(payload), sizeof(payload) / sizeof(payload[0])));
+}
+
 }
diff --git a/modules/flann/include/opencv2/flann.hpp b/modules/flann/include/opencv2/flann.hpp
@@ -116,7 +116,7 @@ cv::flann::L2 - Squared Euclidean distance functor, optimized version.
 
 cv::flann::L1 - Manhattan distance functor, optimized version.
 
-cv::flann::MinkowskiDistance -  The Minkowsky distance functor.
+cv::flann::MinkowskiDistance -  The Minkowski distance functor.
 This is highly optimised with loop unrolling.
 The computation of squared root at the end is omitted for efficiency.
 
diff --git a/modules/flann/include/opencv2/flann/dist.h b/modules/flann/include/opencv2/flann/dist.h
@@ -375,7 +375,7 @@ struct MinkowskiDistance
     MinkowskiDistance(int order_) : order(order_) {}
 
     /**
-     *  Compute the Minkowsky (L_p) distance between two vectors.
+     *  Compute the Minkowski (L_p) distance between two vectors.
      *
      *	This is highly optimised, with loop unrolling, as it is one
      *	of the most expensive inner loops.
diff --git a/modules/highgui/src/window_QT.cpp b/modules/highgui/src/window_QT.cpp
@@ -2198,23 +2198,58 @@ void CvWindow::displayPropertiesWin()
         global_control_panel->hide();
 }
 
+static bool isTranslatableKey(Qt::Key key)
+{
+    // https://github.com/opencv/opencv/issues/21899
+    // https://doc.qt.io/qt-5/qt.html#Key-enum
+    // https://doc.qt.io/qt-6/qt.html#Key-enum
+    // https://github.com/qt/qtbase/blob/dev/src/testlib/qasciikey.cpp
+
+    bool ret = false;
+
+    switch ( key )
+    {
+        // Special keys
+        case Qt::Key_Escape:
+        case Qt::Key_Tab:
+        case Qt::Key_Backtab:
+        case Qt::Key_Backspace:
+        case Qt::Key_Enter:
+        case Qt::Key_Return:
+            ret = true;
+            break;
+
+        // latin-1 keys.
+        default:
+        ret = (
+            ( ( Qt::Key_Space        <= key ) && ( key <= Qt::Key_AsciiTilde ) ) // 0x20--0x7e
+            ||
+            ( ( Qt::Key_nobreakspace <= key ) && ( key <= Qt::Key_ssharp     ) ) // 0x0a0--0x0de
+            ||
+            ( key == Qt::Key_division )                                          // 0x0f7
+            ||
+            ( key == Qt::Key_ydiaeresis )                                        // 0x0ff
+        );
+        break;
+    }
+
+    return ret;
+}
 
 //Need more test here !
 void CvWindow::keyPressEvent(QKeyEvent *evnt)
 {
-    //see http://doc.trolltech.com/4.6/qt.html#Key-enum
     int key = evnt->key();
+    const Qt::Key qtkey = static_cast<Qt::Key>(key);
 
-        Qt::Key qtkey = static_cast<Qt::Key>(key);
-        char asciiCode = QTest::keyToAscii(qtkey);
-        if (asciiCode != 0)
-            key = static_cast<int>(asciiCode);
-        else
-            key = evnt->nativeVirtualKey(); //same codes as returned by GTK-based backend
+    if ( isTranslatableKey( qtkey ) )
+        key = static_cast<int>( QTest::keyToAscii( qtkey ) );
+    else
+        key = evnt->nativeVirtualKey(); //same codes as returned by GTK-based backend
 
     //control plus (Z, +, -, up, down, left, right) are used for zoom/panning functions
-        if (evnt->modifiers() != Qt::ControlModifier)
-        {
+    if (evnt->modifiers() != Qt::ControlModifier)
+    {
         mutexKey.lock();
         last_key = key;
         mutexKey.unlock();
diff --git a/modules/imgproc/src/color_hsv.simd.hpp b/modules/imgproc/src/color_hsv.simd.hpp
@@ -39,36 +39,51 @@ struct RGB2HSV_b
     : srccn(_srccn), blueIdx(_blueIdx), hrange(_hrange)
     {
         CV_Assert( hrange == 180 || hrange == 256 );
+
+        const TablesSingleton& global_tables = TablesSingleton::getInstance();
+        hdiv_table_ = hrange == 180 ? global_tables.hdiv_table180 : global_tables.hdiv_table256;
+        sdiv_table_ = global_tables.sdiv_table;
     }
 
-    void operator()(const uchar* src, uchar* dst, int n) const
+    struct TablesSingleton
     {
-        CV_INSTRUMENT_REGION();
-
-        int i, bidx = blueIdx, scn = srccn;
-        const int hsv_shift = 12;
+        int sdiv_table[256];
+        int hdiv_table180[256];
+        int hdiv_table256[256];
 
-        static int sdiv_table[256];
-        static int hdiv_table180[256];
-        static int hdiv_table256[256];
-        static volatile bool initialized = false;
-
-        int hr = hrange;
-        const int* hdiv_table = hr == 180 ? hdiv_table180 : hdiv_table256;
-
-        if( !initialized )
+    protected:
+        TablesSingleton()
         {
+            const int hsv_shift = 12;
+
             sdiv_table[0] = hdiv_table180[0] = hdiv_table256[0] = 0;
-            for( i = 1; i < 256; i++ )
+            for (int i = 1; i < 256; i++)
             {
                 sdiv_table[i] = saturate_cast<int>((255 << hsv_shift)/(1.*i));
                 hdiv_table180[i] = saturate_cast<int>((180 << hsv_shift)/(6.*i));
                 hdiv_table256[i] = saturate_cast<int>((256 << hsv_shift)/(6.*i));
             }
-            initialized = true;
         }
+    public:
+        static TablesSingleton& getInstance()
+        {
+            static TablesSingleton g_tables;
+            return g_tables;
+        }
+    };
+
+    void operator()(const uchar* src, uchar* dst, int n) const
+    {
+        CV_INSTRUMENT_REGION();
 
-        i = 0;
+        int bidx = blueIdx, scn = srccn;
+        const int hsv_shift = 12;
+
+        int hr = hrange;
+        const int* hdiv_table/*[256]*/ = hdiv_table_;
+        const int* sdiv_table/*[256]*/ = sdiv_table_;
+
+        int i = 0;
 
 #if CV_SIMD
         const int vsize = v_uint8::nlanes;
@@ -231,6 +246,9 @@ struct RGB2HSV_b
     }
 
     int srccn, blueIdx, hrange;
+
+    const int* hdiv_table_/*[256]*/;
+    const int* sdiv_table_/*[256]*/;
 };
 
 
diff --git a/modules/imgproc/src/precomp.hpp b/modules/imgproc/src/precomp.hpp
@@ -115,4 +115,12 @@ inline bool isStorageOrMat(void * arr)
     CV_Error( CV_StsBadArg, "Destination is not CvMemStorage* nor CvMat*" );
 }
 
-#endif /*__OPENCV_CV_INTERNAL_H_*/
+
+namespace cv {
+
+CV_EXPORTS
+cv::Mutex& getInitializationMutex();  // defined in core module
+
+}  // namespace cv
+
+#endif /*__OPENCV_PRECOMP_H__*/
diff --git a/modules/objdetect/perf/perf_qrcode_pipeline.cpp b/modules/objdetect/perf/perf_qrcode_pipeline.cpp
@@ -106,10 +106,11 @@ PERF_TEST_P_(Perf_Objdetect_QRCode_Multi, decodeMulti)
 INSTANTIATE_TEST_CASE_P(/*nothing*/, Perf_Objdetect_QRCode,
     ::testing::Values(
         "version_1_down.jpg", "version_1_left.jpg", "version_1_right.jpg", "version_1_up.jpg", "version_1_top.jpg",
-        "version_5_down.jpg", "version_5_left.jpg", "version_5_right.jpg", "version_5_up.jpg", "version_5_top.jpg",
+        "version_5_down.jpg", "version_5_left.jpg",/*version_5_right.jpg*/ "version_5_up.jpg", "version_5_top.jpg",
         "russian.jpg", "kanji.jpg", "link_github_ocv.jpg", "link_ocv.jpg", "link_wiki_cv.jpg"
     )
 );
+// version_5_right.jpg DISABLED after tile fix, PR #22025
 
 INSTANTIATE_TEST_CASE_P(/*nothing*/, Perf_Objdetect_QRCode_Multi,
     ::testing::Values(
diff --git a/modules/objdetect/src/qrcode.cpp b/modules/objdetect/src/qrcode.cpp
diff --git a/modules/objdetect/src/qrcode_encoder.cpp b/modules/objdetect/src/qrcode_encoder.cpp
diff --git a/modules/objdetect/test/test_qrcode.cpp b/modules/objdetect/test/test_qrcode.cpp
diff --git a/modules/objdetect/test/test_qrcode_encode.cpp b/modules/objdetect/test/test_qrcode_encode.cpp

Original file line number	Diff line number	Diff line change
`@@ -207,7 +207,7 @@ Net readNetFromDarknet(const String &cfgFile, const String &darknetModel /*= Str`
`207`	`207`	`std::ifstream cfgStream(cfgFile.c_str());`
`208`	`208`	`if (!cfgStream.is_open())`
`209`	`209`	`{`
`210`		`- CV_Error(cv::Error::StsParseError, "Failed to parse NetParameter file: " + std::string(cfgFile));`
	`210`	`+ CV_Error(cv::Error::StsParseError, "Failed to open NetParameter file: " + std::string(cfgFile));`
`211`	`211`	`}`
`212`	`212`	`if (darknetModel != String())`
`213`	`213`	`{`
Original file line number	Diff line number	Diff line change
`@@ -990,6 +990,7 @@ void sortByExecutionOrder(tensorflow::GraphDef& net)`
`990`	`990`	`nodesMap.insert(std::make_pair(node.name(), i));`
`991`	`991`	`}`
`992`	`992`
	`993`	`+ CV_CheckEQ(nodesMap.size(), (size_t)net.node_size(), "Node names must be unique");`
`993`	`994`	`// Indices of nodes which use specific node as input.`
`994`	`995`	`std::vector<std::vector<int> > edges(nodesMap.size());`
`995`	`996`	`std::vector<int> numRefsToAdd(nodesMap.size(), 0);`
`@@ -1007,7 +1008,7 @@ void sortByExecutionOrder(tensorflow::GraphDef& net)`
`1007`	`1008`	`nodesMapIt = nodesMap.find(inpName);`
`1008`	`1009`	`if (nodesMapIt != nodesMap.end())`
`1009`	`1010`	`{`
`1010`		`- edges[nodesMapIt->second].push_back(i);`
	`1011`	`+ edges.at(nodesMapIt->second).push_back(i);`
`1011`	`1012`	`numInputsInGraph += 1;`
`1012`	`1013`	`}`
`1013`	`1014`	`}`
`@@ -1019,11 +1020,11 @@ void sortByExecutionOrder(tensorflow::GraphDef& net)`
`1019`	`1020`	`{`
`1020`	`1021`	`int numControlEdges = 0;`
`1021`	`1022`	`for (int j = 0; j < numInputsInGraph; ++j)`
`1022`		`- numControlEdges += node.input(j)[0] == '^';`
`1023`		`- numRefsToAdd[i] = numControlEdges + 1;`
	`1023`	`+ numControlEdges += node.input(j).at(0) == '^';`
	`1024`	`+ numRefsToAdd.at(i) = numControlEdges + 1;`
`1024`	`1025`	`}`
`1025`	`1026`	`else`
`1026`		`- numRefsToAdd[i] = numInputsInGraph;`
	`1027`	`+ numRefsToAdd.at(i) = numInputsInGraph;`
`1027`	`1028`	`}`
`1028`	`1029`	`}`
`1029`	`1030`
`@@ -1035,17 +1036,16 @@ void sortByExecutionOrder(tensorflow::GraphDef& net)`
`1035`	`1036`	`nodesToAdd.pop_back();`
`1036`	`1037`
`1037`	`1038`	`permIds.push_back(nodeToAdd);`
`1038`		`- CV_Assert(nodeToAdd < edges.size());`
`1039`		`- for (int i = 0; i < edges[nodeToAdd].size(); ++i)`
	`1039`	`+ for (int i = 0; i < edges.at(nodeToAdd).size(); ++i)`
`1040`	`1040`	`{`
`1041`		`- int consumerId = edges[nodeToAdd][i];`
`1042`		`- if (numRefsToAdd[consumerId] > 0)`
	`1041`	`+ int consumerId = edges.at(nodeToAdd).at(i);`
	`1042`	`+ if (numRefsToAdd.at(consumerId) > 0)`
`1043`	`1043`	`{`
`1044`		`- if (numRefsToAdd[consumerId] == 1)`
	`1044`	`+ if (numRefsToAdd.at(consumerId) == 1)`
`1045`	`1045`	`nodesToAdd.push_back(consumerId);`
`1046`	`1046`	`else`
`1047`		`- CV_Assert(numRefsToAdd[consumerId] >= 0);`
`1048`		`- numRefsToAdd[consumerId] -= 1;`
	`1047`	`+ CV_Assert(numRefsToAdd.at(consumerId) >= 0);`
	`1048`	`+ numRefsToAdd.at(consumerId) -= 1;`
`1049`	`1049`	`}`
`1050`	`1050`	`}`
`1051`	`1051`	`}`
Original file line number	Diff line number	Diff line change
`@@ -375,7 +375,7 @@ struct MinkowskiDistance`
`375`	`375`	`MinkowskiDistance(int order_) : order(order_) {}`
`376`	`376`
`377`	`377`	`/**`
`378`		`- * Compute the Minkowsky (L_p) distance between two vectors.`
	`378`	`+ * Compute the Minkowski (L_p) distance between two vectors.`
`379`	`379`	`*`
`380`	`380`	`* This is highly optimised, with loop unrolling, as it is one`
`381`	`381`	`* of the most expensive inner loops.`