Add Java wrapper support for List<List<Mat>>

- Added vector_vector_Mat to gen_dict.json
- Implemented Mat_to_vector_vector_Mat and vector_vector_Mat_to_Mat conversion functions in converters.h/cpp and Converters.java
- Added DnnForwardAndRetrieve.java test to verify List<List<Mat>> conversion : Reference: C++ test in modules/dnn/test/test_misc.cpp - TEST(Net, forwardAndRetrieve)

modules/java/generator/src/cpp/converters.cpp

@@ -232,6 +232,32 @@ void vector_Mat_to_Mat(std::vector<cv::Mat>& v_mat, cv::Mat& mat)
     }
 }
 
+void Mat_to_vector_vector_Mat(Mat& mat, std::vector< std::vector< Mat > >& vv_mat)
+{
+    std::vector<Mat> vm;
+    vm.reserve( mat.rows );
+    Mat_to_vector_Mat(mat, vm);
+    for(size_t i=0; i<vm.size(); i++)
+    {
+        std::vector<Mat> vmat;
+        Mat_to_vector_Mat(vm[i], vmat);
+        vv_mat.push_back(vmat);
+    }
+}
+
+void vector_vector_Mat_to_Mat(std::vector< std::vector< Mat > >& vv_mat, Mat& mat)
+{
+    std::vector<Mat> vm;
+    vm.reserve( vv_mat.size() );
+    for(size_t i=0; i<vv_mat.size(); i++)
+    {
+        Mat m;
+        vector_Mat_to_Mat(vv_mat[i], m);
+        vm.push_back(m);
+    }
+    vector_Mat_to_Mat(vm, mat);
+}
+
 void Mat_to_vector_vector_Point(Mat& mat, std::vector< std::vector< Point > >& vv_pt)
 {
     std::vector<Mat> vm;

modules/java/generator/src/cpp/converters.h

@@ -50,6 +50,9 @@ void vector_Vec6f_to_Mat(std::vector<cv::Vec6f>& v_vec, cv::Mat& mat);
 void Mat_to_vector_Mat(cv::Mat& mat, std::vector<cv::Mat>& v_mat);
 void vector_Mat_to_Mat(std::vector<cv::Mat>& v_mat, cv::Mat& mat);
 
+void Mat_to_vector_vector_Mat(cv::Mat& mat, std::vector< std::vector< cv::Mat > >& vv_mat);
+void vector_vector_Mat_to_Mat(std::vector< std::vector< cv::Mat > >& vv_mat, cv::Mat& mat);
+
 void Mat_to_vector_vector_char(cv::Mat& mat, std::vector< std::vector< char > >& vv_ch);
 void vector_vector_char_to_Mat(std::vector< std::vector< char > >& vv_ch, cv::Mat& mat);
 

modules/java/generator/src/java/org/opencv/utils/Converters.java

@@ -514,6 +514,41 @@ public class Converters {
         }
     }
 
+    // vector_vector_Mat
+    public static Mat vector_vector_Mat_to_Mat(List<List<Mat>> vecMats, List<Mat> mats) {
+        Mat res;
+        int lCount = (vecMats != null) ? vecMats.size() : 0;
+        if (lCount > 0) {
+            for (List<Mat> matList : vecMats) {
+                Mat mat = vector_Mat_to_Mat(matList);
+                mats.add(mat);
+            }
+            res = vector_Mat_to_Mat(mats);
+        } else {
+            res = new Mat();
+        }
+        return res;
+    }
+
+    public static void Mat_to_vector_vector_Mat(Mat m, List<List<Mat>> vecMats) {
+        if (vecMats == null)
+            throw new IllegalArgumentException("Output List can't be null");
+
+        if (m == null)
+            throw new IllegalArgumentException("Input Mat can't be null");
+
+        vecMats.clear();
+        List<Mat> mats = new ArrayList<Mat>(m.rows());
+        Mat_to_vector_Mat(m, mats);
+        for (Mat mi : mats) {
+            List<Mat> rowList = new ArrayList<Mat>(mi.rows());
+            Mat_to_vector_Mat(mi, rowList);
+            vecMats.add(rowList);
+            mi.release();
+        }
+        mats.clear();
+    }
+
     // vector_vector_Point
     public static Mat vector_vector_Point_to_Mat(List<MatOfPoint> pts, List<Mat> mats) {
         Mat res;