1
2//
3// This file is auto-generated, please don't edit!
4//
5
6#define LOG_TAG "org.opencv.features2d"
7
8#include "common.h"
9
10#include "opencv2/opencv_modules.hpp"
11#ifdef HAVE_OPENCV_FEATURES2D
12
13#include <string>
14
15#include "opencv2/features2d.hpp"
16
17#include "../../features2d/misc/java/src/cpp/features2d_manual.hpp"
18
19using namespace cv;
20
21/// throw java exception
22static void throwJavaException(JNIEnv *env, const std::exception *e, const char *method) {
23  std::string what = "unknown exception";
24  jclass je = 0;
25
26  if(e) {
27    std::string exception_type = "std::exception";
28
29    if(dynamic_cast<const cv::Exception*>(e)) {
30      exception_type = "cv::Exception";
31      je = env->FindClass("org/opencv/core/CvException");
32    }
33
34    what = exception_type + ": " + e->what();
35  }
36
37  if(!je) je = env->FindClass("java/lang/Exception");
38  env->ThrowNew(je, what.c_str());
39
40  LOGE("%s caught %s", method, what.c_str());
41  (void)method;        // avoid "unused" warning
42}
43
44
45extern "C" {
46
47
48//
49//  void compute(Mat image, vector_KeyPoint& keypoints, Mat descriptors)
50//
51
52JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorExtractor_compute_10 (JNIEnv*, jclass, jlong, jlong, jlong, jlong);
53
54JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorExtractor_compute_10
55  (JNIEnv* env, jclass , jlong self, jlong image_nativeObj, jlong keypoints_mat_nativeObj, jlong descriptors_nativeObj)
56{
57    static const char method_name[] = "features2d::compute_10()";
58    try {
59        LOGD("%s", method_name);
60        std::vector<KeyPoint> keypoints;
61        Mat& keypoints_mat = *((Mat*)keypoints_mat_nativeObj);
62        Mat_to_vector_KeyPoint( keypoints_mat, keypoints );
63        cv::javaDescriptorExtractor* me = (cv::javaDescriptorExtractor*) self; //TODO: check for NULL
64        Mat& image = *((Mat*)image_nativeObj);
65        Mat& descriptors = *((Mat*)descriptors_nativeObj);
66        me->compute( image, keypoints, descriptors );
67        vector_KeyPoint_to_Mat( keypoints, keypoints_mat );
68        return;
69    } catch(const std::exception &e) {
70        throwJavaException(env, &e, method_name);
71    } catch (...) {
72        throwJavaException(env, 0, method_name);
73    }
74    return;
75}
76
77
78
79//
80//  void compute(vector_Mat images, vector_vector_KeyPoint& keypoints, vector_Mat& descriptors)
81//
82
83JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorExtractor_compute_11 (JNIEnv*, jclass, jlong, jlong, jlong, jlong);
84
85JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorExtractor_compute_11
86  (JNIEnv* env, jclass , jlong self, jlong images_mat_nativeObj, jlong keypoints_mat_nativeObj, jlong descriptors_mat_nativeObj)
87{
88    static const char method_name[] = "features2d::compute_11()";
89    try {
90        LOGD("%s", method_name);
91        std::vector<Mat> images;
92        Mat& images_mat = *((Mat*)images_mat_nativeObj);
93        Mat_to_vector_Mat( images_mat, images );
94        std::vector< std::vector<KeyPoint> > keypoints;
95        Mat& keypoints_mat = *((Mat*)keypoints_mat_nativeObj);
96        Mat_to_vector_vector_KeyPoint( keypoints_mat, keypoints );
97        std::vector<Mat> descriptors;
98        Mat& descriptors_mat = *((Mat*)descriptors_mat_nativeObj);
99        cv::javaDescriptorExtractor* me = (cv::javaDescriptorExtractor*) self; //TODO: check for NULL
100        me->compute( images, keypoints, descriptors );
101        vector_vector_KeyPoint_to_Mat( keypoints, keypoints_mat );  vector_Mat_to_Mat( descriptors, descriptors_mat );
102        return;
103    } catch(const std::exception &e) {
104        throwJavaException(env, &e, method_name);
105    } catch (...) {
106        throwJavaException(env, 0, method_name);
107    }
108    return;
109}
110
111
112
113//
114//  int descriptorSize()
115//
116
117JNIEXPORT jint JNICALL Java_org_opencv_features2d_DescriptorExtractor_descriptorSize_10 (JNIEnv*, jclass, jlong);
118
119JNIEXPORT jint JNICALL Java_org_opencv_features2d_DescriptorExtractor_descriptorSize_10
120  (JNIEnv* env, jclass , jlong self)
121{
122    static const char method_name[] = "features2d::descriptorSize_10()";
123    try {
124        LOGD("%s", method_name);
125        cv::javaDescriptorExtractor* me = (cv::javaDescriptorExtractor*) self; //TODO: check for NULL
126        int _retval_ = me->descriptorSize(  );
127        return _retval_;
128    } catch(const std::exception &e) {
129        throwJavaException(env, &e, method_name);
130    } catch (...) {
131        throwJavaException(env, 0, method_name);
132    }
133    return 0;
134}
135
136
137
138//
139//  int descriptorType()
140//
141
142JNIEXPORT jint JNICALL Java_org_opencv_features2d_DescriptorExtractor_descriptorType_10 (JNIEnv*, jclass, jlong);
143
144JNIEXPORT jint JNICALL Java_org_opencv_features2d_DescriptorExtractor_descriptorType_10
145  (JNIEnv* env, jclass , jlong self)
146{
147    static const char method_name[] = "features2d::descriptorType_10()";
148    try {
149        LOGD("%s", method_name);
150        cv::javaDescriptorExtractor* me = (cv::javaDescriptorExtractor*) self; //TODO: check for NULL
151        int _retval_ = me->descriptorType(  );
152        return _retval_;
153    } catch(const std::exception &e) {
154        throwJavaException(env, &e, method_name);
155    } catch (...) {
156        throwJavaException(env, 0, method_name);
157    }
158    return 0;
159}
160
161
162
163//
164//  bool empty()
165//
166
167JNIEXPORT jboolean JNICALL Java_org_opencv_features2d_DescriptorExtractor_empty_10 (JNIEnv*, jclass, jlong);
168
169JNIEXPORT jboolean JNICALL Java_org_opencv_features2d_DescriptorExtractor_empty_10
170  (JNIEnv* env, jclass , jlong self)
171{
172    static const char method_name[] = "features2d::empty_10()";
173    try {
174        LOGD("%s", method_name);
175        cv::javaDescriptorExtractor* me = (cv::javaDescriptorExtractor*) self; //TODO: check for NULL
176        bool _retval_ = me->empty(  );
177        return _retval_;
178    } catch(const std::exception &e) {
179        throwJavaException(env, &e, method_name);
180    } catch (...) {
181        throwJavaException(env, 0, method_name);
182    }
183    return 0;
184}
185
186
187
188//
189// static javaDescriptorExtractor* create(int extractorType)
190//
191
192JNIEXPORT jlong JNICALL Java_org_opencv_features2d_DescriptorExtractor_create_10 (JNIEnv*, jclass, jint);
193
194JNIEXPORT jlong JNICALL Java_org_opencv_features2d_DescriptorExtractor_create_10
195  (JNIEnv* env, jclass , jint extractorType)
196{
197    static const char method_name[] = "features2d::create_10()";
198    try {
199        LOGD("%s", method_name);
200
201        javaDescriptorExtractor* _retval_ = cv::javaDescriptorExtractor::create( (int)extractorType );
202        return (jlong) _retval_;
203    } catch(const std::exception &e) {
204        throwJavaException(env, &e, method_name);
205    } catch (...) {
206        throwJavaException(env, 0, method_name);
207    }
208    return 0;
209}
210
211
212
213//
214//  void write(String fileName)
215//
216
217JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorExtractor_write_10 (JNIEnv*, jclass, jlong, jstring);
218
219JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorExtractor_write_10
220  (JNIEnv* env, jclass , jlong self, jstring fileName)
221{
222    static const char method_name[] = "features2d::write_10()";
223    try {
224        LOGD("%s", method_name);
225        cv::javaDescriptorExtractor* me = (cv::javaDescriptorExtractor*) self; //TODO: check for NULL
226        const char* utf_fileName = env->GetStringUTFChars(fileName, 0); String n_fileName( utf_fileName ? utf_fileName : "" ); env->ReleaseStringUTFChars(fileName, utf_fileName);
227        me->write( n_fileName );
228        return;
229    } catch(const std::exception &e) {
230        throwJavaException(env, &e, method_name);
231    } catch (...) {
232        throwJavaException(env, 0, method_name);
233    }
234    return;
235}
236
237
238
239//
240//  void read(String fileName)
241//
242
243JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorExtractor_read_10 (JNIEnv*, jclass, jlong, jstring);
244
245JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorExtractor_read_10
246  (JNIEnv* env, jclass , jlong self, jstring fileName)
247{
248    static const char method_name[] = "features2d::read_10()";
249    try {
250        LOGD("%s", method_name);
251        cv::javaDescriptorExtractor* me = (cv::javaDescriptorExtractor*) self; //TODO: check for NULL
252        const char* utf_fileName = env->GetStringUTFChars(fileName, 0); String n_fileName( utf_fileName ? utf_fileName : "" ); env->ReleaseStringUTFChars(fileName, utf_fileName);
253        me->read( n_fileName );
254        return;
255    } catch(const std::exception &e) {
256        throwJavaException(env, &e, method_name);
257    } catch (...) {
258        throwJavaException(env, 0, method_name);
259    }
260    return;
261}
262
263
264
265//
266//  native support for java finalize()
267//  static void cv::javaDescriptorExtractor::delete( __int64 self )
268//
269JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorExtractor_delete(JNIEnv*, jclass, jlong);
270
271JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorExtractor_delete
272  (JNIEnv*, jclass, jlong self)
273{
274    delete (cv::javaDescriptorExtractor*) self;
275}
276
277
278//
279//  void drawKeypoints(Mat image, vector_KeyPoint keypoints, Mat outImage, Scalar color = Scalar::all(-1), int flags = 0)
280//
281
282JNIEXPORT void JNICALL Java_org_opencv_features2d_Features2d_drawKeypoints_10 (JNIEnv*, jclass, jlong, jlong, jlong, jdouble, jdouble, jdouble, jdouble, jint);
283
284JNIEXPORT void JNICALL Java_org_opencv_features2d_Features2d_drawKeypoints_10
285  (JNIEnv* env, jclass , jlong image_nativeObj, jlong keypoints_mat_nativeObj, jlong outImage_nativeObj, jdouble color_val0, jdouble color_val1, jdouble color_val2, jdouble color_val3, jint flags)
286{
287    static const char method_name[] = "features2d::drawKeypoints_10()";
288    try {
289        LOGD("%s", method_name);
290        std::vector<KeyPoint> keypoints;
291        Mat& keypoints_mat = *((Mat*)keypoints_mat_nativeObj);
292        Mat_to_vector_KeyPoint( keypoints_mat, keypoints );
293        Mat& image = *((Mat*)image_nativeObj);
294        Mat& outImage = *((Mat*)outImage_nativeObj);
295        Scalar color(color_val0, color_val1, color_val2, color_val3);
296        cv::drawKeypoints( image, keypoints, outImage, color, (int)flags );
297        return;
298    } catch(const std::exception &e) {
299        throwJavaException(env, &e, method_name);
300    } catch (...) {
301        throwJavaException(env, 0, method_name);
302    }
303    return;
304}
305
306
307
308JNIEXPORT void JNICALL Java_org_opencv_features2d_Features2d_drawKeypoints_11 (JNIEnv*, jclass, jlong, jlong, jlong);
309
310JNIEXPORT void JNICALL Java_org_opencv_features2d_Features2d_drawKeypoints_11
311  (JNIEnv* env, jclass , jlong image_nativeObj, jlong keypoints_mat_nativeObj, jlong outImage_nativeObj)
312{
313    static const char method_name[] = "features2d::drawKeypoints_11()";
314    try {
315        LOGD("%s", method_name);
316        std::vector<KeyPoint> keypoints;
317        Mat& keypoints_mat = *((Mat*)keypoints_mat_nativeObj);
318        Mat_to_vector_KeyPoint( keypoints_mat, keypoints );
319        Mat& image = *((Mat*)image_nativeObj);
320        Mat& outImage = *((Mat*)outImage_nativeObj);
321        cv::drawKeypoints( image, keypoints, outImage );
322        return;
323    } catch(const std::exception &e) {
324        throwJavaException(env, &e, method_name);
325    } catch (...) {
326        throwJavaException(env, 0, method_name);
327    }
328    return;
329}
330
331
332
333//
334//  void drawMatches(Mat img1, vector_KeyPoint keypoints1, Mat img2, vector_KeyPoint keypoints2, vector_DMatch matches1to2, Mat outImg, Scalar matchColor = Scalar::all(-1), Scalar singlePointColor = Scalar::all(-1), vector_char matchesMask = std::vector<char>(), int flags = 0)
335//
336
337JNIEXPORT void JNICALL Java_org_opencv_features2d_Features2d_drawMatches_10 (JNIEnv*, jclass, jlong, jlong, jlong, jlong, jlong, jlong, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jlong, jint);
338
339JNIEXPORT void JNICALL Java_org_opencv_features2d_Features2d_drawMatches_10
340  (JNIEnv* env, jclass , jlong img1_nativeObj, jlong keypoints1_mat_nativeObj, jlong img2_nativeObj, jlong keypoints2_mat_nativeObj, jlong matches1to2_mat_nativeObj, jlong outImg_nativeObj, jdouble matchColor_val0, jdouble matchColor_val1, jdouble matchColor_val2, jdouble matchColor_val3, jdouble singlePointColor_val0, jdouble singlePointColor_val1, jdouble singlePointColor_val2, jdouble singlePointColor_val3, jlong matchesMask_mat_nativeObj, jint flags)
341{
342    static const char method_name[] = "features2d::drawMatches_10()";
343    try {
344        LOGD("%s", method_name);
345        std::vector<KeyPoint> keypoints1;
346        Mat& keypoints1_mat = *((Mat*)keypoints1_mat_nativeObj);
347        Mat_to_vector_KeyPoint( keypoints1_mat, keypoints1 );
348        std::vector<KeyPoint> keypoints2;
349        Mat& keypoints2_mat = *((Mat*)keypoints2_mat_nativeObj);
350        Mat_to_vector_KeyPoint( keypoints2_mat, keypoints2 );
351        std::vector<DMatch> matches1to2;
352        Mat& matches1to2_mat = *((Mat*)matches1to2_mat_nativeObj);
353        Mat_to_vector_DMatch( matches1to2_mat, matches1to2 );
354        std::vector<char> matchesMask;
355        Mat& matchesMask_mat = *((Mat*)matchesMask_mat_nativeObj);
356        Mat_to_vector_char( matchesMask_mat, matchesMask );
357        Mat& img1 = *((Mat*)img1_nativeObj);
358        Mat& img2 = *((Mat*)img2_nativeObj);
359        Mat& outImg = *((Mat*)outImg_nativeObj);
360        Scalar matchColor(matchColor_val0, matchColor_val1, matchColor_val2, matchColor_val3);
361        Scalar singlePointColor(singlePointColor_val0, singlePointColor_val1, singlePointColor_val2, singlePointColor_val3);
362        cv::drawMatches( img1, keypoints1, img2, keypoints2, matches1to2, outImg, matchColor, singlePointColor, matchesMask, (int)flags );
363        return;
364    } catch(const std::exception &e) {
365        throwJavaException(env, &e, method_name);
366    } catch (...) {
367        throwJavaException(env, 0, method_name);
368    }
369    return;
370}
371
372
373
374JNIEXPORT void JNICALL Java_org_opencv_features2d_Features2d_drawMatches_11 (JNIEnv*, jclass, jlong, jlong, jlong, jlong, jlong, jlong);
375
376JNIEXPORT void JNICALL Java_org_opencv_features2d_Features2d_drawMatches_11
377  (JNIEnv* env, jclass , jlong img1_nativeObj, jlong keypoints1_mat_nativeObj, jlong img2_nativeObj, jlong keypoints2_mat_nativeObj, jlong matches1to2_mat_nativeObj, jlong outImg_nativeObj)
378{
379    static const char method_name[] = "features2d::drawMatches_11()";
380    try {
381        LOGD("%s", method_name);
382        std::vector<KeyPoint> keypoints1;
383        Mat& keypoints1_mat = *((Mat*)keypoints1_mat_nativeObj);
384        Mat_to_vector_KeyPoint( keypoints1_mat, keypoints1 );
385        std::vector<KeyPoint> keypoints2;
386        Mat& keypoints2_mat = *((Mat*)keypoints2_mat_nativeObj);
387        Mat_to_vector_KeyPoint( keypoints2_mat, keypoints2 );
388        std::vector<DMatch> matches1to2;
389        Mat& matches1to2_mat = *((Mat*)matches1to2_mat_nativeObj);
390        Mat_to_vector_DMatch( matches1to2_mat, matches1to2 );
391        Mat& img1 = *((Mat*)img1_nativeObj);
392        Mat& img2 = *((Mat*)img2_nativeObj);
393        Mat& outImg = *((Mat*)outImg_nativeObj);
394        cv::drawMatches( img1, keypoints1, img2, keypoints2, matches1to2, outImg );
395        return;
396    } catch(const std::exception &e) {
397        throwJavaException(env, &e, method_name);
398    } catch (...) {
399        throwJavaException(env, 0, method_name);
400    }
401    return;
402}
403
404
405
406//
407//  void drawMatches(Mat img1, vector_KeyPoint keypoints1, Mat img2, vector_KeyPoint keypoints2, vector_vector_DMatch matches1to2, Mat outImg, Scalar matchColor = Scalar::all(-1), Scalar singlePointColor = Scalar::all(-1), vector_vector_char matchesMask = std::vector<std::vector<char> >(), int flags = 0)
408//
409
410JNIEXPORT void JNICALL Java_org_opencv_features2d_Features2d_drawMatches2_10 (JNIEnv*, jclass, jlong, jlong, jlong, jlong, jlong, jlong, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jlong, jint);
411
412JNIEXPORT void JNICALL Java_org_opencv_features2d_Features2d_drawMatches2_10
413  (JNIEnv* env, jclass , jlong img1_nativeObj, jlong keypoints1_mat_nativeObj, jlong img2_nativeObj, jlong keypoints2_mat_nativeObj, jlong matches1to2_mat_nativeObj, jlong outImg_nativeObj, jdouble matchColor_val0, jdouble matchColor_val1, jdouble matchColor_val2, jdouble matchColor_val3, jdouble singlePointColor_val0, jdouble singlePointColor_val1, jdouble singlePointColor_val2, jdouble singlePointColor_val3, jlong matchesMask_mat_nativeObj, jint flags)
414{
415    static const char method_name[] = "features2d::drawMatches2_10()";
416    try {
417        LOGD("%s", method_name);
418        std::vector<KeyPoint> keypoints1;
419        Mat& keypoints1_mat = *((Mat*)keypoints1_mat_nativeObj);
420        Mat_to_vector_KeyPoint( keypoints1_mat, keypoints1 );
421        std::vector<KeyPoint> keypoints2;
422        Mat& keypoints2_mat = *((Mat*)keypoints2_mat_nativeObj);
423        Mat_to_vector_KeyPoint( keypoints2_mat, keypoints2 );
424        std::vector< std::vector<DMatch> > matches1to2;
425        Mat& matches1to2_mat = *((Mat*)matches1to2_mat_nativeObj);
426        Mat_to_vector_vector_DMatch( matches1to2_mat, matches1to2 );
427        std::vector< std::vector<char> > matchesMask;
428        Mat& matchesMask_mat = *((Mat*)matchesMask_mat_nativeObj);
429        Mat_to_vector_vector_char( matchesMask_mat, matchesMask );
430        Mat& img1 = *((Mat*)img1_nativeObj);
431        Mat& img2 = *((Mat*)img2_nativeObj);
432        Mat& outImg = *((Mat*)outImg_nativeObj);
433        Scalar matchColor(matchColor_val0, matchColor_val1, matchColor_val2, matchColor_val3);
434        Scalar singlePointColor(singlePointColor_val0, singlePointColor_val1, singlePointColor_val2, singlePointColor_val3);
435        cv::drawMatches( img1, keypoints1, img2, keypoints2, matches1to2, outImg, matchColor, singlePointColor, matchesMask, (int)flags );
436        return;
437    } catch(const std::exception &e) {
438        throwJavaException(env, &e, method_name);
439    } catch (...) {
440        throwJavaException(env, 0, method_name);
441    }
442    return;
443}
444
445
446
447JNIEXPORT void JNICALL Java_org_opencv_features2d_Features2d_drawMatches2_11 (JNIEnv*, jclass, jlong, jlong, jlong, jlong, jlong, jlong);
448
449JNIEXPORT void JNICALL Java_org_opencv_features2d_Features2d_drawMatches2_11
450  (JNIEnv* env, jclass , jlong img1_nativeObj, jlong keypoints1_mat_nativeObj, jlong img2_nativeObj, jlong keypoints2_mat_nativeObj, jlong matches1to2_mat_nativeObj, jlong outImg_nativeObj)
451{
452    static const char method_name[] = "features2d::drawMatches2_11()";
453    try {
454        LOGD("%s", method_name);
455        std::vector<KeyPoint> keypoints1;
456        Mat& keypoints1_mat = *((Mat*)keypoints1_mat_nativeObj);
457        Mat_to_vector_KeyPoint( keypoints1_mat, keypoints1 );
458        std::vector<KeyPoint> keypoints2;
459        Mat& keypoints2_mat = *((Mat*)keypoints2_mat_nativeObj);
460        Mat_to_vector_KeyPoint( keypoints2_mat, keypoints2 );
461        std::vector< std::vector<DMatch> > matches1to2;
462        Mat& matches1to2_mat = *((Mat*)matches1to2_mat_nativeObj);
463        Mat_to_vector_vector_DMatch( matches1to2_mat, matches1to2 );
464        Mat& img1 = *((Mat*)img1_nativeObj);
465        Mat& img2 = *((Mat*)img2_nativeObj);
466        Mat& outImg = *((Mat*)outImg_nativeObj);
467        cv::drawMatches( img1, keypoints1, img2, keypoints2, matches1to2, outImg );
468        return;
469    } catch(const std::exception &e) {
470        throwJavaException(env, &e, method_name);
471    } catch (...) {
472        throwJavaException(env, 0, method_name);
473    }
474    return;
475}
476
477
478
479//
480//  bool isMaskSupported()
481//
482
483JNIEXPORT jboolean JNICALL Java_org_opencv_features2d_DescriptorMatcher_isMaskSupported_10 (JNIEnv*, jclass, jlong);
484
485JNIEXPORT jboolean JNICALL Java_org_opencv_features2d_DescriptorMatcher_isMaskSupported_10
486  (JNIEnv* env, jclass , jlong self)
487{
488    static const char method_name[] = "features2d::isMaskSupported_10()";
489    try {
490        LOGD("%s", method_name);
491        cv::javaDescriptorMatcher* me = (cv::javaDescriptorMatcher*) self; //TODO: check for NULL
492        bool _retval_ = me->isMaskSupported(  );
493        return _retval_;
494    } catch(const std::exception &e) {
495        throwJavaException(env, &e, method_name);
496    } catch (...) {
497        throwJavaException(env, 0, method_name);
498    }
499    return 0;
500}
501
502
503
504//
505//  void add(vector_Mat descriptors)
506//
507
508JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorMatcher_add_10 (JNIEnv*, jclass, jlong, jlong);
509
510JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorMatcher_add_10
511  (JNIEnv* env, jclass , jlong self, jlong descriptors_mat_nativeObj)
512{
513    static const char method_name[] = "features2d::add_10()";
514    try {
515        LOGD("%s", method_name);
516        std::vector<Mat> descriptors;
517        Mat& descriptors_mat = *((Mat*)descriptors_mat_nativeObj);
518        Mat_to_vector_Mat( descriptors_mat, descriptors );
519        cv::javaDescriptorMatcher* me = (cv::javaDescriptorMatcher*) self; //TODO: check for NULL
520        me->add( descriptors );
521        return;
522    } catch(const std::exception &e) {
523        throwJavaException(env, &e, method_name);
524    } catch (...) {
525        throwJavaException(env, 0, method_name);
526    }
527    return;
528}
529
530
531
532//
533//  vector_Mat getTrainDescriptors()
534//
535
536JNIEXPORT jlong JNICALL Java_org_opencv_features2d_DescriptorMatcher_getTrainDescriptors_10 (JNIEnv*, jclass, jlong);
537
538JNIEXPORT jlong JNICALL Java_org_opencv_features2d_DescriptorMatcher_getTrainDescriptors_10
539  (JNIEnv* env, jclass , jlong self)
540{
541    static const char method_name[] = "features2d::getTrainDescriptors_10()";
542    try {
543        LOGD("%s", method_name);
544        cv::javaDescriptorMatcher* me = (cv::javaDescriptorMatcher*) self; //TODO: check for NULL
545        std::vector<Mat> _ret_val_vector_ = me->getTrainDescriptors(  );
546        Mat* _retval_ = new Mat();  vector_Mat_to_Mat(_ret_val_vector_, *_retval_);
547        return (jlong) _retval_;
548    } catch(const std::exception &e) {
549        throwJavaException(env, &e, method_name);
550    } catch (...) {
551        throwJavaException(env, 0, method_name);
552    }
553    return 0;
554}
555
556
557
558//
559//  void clear()
560//
561
562JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorMatcher_clear_10 (JNIEnv*, jclass, jlong);
563
564JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorMatcher_clear_10
565  (JNIEnv* env, jclass , jlong self)
566{
567    static const char method_name[] = "features2d::clear_10()";
568    try {
569        LOGD("%s", method_name);
570        cv::javaDescriptorMatcher* me = (cv::javaDescriptorMatcher*) self; //TODO: check for NULL
571        me->clear(  );
572        return;
573    } catch(const std::exception &e) {
574        throwJavaException(env, &e, method_name);
575    } catch (...) {
576        throwJavaException(env, 0, method_name);
577    }
578    return;
579}
580
581
582
583//
584//  bool empty()
585//
586
587JNIEXPORT jboolean JNICALL Java_org_opencv_features2d_DescriptorMatcher_empty_10 (JNIEnv*, jclass, jlong);
588
589JNIEXPORT jboolean JNICALL Java_org_opencv_features2d_DescriptorMatcher_empty_10
590  (JNIEnv* env, jclass , jlong self)
591{
592    static const char method_name[] = "features2d::empty_10()";
593    try {
594        LOGD("%s", method_name);
595        cv::javaDescriptorMatcher* me = (cv::javaDescriptorMatcher*) self; //TODO: check for NULL
596        bool _retval_ = me->empty(  );
597        return _retval_;
598    } catch(const std::exception &e) {
599        throwJavaException(env, &e, method_name);
600    } catch (...) {
601        throwJavaException(env, 0, method_name);
602    }
603    return 0;
604}
605
606
607
608//
609//  void train()
610//
611
612JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorMatcher_train_10 (JNIEnv*, jclass, jlong);
613
614JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorMatcher_train_10
615  (JNIEnv* env, jclass , jlong self)
616{
617    static const char method_name[] = "features2d::train_10()";
618    try {
619        LOGD("%s", method_name);
620        cv::javaDescriptorMatcher* me = (cv::javaDescriptorMatcher*) self; //TODO: check for NULL
621        me->train(  );
622        return;
623    } catch(const std::exception &e) {
624        throwJavaException(env, &e, method_name);
625    } catch (...) {
626        throwJavaException(env, 0, method_name);
627    }
628    return;
629}
630
631
632
633//
634//  void match(Mat queryDescriptors, Mat trainDescriptors, vector_DMatch& matches, Mat mask = Mat())
635//
636
637JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorMatcher_match_10 (JNIEnv*, jclass, jlong, jlong, jlong, jlong, jlong);
638
639JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorMatcher_match_10
640  (JNIEnv* env, jclass , jlong self, jlong queryDescriptors_nativeObj, jlong trainDescriptors_nativeObj, jlong matches_mat_nativeObj, jlong mask_nativeObj)
641{
642    static const char method_name[] = "features2d::match_10()";
643    try {
644        LOGD("%s", method_name);
645        std::vector<DMatch> matches;
646        Mat& matches_mat = *((Mat*)matches_mat_nativeObj);
647        cv::javaDescriptorMatcher* me = (cv::javaDescriptorMatcher*) self; //TODO: check for NULL
648        Mat& queryDescriptors = *((Mat*)queryDescriptors_nativeObj);
649        Mat& trainDescriptors = *((Mat*)trainDescriptors_nativeObj);
650        Mat& mask = *((Mat*)mask_nativeObj);
651        me->match( queryDescriptors, trainDescriptors, matches, mask );
652        vector_DMatch_to_Mat( matches, matches_mat );
653        return;
654    } catch(const std::exception &e) {
655        throwJavaException(env, &e, method_name);
656    } catch (...) {
657        throwJavaException(env, 0, method_name);
658    }
659    return;
660}
661
662
663
664JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorMatcher_match_11 (JNIEnv*, jclass, jlong, jlong, jlong, jlong);
665
666JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorMatcher_match_11
667  (JNIEnv* env, jclass , jlong self, jlong queryDescriptors_nativeObj, jlong trainDescriptors_nativeObj, jlong matches_mat_nativeObj)
668{
669    static const char method_name[] = "features2d::match_11()";
670    try {
671        LOGD("%s", method_name);
672        std::vector<DMatch> matches;
673        Mat& matches_mat = *((Mat*)matches_mat_nativeObj);
674        cv::javaDescriptorMatcher* me = (cv::javaDescriptorMatcher*) self; //TODO: check for NULL
675        Mat& queryDescriptors = *((Mat*)queryDescriptors_nativeObj);
676        Mat& trainDescriptors = *((Mat*)trainDescriptors_nativeObj);
677        me->match( queryDescriptors, trainDescriptors, matches );
678        vector_DMatch_to_Mat( matches, matches_mat );
679        return;
680    } catch(const std::exception &e) {
681        throwJavaException(env, &e, method_name);
682    } catch (...) {
683        throwJavaException(env, 0, method_name);
684    }
685    return;
686}
687
688
689
690//
691//  void knnMatch(Mat queryDescriptors, Mat trainDescriptors, vector_vector_DMatch& matches, int k, Mat mask = Mat(), bool compactResult = false)
692//
693
694JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorMatcher_knnMatch_10 (JNIEnv*, jclass, jlong, jlong, jlong, jlong, jint, jlong, jboolean);
695
696JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorMatcher_knnMatch_10
697  (JNIEnv* env, jclass , jlong self, jlong queryDescriptors_nativeObj, jlong trainDescriptors_nativeObj, jlong matches_mat_nativeObj, jint k, jlong mask_nativeObj, jboolean compactResult)
698{
699    static const char method_name[] = "features2d::knnMatch_10()";
700    try {
701        LOGD("%s", method_name);
702        std::vector< std::vector<DMatch> > matches;
703        Mat& matches_mat = *((Mat*)matches_mat_nativeObj);
704        cv::javaDescriptorMatcher* me = (cv::javaDescriptorMatcher*) self; //TODO: check for NULL
705        Mat& queryDescriptors = *((Mat*)queryDescriptors_nativeObj);
706        Mat& trainDescriptors = *((Mat*)trainDescriptors_nativeObj);
707        Mat& mask = *((Mat*)mask_nativeObj);
708        me->knnMatch( queryDescriptors, trainDescriptors, matches, (int)k, mask, (bool)compactResult );
709        vector_vector_DMatch_to_Mat( matches, matches_mat );
710        return;
711    } catch(const std::exception &e) {
712        throwJavaException(env, &e, method_name);
713    } catch (...) {
714        throwJavaException(env, 0, method_name);
715    }
716    return;
717}
718
719
720
721JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorMatcher_knnMatch_11 (JNIEnv*, jclass, jlong, jlong, jlong, jlong, jint);
722
723JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorMatcher_knnMatch_11
724  (JNIEnv* env, jclass , jlong self, jlong queryDescriptors_nativeObj, jlong trainDescriptors_nativeObj, jlong matches_mat_nativeObj, jint k)
725{
726    static const char method_name[] = "features2d::knnMatch_11()";
727    try {
728        LOGD("%s", method_name);
729        std::vector< std::vector<DMatch> > matches;
730        Mat& matches_mat = *((Mat*)matches_mat_nativeObj);
731        cv::javaDescriptorMatcher* me = (cv::javaDescriptorMatcher*) self; //TODO: check for NULL
732        Mat& queryDescriptors = *((Mat*)queryDescriptors_nativeObj);
733        Mat& trainDescriptors = *((Mat*)trainDescriptors_nativeObj);
734        me->knnMatch( queryDescriptors, trainDescriptors, matches, (int)k );
735        vector_vector_DMatch_to_Mat( matches, matches_mat );
736        return;
737    } catch(const std::exception &e) {
738        throwJavaException(env, &e, method_name);
739    } catch (...) {
740        throwJavaException(env, 0, method_name);
741    }
742    return;
743}
744
745
746
747//
748//  void radiusMatch(Mat queryDescriptors, Mat trainDescriptors, vector_vector_DMatch& matches, float maxDistance, Mat mask = Mat(), bool compactResult = false)
749//
750
751JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorMatcher_radiusMatch_10 (JNIEnv*, jclass, jlong, jlong, jlong, jlong, jfloat, jlong, jboolean);
752
753JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorMatcher_radiusMatch_10
754  (JNIEnv* env, jclass , jlong self, jlong queryDescriptors_nativeObj, jlong trainDescriptors_nativeObj, jlong matches_mat_nativeObj, jfloat maxDistance, jlong mask_nativeObj, jboolean compactResult)
755{
756    static const char method_name[] = "features2d::radiusMatch_10()";
757    try {
758        LOGD("%s", method_name);
759        std::vector< std::vector<DMatch> > matches;
760        Mat& matches_mat = *((Mat*)matches_mat_nativeObj);
761        cv::javaDescriptorMatcher* me = (cv::javaDescriptorMatcher*) self; //TODO: check for NULL
762        Mat& queryDescriptors = *((Mat*)queryDescriptors_nativeObj);
763        Mat& trainDescriptors = *((Mat*)trainDescriptors_nativeObj);
764        Mat& mask = *((Mat*)mask_nativeObj);
765        me->radiusMatch( queryDescriptors, trainDescriptors, matches, (float)maxDistance, mask, (bool)compactResult );
766        vector_vector_DMatch_to_Mat( matches, matches_mat );
767        return;
768    } catch(const std::exception &e) {
769        throwJavaException(env, &e, method_name);
770    } catch (...) {
771        throwJavaException(env, 0, method_name);
772    }
773    return;
774}
775
776
777
778JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorMatcher_radiusMatch_11 (JNIEnv*, jclass, jlong, jlong, jlong, jlong, jfloat);
779
780JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorMatcher_radiusMatch_11
781  (JNIEnv* env, jclass , jlong self, jlong queryDescriptors_nativeObj, jlong trainDescriptors_nativeObj, jlong matches_mat_nativeObj, jfloat maxDistance)
782{
783    static const char method_name[] = "features2d::radiusMatch_11()";
784    try {
785        LOGD("%s", method_name);
786        std::vector< std::vector<DMatch> > matches;
787        Mat& matches_mat = *((Mat*)matches_mat_nativeObj);
788        cv::javaDescriptorMatcher* me = (cv::javaDescriptorMatcher*) self; //TODO: check for NULL
789        Mat& queryDescriptors = *((Mat*)queryDescriptors_nativeObj);
790        Mat& trainDescriptors = *((Mat*)trainDescriptors_nativeObj);
791        me->radiusMatch( queryDescriptors, trainDescriptors, matches, (float)maxDistance );
792        vector_vector_DMatch_to_Mat( matches, matches_mat );
793        return;
794    } catch(const std::exception &e) {
795        throwJavaException(env, &e, method_name);
796    } catch (...) {
797        throwJavaException(env, 0, method_name);
798    }
799    return;
800}
801
802
803
804//
805//  void match(Mat queryDescriptors, vector_DMatch& matches, vector_Mat masks = std::vector<Mat>())
806//
807
808JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorMatcher_match_12 (JNIEnv*, jclass, jlong, jlong, jlong, jlong);
809
810JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorMatcher_match_12
811  (JNIEnv* env, jclass , jlong self, jlong queryDescriptors_nativeObj, jlong matches_mat_nativeObj, jlong masks_mat_nativeObj)
812{
813    static const char method_name[] = "features2d::match_12()";
814    try {
815        LOGD("%s", method_name);
816        std::vector<DMatch> matches;
817        Mat& matches_mat = *((Mat*)matches_mat_nativeObj);
818        std::vector<Mat> masks;
819        Mat& masks_mat = *((Mat*)masks_mat_nativeObj);
820        Mat_to_vector_Mat( masks_mat, masks );
821        cv::javaDescriptorMatcher* me = (cv::javaDescriptorMatcher*) self; //TODO: check for NULL
822        Mat& queryDescriptors = *((Mat*)queryDescriptors_nativeObj);
823        me->match( queryDescriptors, matches, masks );
824        vector_DMatch_to_Mat( matches, matches_mat );
825        return;
826    } catch(const std::exception &e) {
827        throwJavaException(env, &e, method_name);
828    } catch (...) {
829        throwJavaException(env, 0, method_name);
830    }
831    return;
832}
833
834
835
836JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorMatcher_match_13 (JNIEnv*, jclass, jlong, jlong, jlong);
837
838JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorMatcher_match_13
839  (JNIEnv* env, jclass , jlong self, jlong queryDescriptors_nativeObj, jlong matches_mat_nativeObj)
840{
841    static const char method_name[] = "features2d::match_13()";
842    try {
843        LOGD("%s", method_name);
844        std::vector<DMatch> matches;
845        Mat& matches_mat = *((Mat*)matches_mat_nativeObj);
846        cv::javaDescriptorMatcher* me = (cv::javaDescriptorMatcher*) self; //TODO: check for NULL
847        Mat& queryDescriptors = *((Mat*)queryDescriptors_nativeObj);
848        me->match( queryDescriptors, matches );
849        vector_DMatch_to_Mat( matches, matches_mat );
850        return;
851    } catch(const std::exception &e) {
852        throwJavaException(env, &e, method_name);
853    } catch (...) {
854        throwJavaException(env, 0, method_name);
855    }
856    return;
857}
858
859
860
861//
862//  void knnMatch(Mat queryDescriptors, vector_vector_DMatch& matches, int k, vector_Mat masks = std::vector<Mat>(), bool compactResult = false)
863//
864
865JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorMatcher_knnMatch_12 (JNIEnv*, jclass, jlong, jlong, jlong, jint, jlong, jboolean);
866
867JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorMatcher_knnMatch_12
868  (JNIEnv* env, jclass , jlong self, jlong queryDescriptors_nativeObj, jlong matches_mat_nativeObj, jint k, jlong masks_mat_nativeObj, jboolean compactResult)
869{
870    static const char method_name[] = "features2d::knnMatch_12()";
871    try {
872        LOGD("%s", method_name);
873        std::vector< std::vector<DMatch> > matches;
874        Mat& matches_mat = *((Mat*)matches_mat_nativeObj);
875        std::vector<Mat> masks;
876        Mat& masks_mat = *((Mat*)masks_mat_nativeObj);
877        Mat_to_vector_Mat( masks_mat, masks );
878        cv::javaDescriptorMatcher* me = (cv::javaDescriptorMatcher*) self; //TODO: check for NULL
879        Mat& queryDescriptors = *((Mat*)queryDescriptors_nativeObj);
880        me->knnMatch( queryDescriptors, matches, (int)k, masks, (bool)compactResult );
881        vector_vector_DMatch_to_Mat( matches, matches_mat );
882        return;
883    } catch(const std::exception &e) {
884        throwJavaException(env, &e, method_name);
885    } catch (...) {
886        throwJavaException(env, 0, method_name);
887    }
888    return;
889}
890
891
892
893JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorMatcher_knnMatch_13 (JNIEnv*, jclass, jlong, jlong, jlong, jint);
894
895JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorMatcher_knnMatch_13
896  (JNIEnv* env, jclass , jlong self, jlong queryDescriptors_nativeObj, jlong matches_mat_nativeObj, jint k)
897{
898    static const char method_name[] = "features2d::knnMatch_13()";
899    try {
900        LOGD("%s", method_name);
901        std::vector< std::vector<DMatch> > matches;
902        Mat& matches_mat = *((Mat*)matches_mat_nativeObj);
903        cv::javaDescriptorMatcher* me = (cv::javaDescriptorMatcher*) self; //TODO: check for NULL
904        Mat& queryDescriptors = *((Mat*)queryDescriptors_nativeObj);
905        me->knnMatch( queryDescriptors, matches, (int)k );
906        vector_vector_DMatch_to_Mat( matches, matches_mat );
907        return;
908    } catch(const std::exception &e) {
909        throwJavaException(env, &e, method_name);
910    } catch (...) {
911        throwJavaException(env, 0, method_name);
912    }
913    return;
914}
915
916
917
918//
919//  void radiusMatch(Mat queryDescriptors, vector_vector_DMatch& matches, float maxDistance, vector_Mat masks = std::vector<Mat>(), bool compactResult = false)
920//
921
922JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorMatcher_radiusMatch_12 (JNIEnv*, jclass, jlong, jlong, jlong, jfloat, jlong, jboolean);
923
924JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorMatcher_radiusMatch_12
925  (JNIEnv* env, jclass , jlong self, jlong queryDescriptors_nativeObj, jlong matches_mat_nativeObj, jfloat maxDistance, jlong masks_mat_nativeObj, jboolean compactResult)
926{
927    static const char method_name[] = "features2d::radiusMatch_12()";
928    try {
929        LOGD("%s", method_name);
930        std::vector< std::vector<DMatch> > matches;
931        Mat& matches_mat = *((Mat*)matches_mat_nativeObj);
932        std::vector<Mat> masks;
933        Mat& masks_mat = *((Mat*)masks_mat_nativeObj);
934        Mat_to_vector_Mat( masks_mat, masks );
935        cv::javaDescriptorMatcher* me = (cv::javaDescriptorMatcher*) self; //TODO: check for NULL
936        Mat& queryDescriptors = *((Mat*)queryDescriptors_nativeObj);
937        me->radiusMatch( queryDescriptors, matches, (float)maxDistance, masks, (bool)compactResult );
938        vector_vector_DMatch_to_Mat( matches, matches_mat );
939        return;
940    } catch(const std::exception &e) {
941        throwJavaException(env, &e, method_name);
942    } catch (...) {
943        throwJavaException(env, 0, method_name);
944    }
945    return;
946}
947
948
949
950JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorMatcher_radiusMatch_13 (JNIEnv*, jclass, jlong, jlong, jlong, jfloat);
951
952JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorMatcher_radiusMatch_13
953  (JNIEnv* env, jclass , jlong self, jlong queryDescriptors_nativeObj, jlong matches_mat_nativeObj, jfloat maxDistance)
954{
955    static const char method_name[] = "features2d::radiusMatch_13()";
956    try {
957        LOGD("%s", method_name);
958        std::vector< std::vector<DMatch> > matches;
959        Mat& matches_mat = *((Mat*)matches_mat_nativeObj);
960        cv::javaDescriptorMatcher* me = (cv::javaDescriptorMatcher*) self; //TODO: check for NULL
961        Mat& queryDescriptors = *((Mat*)queryDescriptors_nativeObj);
962        me->radiusMatch( queryDescriptors, matches, (float)maxDistance );
963        vector_vector_DMatch_to_Mat( matches, matches_mat );
964        return;
965    } catch(const std::exception &e) {
966        throwJavaException(env, &e, method_name);
967    } catch (...) {
968        throwJavaException(env, 0, method_name);
969    }
970    return;
971}
972
973
974
975//
976//  javaDescriptorMatcher* jclone(bool emptyTrainData = false)
977//
978
979JNIEXPORT jlong JNICALL Java_org_opencv_features2d_DescriptorMatcher_clone_10 (JNIEnv*, jclass, jlong, jboolean);
980
981JNIEXPORT jlong JNICALL Java_org_opencv_features2d_DescriptorMatcher_clone_10
982  (JNIEnv* env, jclass , jlong self, jboolean emptyTrainData)
983{
984    static const char method_name[] = "features2d::clone_10()";
985    try {
986        LOGD("%s", method_name);
987        cv::javaDescriptorMatcher* me = (cv::javaDescriptorMatcher*) self; //TODO: check for NULL
988        javaDescriptorMatcher* _retval_ = me->jclone( (bool)emptyTrainData );
989        return (jlong) _retval_;
990    } catch(const std::exception &e) {
991        throwJavaException(env, &e, method_name);
992    } catch (...) {
993        throwJavaException(env, 0, method_name);
994    }
995    return 0;
996}
997
998
999
1000JNIEXPORT jlong JNICALL Java_org_opencv_features2d_DescriptorMatcher_clone_11 (JNIEnv*, jclass, jlong);
1001
1002JNIEXPORT jlong JNICALL Java_org_opencv_features2d_DescriptorMatcher_clone_11
1003  (JNIEnv* env, jclass , jlong self)
1004{
1005    static const char method_name[] = "features2d::clone_11()";
1006    try {
1007        LOGD("%s", method_name);
1008        cv::javaDescriptorMatcher* me = (cv::javaDescriptorMatcher*) self; //TODO: check for NULL
1009        javaDescriptorMatcher* _retval_ = me->jclone(  );
1010        return (jlong) _retval_;
1011    } catch(const std::exception &e) {
1012        throwJavaException(env, &e, method_name);
1013    } catch (...) {
1014        throwJavaException(env, 0, method_name);
1015    }
1016    return 0;
1017}
1018
1019
1020
1021//
1022// static javaDescriptorMatcher* create(int matcherType)
1023//
1024
1025JNIEXPORT jlong JNICALL Java_org_opencv_features2d_DescriptorMatcher_create_10 (JNIEnv*, jclass, jint);
1026
1027JNIEXPORT jlong JNICALL Java_org_opencv_features2d_DescriptorMatcher_create_10
1028  (JNIEnv* env, jclass , jint matcherType)
1029{
1030    static const char method_name[] = "features2d::create_10()";
1031    try {
1032        LOGD("%s", method_name);
1033
1034        javaDescriptorMatcher* _retval_ = cv::javaDescriptorMatcher::create( (int)matcherType );
1035        return (jlong) _retval_;
1036    } catch(const std::exception &e) {
1037        throwJavaException(env, &e, method_name);
1038    } catch (...) {
1039        throwJavaException(env, 0, method_name);
1040    }
1041    return 0;
1042}
1043
1044
1045
1046//
1047//  void write(String fileName)
1048//
1049
1050JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorMatcher_write_10 (JNIEnv*, jclass, jlong, jstring);
1051
1052JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorMatcher_write_10
1053  (JNIEnv* env, jclass , jlong self, jstring fileName)
1054{
1055    static const char method_name[] = "features2d::write_10()";
1056    try {
1057        LOGD("%s", method_name);
1058        cv::javaDescriptorMatcher* me = (cv::javaDescriptorMatcher*) self; //TODO: check for NULL
1059        const char* utf_fileName = env->GetStringUTFChars(fileName, 0); String n_fileName( utf_fileName ? utf_fileName : "" ); env->ReleaseStringUTFChars(fileName, utf_fileName);
1060        me->write( n_fileName );
1061        return;
1062    } catch(const std::exception &e) {
1063        throwJavaException(env, &e, method_name);
1064    } catch (...) {
1065        throwJavaException(env, 0, method_name);
1066    }
1067    return;
1068}
1069
1070
1071
1072//
1073//  void read(String fileName)
1074//
1075
1076JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorMatcher_read_10 (JNIEnv*, jclass, jlong, jstring);
1077
1078JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorMatcher_read_10
1079  (JNIEnv* env, jclass , jlong self, jstring fileName)
1080{
1081    static const char method_name[] = "features2d::read_10()";
1082    try {
1083        LOGD("%s", method_name);
1084        cv::javaDescriptorMatcher* me = (cv::javaDescriptorMatcher*) self; //TODO: check for NULL
1085        const char* utf_fileName = env->GetStringUTFChars(fileName, 0); String n_fileName( utf_fileName ? utf_fileName : "" ); env->ReleaseStringUTFChars(fileName, utf_fileName);
1086        me->read( n_fileName );
1087        return;
1088    } catch(const std::exception &e) {
1089        throwJavaException(env, &e, method_name);
1090    } catch (...) {
1091        throwJavaException(env, 0, method_name);
1092    }
1093    return;
1094}
1095
1096
1097
1098//
1099//  native support for java finalize()
1100//  static void cv::javaDescriptorMatcher::delete( __int64 self )
1101//
1102JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorMatcher_delete(JNIEnv*, jclass, jlong);
1103
1104JNIEXPORT void JNICALL Java_org_opencv_features2d_DescriptorMatcher_delete
1105  (JNIEnv*, jclass, jlong self)
1106{
1107    delete (cv::javaDescriptorMatcher*) self;
1108}
1109
1110
1111//
1112//  void detect(Mat image, vector_KeyPoint& keypoints, Mat mask = Mat())
1113//
1114
1115JNIEXPORT void JNICALL Java_org_opencv_features2d_FeatureDetector_detect_10 (JNIEnv*, jclass, jlong, jlong, jlong, jlong);
1116
1117JNIEXPORT void JNICALL Java_org_opencv_features2d_FeatureDetector_detect_10
1118  (JNIEnv* env, jclass , jlong self, jlong image_nativeObj, jlong keypoints_mat_nativeObj, jlong mask_nativeObj)
1119{
1120    static const char method_name[] = "features2d::detect_10()";
1121    try {
1122        LOGD("%s", method_name);
1123        std::vector<KeyPoint> keypoints;
1124        Mat& keypoints_mat = *((Mat*)keypoints_mat_nativeObj);
1125        cv::javaFeatureDetector* me = (cv::javaFeatureDetector*) self; //TODO: check for NULL
1126        Mat& image = *((Mat*)image_nativeObj);
1127        Mat& mask = *((Mat*)mask_nativeObj);
1128        me->detect( image, keypoints, mask );
1129        vector_KeyPoint_to_Mat( keypoints, keypoints_mat );
1130        return;
1131    } catch(const std::exception &e) {
1132        throwJavaException(env, &e, method_name);
1133    } catch (...) {
1134        throwJavaException(env, 0, method_name);
1135    }
1136    return;
1137}
1138
1139
1140
1141JNIEXPORT void JNICALL Java_org_opencv_features2d_FeatureDetector_detect_11 (JNIEnv*, jclass, jlong, jlong, jlong);
1142
1143JNIEXPORT void JNICALL Java_org_opencv_features2d_FeatureDetector_detect_11
1144  (JNIEnv* env, jclass , jlong self, jlong image_nativeObj, jlong keypoints_mat_nativeObj)
1145{
1146    static const char method_name[] = "features2d::detect_11()";
1147    try {
1148        LOGD("%s", method_name);
1149        std::vector<KeyPoint> keypoints;
1150        Mat& keypoints_mat = *((Mat*)keypoints_mat_nativeObj);
1151        cv::javaFeatureDetector* me = (cv::javaFeatureDetector*) self; //TODO: check for NULL
1152        Mat& image = *((Mat*)image_nativeObj);
1153        me->detect( image, keypoints );
1154        vector_KeyPoint_to_Mat( keypoints, keypoints_mat );
1155        return;
1156    } catch(const std::exception &e) {
1157        throwJavaException(env, &e, method_name);
1158    } catch (...) {
1159        throwJavaException(env, 0, method_name);
1160    }
1161    return;
1162}
1163
1164
1165
1166//
1167//  void detect(vector_Mat images, vector_vector_KeyPoint& keypoints, vector_Mat masks = std::vector<Mat>())
1168//
1169
1170JNIEXPORT void JNICALL Java_org_opencv_features2d_FeatureDetector_detect_12 (JNIEnv*, jclass, jlong, jlong, jlong, jlong);
1171
1172JNIEXPORT void JNICALL Java_org_opencv_features2d_FeatureDetector_detect_12
1173  (JNIEnv* env, jclass , jlong self, jlong images_mat_nativeObj, jlong keypoints_mat_nativeObj, jlong masks_mat_nativeObj)
1174{
1175    static const char method_name[] = "features2d::detect_12()";
1176    try {
1177        LOGD("%s", method_name);
1178        std::vector<Mat> images;
1179        Mat& images_mat = *((Mat*)images_mat_nativeObj);
1180        Mat_to_vector_Mat( images_mat, images );
1181        std::vector< std::vector<KeyPoint> > keypoints;
1182        Mat& keypoints_mat = *((Mat*)keypoints_mat_nativeObj);
1183        std::vector<Mat> masks;
1184        Mat& masks_mat = *((Mat*)masks_mat_nativeObj);
1185        Mat_to_vector_Mat( masks_mat, masks );
1186        cv::javaFeatureDetector* me = (cv::javaFeatureDetector*) self; //TODO: check for NULL
1187        me->detect( images, keypoints, masks );
1188        vector_vector_KeyPoint_to_Mat( keypoints, keypoints_mat );
1189        return;
1190    } catch(const std::exception &e) {
1191        throwJavaException(env, &e, method_name);
1192    } catch (...) {
1193        throwJavaException(env, 0, method_name);
1194    }
1195    return;
1196}
1197
1198
1199
1200JNIEXPORT void JNICALL Java_org_opencv_features2d_FeatureDetector_detect_13 (JNIEnv*, jclass, jlong, jlong, jlong);
1201
1202JNIEXPORT void JNICALL Java_org_opencv_features2d_FeatureDetector_detect_13
1203  (JNIEnv* env, jclass , jlong self, jlong images_mat_nativeObj, jlong keypoints_mat_nativeObj)
1204{
1205    static const char method_name[] = "features2d::detect_13()";
1206    try {
1207        LOGD("%s", method_name);
1208        std::vector<Mat> images;
1209        Mat& images_mat = *((Mat*)images_mat_nativeObj);
1210        Mat_to_vector_Mat( images_mat, images );
1211        std::vector< std::vector<KeyPoint> > keypoints;
1212        Mat& keypoints_mat = *((Mat*)keypoints_mat_nativeObj);
1213        cv::javaFeatureDetector* me = (cv::javaFeatureDetector*) self; //TODO: check for NULL
1214        me->detect( images, keypoints );
1215        vector_vector_KeyPoint_to_Mat( keypoints, keypoints_mat );
1216        return;
1217    } catch(const std::exception &e) {
1218        throwJavaException(env, &e, method_name);
1219    } catch (...) {
1220        throwJavaException(env, 0, method_name);
1221    }
1222    return;
1223}
1224
1225
1226
1227//
1228//  bool empty()
1229//
1230
1231JNIEXPORT jboolean JNICALL Java_org_opencv_features2d_FeatureDetector_empty_10 (JNIEnv*, jclass, jlong);
1232
1233JNIEXPORT jboolean JNICALL Java_org_opencv_features2d_FeatureDetector_empty_10
1234  (JNIEnv* env, jclass , jlong self)
1235{
1236    static const char method_name[] = "features2d::empty_10()";
1237    try {
1238        LOGD("%s", method_name);
1239        cv::javaFeatureDetector* me = (cv::javaFeatureDetector*) self; //TODO: check for NULL
1240        bool _retval_ = me->empty(  );
1241        return _retval_;
1242    } catch(const std::exception &e) {
1243        throwJavaException(env, &e, method_name);
1244    } catch (...) {
1245        throwJavaException(env, 0, method_name);
1246    }
1247    return 0;
1248}
1249
1250
1251
1252//
1253// static javaFeatureDetector* create(int detectorType)
1254//
1255
1256JNIEXPORT jlong JNICALL Java_org_opencv_features2d_FeatureDetector_create_10 (JNIEnv*, jclass, jint);
1257
1258JNIEXPORT jlong JNICALL Java_org_opencv_features2d_FeatureDetector_create_10
1259  (JNIEnv* env, jclass , jint detectorType)
1260{
1261    static const char method_name[] = "features2d::create_10()";
1262    try {
1263        LOGD("%s", method_name);
1264
1265        javaFeatureDetector* _retval_ = cv::javaFeatureDetector::create( (int)detectorType );
1266        return (jlong) _retval_;
1267    } catch(const std::exception &e) {
1268        throwJavaException(env, &e, method_name);
1269    } catch (...) {
1270        throwJavaException(env, 0, method_name);
1271    }
1272    return 0;
1273}
1274
1275
1276
1277//
1278//  void write(String fileName)
1279//
1280
1281JNIEXPORT void JNICALL Java_org_opencv_features2d_FeatureDetector_write_10 (JNIEnv*, jclass, jlong, jstring);
1282
1283JNIEXPORT void JNICALL Java_org_opencv_features2d_FeatureDetector_write_10
1284  (JNIEnv* env, jclass , jlong self, jstring fileName)
1285{
1286    static const char method_name[] = "features2d::write_10()";
1287    try {
1288        LOGD("%s", method_name);
1289        cv::javaFeatureDetector* me = (cv::javaFeatureDetector*) self; //TODO: check for NULL
1290        const char* utf_fileName = env->GetStringUTFChars(fileName, 0); String n_fileName( utf_fileName ? utf_fileName : "" ); env->ReleaseStringUTFChars(fileName, utf_fileName);
1291        me->write( n_fileName );
1292        return;
1293    } catch(const std::exception &e) {
1294        throwJavaException(env, &e, method_name);
1295    } catch (...) {
1296        throwJavaException(env, 0, method_name);
1297    }
1298    return;
1299}
1300
1301
1302
1303//
1304//  void read(String fileName)
1305//
1306
1307JNIEXPORT void JNICALL Java_org_opencv_features2d_FeatureDetector_read_10 (JNIEnv*, jclass, jlong, jstring);
1308
1309JNIEXPORT void JNICALL Java_org_opencv_features2d_FeatureDetector_read_10
1310  (JNIEnv* env, jclass , jlong self, jstring fileName)
1311{
1312    static const char method_name[] = "features2d::read_10()";
1313    try {
1314        LOGD("%s", method_name);
1315        cv::javaFeatureDetector* me = (cv::javaFeatureDetector*) self; //TODO: check for NULL
1316        const char* utf_fileName = env->GetStringUTFChars(fileName, 0); String n_fileName( utf_fileName ? utf_fileName : "" ); env->ReleaseStringUTFChars(fileName, utf_fileName);
1317        me->read( n_fileName );
1318        return;
1319    } catch(const std::exception &e) {
1320        throwJavaException(env, &e, method_name);
1321    } catch (...) {
1322        throwJavaException(env, 0, method_name);
1323    }
1324    return;
1325}
1326
1327
1328
1329//
1330//  native support for java finalize()
1331//  static void cv::javaFeatureDetector::delete( __int64 self )
1332//
1333JNIEXPORT void JNICALL Java_org_opencv_features2d_FeatureDetector_delete(JNIEnv*, jclass, jlong);
1334
1335JNIEXPORT void JNICALL Java_org_opencv_features2d_FeatureDetector_delete
1336  (JNIEnv*, jclass, jlong self)
1337{
1338    delete (cv::javaFeatureDetector*) self;
1339}
1340
1341
1342
1343} // extern "C"
1344
1345#endif // HAVE_OPENCV_FEATURES2D
1346