Merge remote-tracking branch 'refs/remotes/upstream/master'

modules/calib3d/CMakeLists.txt

@@ -1,2 +1,2 @@
 set(the_description "Camera Calibration and 3D Reconstruction")
-ocv_define_module(calib3d opencv_imgproc opencv_features2d)
+ocv_define_module(calib3d opencv_imgproc opencv_features2d WRAP java python)

modules/calib3d/src/circlesgrid.cpp

@@ -69,7 +69,7 @@ void drawPoints(const std::vector<Point2f> &points, Mat &outImage, int radius =
 void CirclesGridClusterFinder::hierarchicalClustering(const std::vector<Point2f> &points, const Size &patternSz, std::vector<Point2f> &patternPoints)
 {
 #ifdef HAVE_TEGRA_OPTIMIZATION
-    if(tegra::hierarchicalClustering(points, patternSz, patternPoints))
+    if(tegra::useTegra() && tegra::hierarchicalClustering(points, patternSz, patternPoints))
         return;
 #endif
     int j, n = (int)points.size();

modules/calib3d/src/dls.h

@@ -504,7 +504,7 @@ private:
                 H[n1][n1 - 1] = 0.0;
                 H[n1][n1] = 1.0;
                 for (int i = n1 - 2; i >= 0; i--) {
-                    double ra, sa, vr, vi;
+                    double ra, sa;
                     ra = 0.0;
                     sa = 0.0;
                     for (int j = l; j <= n1; j++) {
@@ -529,8 +529,8 @@ private:
 
                             x = H[i][i + 1];
                             y = H[i + 1][i];
-                            vr = (d[i] - p) * (d[i] - p) + e[i] * e[i] - q * q;
-                            vi = (d[i] - p) * 2.0 * q;
+                            double vr = (d[i] - p) * (d[i] - p) + e[i] * e[i] - q * q;
+                            double vi = (d[i] - p) * 2.0 * q;
                             if (vr == 0.0 && vi == 0.0) {
                                 vr = eps * norm * (std::abs(w) + std::abs(q) + std::abs(x)
                                                    + std::abs(y) + std::abs(z));

modules/calib3d/src/posit.cpp

@@ -116,7 +116,7 @@ static  CvStatus  icvPOSIT( CvPOSITObject *pObject, CvPoint2D32f *imagePoints,
 {
     int i, j, k;
     int count = 0, converged = 0;
-    float inorm, jnorm, invInorm, invJnorm, invScale, scale = 0, inv_Z = 0;
+    float scale = 0, inv_Z = 0;
     float diff = (float)criteria.epsilon;
 
     /* Check bad arguments */
@@ -195,16 +195,18 @@ static  CvStatus  icvPOSIT( CvPOSITObject *pObject, CvPoint2D32f *imagePoints,
             }
         }
 
-        inorm = rotation[0] /*[0][0]*/ * rotation[0] /*[0][0]*/ +
+        float inorm =
+                rotation[0] /*[0][0]*/ * rotation[0] /*[0][0]*/ +
                 rotation[1] /*[0][1]*/ * rotation[1] /*[0][1]*/ +
                 rotation[2] /*[0][2]*/ * rotation[2] /*[0][2]*/;
 
-        jnorm = rotation[3] /*[1][0]*/ * rotation[3] /*[1][0]*/ +
+        float jnorm =
+                rotation[3] /*[1][0]*/ * rotation[3] /*[1][0]*/ +
                 rotation[4] /*[1][1]*/ * rotation[4] /*[1][1]*/ +
                 rotation[5] /*[1][2]*/ * rotation[5] /*[1][2]*/;
 
-        invInorm = cvInvSqrt( inorm );
-        invJnorm = cvInvSqrt( jnorm );
+        const float invInorm = cvInvSqrt( inorm );
+        const float invJnorm = cvInvSqrt( jnorm );
 
         inorm *= invInorm;
         jnorm *= invJnorm;
@@ -234,7 +236,7 @@ static  CvStatus  icvPOSIT( CvPOSITObject *pObject, CvPoint2D32f *imagePoints,
         converged = ((criteria.type & CV_TERMCRIT_EPS) && (diff < criteria.epsilon));
         converged |= ((criteria.type & CV_TERMCRIT_ITER) && (count == criteria.max_iter));
     }
-    invScale = 1 / scale;
+    const float invScale = 1 / scale;
     translation[0] = imagePoints[0].x * invScale;
     translation[1] = imagePoints[0].y * invScale;
     translation[2] = 1 / inv_Z;
@@ -266,8 +268,6 @@ static  CvStatus  icvReleasePOSITObject( CvPOSITObject ** ppObject )
 void
 icvPseudoInverse3D( float *a, float *b, int n, int method )
 {
-    int k;
-
     if( method == 0 )
     {
         float ata00 = 0;
@@ -276,8 +276,8 @@ icvPseudoInverse3D( float *a, float *b, int n, int method )
         float ata01 = 0;
         float ata02 = 0;
         float ata12 = 0;
-        float det = 0;
 
+        int k;
         /* compute matrix ata = transpose(a) * a  */
         for( k = 0; k < n; k++ )
         {
@@ -295,7 +295,6 @@ icvPseudoInverse3D( float *a, float *b, int n, int method )
         }
         /* inverse matrix ata */
         {
-            float inv_det;
             float p00 = ata11 * ata22 - ata12 * ata12;
             float p01 = -(ata01 * ata22 - ata12 * ata02);
             float p02 = ata12 * ata01 - ata11 * ata02;
@@ -304,11 +303,12 @@ icvPseudoInverse3D( float *a, float *b, int n, int method )
             float p12 = -(ata00 * ata12 - ata01 * ata02);
             float p22 = ata00 * ata11 - ata01 * ata01;
 
+            float det = 0;
             det += ata00 * p00;
             det += ata01 * p01;
             det += ata02 * p02;
 
-            inv_det = 1 / det;
+            const float inv_det = 1 / det;
 
             /* compute resultant matrix */
             for( k = 0; k < n; k++ )

modules/core/CMakeLists.txt

@@ -1,5 +1,7 @@
 set(the_description "The Core Functionality")
-ocv_add_module(core PRIVATE_REQUIRED ${ZLIB_LIBRARIES} "${OPENCL_LIBRARIES}" OPTIONAL opencv_cudev)
+ocv_add_module(core PRIVATE_REQUIRED ${ZLIB_LIBRARIES} "${OPENCL_LIBRARIES}"
+               OPTIONAL opencv_cudev
+             WRAP java python)
 
 if(HAVE_WINRT_CX)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /ZW")

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

@@ -191,7 +191,7 @@
 # include "arm_neon.h"
 # define CV_NEON 1
 # define CPU_HAS_NEON_FEATURE (true)
-#elif defined(__ARM_NEON__)
+#elif defined(__ARM_NEON__) || (defined (__ARM_NEON) && defined(__aarch64__))
 #  include <arm_neon.h>
 #  define CV_NEON 1
 #endif

modules/core/include/opencv2/core/private.hpp

@@ -269,6 +269,15 @@ typedef enum CvStatus
 }
 CvStatus;
 
+#ifdef HAVE_TEGRA_OPTIMIZATION
+namespace tegra {
+
+CV_EXPORTS bool useTegra();
+CV_EXPORTS void setUseTegra(bool flag);
+
+}
+#endif
+
 //! @endcond
 
 #endif // __OPENCV_CORE_PRIVATE_HPP__

modules/core/misc/java/filelist

@@ -1,4 +1,4 @@
 include/opencv2/core/base.hpp
 include/opencv2/core.hpp
 include/opencv2/core/utility.hpp
-../java/generator/src/cpp/core_manual.hpp
+misc/java/src/cpp/core_manual.hpp

modules/core/misc/java/src/cpp/core_manual.cpp

@@ -1,6 +1,6 @@
 #define LOG_TAG "org.opencv.core.Core"
 #include "common.h"
-
+#include "core_manual.hpp"
 #include "opencv2/core/utility.hpp"
 
 static int quietCallback( int, const char*, const char*, const char*, int, void* )
@@ -8,10 +8,14 @@ static int quietCallback( int, const char*, const char*, const char*, int, void*
     return 0;
 }
 
-void cv::setErrorVerbosity(bool verbose)
+namespace cv {
+
+void setErrorVerbosity(bool verbose)
 {
     if(verbose)
         cv::redirectError(0);
     else
         cv::redirectError((cv::ErrorCallback)quietCallback);
 }
+
+}

modules/core/src/arithm.cpp

@@ -2256,51 +2256,54 @@ void cv::subtract( InputArray _src1, InputArray _src2, OutputArray _dst,
                InputArray mask, int dtype )
 {
 #ifdef HAVE_TEGRA_OPTIMIZATION
-    int kind1 = _src1.kind(), kind2 = _src2.kind();
-    Mat src1 = _src1.getMat(), src2 = _src2.getMat();
-    bool src1Scalar = checkScalar(src1, _src2.type(), kind1, kind2);
-    bool src2Scalar = checkScalar(src2, _src1.type(), kind2, kind1);
-
-    if (!src1Scalar && !src2Scalar &&
-        src1.depth() == CV_8U && src2.type() == src1.type() &&
-        src1.dims == 2 && src2.size() == src1.size() &&
-        mask.empty())
+    if (tegra::useTegra())
     {
-        if (dtype < 0)
+        int kind1 = _src1.kind(), kind2 = _src2.kind();
+        Mat src1 = _src1.getMat(), src2 = _src2.getMat();
+        bool src1Scalar = checkScalar(src1, _src2.type(), kind1, kind2);
+        bool src2Scalar = checkScalar(src2, _src1.type(), kind2, kind1);
+
+        if (!src1Scalar && !src2Scalar &&
+            src1.depth() == CV_8U && src2.type() == src1.type() &&
+            src1.dims == 2 && src2.size() == src1.size() &&
+            mask.empty())
         {
-            if (_dst.fixedType())
+            if (dtype < 0)
             {
-                dtype = _dst.depth();
+                if (_dst.fixedType())
+                {
+                    dtype = _dst.depth();
+                }
+                else
+                {
+                    dtype = src1.depth();
+                }
             }
-            else
-            {
-                dtype = src1.depth();
-            }
-        }
 
-        dtype = CV_MAT_DEPTH(dtype);
+            dtype = CV_MAT_DEPTH(dtype);
 
-        if (!_dst.fixedType() || dtype == _dst.depth())
-        {
-            _dst.create(src1.size(), CV_MAKE_TYPE(dtype, src1.channels()));
+            if (!_dst.fixedType() || dtype == _dst.depth())
+            {
+                _dst.create(src1.size(), CV_MAKE_TYPE(dtype, src1.channels()));
 
-            if (dtype == CV_16S)
-            {
-                Mat dst = _dst.getMat();
-                if(tegra::subtract_8u8u16s(src1, src2, dst))
-                    return;
-            }
-            else if (dtype == CV_32F)
-            {
-                Mat dst = _dst.getMat();
-                if(tegra::subtract_8u8u32f(src1, src2, dst))
-                    return;
-            }
-            else if (dtype == CV_8S)
-            {
-                Mat dst = _dst.getMat();
-                if(tegra::subtract_8u8u8s(src1, src2, dst))
-                    return;
+                if (dtype == CV_16S)
+                {
+                    Mat dst = _dst.getMat();
+                    if(tegra::subtract_8u8u16s(src1, src2, dst))
+                        return;
+                }
+                else if (dtype == CV_32F)
+                {
+                    Mat dst = _dst.getMat();
+                    if(tegra::subtract_8u8u32f(src1, src2, dst))
+                        return;
+                }
+                else if (dtype == CV_8S)
+                {
+                    Mat dst = _dst.getMat();
+                    if(tegra::subtract_8u8u8s(src1, src2, dst))
+                        return;
+                }
             }
         }
     }

modules/core/src/mathfuncs.cpp

@@ -127,7 +127,7 @@ static void FastAtan2_32f(const float *Y, const float *X, float *angle, int len,
     float scale = angleInDegrees ? 1 : (float)(CV_PI/180);
 
 #ifdef HAVE_TEGRA_OPTIMIZATION
-    if (tegra::FastAtan2_32f(Y, X, angle, len, scale))
+    if (tegra::useTegra() && tegra::FastAtan2_32f(Y, X, angle, len, scale))
         return;
 #endif
 

modules/core/src/precomp.hpp

@@ -236,6 +236,9 @@ struct CoreTLSData
 {
     CoreTLSData() : device(0), useOpenCL(-1), useIPP(-1), useCollection(false)
     {
+#ifdef HAVE_TEGRA_OPTIMIZATION
+        useTegra = -1;
+#endif
 #ifdef CV_COLLECT_IMPL_DATA
         implFlags = 0;
 #endif
@@ -246,6 +249,9 @@ struct CoreTLSData
     ocl::Queue oclQueue;
     int useOpenCL; // 1 - use, 0 - do not use, -1 - auto/not initialized
     int useIPP; // 1 - use, 0 - do not use, -1 - auto/not initialized
+#ifdef HAVE_TEGRA_OPTIMIZATION
+    int useTegra; // 1 - use, 0 - do not use, -1 - auto/not initialized
+#endif
     bool useCollection; // enable/disable impl data collection
 
 #ifdef CV_COLLECT_IMPL_DATA

modules/core/src/stat.cpp

@@ -517,9 +517,11 @@ static const uchar * initPopcountTable()
         unsigned int j = 0u;
 #if CV_POPCNT
         if (checkHardwareSupport(CV_CPU_POPCNT))
+        {
             for( ; j < 256u; j++ )
                 tab[j] = (uchar)(8 - _mm_popcnt_u32(j));
-#else
+        }
+#endif
         for( ; j < 256u; j++ )
         {
             int val = 0;
@@ -527,7 +529,6 @@ static const uchar * initPopcountTable()
                 val += (j & mask) == 0;
             tab[j] = (uchar)val;
         }
-#endif
         initialized = true;
     }
 

modules/core/src/system.cpp

@@ -319,6 +319,9 @@ struct HWFeatures
         }
 
     #if defined ANDROID || defined __linux__
+    #ifdef __aarch64__
+        f.have[CV_CPU_NEON] = true;
+    #else
         int cpufile = open("/proc/self/auxv", O_RDONLY);
 
         if (cpufile >= 0)
@@ -337,7 +340,8 @@ struct HWFeatures
 
             close(cpufile);
         }
-    #elif (defined __clang__ || defined __APPLE__) && defined __ARM_NEON__
+    #endif
+    #elif (defined __clang__ || defined __APPLE__) && (defined __ARM_NEON__ || (defined __ARM_NEON && defined __aarch64__))
         f.have[CV_CPU_NEON] = true;
     #endif
 
@@ -385,6 +389,12 @@ void setUseOptimized( bool flag )
     useOptimizedFlag = flag;
     currentFeatures = flag ? &featuresEnabled : &featuresDisabled;
     USE_SSE2 = currentFeatures->have[CV_CPU_SSE2];
+
+    ipp::setUseIPP(flag);
+    ocl::setUseOpenCL(flag);
+#ifdef HAVE_TEGRA_OPTIMIZATION
+    ::tegra::setUseTegra(flag);
+#endif
 }
 
 bool useOptimized(void)
@@ -1259,4 +1269,34 @@ void setUseIPP(bool flag)
 
 } // namespace cv
 
+#ifdef HAVE_TEGRA_OPTIMIZATION
+
+namespace tegra {
+
+bool useTegra()
+{
+    cv::CoreTLSData* data = cv::getCoreTlsData().get();
+
+    if (data->useTegra < 0)
+    {
+        const char* pTegraEnv = getenv("OPENCV_TEGRA");
+        if (pTegraEnv && (cv::String(pTegraEnv) == "disabled"))
+            data->useTegra = false;
+        else
+            data->useTegra = true;
+    }
+
+    return (data->useTegra > 0);
+}
+
+void setUseTegra(bool flag)
+{
+    cv::CoreTLSData* data = cv::getCoreTlsData().get();
+    data->useTegra = flag;
+}
+
+} // namespace tegra
+
+#endif
+
 /* End of file. */

modules/core/test/test_main.cpp

@@ -7,14 +7,4 @@
 
 #include "test_precomp.hpp"
 
-#ifndef HAVE_CUDA
-
 CV_TEST_MAIN("cv")
-
-#else
-
-#include "opencv2/ts/cuda_test.hpp"
-
-CV_CUDA_TEST_MAIN("cv")
-
-#endif

modules/cudaarithm/test/test_buffer_pool.cpp

@@ -40,7 +40,7 @@
 //
 //M*/
 
-#include "../test_precomp.hpp"
+#include "test_precomp.hpp"
 
 #ifdef HAVE_CUDA
 

modules/cudaarithm/test/test_gpumat.cpp

@@ -40,7 +40,7 @@
 //
 //M*/
 
-#include "../test_precomp.hpp"
+#include "test_precomp.hpp"
 
 #ifdef HAVE_CUDA
 

modules/cudaarithm/test/test_opengl.cpp

@@ -40,7 +40,7 @@
 //
 //M*/
 
-#include "../test_precomp.hpp"
+#include "test_precomp.hpp"
 
 #if defined(HAVE_CUDA) && defined(HAVE_OPENGL)
 

modules/cudaarithm/test/test_stream.cpp

@@ -40,7 +40,7 @@
 //
 //M*/
 
-#include "../test_precomp.hpp"
+#include "test_precomp.hpp"
 
 #ifdef HAVE_CUDA
 

modules/cudalegacy/test/TestHaarCascadeApplication.cpp

@@ -52,7 +52,7 @@ namespace
         ~FpuControl();
 
     private:
-    #if defined(__GNUC__) && !defined(__APPLE__) && !defined(__arm__)
+    #if defined(__GNUC__) && !defined(__APPLE__) && !defined(__arm__) && !defined(__aarch64__)
         fpu_control_t fpu_oldcw, fpu_cw;
     #elif defined(_WIN32) && !defined(_WIN64)
         unsigned int fpu_oldcw, fpu_cw;
@@ -61,7 +61,7 @@ namespace
 
     FpuControl::FpuControl()
     {
-    #if defined(__GNUC__) && !defined(__APPLE__) && !defined(__arm__)
+    #if defined(__GNUC__) && !defined(__APPLE__) && !defined(__arm__) && !defined(__aarch64__)
         _FPU_GETCW(fpu_oldcw);
         fpu_cw = (fpu_oldcw & ~_FPU_EXTENDED & ~_FPU_DOUBLE & ~_FPU_SINGLE) | _FPU_SINGLE;
         _FPU_SETCW(fpu_cw);
@@ -74,7 +74,7 @@ namespace
 
     FpuControl::~FpuControl()
     {
-    #if defined(__GNUC__) && !defined(__APPLE__) && !defined(__arm__)
+    #if defined(__GNUC__) && !defined(__APPLE__) && !defined(__arm__) && !defined(__aarch64__)
         _FPU_SETCW(fpu_oldcw);
     #elif defined(_WIN32) && !defined(_WIN64)
         _controlfp_s(&fpu_cw, fpu_oldcw, _MCW_PC);

modules/cudalegacy/test/test_precomp.hpp

@@ -51,7 +51,7 @@
 #ifndef __OPENCV_TEST_PRECOMP_HPP__
 #define __OPENCV_TEST_PRECOMP_HPP__
 
-#if defined(__GNUC__) && !defined(__APPLE__) && !defined(__arm__)
+#if defined(__GNUC__) && !defined(__APPLE__) && !defined(__arm__) && !defined(__aarch64__)
     #include <fpu_control.h>
 #endif
 

modules/cudaobjdetect/include/opencv2/cudaobjdetect.hpp

@@ -207,7 +207,7 @@ public:
 
     @param filename Name of the file from which the classifier is loaded. Only the old haar classifier
     (trained by the haar training application) and NVIDIA's nvbin are supported for HAAR and only new
-    type of OpenCV XML cascade supported for LBP.
+    type of OpenCV XML cascade supported for LBP. The working haar models can be found at opencv_folder/data/haarcascades_cuda/
      */
     static Ptr<CascadeClassifier> create(const String& filename);
     /** @overload

modules/features2d/CMakeLists.txt

@@ -1,2 +1,2 @@
 set(the_description "2D Features Framework")
-ocv_define_module(features2d opencv_imgproc opencv_ml opencv_flann OPTIONAL opencv_highgui)
+ocv_define_module(features2d opencv_imgproc opencv_ml opencv_flann OPTIONAL opencv_highgui WRAP java python)

modules/features2d/misc/java/filelist

@@ -0,0 +1 @@
+misc/java/src/cpp/features2d_manual.hpp

modules/features2d/misc/java/src/cpp/features2d_converters.cpp

@@ -0,0 +1,112 @@
+#define LOG_TAG "org.opencv.utils.Converters"
+#include "common.h"
+#include "features2d_converters.hpp"
+
+using namespace cv;
+
+#define CHECK_MAT(cond) if(!(cond)){ LOGD("FAILED: " #cond); return; }
+
+
+//vector_KeyPoint
+void Mat_to_vector_KeyPoint(Mat& mat, std::vector<KeyPoint>& v_kp)
+{
+    v_kp.clear();
+    CHECK_MAT(mat.type()==CV_32FC(7) && mat.cols==1);
+    for(int i=0; i<mat.rows; i++)
+    {
+        Vec<float, 7> v = mat.at< Vec<float, 7> >(i, 0);
+        KeyPoint kp(v[0], v[1], v[2], v[3], v[4], (int)v[5], (int)v[6]);
+        v_kp.push_back(kp);
+    }
+    return;
+}
+
+
+void vector_KeyPoint_to_Mat(std::vector<KeyPoint>& v_kp, Mat& mat)
+{
+    int count = (int)v_kp.size();
+    mat.create(count, 1, CV_32FC(7));
+    for(int i=0; i<count; i++)
+    {
+        KeyPoint kp = v_kp[i];
+        mat.at< Vec<float, 7> >(i, 0) = Vec<float, 7>(kp.pt.x, kp.pt.y, kp.size, kp.angle, kp.response, (float)kp.octave, (float)kp.class_id);
+    }
+}
+
+//vector_DMatch
+void Mat_to_vector_DMatch(Mat& mat, std::vector<DMatch>& v_dm)
+{
+    v_dm.clear();
+    CHECK_MAT(mat.type()==CV_32FC4 && mat.cols==1);
+    for(int i=0; i<mat.rows; i++)
+    {
+        Vec<float, 4> v = mat.at< Vec<float, 4> >(i, 0);
+        DMatch dm((int)v[0], (int)v[1], (int)v[2], v[3]);
+        v_dm.push_back(dm);
+    }
+    return;
+}
+
+
+void vector_DMatch_to_Mat(std::vector<DMatch>& v_dm, Mat& mat)
+{
+    int count = (int)v_dm.size();
+    mat.create(count, 1, CV_32FC4);
+    for(int i=0; i<count; i++)
+    {
+        DMatch dm = v_dm[i];
+        mat.at< Vec<float, 4> >(i, 0) = Vec<float, 4>((float)dm.queryIdx, (float)dm.trainIdx, (float)dm.imgIdx, dm.distance);
+    }
+}
+
+void Mat_to_vector_vector_KeyPoint(Mat& mat, std::vector< std::vector< KeyPoint > >& vv_kp)
+{
+    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<KeyPoint> vkp;
+        Mat_to_vector_KeyPoint(vm[i], vkp);
+        vv_kp.push_back(vkp);
+    }
+}
+
+void vector_vector_KeyPoint_to_Mat(std::vector< std::vector< KeyPoint > >& vv_kp, Mat& mat)
+{
+    std::vector<Mat> vm;
+    vm.reserve( vv_kp.size() );
+    for(size_t i=0; i<vv_kp.size(); i++)
+    {
+        Mat m;
+        vector_KeyPoint_to_Mat(vv_kp[i], m);
+        vm.push_back(m);
+    }
+    vector_Mat_to_Mat(vm, mat);
+}
+
+void Mat_to_vector_vector_DMatch(Mat& mat, std::vector< std::vector< DMatch > >& vv_dm)
+{
+    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<DMatch> vdm;
+        Mat_to_vector_DMatch(vm[i], vdm);
+        vv_dm.push_back(vdm);
+    }
+}
+
+void vector_vector_DMatch_to_Mat(std::vector< std::vector< DMatch > >& vv_dm, Mat& mat)
+{
+    std::vector<Mat> vm;
+    vm.reserve( vv_dm.size() );
+    for(size_t i=0; i<vv_dm.size(); i++)
+    {
+        Mat m;
+        vector_DMatch_to_Mat(vv_dm[i], m);
+        vm.push_back(m);
+    }
+    vector_Mat_to_Mat(vm, mat);
+}

modules/features2d/misc/java/src/cpp/features2d_converters.hpp

@@ -0,0 +1,22 @@
+#ifndef __FEATURES2D_CONVERTERS_HPP__
+#define __FEATURES2D_CONVERTERS_HPP__
+
+#include "opencv2/opencv_modules.hpp"
+#include "opencv2/core.hpp"
+
+#include "features2d_manual.hpp"
+
+void Mat_to_vector_KeyPoint(cv::Mat& mat, std::vector<cv::KeyPoint>& v_kp);
+void vector_KeyPoint_to_Mat(std::vector<cv::KeyPoint>& v_kp, cv::Mat& mat);
+
+void Mat_to_vector_DMatch(cv::Mat& mat, std::vector<cv::DMatch>& v_dm);
+void vector_DMatch_to_Mat(std::vector<cv::DMatch>& v_dm, cv::Mat& mat);
+
+void Mat_to_vector_vector_KeyPoint(cv::Mat& mat, std::vector< std::vector< cv::KeyPoint > >& vv_kp);
+void vector_vector_KeyPoint_to_Mat(std::vector< std::vector< cv::KeyPoint > >& vv_kp, cv::Mat& mat);
+
+void Mat_to_vector_vector_DMatch(cv::Mat& mat, std::vector< std::vector< cv::DMatch > >& vv_dm);
+void vector_vector_DMatch_to_Mat(std::vector< std::vector< cv::DMatch > >& vv_dm, cv::Mat& mat);
+
+
+#endif

modules/features2d/misc/java/src/cpp/features2d_manual.hpp

@@ -5,6 +5,7 @@
 
 #ifdef HAVE_OPENCV_FEATURES2D
 #include "opencv2/features2d.hpp"
+#include "features2d_converters.hpp"
 
 #undef SIMPLEBLOB // to solve conflict with wincrypt.h on windows