Modified java wrapping mechanism

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)

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)
 
 if(HAVE_WINRT_CX)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /ZW")

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/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)

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