1 2 // 3 // This file is auto-generated, please don't edit! 4 // 5 6 #define LOG_TAG "org.opencv.imgproc" 7 8 #include "common.h" 9 10 #include "opencv2/opencv_modules.hpp" 11 #ifdef HAVE_OPENCV_IMGPROC 12 13 #include <string> 14 15 #include "opencv2/imgproc.hpp" 16 17 #include "../../imgproc/include/opencv2/imgproc/types_c.h" 18 #include "../../imgproc/include/opencv2/imgproc.hpp" 19 20 using namespace cv; 21 22 /// throw java exception 23 static void throwJavaException(JNIEnv *env, const std::exception *e, const char *method) { 24 std::string what = "unknown exception"; 25 jclass je = 0; 26 27 if(e) { 28 std::string exception_type = "std::exception"; 29 30 if(dynamic_cast<const cv::Exception*>(e)) { 31 exception_type = "cv::Exception"; 32 je = env->FindClass("org/opencv/core/CvException"); 33 } 34 35 what = exception_type + ": " + e->what(); 36 } 37 38 if(!je) je = env->FindClass("java/lang/Exception"); 39 env->ThrowNew(je, what.c_str()); 40 41 LOGE("%s caught %s", method, what.c_str()); 42 (void)method; // avoid "unused" warning 43 } 44 45 46 extern "C" { 47 48 49 // 50 // void detect(Mat _image, Mat& _lines, Mat& width = Mat(), Mat& prec = Mat(), Mat& nfa = Mat()) 51 // 52 53 JNIEXPORT void JNICALL Java_org_opencv_imgproc_LineSegmentDetector_detect_10 (JNIEnv*, jclass, jlong, jlong, jlong, jlong, jlong, jlong); 54 55 JNIEXPORT void JNICALL Java_org_opencv_imgproc_LineSegmentDetector_detect_10 56 (JNIEnv* env, jclass , jlong self, jlong _image_nativeObj, jlong _lines_nativeObj, jlong width_nativeObj, jlong prec_nativeObj, jlong nfa_nativeObj) 57 { 58 static const char method_name[] = "imgproc::detect_10()"; 59 try { 60 LOGD("%s", method_name); 61 Ptr<cv::LineSegmentDetector>* me = (Ptr<cv::LineSegmentDetector>*) self; //TODO: check for NULL 62 Mat& _image = *((Mat*)_image_nativeObj); 63 Mat& _lines = *((Mat*)_lines_nativeObj); 64 Mat& width = *((Mat*)width_nativeObj); 65 Mat& prec = *((Mat*)prec_nativeObj); 66 Mat& nfa = *((Mat*)nfa_nativeObj); 67 (*me)->detect( _image, _lines, width, prec, nfa ); 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 JNIEXPORT void JNICALL Java_org_opencv_imgproc_LineSegmentDetector_detect_11 (JNIEnv*, jclass, jlong, jlong, jlong); 80 81 JNIEXPORT void JNICALL Java_org_opencv_imgproc_LineSegmentDetector_detect_11 82 (JNIEnv* env, jclass , jlong self, jlong _image_nativeObj, jlong _lines_nativeObj) 83 { 84 static const char method_name[] = "imgproc::detect_11()"; 85 try { 86 LOGD("%s", method_name); 87 Ptr<cv::LineSegmentDetector>* me = (Ptr<cv::LineSegmentDetector>*) self; //TODO: check for NULL 88 Mat& _image = *((Mat*)_image_nativeObj); 89 Mat& _lines = *((Mat*)_lines_nativeObj); 90 (*me)->detect( _image, _lines ); 91 return; 92 } catch(const std::exception &e) { 93 throwJavaException(env, &e, method_name); 94 } catch (...) { 95 throwJavaException(env, 0, method_name); 96 } 97 return; 98 } 99 100 101 102 // 103 // void drawSegments(Mat& _image, Mat lines) 104 // 105 106 JNIEXPORT void JNICALL Java_org_opencv_imgproc_LineSegmentDetector_drawSegments_10 (JNIEnv*, jclass, jlong, jlong, jlong); 107 108 JNIEXPORT void JNICALL Java_org_opencv_imgproc_LineSegmentDetector_drawSegments_10 109 (JNIEnv* env, jclass , jlong self, jlong _image_nativeObj, jlong lines_nativeObj) 110 { 111 static const char method_name[] = "imgproc::drawSegments_10()"; 112 try { 113 LOGD("%s", method_name); 114 Ptr<cv::LineSegmentDetector>* me = (Ptr<cv::LineSegmentDetector>*) self; //TODO: check for NULL 115 Mat& _image = *((Mat*)_image_nativeObj); 116 Mat& lines = *((Mat*)lines_nativeObj); 117 (*me)->drawSegments( _image, lines ); 118 return; 119 } catch(const std::exception &e) { 120 throwJavaException(env, &e, method_name); 121 } catch (...) { 122 throwJavaException(env, 0, method_name); 123 } 124 return; 125 } 126 127 128 129 // 130 // int compareSegments(Size size, Mat lines1, Mat lines2, Mat& _image = Mat()) 131 // 132 133 JNIEXPORT jint JNICALL Java_org_opencv_imgproc_LineSegmentDetector_compareSegments_10 (JNIEnv*, jclass, jlong, jdouble, jdouble, jlong, jlong, jlong); 134 135 JNIEXPORT jint JNICALL Java_org_opencv_imgproc_LineSegmentDetector_compareSegments_10 136 (JNIEnv* env, jclass , jlong self, jdouble size_width, jdouble size_height, jlong lines1_nativeObj, jlong lines2_nativeObj, jlong _image_nativeObj) 137 { 138 static const char method_name[] = "imgproc::compareSegments_10()"; 139 try { 140 LOGD("%s", method_name); 141 Ptr<cv::LineSegmentDetector>* me = (Ptr<cv::LineSegmentDetector>*) self; //TODO: check for NULL 142 Size size((int)size_width, (int)size_height); 143 Mat& lines1 = *((Mat*)lines1_nativeObj); 144 Mat& lines2 = *((Mat*)lines2_nativeObj); 145 Mat& _image = *((Mat*)_image_nativeObj); 146 int _retval_ = (*me)->compareSegments( size, lines1, lines2, _image ); 147 return _retval_; 148 } catch(const std::exception &e) { 149 throwJavaException(env, &e, method_name); 150 } catch (...) { 151 throwJavaException(env, 0, method_name); 152 } 153 return 0; 154 } 155 156 157 158 JNIEXPORT jint JNICALL Java_org_opencv_imgproc_LineSegmentDetector_compareSegments_11 (JNIEnv*, jclass, jlong, jdouble, jdouble, jlong, jlong); 159 160 JNIEXPORT jint JNICALL Java_org_opencv_imgproc_LineSegmentDetector_compareSegments_11 161 (JNIEnv* env, jclass , jlong self, jdouble size_width, jdouble size_height, jlong lines1_nativeObj, jlong lines2_nativeObj) 162 { 163 static const char method_name[] = "imgproc::compareSegments_11()"; 164 try { 165 LOGD("%s", method_name); 166 Ptr<cv::LineSegmentDetector>* me = (Ptr<cv::LineSegmentDetector>*) self; //TODO: check for NULL 167 Size size((int)size_width, (int)size_height); 168 Mat& lines1 = *((Mat*)lines1_nativeObj); 169 Mat& lines2 = *((Mat*)lines2_nativeObj); 170 int _retval_ = (*me)->compareSegments( size, lines1, lines2 ); 171 return _retval_; 172 } catch(const std::exception &e) { 173 throwJavaException(env, &e, method_name); 174 } catch (...) { 175 throwJavaException(env, 0, method_name); 176 } 177 return 0; 178 } 179 180 181 182 // 183 // native support for java finalize() 184 // static void Ptr<cv::LineSegmentDetector>::delete( __int64 self ) 185 // 186 JNIEXPORT void JNICALL Java_org_opencv_imgproc_LineSegmentDetector_delete(JNIEnv*, jclass, jlong); 187 188 JNIEXPORT void JNICALL Java_org_opencv_imgproc_LineSegmentDetector_delete 189 (JNIEnv*, jclass, jlong self) 190 { 191 delete (Ptr<cv::LineSegmentDetector>*) self; 192 } 193 194 195 // 196 // Subdiv2D() 197 // 198 199 JNIEXPORT jlong JNICALL Java_org_opencv_imgproc_Subdiv2D_Subdiv2D_10 (JNIEnv*, jclass); 200 201 JNIEXPORT jlong JNICALL Java_org_opencv_imgproc_Subdiv2D_Subdiv2D_10 202 (JNIEnv* env, jclass ) 203 { 204 static const char method_name[] = "imgproc::Subdiv2D_10()"; 205 try { 206 LOGD("%s", method_name); 207 208 cv::Subdiv2D* _retval_ = new cv::Subdiv2D( ); 209 return (jlong) _retval_; 210 } catch(const std::exception &e) { 211 throwJavaException(env, &e, method_name); 212 } catch (...) { 213 throwJavaException(env, 0, method_name); 214 } 215 return 0; 216 } 217 218 219 220 // 221 // Subdiv2D(Rect rect) 222 // 223 224 JNIEXPORT jlong JNICALL Java_org_opencv_imgproc_Subdiv2D_Subdiv2D_11 (JNIEnv*, jclass, jint, jint, jint, jint); 225 226 JNIEXPORT jlong JNICALL Java_org_opencv_imgproc_Subdiv2D_Subdiv2D_11 227 (JNIEnv* env, jclass , jint rect_x, jint rect_y, jint rect_width, jint rect_height) 228 { 229 static const char method_name[] = "imgproc::Subdiv2D_11()"; 230 try { 231 LOGD("%s", method_name); 232 Rect rect(rect_x, rect_y, rect_width, rect_height); 233 cv::Subdiv2D* _retval_ = new cv::Subdiv2D( rect ); 234 return (jlong) _retval_; 235 } catch(const std::exception &e) { 236 throwJavaException(env, &e, method_name); 237 } catch (...) { 238 throwJavaException(env, 0, method_name); 239 } 240 return 0; 241 } 242 243 244 245 // 246 // void getTriangleList(vector_Vec6f& triangleList) 247 // 248 249 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Subdiv2D_getTriangleList_10 (JNIEnv*, jclass, jlong, jlong); 250 251 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Subdiv2D_getTriangleList_10 252 (JNIEnv* env, jclass , jlong self, jlong triangleList_mat_nativeObj) 253 { 254 static const char method_name[] = "imgproc::getTriangleList_10()"; 255 try { 256 LOGD("%s", method_name); 257 std::vector<Vec6f> triangleList; 258 Mat& triangleList_mat = *((Mat*)triangleList_mat_nativeObj); 259 cv::Subdiv2D* me = (cv::Subdiv2D*) self; //TODO: check for NULL 260 me->getTriangleList( triangleList ); 261 vector_Vec6f_to_Mat( triangleList, triangleList_mat ); 262 return; 263 } catch(const std::exception &e) { 264 throwJavaException(env, &e, method_name); 265 } catch (...) { 266 throwJavaException(env, 0, method_name); 267 } 268 return; 269 } 270 271 272 273 // 274 // void getVoronoiFacetList(vector_int idx, vector_vector_Point2f& facetList, vector_Point2f& facetCenters) 275 // 276 277 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Subdiv2D_getVoronoiFacetList_10 (JNIEnv*, jclass, jlong, jlong, jlong, jlong); 278 279 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Subdiv2D_getVoronoiFacetList_10 280 (JNIEnv* env, jclass , jlong self, jlong idx_mat_nativeObj, jlong facetList_mat_nativeObj, jlong facetCenters_mat_nativeObj) 281 { 282 static const char method_name[] = "imgproc::getVoronoiFacetList_10()"; 283 try { 284 LOGD("%s", method_name); 285 std::vector<int> idx; 286 Mat& idx_mat = *((Mat*)idx_mat_nativeObj); 287 Mat_to_vector_int( idx_mat, idx ); 288 std::vector< std::vector<Point2f> > facetList; 289 Mat& facetList_mat = *((Mat*)facetList_mat_nativeObj); 290 std::vector<Point2f> facetCenters; 291 Mat& facetCenters_mat = *((Mat*)facetCenters_mat_nativeObj); 292 cv::Subdiv2D* me = (cv::Subdiv2D*) self; //TODO: check for NULL 293 me->getVoronoiFacetList( idx, facetList, facetCenters ); 294 vector_vector_Point2f_to_Mat( facetList, facetList_mat ); vector_Point2f_to_Mat( facetCenters, facetCenters_mat ); 295 return; 296 } catch(const std::exception &e) { 297 throwJavaException(env, &e, method_name); 298 } catch (...) { 299 throwJavaException(env, 0, method_name); 300 } 301 return; 302 } 303 304 305 306 // 307 // Point2f getVertex(int vertex, int* firstEdge = 0) 308 // 309 310 JNIEXPORT jdoubleArray JNICALL Java_org_opencv_imgproc_Subdiv2D_getVertex_10 (JNIEnv*, jclass, jlong, jint, jdoubleArray); 311 312 JNIEXPORT jdoubleArray JNICALL Java_org_opencv_imgproc_Subdiv2D_getVertex_10 313 (JNIEnv* env, jclass , jlong self, jint vertex, jdoubleArray firstEdge_out) 314 { 315 static const char method_name[] = "imgproc::getVertex_10()"; 316 try { 317 LOGD("%s", method_name); 318 cv::Subdiv2D* me = (cv::Subdiv2D*) self; //TODO: check for NULL 319 int firstEdge; 320 Point2f _retval_ = me->getVertex( (int)vertex, &firstEdge ); 321 jdoubleArray _da_retval_ = env->NewDoubleArray(2); jdouble _tmp_retval_[2] = {_retval_.x, _retval_.y}; env->SetDoubleArrayRegion(_da_retval_, 0, 2, _tmp_retval_); jdouble tmp_firstEdge[1] = {firstEdge}; env->SetDoubleArrayRegion(firstEdge_out, 0, 1, tmp_firstEdge); 322 return _da_retval_; 323 } catch(const std::exception &e) { 324 throwJavaException(env, &e, method_name); 325 } catch (...) { 326 throwJavaException(env, 0, method_name); 327 } 328 return 0; 329 } 330 331 332 333 JNIEXPORT jdoubleArray JNICALL Java_org_opencv_imgproc_Subdiv2D_getVertex_11 (JNIEnv*, jclass, jlong, jint); 334 335 JNIEXPORT jdoubleArray JNICALL Java_org_opencv_imgproc_Subdiv2D_getVertex_11 336 (JNIEnv* env, jclass , jlong self, jint vertex) 337 { 338 static const char method_name[] = "imgproc::getVertex_11()"; 339 try { 340 LOGD("%s", method_name); 341 cv::Subdiv2D* me = (cv::Subdiv2D*) self; //TODO: check for NULL 342 Point2f _retval_ = me->getVertex( (int)vertex ); 343 jdoubleArray _da_retval_ = env->NewDoubleArray(2); jdouble _tmp_retval_[2] = {_retval_.x, _retval_.y}; env->SetDoubleArrayRegion(_da_retval_, 0, 2, _tmp_retval_); 344 return _da_retval_; 345 } catch(const std::exception &e) { 346 throwJavaException(env, &e, method_name); 347 } catch (...) { 348 throwJavaException(env, 0, method_name); 349 } 350 return 0; 351 } 352 353 354 355 // 356 // int getEdge(int edge, int nextEdgeType) 357 // 358 359 JNIEXPORT jint JNICALL Java_org_opencv_imgproc_Subdiv2D_getEdge_10 (JNIEnv*, jclass, jlong, jint, jint); 360 361 JNIEXPORT jint JNICALL Java_org_opencv_imgproc_Subdiv2D_getEdge_10 362 (JNIEnv* env, jclass , jlong self, jint edge, jint nextEdgeType) 363 { 364 static const char method_name[] = "imgproc::getEdge_10()"; 365 try { 366 LOGD("%s", method_name); 367 cv::Subdiv2D* me = (cv::Subdiv2D*) self; //TODO: check for NULL 368 int _retval_ = me->getEdge( (int)edge, (int)nextEdgeType ); 369 return _retval_; 370 } catch(const std::exception &e) { 371 throwJavaException(env, &e, method_name); 372 } catch (...) { 373 throwJavaException(env, 0, method_name); 374 } 375 return 0; 376 } 377 378 379 380 // 381 // int nextEdge(int edge) 382 // 383 384 JNIEXPORT jint JNICALL Java_org_opencv_imgproc_Subdiv2D_nextEdge_10 (JNIEnv*, jclass, jlong, jint); 385 386 JNIEXPORT jint JNICALL Java_org_opencv_imgproc_Subdiv2D_nextEdge_10 387 (JNIEnv* env, jclass , jlong self, jint edge) 388 { 389 static const char method_name[] = "imgproc::nextEdge_10()"; 390 try { 391 LOGD("%s", method_name); 392 cv::Subdiv2D* me = (cv::Subdiv2D*) self; //TODO: check for NULL 393 int _retval_ = me->nextEdge( (int)edge ); 394 return _retval_; 395 } catch(const std::exception &e) { 396 throwJavaException(env, &e, method_name); 397 } catch (...) { 398 throwJavaException(env, 0, method_name); 399 } 400 return 0; 401 } 402 403 404 405 // 406 // int rotateEdge(int edge, int rotate) 407 // 408 409 JNIEXPORT jint JNICALL Java_org_opencv_imgproc_Subdiv2D_rotateEdge_10 (JNIEnv*, jclass, jlong, jint, jint); 410 411 JNIEXPORT jint JNICALL Java_org_opencv_imgproc_Subdiv2D_rotateEdge_10 412 (JNIEnv* env, jclass , jlong self, jint edge, jint rotate) 413 { 414 static const char method_name[] = "imgproc::rotateEdge_10()"; 415 try { 416 LOGD("%s", method_name); 417 cv::Subdiv2D* me = (cv::Subdiv2D*) self; //TODO: check for NULL 418 int _retval_ = me->rotateEdge( (int)edge, (int)rotate ); 419 return _retval_; 420 } catch(const std::exception &e) { 421 throwJavaException(env, &e, method_name); 422 } catch (...) { 423 throwJavaException(env, 0, method_name); 424 } 425 return 0; 426 } 427 428 429 430 // 431 // int symEdge(int edge) 432 // 433 434 JNIEXPORT jint JNICALL Java_org_opencv_imgproc_Subdiv2D_symEdge_10 (JNIEnv*, jclass, jlong, jint); 435 436 JNIEXPORT jint JNICALL Java_org_opencv_imgproc_Subdiv2D_symEdge_10 437 (JNIEnv* env, jclass , jlong self, jint edge) 438 { 439 static const char method_name[] = "imgproc::symEdge_10()"; 440 try { 441 LOGD("%s", method_name); 442 cv::Subdiv2D* me = (cv::Subdiv2D*) self; //TODO: check for NULL 443 int _retval_ = me->symEdge( (int)edge ); 444 return _retval_; 445 } catch(const std::exception &e) { 446 throwJavaException(env, &e, method_name); 447 } catch (...) { 448 throwJavaException(env, 0, method_name); 449 } 450 return 0; 451 } 452 453 454 455 // 456 // int edgeOrg(int edge, Point2f* orgpt = 0) 457 // 458 459 JNIEXPORT jint JNICALL Java_org_opencv_imgproc_Subdiv2D_edgeOrg_10 (JNIEnv*, jclass, jlong, jint, jdoubleArray); 460 461 JNIEXPORT jint JNICALL Java_org_opencv_imgproc_Subdiv2D_edgeOrg_10 462 (JNIEnv* env, jclass , jlong self, jint edge, jdoubleArray orgpt_out) 463 { 464 static const char method_name[] = "imgproc::edgeOrg_10()"; 465 try { 466 LOGD("%s", method_name); 467 cv::Subdiv2D* me = (cv::Subdiv2D*) self; //TODO: check for NULL 468 Point2f orgpt; 469 int _retval_ = me->edgeOrg( (int)edge, &orgpt ); 470 jdouble tmp_orgpt[2] = {orgpt.x, orgpt.y}; env->SetDoubleArrayRegion(orgpt_out, 0, 2, tmp_orgpt); 471 return _retval_; 472 } catch(const std::exception &e) { 473 throwJavaException(env, &e, method_name); 474 } catch (...) { 475 throwJavaException(env, 0, method_name); 476 } 477 return 0; 478 } 479 480 481 482 JNIEXPORT jint JNICALL Java_org_opencv_imgproc_Subdiv2D_edgeOrg_11 (JNIEnv*, jclass, jlong, jint); 483 484 JNIEXPORT jint JNICALL Java_org_opencv_imgproc_Subdiv2D_edgeOrg_11 485 (JNIEnv* env, jclass , jlong self, jint edge) 486 { 487 static const char method_name[] = "imgproc::edgeOrg_11()"; 488 try { 489 LOGD("%s", method_name); 490 cv::Subdiv2D* me = (cv::Subdiv2D*) self; //TODO: check for NULL 491 int _retval_ = me->edgeOrg( (int)edge ); 492 return _retval_; 493 } catch(const std::exception &e) { 494 throwJavaException(env, &e, method_name); 495 } catch (...) { 496 throwJavaException(env, 0, method_name); 497 } 498 return 0; 499 } 500 501 502 503 // 504 // int edgeDst(int edge, Point2f* dstpt = 0) 505 // 506 507 JNIEXPORT jint JNICALL Java_org_opencv_imgproc_Subdiv2D_edgeDst_10 (JNIEnv*, jclass, jlong, jint, jdoubleArray); 508 509 JNIEXPORT jint JNICALL Java_org_opencv_imgproc_Subdiv2D_edgeDst_10 510 (JNIEnv* env, jclass , jlong self, jint edge, jdoubleArray dstpt_out) 511 { 512 static const char method_name[] = "imgproc::edgeDst_10()"; 513 try { 514 LOGD("%s", method_name); 515 cv::Subdiv2D* me = (cv::Subdiv2D*) self; //TODO: check for NULL 516 Point2f dstpt; 517 int _retval_ = me->edgeDst( (int)edge, &dstpt ); 518 jdouble tmp_dstpt[2] = {dstpt.x, dstpt.y}; env->SetDoubleArrayRegion(dstpt_out, 0, 2, tmp_dstpt); 519 return _retval_; 520 } catch(const std::exception &e) { 521 throwJavaException(env, &e, method_name); 522 } catch (...) { 523 throwJavaException(env, 0, method_name); 524 } 525 return 0; 526 } 527 528 529 530 JNIEXPORT jint JNICALL Java_org_opencv_imgproc_Subdiv2D_edgeDst_11 (JNIEnv*, jclass, jlong, jint); 531 532 JNIEXPORT jint JNICALL Java_org_opencv_imgproc_Subdiv2D_edgeDst_11 533 (JNIEnv* env, jclass , jlong self, jint edge) 534 { 535 static const char method_name[] = "imgproc::edgeDst_11()"; 536 try { 537 LOGD("%s", method_name); 538 cv::Subdiv2D* me = (cv::Subdiv2D*) self; //TODO: check for NULL 539 int _retval_ = me->edgeDst( (int)edge ); 540 return _retval_; 541 } catch(const std::exception &e) { 542 throwJavaException(env, &e, method_name); 543 } catch (...) { 544 throwJavaException(env, 0, method_name); 545 } 546 return 0; 547 } 548 549 550 551 // 552 // void initDelaunay(Rect rect) 553 // 554 555 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Subdiv2D_initDelaunay_10 (JNIEnv*, jclass, jlong, jint, jint, jint, jint); 556 557 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Subdiv2D_initDelaunay_10 558 (JNIEnv* env, jclass , jlong self, jint rect_x, jint rect_y, jint rect_width, jint rect_height) 559 { 560 static const char method_name[] = "imgproc::initDelaunay_10()"; 561 try { 562 LOGD("%s", method_name); 563 cv::Subdiv2D* me = (cv::Subdiv2D*) self; //TODO: check for NULL 564 Rect rect(rect_x, rect_y, rect_width, rect_height); 565 me->initDelaunay( rect ); 566 return; 567 } catch(const std::exception &e) { 568 throwJavaException(env, &e, method_name); 569 } catch (...) { 570 throwJavaException(env, 0, method_name); 571 } 572 return; 573 } 574 575 576 577 // 578 // int insert(Point2f pt) 579 // 580 581 JNIEXPORT jint JNICALL Java_org_opencv_imgproc_Subdiv2D_insert_10 (JNIEnv*, jclass, jlong, jdouble, jdouble); 582 583 JNIEXPORT jint JNICALL Java_org_opencv_imgproc_Subdiv2D_insert_10 584 (JNIEnv* env, jclass , jlong self, jdouble pt_x, jdouble pt_y) 585 { 586 static const char method_name[] = "imgproc::insert_10()"; 587 try { 588 LOGD("%s", method_name); 589 cv::Subdiv2D* me = (cv::Subdiv2D*) self; //TODO: check for NULL 590 Point2f pt((float)pt_x, (float)pt_y); 591 int _retval_ = me->insert( pt ); 592 return _retval_; 593 } catch(const std::exception &e) { 594 throwJavaException(env, &e, method_name); 595 } catch (...) { 596 throwJavaException(env, 0, method_name); 597 } 598 return 0; 599 } 600 601 602 603 // 604 // void insert(vector_Point2f ptvec) 605 // 606 607 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Subdiv2D_insert_11 (JNIEnv*, jclass, jlong, jlong); 608 609 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Subdiv2D_insert_11 610 (JNIEnv* env, jclass , jlong self, jlong ptvec_mat_nativeObj) 611 { 612 static const char method_name[] = "imgproc::insert_11()"; 613 try { 614 LOGD("%s", method_name); 615 std::vector<Point2f> ptvec; 616 Mat& ptvec_mat = *((Mat*)ptvec_mat_nativeObj); 617 Mat_to_vector_Point2f( ptvec_mat, ptvec ); 618 cv::Subdiv2D* me = (cv::Subdiv2D*) self; //TODO: check for NULL 619 me->insert( ptvec ); 620 return; 621 } catch(const std::exception &e) { 622 throwJavaException(env, &e, method_name); 623 } catch (...) { 624 throwJavaException(env, 0, method_name); 625 } 626 return; 627 } 628 629 630 631 // 632 // int locate(Point2f pt, int& edge, int& vertex) 633 // 634 635 JNIEXPORT jint JNICALL Java_org_opencv_imgproc_Subdiv2D_locate_10 (JNIEnv*, jclass, jlong, jdouble, jdouble, jdoubleArray, jdoubleArray); 636 637 JNIEXPORT jint JNICALL Java_org_opencv_imgproc_Subdiv2D_locate_10 638 (JNIEnv* env, jclass , jlong self, jdouble pt_x, jdouble pt_y, jdoubleArray edge_out, jdoubleArray vertex_out) 639 { 640 static const char method_name[] = "imgproc::locate_10()"; 641 try { 642 LOGD("%s", method_name); 643 cv::Subdiv2D* me = (cv::Subdiv2D*) self; //TODO: check for NULL 644 Point2f pt((float)pt_x, (float)pt_y); 645 int edge; 646 int vertex; 647 int _retval_ = me->locate( pt, edge, vertex ); 648 jdouble tmp_edge[1] = {edge}; env->SetDoubleArrayRegion(edge_out, 0, 1, tmp_edge); jdouble tmp_vertex[1] = {vertex}; env->SetDoubleArrayRegion(vertex_out, 0, 1, tmp_vertex); 649 return _retval_; 650 } catch(const std::exception &e) { 651 throwJavaException(env, &e, method_name); 652 } catch (...) { 653 throwJavaException(env, 0, method_name); 654 } 655 return 0; 656 } 657 658 659 660 // 661 // int findNearest(Point2f pt, Point2f* nearestPt = 0) 662 // 663 664 JNIEXPORT jint JNICALL Java_org_opencv_imgproc_Subdiv2D_findNearest_10 (JNIEnv*, jclass, jlong, jdouble, jdouble, jdoubleArray); 665 666 JNIEXPORT jint JNICALL Java_org_opencv_imgproc_Subdiv2D_findNearest_10 667 (JNIEnv* env, jclass , jlong self, jdouble pt_x, jdouble pt_y, jdoubleArray nearestPt_out) 668 { 669 static const char method_name[] = "imgproc::findNearest_10()"; 670 try { 671 LOGD("%s", method_name); 672 cv::Subdiv2D* me = (cv::Subdiv2D*) self; //TODO: check for NULL 673 Point2f pt((float)pt_x, (float)pt_y); 674 Point2f nearestPt; 675 int _retval_ = me->findNearest( pt, &nearestPt ); 676 jdouble tmp_nearestPt[2] = {nearestPt.x, nearestPt.y}; env->SetDoubleArrayRegion(nearestPt_out, 0, 2, tmp_nearestPt); 677 return _retval_; 678 } catch(const std::exception &e) { 679 throwJavaException(env, &e, method_name); 680 } catch (...) { 681 throwJavaException(env, 0, method_name); 682 } 683 return 0; 684 } 685 686 687 688 JNIEXPORT jint JNICALL Java_org_opencv_imgproc_Subdiv2D_findNearest_11 (JNIEnv*, jclass, jlong, jdouble, jdouble); 689 690 JNIEXPORT jint JNICALL Java_org_opencv_imgproc_Subdiv2D_findNearest_11 691 (JNIEnv* env, jclass , jlong self, jdouble pt_x, jdouble pt_y) 692 { 693 static const char method_name[] = "imgproc::findNearest_11()"; 694 try { 695 LOGD("%s", method_name); 696 cv::Subdiv2D* me = (cv::Subdiv2D*) self; //TODO: check for NULL 697 Point2f pt((float)pt_x, (float)pt_y); 698 int _retval_ = me->findNearest( pt ); 699 return _retval_; 700 } catch(const std::exception &e) { 701 throwJavaException(env, &e, method_name); 702 } catch (...) { 703 throwJavaException(env, 0, method_name); 704 } 705 return 0; 706 } 707 708 709 710 // 711 // void getEdgeList(vector_Vec4f& edgeList) 712 // 713 714 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Subdiv2D_getEdgeList_10 (JNIEnv*, jclass, jlong, jlong); 715 716 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Subdiv2D_getEdgeList_10 717 (JNIEnv* env, jclass , jlong self, jlong edgeList_mat_nativeObj) 718 { 719 static const char method_name[] = "imgproc::getEdgeList_10()"; 720 try { 721 LOGD("%s", method_name); 722 std::vector<Vec4f> edgeList; 723 Mat& edgeList_mat = *((Mat*)edgeList_mat_nativeObj); 724 cv::Subdiv2D* me = (cv::Subdiv2D*) self; //TODO: check for NULL 725 me->getEdgeList( edgeList ); 726 vector_Vec4f_to_Mat( edgeList, edgeList_mat ); 727 return; 728 } catch(const std::exception &e) { 729 throwJavaException(env, &e, method_name); 730 } catch (...) { 731 throwJavaException(env, 0, method_name); 732 } 733 return; 734 } 735 736 737 738 // 739 // native support for java finalize() 740 // static void cv::Subdiv2D::delete( __int64 self ) 741 // 742 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Subdiv2D_delete(JNIEnv*, jclass, jlong); 743 744 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Subdiv2D_delete 745 (JNIEnv*, jclass, jlong self) 746 { 747 delete (cv::Subdiv2D*) self; 748 } 749 750 751 // 752 // void remap(Mat src, Mat& dst, Mat map1, Mat map2, int interpolation, int borderMode = BORDER_CONSTANT, Scalar borderValue = Scalar()) 753 // 754 755 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_remap_10 (JNIEnv*, jclass, jlong, jlong, jlong, jlong, jint, jint, jdouble, jdouble, jdouble, jdouble); 756 757 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_remap_10 758 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jlong map1_nativeObj, jlong map2_nativeObj, jint interpolation, jint borderMode, jdouble borderValue_val0, jdouble borderValue_val1, jdouble borderValue_val2, jdouble borderValue_val3) 759 { 760 static const char method_name[] = "imgproc::remap_10()"; 761 try { 762 LOGD("%s", method_name); 763 Mat& src = *((Mat*)src_nativeObj); 764 Mat& dst = *((Mat*)dst_nativeObj); 765 Mat& map1 = *((Mat*)map1_nativeObj); 766 Mat& map2 = *((Mat*)map2_nativeObj); 767 Scalar borderValue(borderValue_val0, borderValue_val1, borderValue_val2, borderValue_val3); 768 cv::remap( src, dst, map1, map2, (int)interpolation, (int)borderMode, borderValue ); 769 return; 770 } catch(const std::exception &e) { 771 throwJavaException(env, &e, method_name); 772 } catch (...) { 773 throwJavaException(env, 0, method_name); 774 } 775 return; 776 } 777 778 779 780 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_remap_11 (JNIEnv*, jclass, jlong, jlong, jlong, jlong, jint); 781 782 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_remap_11 783 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jlong map1_nativeObj, jlong map2_nativeObj, jint interpolation) 784 { 785 static const char method_name[] = "imgproc::remap_11()"; 786 try { 787 LOGD("%s", method_name); 788 Mat& src = *((Mat*)src_nativeObj); 789 Mat& dst = *((Mat*)dst_nativeObj); 790 Mat& map1 = *((Mat*)map1_nativeObj); 791 Mat& map2 = *((Mat*)map2_nativeObj); 792 cv::remap( src, dst, map1, map2, (int)interpolation ); 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 convertMaps(Mat map1, Mat map2, Mat& dstmap1, Mat& dstmap2, int dstmap1type, bool nninterpolation = false) 806 // 807 808 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_convertMaps_10 (JNIEnv*, jclass, jlong, jlong, jlong, jlong, jint, jboolean); 809 810 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_convertMaps_10 811 (JNIEnv* env, jclass , jlong map1_nativeObj, jlong map2_nativeObj, jlong dstmap1_nativeObj, jlong dstmap2_nativeObj, jint dstmap1type, jboolean nninterpolation) 812 { 813 static const char method_name[] = "imgproc::convertMaps_10()"; 814 try { 815 LOGD("%s", method_name); 816 Mat& map1 = *((Mat*)map1_nativeObj); 817 Mat& map2 = *((Mat*)map2_nativeObj); 818 Mat& dstmap1 = *((Mat*)dstmap1_nativeObj); 819 Mat& dstmap2 = *((Mat*)dstmap2_nativeObj); 820 cv::convertMaps( map1, map2, dstmap1, dstmap2, (int)dstmap1type, (bool)nninterpolation ); 821 return; 822 } catch(const std::exception &e) { 823 throwJavaException(env, &e, method_name); 824 } catch (...) { 825 throwJavaException(env, 0, method_name); 826 } 827 return; 828 } 829 830 831 832 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_convertMaps_11 (JNIEnv*, jclass, jlong, jlong, jlong, jlong, jint); 833 834 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_convertMaps_11 835 (JNIEnv* env, jclass , jlong map1_nativeObj, jlong map2_nativeObj, jlong dstmap1_nativeObj, jlong dstmap2_nativeObj, jint dstmap1type) 836 { 837 static const char method_name[] = "imgproc::convertMaps_11()"; 838 try { 839 LOGD("%s", method_name); 840 Mat& map1 = *((Mat*)map1_nativeObj); 841 Mat& map2 = *((Mat*)map2_nativeObj); 842 Mat& dstmap1 = *((Mat*)dstmap1_nativeObj); 843 Mat& dstmap2 = *((Mat*)dstmap2_nativeObj); 844 cv::convertMaps( map1, map2, dstmap1, dstmap2, (int)dstmap1type ); 845 return; 846 } catch(const std::exception &e) { 847 throwJavaException(env, &e, method_name); 848 } catch (...) { 849 throwJavaException(env, 0, method_name); 850 } 851 return; 852 } 853 854 855 856 // 857 // Mat getRotationMatrix2D(Point2f center, double angle, double scale) 858 // 859 860 JNIEXPORT jlong JNICALL Java_org_opencv_imgproc_Imgproc_getRotationMatrix2D_10 (JNIEnv*, jclass, jdouble, jdouble, jdouble, jdouble); 861 862 JNIEXPORT jlong JNICALL Java_org_opencv_imgproc_Imgproc_getRotationMatrix2D_10 863 (JNIEnv* env, jclass , jdouble center_x, jdouble center_y, jdouble angle, jdouble scale) 864 { 865 static const char method_name[] = "imgproc::getRotationMatrix2D_10()"; 866 try { 867 LOGD("%s", method_name); 868 Point2f center((float)center_x, (float)center_y); 869 ::Mat _retval_ = cv::getRotationMatrix2D( center, (double)angle, (double)scale ); 870 return (jlong) new ::Mat(_retval_); 871 } catch(const std::exception &e) { 872 throwJavaException(env, &e, method_name); 873 } catch (...) { 874 throwJavaException(env, 0, method_name); 875 } 876 return 0; 877 } 878 879 880 881 // 882 // void invertAffineTransform(Mat M, Mat& iM) 883 // 884 885 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_invertAffineTransform_10 (JNIEnv*, jclass, jlong, jlong); 886 887 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_invertAffineTransform_10 888 (JNIEnv* env, jclass , jlong M_nativeObj, jlong iM_nativeObj) 889 { 890 static const char method_name[] = "imgproc::invertAffineTransform_10()"; 891 try { 892 LOGD("%s", method_name); 893 Mat& M = *((Mat*)M_nativeObj); 894 Mat& iM = *((Mat*)iM_nativeObj); 895 cv::invertAffineTransform( M, iM ); 896 return; 897 } catch(const std::exception &e) { 898 throwJavaException(env, &e, method_name); 899 } catch (...) { 900 throwJavaException(env, 0, method_name); 901 } 902 return; 903 } 904 905 906 907 // 908 // Mat getPerspectiveTransform(Mat src, Mat dst) 909 // 910 911 JNIEXPORT jlong JNICALL Java_org_opencv_imgproc_Imgproc_getPerspectiveTransform_10 (JNIEnv*, jclass, jlong, jlong); 912 913 JNIEXPORT jlong JNICALL Java_org_opencv_imgproc_Imgproc_getPerspectiveTransform_10 914 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj) 915 { 916 static const char method_name[] = "imgproc::getPerspectiveTransform_10()"; 917 try { 918 LOGD("%s", method_name); 919 Mat& src = *((Mat*)src_nativeObj); 920 Mat& dst = *((Mat*)dst_nativeObj); 921 ::Mat _retval_ = cv::getPerspectiveTransform( src, dst ); 922 return (jlong) new ::Mat(_retval_); 923 } catch(const std::exception &e) { 924 throwJavaException(env, &e, method_name); 925 } catch (...) { 926 throwJavaException(env, 0, method_name); 927 } 928 return 0; 929 } 930 931 932 933 // 934 // Mat getAffineTransform(vector_Point2f src, vector_Point2f dst) 935 // 936 937 JNIEXPORT jlong JNICALL Java_org_opencv_imgproc_Imgproc_getAffineTransform_10 (JNIEnv*, jclass, jlong, jlong); 938 939 JNIEXPORT jlong JNICALL Java_org_opencv_imgproc_Imgproc_getAffineTransform_10 940 (JNIEnv* env, jclass , jlong src_mat_nativeObj, jlong dst_mat_nativeObj) 941 { 942 static const char method_name[] = "imgproc::getAffineTransform_10()"; 943 try { 944 LOGD("%s", method_name); 945 std::vector<Point2f> src; 946 Mat& src_mat = *((Mat*)src_mat_nativeObj); 947 Mat_to_vector_Point2f( src_mat, src ); 948 std::vector<Point2f> dst; 949 Mat& dst_mat = *((Mat*)dst_mat_nativeObj); 950 Mat_to_vector_Point2f( dst_mat, dst ); 951 ::Mat _retval_ = cv::getAffineTransform( src, dst ); 952 return (jlong) new ::Mat(_retval_); 953 } catch(const std::exception &e) { 954 throwJavaException(env, &e, method_name); 955 } catch (...) { 956 throwJavaException(env, 0, method_name); 957 } 958 return 0; 959 } 960 961 962 963 // 964 // void getRectSubPix(Mat image, Size patchSize, Point2f center, Mat& patch, int patchType = -1) 965 // 966 967 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_getRectSubPix_10 (JNIEnv*, jclass, jlong, jdouble, jdouble, jdouble, jdouble, jlong, jint); 968 969 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_getRectSubPix_10 970 (JNIEnv* env, jclass , jlong image_nativeObj, jdouble patchSize_width, jdouble patchSize_height, jdouble center_x, jdouble center_y, jlong patch_nativeObj, jint patchType) 971 { 972 static const char method_name[] = "imgproc::getRectSubPix_10()"; 973 try { 974 LOGD("%s", method_name); 975 Mat& image = *((Mat*)image_nativeObj); 976 Size patchSize((int)patchSize_width, (int)patchSize_height); 977 Point2f center((float)center_x, (float)center_y); 978 Mat& patch = *((Mat*)patch_nativeObj); 979 cv::getRectSubPix( image, patchSize, center, patch, (int)patchType ); 980 return; 981 } catch(const std::exception &e) { 982 throwJavaException(env, &e, method_name); 983 } catch (...) { 984 throwJavaException(env, 0, method_name); 985 } 986 return; 987 } 988 989 990 991 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_getRectSubPix_11 (JNIEnv*, jclass, jlong, jdouble, jdouble, jdouble, jdouble, jlong); 992 993 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_getRectSubPix_11 994 (JNIEnv* env, jclass , jlong image_nativeObj, jdouble patchSize_width, jdouble patchSize_height, jdouble center_x, jdouble center_y, jlong patch_nativeObj) 995 { 996 static const char method_name[] = "imgproc::getRectSubPix_11()"; 997 try { 998 LOGD("%s", method_name); 999 Mat& image = *((Mat*)image_nativeObj); 1000 Size patchSize((int)patchSize_width, (int)patchSize_height); 1001 Point2f center((float)center_x, (float)center_y); 1002 Mat& patch = *((Mat*)patch_nativeObj); 1003 cv::getRectSubPix( image, patchSize, center, patch ); 1004 return; 1005 } catch(const std::exception &e) { 1006 throwJavaException(env, &e, method_name); 1007 } catch (...) { 1008 throwJavaException(env, 0, method_name); 1009 } 1010 return; 1011 } 1012 1013 1014 1015 // 1016 // void logPolar(Mat src, Mat& dst, Point2f center, double M, int flags) 1017 // 1018 1019 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_logPolar_10 (JNIEnv*, jclass, jlong, jlong, jdouble, jdouble, jdouble, jint); 1020 1021 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_logPolar_10 1022 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jdouble center_x, jdouble center_y, jdouble M, jint flags) 1023 { 1024 static const char method_name[] = "imgproc::logPolar_10()"; 1025 try { 1026 LOGD("%s", method_name); 1027 Mat& src = *((Mat*)src_nativeObj); 1028 Mat& dst = *((Mat*)dst_nativeObj); 1029 Point2f center((float)center_x, (float)center_y); 1030 cv::logPolar( src, dst, center, (double)M, (int)flags ); 1031 return; 1032 } catch(const std::exception &e) { 1033 throwJavaException(env, &e, method_name); 1034 } catch (...) { 1035 throwJavaException(env, 0, method_name); 1036 } 1037 return; 1038 } 1039 1040 1041 1042 // 1043 // void linearPolar(Mat src, Mat& dst, Point2f center, double maxRadius, int flags) 1044 // 1045 1046 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_linearPolar_10 (JNIEnv*, jclass, jlong, jlong, jdouble, jdouble, jdouble, jint); 1047 1048 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_linearPolar_10 1049 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jdouble center_x, jdouble center_y, jdouble maxRadius, jint flags) 1050 { 1051 static const char method_name[] = "imgproc::linearPolar_10()"; 1052 try { 1053 LOGD("%s", method_name); 1054 Mat& src = *((Mat*)src_nativeObj); 1055 Mat& dst = *((Mat*)dst_nativeObj); 1056 Point2f center((float)center_x, (float)center_y); 1057 cv::linearPolar( src, dst, center, (double)maxRadius, (int)flags ); 1058 return; 1059 } catch(const std::exception &e) { 1060 throwJavaException(env, &e, method_name); 1061 } catch (...) { 1062 throwJavaException(env, 0, method_name); 1063 } 1064 return; 1065 } 1066 1067 1068 1069 // 1070 // void integral(Mat src, Mat& sum, int sdepth = -1) 1071 // 1072 1073 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_integral_10 (JNIEnv*, jclass, jlong, jlong, jint); 1074 1075 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_integral_10 1076 (JNIEnv* env, jclass , jlong src_nativeObj, jlong sum_nativeObj, jint sdepth) 1077 { 1078 static const char method_name[] = "imgproc::integral_10()"; 1079 try { 1080 LOGD("%s", method_name); 1081 Mat& src = *((Mat*)src_nativeObj); 1082 Mat& sum = *((Mat*)sum_nativeObj); 1083 cv::integral( src, sum, (int)sdepth ); 1084 return; 1085 } catch(const std::exception &e) { 1086 throwJavaException(env, &e, method_name); 1087 } catch (...) { 1088 throwJavaException(env, 0, method_name); 1089 } 1090 return; 1091 } 1092 1093 1094 1095 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_integral_11 (JNIEnv*, jclass, jlong, jlong); 1096 1097 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_integral_11 1098 (JNIEnv* env, jclass , jlong src_nativeObj, jlong sum_nativeObj) 1099 { 1100 static const char method_name[] = "imgproc::integral_11()"; 1101 try { 1102 LOGD("%s", method_name); 1103 Mat& src = *((Mat*)src_nativeObj); 1104 Mat& sum = *((Mat*)sum_nativeObj); 1105 cv::integral( src, sum ); 1106 return; 1107 } catch(const std::exception &e) { 1108 throwJavaException(env, &e, method_name); 1109 } catch (...) { 1110 throwJavaException(env, 0, method_name); 1111 } 1112 return; 1113 } 1114 1115 1116 1117 // 1118 // void filter2D(Mat src, Mat& dst, int ddepth, Mat kernel, Point anchor = Point(-1,-1), double delta = 0, int borderType = BORDER_DEFAULT) 1119 // 1120 1121 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_filter2D_10 (JNIEnv*, jclass, jlong, jlong, jint, jlong, jdouble, jdouble, jdouble, jint); 1122 1123 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_filter2D_10 1124 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jint ddepth, jlong kernel_nativeObj, jdouble anchor_x, jdouble anchor_y, jdouble delta, jint borderType) 1125 { 1126 static const char method_name[] = "imgproc::filter2D_10()"; 1127 try { 1128 LOGD("%s", method_name); 1129 Mat& src = *((Mat*)src_nativeObj); 1130 Mat& dst = *((Mat*)dst_nativeObj); 1131 Mat& kernel = *((Mat*)kernel_nativeObj); 1132 Point anchor((int)anchor_x, (int)anchor_y); 1133 cv::filter2D( src, dst, (int)ddepth, kernel, anchor, (double)delta, (int)borderType ); 1134 return; 1135 } catch(const std::exception &e) { 1136 throwJavaException(env, &e, method_name); 1137 } catch (...) { 1138 throwJavaException(env, 0, method_name); 1139 } 1140 return; 1141 } 1142 1143 1144 1145 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_filter2D_11 (JNIEnv*, jclass, jlong, jlong, jint, jlong, jdouble, jdouble, jdouble); 1146 1147 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_filter2D_11 1148 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jint ddepth, jlong kernel_nativeObj, jdouble anchor_x, jdouble anchor_y, jdouble delta) 1149 { 1150 static const char method_name[] = "imgproc::filter2D_11()"; 1151 try { 1152 LOGD("%s", method_name); 1153 Mat& src = *((Mat*)src_nativeObj); 1154 Mat& dst = *((Mat*)dst_nativeObj); 1155 Mat& kernel = *((Mat*)kernel_nativeObj); 1156 Point anchor((int)anchor_x, (int)anchor_y); 1157 cv::filter2D( src, dst, (int)ddepth, kernel, anchor, (double)delta ); 1158 return; 1159 } catch(const std::exception &e) { 1160 throwJavaException(env, &e, method_name); 1161 } catch (...) { 1162 throwJavaException(env, 0, method_name); 1163 } 1164 return; 1165 } 1166 1167 1168 1169 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_filter2D_12 (JNIEnv*, jclass, jlong, jlong, jint, jlong); 1170 1171 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_filter2D_12 1172 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jint ddepth, jlong kernel_nativeObj) 1173 { 1174 static const char method_name[] = "imgproc::filter2D_12()"; 1175 try { 1176 LOGD("%s", method_name); 1177 Mat& src = *((Mat*)src_nativeObj); 1178 Mat& dst = *((Mat*)dst_nativeObj); 1179 Mat& kernel = *((Mat*)kernel_nativeObj); 1180 cv::filter2D( src, dst, (int)ddepth, kernel ); 1181 return; 1182 } catch(const std::exception &e) { 1183 throwJavaException(env, &e, method_name); 1184 } catch (...) { 1185 throwJavaException(env, 0, method_name); 1186 } 1187 return; 1188 } 1189 1190 1191 1192 // 1193 // void sepFilter2D(Mat src, Mat& dst, int ddepth, Mat kernelX, Mat kernelY, Point anchor = Point(-1,-1), double delta = 0, int borderType = BORDER_DEFAULT) 1194 // 1195 1196 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_sepFilter2D_10 (JNIEnv*, jclass, jlong, jlong, jint, jlong, jlong, jdouble, jdouble, jdouble, jint); 1197 1198 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_sepFilter2D_10 1199 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jint ddepth, jlong kernelX_nativeObj, jlong kernelY_nativeObj, jdouble anchor_x, jdouble anchor_y, jdouble delta, jint borderType) 1200 { 1201 static const char method_name[] = "imgproc::sepFilter2D_10()"; 1202 try { 1203 LOGD("%s", method_name); 1204 Mat& src = *((Mat*)src_nativeObj); 1205 Mat& dst = *((Mat*)dst_nativeObj); 1206 Mat& kernelX = *((Mat*)kernelX_nativeObj); 1207 Mat& kernelY = *((Mat*)kernelY_nativeObj); 1208 Point anchor((int)anchor_x, (int)anchor_y); 1209 cv::sepFilter2D( src, dst, (int)ddepth, kernelX, kernelY, anchor, (double)delta, (int)borderType ); 1210 return; 1211 } catch(const std::exception &e) { 1212 throwJavaException(env, &e, method_name); 1213 } catch (...) { 1214 throwJavaException(env, 0, method_name); 1215 } 1216 return; 1217 } 1218 1219 1220 1221 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_sepFilter2D_11 (JNIEnv*, jclass, jlong, jlong, jint, jlong, jlong, jdouble, jdouble, jdouble); 1222 1223 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_sepFilter2D_11 1224 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jint ddepth, jlong kernelX_nativeObj, jlong kernelY_nativeObj, jdouble anchor_x, jdouble anchor_y, jdouble delta) 1225 { 1226 static const char method_name[] = "imgproc::sepFilter2D_11()"; 1227 try { 1228 LOGD("%s", method_name); 1229 Mat& src = *((Mat*)src_nativeObj); 1230 Mat& dst = *((Mat*)dst_nativeObj); 1231 Mat& kernelX = *((Mat*)kernelX_nativeObj); 1232 Mat& kernelY = *((Mat*)kernelY_nativeObj); 1233 Point anchor((int)anchor_x, (int)anchor_y); 1234 cv::sepFilter2D( src, dst, (int)ddepth, kernelX, kernelY, anchor, (double)delta ); 1235 return; 1236 } catch(const std::exception &e) { 1237 throwJavaException(env, &e, method_name); 1238 } catch (...) { 1239 throwJavaException(env, 0, method_name); 1240 } 1241 return; 1242 } 1243 1244 1245 1246 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_sepFilter2D_12 (JNIEnv*, jclass, jlong, jlong, jint, jlong, jlong); 1247 1248 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_sepFilter2D_12 1249 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jint ddepth, jlong kernelX_nativeObj, jlong kernelY_nativeObj) 1250 { 1251 static const char method_name[] = "imgproc::sepFilter2D_12()"; 1252 try { 1253 LOGD("%s", method_name); 1254 Mat& src = *((Mat*)src_nativeObj); 1255 Mat& dst = *((Mat*)dst_nativeObj); 1256 Mat& kernelX = *((Mat*)kernelX_nativeObj); 1257 Mat& kernelY = *((Mat*)kernelY_nativeObj); 1258 cv::sepFilter2D( src, dst, (int)ddepth, kernelX, kernelY ); 1259 return; 1260 } catch(const std::exception &e) { 1261 throwJavaException(env, &e, method_name); 1262 } catch (...) { 1263 throwJavaException(env, 0, method_name); 1264 } 1265 return; 1266 } 1267 1268 1269 1270 // 1271 // void Sobel(Mat src, Mat& dst, int ddepth, int dx, int dy, int ksize = 3, double scale = 1, double delta = 0, int borderType = BORDER_DEFAULT) 1272 // 1273 1274 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_Sobel_10 (JNIEnv*, jclass, jlong, jlong, jint, jint, jint, jint, jdouble, jdouble, jint); 1275 1276 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_Sobel_10 1277 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jint ddepth, jint dx, jint dy, jint ksize, jdouble scale, jdouble delta, jint borderType) 1278 { 1279 static const char method_name[] = "imgproc::Sobel_10()"; 1280 try { 1281 LOGD("%s", method_name); 1282 Mat& src = *((Mat*)src_nativeObj); 1283 Mat& dst = *((Mat*)dst_nativeObj); 1284 cv::Sobel( src, dst, (int)ddepth, (int)dx, (int)dy, (int)ksize, (double)scale, (double)delta, (int)borderType ); 1285 return; 1286 } catch(const std::exception &e) { 1287 throwJavaException(env, &e, method_name); 1288 } catch (...) { 1289 throwJavaException(env, 0, method_name); 1290 } 1291 return; 1292 } 1293 1294 1295 1296 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_Sobel_11 (JNIEnv*, jclass, jlong, jlong, jint, jint, jint, jint, jdouble, jdouble); 1297 1298 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_Sobel_11 1299 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jint ddepth, jint dx, jint dy, jint ksize, jdouble scale, jdouble delta) 1300 { 1301 static const char method_name[] = "imgproc::Sobel_11()"; 1302 try { 1303 LOGD("%s", method_name); 1304 Mat& src = *((Mat*)src_nativeObj); 1305 Mat& dst = *((Mat*)dst_nativeObj); 1306 cv::Sobel( src, dst, (int)ddepth, (int)dx, (int)dy, (int)ksize, (double)scale, (double)delta ); 1307 return; 1308 } catch(const std::exception &e) { 1309 throwJavaException(env, &e, method_name); 1310 } catch (...) { 1311 throwJavaException(env, 0, method_name); 1312 } 1313 return; 1314 } 1315 1316 1317 1318 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_Sobel_12 (JNIEnv*, jclass, jlong, jlong, jint, jint, jint); 1319 1320 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_Sobel_12 1321 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jint ddepth, jint dx, jint dy) 1322 { 1323 static const char method_name[] = "imgproc::Sobel_12()"; 1324 try { 1325 LOGD("%s", method_name); 1326 Mat& src = *((Mat*)src_nativeObj); 1327 Mat& dst = *((Mat*)dst_nativeObj); 1328 cv::Sobel( src, dst, (int)ddepth, (int)dx, (int)dy ); 1329 return; 1330 } catch(const std::exception &e) { 1331 throwJavaException(env, &e, method_name); 1332 } catch (...) { 1333 throwJavaException(env, 0, method_name); 1334 } 1335 return; 1336 } 1337 1338 1339 1340 // 1341 // void Scharr(Mat src, Mat& dst, int ddepth, int dx, int dy, double scale = 1, double delta = 0, int borderType = BORDER_DEFAULT) 1342 // 1343 1344 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_Scharr_10 (JNIEnv*, jclass, jlong, jlong, jint, jint, jint, jdouble, jdouble, jint); 1345 1346 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_Scharr_10 1347 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jint ddepth, jint dx, jint dy, jdouble scale, jdouble delta, jint borderType) 1348 { 1349 static const char method_name[] = "imgproc::Scharr_10()"; 1350 try { 1351 LOGD("%s", method_name); 1352 Mat& src = *((Mat*)src_nativeObj); 1353 Mat& dst = *((Mat*)dst_nativeObj); 1354 cv::Scharr( src, dst, (int)ddepth, (int)dx, (int)dy, (double)scale, (double)delta, (int)borderType ); 1355 return; 1356 } catch(const std::exception &e) { 1357 throwJavaException(env, &e, method_name); 1358 } catch (...) { 1359 throwJavaException(env, 0, method_name); 1360 } 1361 return; 1362 } 1363 1364 1365 1366 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_Scharr_11 (JNIEnv*, jclass, jlong, jlong, jint, jint, jint, jdouble, jdouble); 1367 1368 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_Scharr_11 1369 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jint ddepth, jint dx, jint dy, jdouble scale, jdouble delta) 1370 { 1371 static const char method_name[] = "imgproc::Scharr_11()"; 1372 try { 1373 LOGD("%s", method_name); 1374 Mat& src = *((Mat*)src_nativeObj); 1375 Mat& dst = *((Mat*)dst_nativeObj); 1376 cv::Scharr( src, dst, (int)ddepth, (int)dx, (int)dy, (double)scale, (double)delta ); 1377 return; 1378 } catch(const std::exception &e) { 1379 throwJavaException(env, &e, method_name); 1380 } catch (...) { 1381 throwJavaException(env, 0, method_name); 1382 } 1383 return; 1384 } 1385 1386 1387 1388 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_Scharr_12 (JNIEnv*, jclass, jlong, jlong, jint, jint, jint); 1389 1390 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_Scharr_12 1391 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jint ddepth, jint dx, jint dy) 1392 { 1393 static const char method_name[] = "imgproc::Scharr_12()"; 1394 try { 1395 LOGD("%s", method_name); 1396 Mat& src = *((Mat*)src_nativeObj); 1397 Mat& dst = *((Mat*)dst_nativeObj); 1398 cv::Scharr( src, dst, (int)ddepth, (int)dx, (int)dy ); 1399 return; 1400 } catch(const std::exception &e) { 1401 throwJavaException(env, &e, method_name); 1402 } catch (...) { 1403 throwJavaException(env, 0, method_name); 1404 } 1405 return; 1406 } 1407 1408 1409 1410 // 1411 // void Laplacian(Mat src, Mat& dst, int ddepth, int ksize = 1, double scale = 1, double delta = 0, int borderType = BORDER_DEFAULT) 1412 // 1413 1414 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_Laplacian_10 (JNIEnv*, jclass, jlong, jlong, jint, jint, jdouble, jdouble, jint); 1415 1416 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_Laplacian_10 1417 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jint ddepth, jint ksize, jdouble scale, jdouble delta, jint borderType) 1418 { 1419 static const char method_name[] = "imgproc::Laplacian_10()"; 1420 try { 1421 LOGD("%s", method_name); 1422 Mat& src = *((Mat*)src_nativeObj); 1423 Mat& dst = *((Mat*)dst_nativeObj); 1424 cv::Laplacian( src, dst, (int)ddepth, (int)ksize, (double)scale, (double)delta, (int)borderType ); 1425 return; 1426 } catch(const std::exception &e) { 1427 throwJavaException(env, &e, method_name); 1428 } catch (...) { 1429 throwJavaException(env, 0, method_name); 1430 } 1431 return; 1432 } 1433 1434 1435 1436 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_Laplacian_11 (JNIEnv*, jclass, jlong, jlong, jint, jint, jdouble, jdouble); 1437 1438 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_Laplacian_11 1439 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jint ddepth, jint ksize, jdouble scale, jdouble delta) 1440 { 1441 static const char method_name[] = "imgproc::Laplacian_11()"; 1442 try { 1443 LOGD("%s", method_name); 1444 Mat& src = *((Mat*)src_nativeObj); 1445 Mat& dst = *((Mat*)dst_nativeObj); 1446 cv::Laplacian( src, dst, (int)ddepth, (int)ksize, (double)scale, (double)delta ); 1447 return; 1448 } catch(const std::exception &e) { 1449 throwJavaException(env, &e, method_name); 1450 } catch (...) { 1451 throwJavaException(env, 0, method_name); 1452 } 1453 return; 1454 } 1455 1456 1457 1458 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_Laplacian_12 (JNIEnv*, jclass, jlong, jlong, jint); 1459 1460 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_Laplacian_12 1461 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jint ddepth) 1462 { 1463 static const char method_name[] = "imgproc::Laplacian_12()"; 1464 try { 1465 LOGD("%s", method_name); 1466 Mat& src = *((Mat*)src_nativeObj); 1467 Mat& dst = *((Mat*)dst_nativeObj); 1468 cv::Laplacian( src, dst, (int)ddepth ); 1469 return; 1470 } catch(const std::exception &e) { 1471 throwJavaException(env, &e, method_name); 1472 } catch (...) { 1473 throwJavaException(env, 0, method_name); 1474 } 1475 return; 1476 } 1477 1478 1479 1480 // 1481 // void Canny(Mat image, Mat& edges, double threshold1, double threshold2, int apertureSize = 3, bool L2gradient = false) 1482 // 1483 1484 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_Canny_10 (JNIEnv*, jclass, jlong, jlong, jdouble, jdouble, jint, jboolean); 1485 1486 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_Canny_10 1487 (JNIEnv* env, jclass , jlong image_nativeObj, jlong edges_nativeObj, jdouble threshold1, jdouble threshold2, jint apertureSize, jboolean L2gradient) 1488 { 1489 static const char method_name[] = "imgproc::Canny_10()"; 1490 try { 1491 LOGD("%s", method_name); 1492 Mat& image = *((Mat*)image_nativeObj); 1493 Mat& edges = *((Mat*)edges_nativeObj); 1494 cv::Canny( image, edges, (double)threshold1, (double)threshold2, (int)apertureSize, (bool)L2gradient ); 1495 return; 1496 } catch(const std::exception &e) { 1497 throwJavaException(env, &e, method_name); 1498 } catch (...) { 1499 throwJavaException(env, 0, method_name); 1500 } 1501 return; 1502 } 1503 1504 1505 1506 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_Canny_11 (JNIEnv*, jclass, jlong, jlong, jdouble, jdouble); 1507 1508 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_Canny_11 1509 (JNIEnv* env, jclass , jlong image_nativeObj, jlong edges_nativeObj, jdouble threshold1, jdouble threshold2) 1510 { 1511 static const char method_name[] = "imgproc::Canny_11()"; 1512 try { 1513 LOGD("%s", method_name); 1514 Mat& image = *((Mat*)image_nativeObj); 1515 Mat& edges = *((Mat*)edges_nativeObj); 1516 cv::Canny( image, edges, (double)threshold1, (double)threshold2 ); 1517 return; 1518 } catch(const std::exception &e) { 1519 throwJavaException(env, &e, method_name); 1520 } catch (...) { 1521 throwJavaException(env, 0, method_name); 1522 } 1523 return; 1524 } 1525 1526 1527 1528 // 1529 // void cornerMinEigenVal(Mat src, Mat& dst, int blockSize, int ksize = 3, int borderType = BORDER_DEFAULT) 1530 // 1531 1532 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_cornerMinEigenVal_10 (JNIEnv*, jclass, jlong, jlong, jint, jint, jint); 1533 1534 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_cornerMinEigenVal_10 1535 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jint blockSize, jint ksize, jint borderType) 1536 { 1537 static const char method_name[] = "imgproc::cornerMinEigenVal_10()"; 1538 try { 1539 LOGD("%s", method_name); 1540 Mat& src = *((Mat*)src_nativeObj); 1541 Mat& dst = *((Mat*)dst_nativeObj); 1542 cv::cornerMinEigenVal( src, dst, (int)blockSize, (int)ksize, (int)borderType ); 1543 return; 1544 } catch(const std::exception &e) { 1545 throwJavaException(env, &e, method_name); 1546 } catch (...) { 1547 throwJavaException(env, 0, method_name); 1548 } 1549 return; 1550 } 1551 1552 1553 1554 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_cornerMinEigenVal_11 (JNIEnv*, jclass, jlong, jlong, jint, jint); 1555 1556 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_cornerMinEigenVal_11 1557 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jint blockSize, jint ksize) 1558 { 1559 static const char method_name[] = "imgproc::cornerMinEigenVal_11()"; 1560 try { 1561 LOGD("%s", method_name); 1562 Mat& src = *((Mat*)src_nativeObj); 1563 Mat& dst = *((Mat*)dst_nativeObj); 1564 cv::cornerMinEigenVal( src, dst, (int)blockSize, (int)ksize ); 1565 return; 1566 } catch(const std::exception &e) { 1567 throwJavaException(env, &e, method_name); 1568 } catch (...) { 1569 throwJavaException(env, 0, method_name); 1570 } 1571 return; 1572 } 1573 1574 1575 1576 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_cornerMinEigenVal_12 (JNIEnv*, jclass, jlong, jlong, jint); 1577 1578 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_cornerMinEigenVal_12 1579 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jint blockSize) 1580 { 1581 static const char method_name[] = "imgproc::cornerMinEigenVal_12()"; 1582 try { 1583 LOGD("%s", method_name); 1584 Mat& src = *((Mat*)src_nativeObj); 1585 Mat& dst = *((Mat*)dst_nativeObj); 1586 cv::cornerMinEigenVal( src, dst, (int)blockSize ); 1587 return; 1588 } catch(const std::exception &e) { 1589 throwJavaException(env, &e, method_name); 1590 } catch (...) { 1591 throwJavaException(env, 0, method_name); 1592 } 1593 return; 1594 } 1595 1596 1597 1598 // 1599 // Ptr_LineSegmentDetector createLineSegmentDetector(int _refine = LSD_REFINE_STD, double _scale = 0.8, double _sigma_scale = 0.6, double _quant = 2.0, double _ang_th = 22.5, double _log_eps = 0, double _density_th = 0.7, int _n_bins = 1024) 1600 // 1601 1602 JNIEXPORT jlong JNICALL Java_org_opencv_imgproc_Imgproc_createLineSegmentDetector_10 (JNIEnv*, jclass, jint, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jint); 1603 1604 JNIEXPORT jlong JNICALL Java_org_opencv_imgproc_Imgproc_createLineSegmentDetector_10 1605 (JNIEnv* env, jclass , jint _refine, jdouble _scale, jdouble _sigma_scale, jdouble _quant, jdouble _ang_th, jdouble _log_eps, jdouble _density_th, jint _n_bins) 1606 { 1607 static const char method_name[] = "imgproc::createLineSegmentDetector_10()"; 1608 try { 1609 LOGD("%s", method_name); 1610 typedef Ptr<cv::LineSegmentDetector> Ptr_LineSegmentDetector; 1611 Ptr_LineSegmentDetector _retval_ = cv::createLineSegmentDetector( (int)_refine, (double)_scale, (double)_sigma_scale, (double)_quant, (double)_ang_th, (double)_log_eps, (double)_density_th, (int)_n_bins ); 1612 return (jlong)(new Ptr_LineSegmentDetector(_retval_)); 1613 } catch(const std::exception &e) { 1614 throwJavaException(env, &e, method_name); 1615 } catch (...) { 1616 throwJavaException(env, 0, method_name); 1617 } 1618 return 0; 1619 } 1620 1621 1622 1623 JNIEXPORT jlong JNICALL Java_org_opencv_imgproc_Imgproc_createLineSegmentDetector_11 (JNIEnv*, jclass); 1624 1625 JNIEXPORT jlong JNICALL Java_org_opencv_imgproc_Imgproc_createLineSegmentDetector_11 1626 (JNIEnv* env, jclass ) 1627 { 1628 static const char method_name[] = "imgproc::createLineSegmentDetector_11()"; 1629 try { 1630 LOGD("%s", method_name); 1631 typedef Ptr<cv::LineSegmentDetector> Ptr_LineSegmentDetector; 1632 Ptr_LineSegmentDetector _retval_ = cv::createLineSegmentDetector( ); 1633 return (jlong)(new Ptr_LineSegmentDetector(_retval_)); 1634 } catch(const std::exception &e) { 1635 throwJavaException(env, &e, method_name); 1636 } catch (...) { 1637 throwJavaException(env, 0, method_name); 1638 } 1639 return 0; 1640 } 1641 1642 1643 1644 // 1645 // Mat getGaussianKernel(int ksize, double sigma, int ktype = CV_64F) 1646 // 1647 1648 JNIEXPORT jlong JNICALL Java_org_opencv_imgproc_Imgproc_getGaussianKernel_10 (JNIEnv*, jclass, jint, jdouble, jint); 1649 1650 JNIEXPORT jlong JNICALL Java_org_opencv_imgproc_Imgproc_getGaussianKernel_10 1651 (JNIEnv* env, jclass , jint ksize, jdouble sigma, jint ktype) 1652 { 1653 static const char method_name[] = "imgproc::getGaussianKernel_10()"; 1654 try { 1655 LOGD("%s", method_name); 1656 1657 ::Mat _retval_ = cv::getGaussianKernel( (int)ksize, (double)sigma, (int)ktype ); 1658 return (jlong) new ::Mat(_retval_); 1659 } catch(const std::exception &e) { 1660 throwJavaException(env, &e, method_name); 1661 } catch (...) { 1662 throwJavaException(env, 0, method_name); 1663 } 1664 return 0; 1665 } 1666 1667 1668 1669 JNIEXPORT jlong JNICALL Java_org_opencv_imgproc_Imgproc_getGaussianKernel_11 (JNIEnv*, jclass, jint, jdouble); 1670 1671 JNIEXPORT jlong JNICALL Java_org_opencv_imgproc_Imgproc_getGaussianKernel_11 1672 (JNIEnv* env, jclass , jint ksize, jdouble sigma) 1673 { 1674 static const char method_name[] = "imgproc::getGaussianKernel_11()"; 1675 try { 1676 LOGD("%s", method_name); 1677 1678 ::Mat _retval_ = cv::getGaussianKernel( (int)ksize, (double)sigma ); 1679 return (jlong) new ::Mat(_retval_); 1680 } catch(const std::exception &e) { 1681 throwJavaException(env, &e, method_name); 1682 } catch (...) { 1683 throwJavaException(env, 0, method_name); 1684 } 1685 return 0; 1686 } 1687 1688 1689 1690 // 1691 // void getDerivKernels(Mat& kx, Mat& ky, int dx, int dy, int ksize, bool normalize = false, int ktype = CV_32F) 1692 // 1693 1694 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_getDerivKernels_10 (JNIEnv*, jclass, jlong, jlong, jint, jint, jint, jboolean, jint); 1695 1696 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_getDerivKernels_10 1697 (JNIEnv* env, jclass , jlong kx_nativeObj, jlong ky_nativeObj, jint dx, jint dy, jint ksize, jboolean normalize, jint ktype) 1698 { 1699 static const char method_name[] = "imgproc::getDerivKernels_10()"; 1700 try { 1701 LOGD("%s", method_name); 1702 Mat& kx = *((Mat*)kx_nativeObj); 1703 Mat& ky = *((Mat*)ky_nativeObj); 1704 cv::getDerivKernels( kx, ky, (int)dx, (int)dy, (int)ksize, (bool)normalize, (int)ktype ); 1705 return; 1706 } catch(const std::exception &e) { 1707 throwJavaException(env, &e, method_name); 1708 } catch (...) { 1709 throwJavaException(env, 0, method_name); 1710 } 1711 return; 1712 } 1713 1714 1715 1716 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_getDerivKernels_11 (JNIEnv*, jclass, jlong, jlong, jint, jint, jint); 1717 1718 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_getDerivKernels_11 1719 (JNIEnv* env, jclass , jlong kx_nativeObj, jlong ky_nativeObj, jint dx, jint dy, jint ksize) 1720 { 1721 static const char method_name[] = "imgproc::getDerivKernels_11()"; 1722 try { 1723 LOGD("%s", method_name); 1724 Mat& kx = *((Mat*)kx_nativeObj); 1725 Mat& ky = *((Mat*)ky_nativeObj); 1726 cv::getDerivKernels( kx, ky, (int)dx, (int)dy, (int)ksize ); 1727 return; 1728 } catch(const std::exception &e) { 1729 throwJavaException(env, &e, method_name); 1730 } catch (...) { 1731 throwJavaException(env, 0, method_name); 1732 } 1733 return; 1734 } 1735 1736 1737 1738 // 1739 // Mat getGaborKernel(Size ksize, double sigma, double theta, double lambd, double gamma, double psi = CV_PI*0.5, int ktype = CV_64F) 1740 // 1741 1742 JNIEXPORT jlong JNICALL Java_org_opencv_imgproc_Imgproc_getGaborKernel_10 (JNIEnv*, jclass, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jint); 1743 1744 JNIEXPORT jlong JNICALL Java_org_opencv_imgproc_Imgproc_getGaborKernel_10 1745 (JNIEnv* env, jclass , jdouble ksize_width, jdouble ksize_height, jdouble sigma, jdouble theta, jdouble lambd, jdouble gamma, jdouble psi, jint ktype) 1746 { 1747 static const char method_name[] = "imgproc::getGaborKernel_10()"; 1748 try { 1749 LOGD("%s", method_name); 1750 Size ksize((int)ksize_width, (int)ksize_height); 1751 ::Mat _retval_ = cv::getGaborKernel( ksize, (double)sigma, (double)theta, (double)lambd, (double)gamma, (double)psi, (int)ktype ); 1752 return (jlong) new ::Mat(_retval_); 1753 } catch(const std::exception &e) { 1754 throwJavaException(env, &e, method_name); 1755 } catch (...) { 1756 throwJavaException(env, 0, method_name); 1757 } 1758 return 0; 1759 } 1760 1761 1762 1763 JNIEXPORT jlong JNICALL Java_org_opencv_imgproc_Imgproc_getGaborKernel_11 (JNIEnv*, jclass, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble); 1764 1765 JNIEXPORT jlong JNICALL Java_org_opencv_imgproc_Imgproc_getGaborKernel_11 1766 (JNIEnv* env, jclass , jdouble ksize_width, jdouble ksize_height, jdouble sigma, jdouble theta, jdouble lambd, jdouble gamma) 1767 { 1768 static const char method_name[] = "imgproc::getGaborKernel_11()"; 1769 try { 1770 LOGD("%s", method_name); 1771 Size ksize((int)ksize_width, (int)ksize_height); 1772 ::Mat _retval_ = cv::getGaborKernel( ksize, (double)sigma, (double)theta, (double)lambd, (double)gamma ); 1773 return (jlong) new ::Mat(_retval_); 1774 } catch(const std::exception &e) { 1775 throwJavaException(env, &e, method_name); 1776 } catch (...) { 1777 throwJavaException(env, 0, method_name); 1778 } 1779 return 0; 1780 } 1781 1782 1783 1784 // 1785 // Mat getStructuringElement(int shape, Size ksize, Point anchor = Point(-1,-1)) 1786 // 1787 1788 JNIEXPORT jlong JNICALL Java_org_opencv_imgproc_Imgproc_getStructuringElement_10 (JNIEnv*, jclass, jint, jdouble, jdouble, jdouble, jdouble); 1789 1790 JNIEXPORT jlong JNICALL Java_org_opencv_imgproc_Imgproc_getStructuringElement_10 1791 (JNIEnv* env, jclass , jint shape, jdouble ksize_width, jdouble ksize_height, jdouble anchor_x, jdouble anchor_y) 1792 { 1793 static const char method_name[] = "imgproc::getStructuringElement_10()"; 1794 try { 1795 LOGD("%s", method_name); 1796 Size ksize((int)ksize_width, (int)ksize_height); 1797 Point anchor((int)anchor_x, (int)anchor_y); 1798 ::Mat _retval_ = cv::getStructuringElement( (int)shape, ksize, anchor ); 1799 return (jlong) new ::Mat(_retval_); 1800 } catch(const std::exception &e) { 1801 throwJavaException(env, &e, method_name); 1802 } catch (...) { 1803 throwJavaException(env, 0, method_name); 1804 } 1805 return 0; 1806 } 1807 1808 1809 1810 JNIEXPORT jlong JNICALL Java_org_opencv_imgproc_Imgproc_getStructuringElement_11 (JNIEnv*, jclass, jint, jdouble, jdouble); 1811 1812 JNIEXPORT jlong JNICALL Java_org_opencv_imgproc_Imgproc_getStructuringElement_11 1813 (JNIEnv* env, jclass , jint shape, jdouble ksize_width, jdouble ksize_height) 1814 { 1815 static const char method_name[] = "imgproc::getStructuringElement_11()"; 1816 try { 1817 LOGD("%s", method_name); 1818 Size ksize((int)ksize_width, (int)ksize_height); 1819 ::Mat _retval_ = cv::getStructuringElement( (int)shape, ksize ); 1820 return (jlong) new ::Mat(_retval_); 1821 } catch(const std::exception &e) { 1822 throwJavaException(env, &e, method_name); 1823 } catch (...) { 1824 throwJavaException(env, 0, method_name); 1825 } 1826 return 0; 1827 } 1828 1829 1830 1831 // 1832 // void medianBlur(Mat src, Mat& dst, int ksize) 1833 // 1834 1835 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_medianBlur_10 (JNIEnv*, jclass, jlong, jlong, jint); 1836 1837 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_medianBlur_10 1838 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jint ksize) 1839 { 1840 static const char method_name[] = "imgproc::medianBlur_10()"; 1841 try { 1842 LOGD("%s", method_name); 1843 Mat& src = *((Mat*)src_nativeObj); 1844 Mat& dst = *((Mat*)dst_nativeObj); 1845 cv::medianBlur( src, dst, (int)ksize ); 1846 return; 1847 } catch(const std::exception &e) { 1848 throwJavaException(env, &e, method_name); 1849 } catch (...) { 1850 throwJavaException(env, 0, method_name); 1851 } 1852 return; 1853 } 1854 1855 1856 1857 // 1858 // void GaussianBlur(Mat src, Mat& dst, Size ksize, double sigmaX, double sigmaY = 0, int borderType = BORDER_DEFAULT) 1859 // 1860 1861 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_GaussianBlur_10 (JNIEnv*, jclass, jlong, jlong, jdouble, jdouble, jdouble, jdouble, jint); 1862 1863 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_GaussianBlur_10 1864 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jdouble ksize_width, jdouble ksize_height, jdouble sigmaX, jdouble sigmaY, jint borderType) 1865 { 1866 static const char method_name[] = "imgproc::GaussianBlur_10()"; 1867 try { 1868 LOGD("%s", method_name); 1869 Mat& src = *((Mat*)src_nativeObj); 1870 Mat& dst = *((Mat*)dst_nativeObj); 1871 Size ksize((int)ksize_width, (int)ksize_height); 1872 cv::GaussianBlur( src, dst, ksize, (double)sigmaX, (double)sigmaY, (int)borderType ); 1873 return; 1874 } catch(const std::exception &e) { 1875 throwJavaException(env, &e, method_name); 1876 } catch (...) { 1877 throwJavaException(env, 0, method_name); 1878 } 1879 return; 1880 } 1881 1882 1883 1884 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_GaussianBlur_11 (JNIEnv*, jclass, jlong, jlong, jdouble, jdouble, jdouble, jdouble); 1885 1886 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_GaussianBlur_11 1887 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jdouble ksize_width, jdouble ksize_height, jdouble sigmaX, jdouble sigmaY) 1888 { 1889 static const char method_name[] = "imgproc::GaussianBlur_11()"; 1890 try { 1891 LOGD("%s", method_name); 1892 Mat& src = *((Mat*)src_nativeObj); 1893 Mat& dst = *((Mat*)dst_nativeObj); 1894 Size ksize((int)ksize_width, (int)ksize_height); 1895 cv::GaussianBlur( src, dst, ksize, (double)sigmaX, (double)sigmaY ); 1896 return; 1897 } catch(const std::exception &e) { 1898 throwJavaException(env, &e, method_name); 1899 } catch (...) { 1900 throwJavaException(env, 0, method_name); 1901 } 1902 return; 1903 } 1904 1905 1906 1907 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_GaussianBlur_12 (JNIEnv*, jclass, jlong, jlong, jdouble, jdouble, jdouble); 1908 1909 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_GaussianBlur_12 1910 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jdouble ksize_width, jdouble ksize_height, jdouble sigmaX) 1911 { 1912 static const char method_name[] = "imgproc::GaussianBlur_12()"; 1913 try { 1914 LOGD("%s", method_name); 1915 Mat& src = *((Mat*)src_nativeObj); 1916 Mat& dst = *((Mat*)dst_nativeObj); 1917 Size ksize((int)ksize_width, (int)ksize_height); 1918 cv::GaussianBlur( src, dst, ksize, (double)sigmaX ); 1919 return; 1920 } catch(const std::exception &e) { 1921 throwJavaException(env, &e, method_name); 1922 } catch (...) { 1923 throwJavaException(env, 0, method_name); 1924 } 1925 return; 1926 } 1927 1928 1929 1930 // 1931 // void bilateralFilter(Mat src, Mat& dst, int d, double sigmaColor, double sigmaSpace, int borderType = BORDER_DEFAULT) 1932 // 1933 1934 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_bilateralFilter_10 (JNIEnv*, jclass, jlong, jlong, jint, jdouble, jdouble, jint); 1935 1936 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_bilateralFilter_10 1937 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jint d, jdouble sigmaColor, jdouble sigmaSpace, jint borderType) 1938 { 1939 static const char method_name[] = "imgproc::bilateralFilter_10()"; 1940 try { 1941 LOGD("%s", method_name); 1942 Mat& src = *((Mat*)src_nativeObj); 1943 Mat& dst = *((Mat*)dst_nativeObj); 1944 cv::bilateralFilter( src, dst, (int)d, (double)sigmaColor, (double)sigmaSpace, (int)borderType ); 1945 return; 1946 } catch(const std::exception &e) { 1947 throwJavaException(env, &e, method_name); 1948 } catch (...) { 1949 throwJavaException(env, 0, method_name); 1950 } 1951 return; 1952 } 1953 1954 1955 1956 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_bilateralFilter_11 (JNIEnv*, jclass, jlong, jlong, jint, jdouble, jdouble); 1957 1958 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_bilateralFilter_11 1959 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jint d, jdouble sigmaColor, jdouble sigmaSpace) 1960 { 1961 static const char method_name[] = "imgproc::bilateralFilter_11()"; 1962 try { 1963 LOGD("%s", method_name); 1964 Mat& src = *((Mat*)src_nativeObj); 1965 Mat& dst = *((Mat*)dst_nativeObj); 1966 cv::bilateralFilter( src, dst, (int)d, (double)sigmaColor, (double)sigmaSpace ); 1967 return; 1968 } catch(const std::exception &e) { 1969 throwJavaException(env, &e, method_name); 1970 } catch (...) { 1971 throwJavaException(env, 0, method_name); 1972 } 1973 return; 1974 } 1975 1976 1977 1978 // 1979 // void boxFilter(Mat src, Mat& dst, int ddepth, Size ksize, Point anchor = Point(-1,-1), bool normalize = true, int borderType = BORDER_DEFAULT) 1980 // 1981 1982 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_boxFilter_10 (JNIEnv*, jclass, jlong, jlong, jint, jdouble, jdouble, jdouble, jdouble, jboolean, jint); 1983 1984 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_boxFilter_10 1985 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jint ddepth, jdouble ksize_width, jdouble ksize_height, jdouble anchor_x, jdouble anchor_y, jboolean normalize, jint borderType) 1986 { 1987 static const char method_name[] = "imgproc::boxFilter_10()"; 1988 try { 1989 LOGD("%s", method_name); 1990 Mat& src = *((Mat*)src_nativeObj); 1991 Mat& dst = *((Mat*)dst_nativeObj); 1992 Size ksize((int)ksize_width, (int)ksize_height); 1993 Point anchor((int)anchor_x, (int)anchor_y); 1994 cv::boxFilter( src, dst, (int)ddepth, ksize, anchor, (bool)normalize, (int)borderType ); 1995 return; 1996 } catch(const std::exception &e) { 1997 throwJavaException(env, &e, method_name); 1998 } catch (...) { 1999 throwJavaException(env, 0, method_name); 2000 } 2001 return; 2002 } 2003 2004 2005 2006 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_boxFilter_11 (JNIEnv*, jclass, jlong, jlong, jint, jdouble, jdouble, jdouble, jdouble, jboolean); 2007 2008 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_boxFilter_11 2009 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jint ddepth, jdouble ksize_width, jdouble ksize_height, jdouble anchor_x, jdouble anchor_y, jboolean normalize) 2010 { 2011 static const char method_name[] = "imgproc::boxFilter_11()"; 2012 try { 2013 LOGD("%s", method_name); 2014 Mat& src = *((Mat*)src_nativeObj); 2015 Mat& dst = *((Mat*)dst_nativeObj); 2016 Size ksize((int)ksize_width, (int)ksize_height); 2017 Point anchor((int)anchor_x, (int)anchor_y); 2018 cv::boxFilter( src, dst, (int)ddepth, ksize, anchor, (bool)normalize ); 2019 return; 2020 } catch(const std::exception &e) { 2021 throwJavaException(env, &e, method_name); 2022 } catch (...) { 2023 throwJavaException(env, 0, method_name); 2024 } 2025 return; 2026 } 2027 2028 2029 2030 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_boxFilter_12 (JNIEnv*, jclass, jlong, jlong, jint, jdouble, jdouble); 2031 2032 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_boxFilter_12 2033 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jint ddepth, jdouble ksize_width, jdouble ksize_height) 2034 { 2035 static const char method_name[] = "imgproc::boxFilter_12()"; 2036 try { 2037 LOGD("%s", method_name); 2038 Mat& src = *((Mat*)src_nativeObj); 2039 Mat& dst = *((Mat*)dst_nativeObj); 2040 Size ksize((int)ksize_width, (int)ksize_height); 2041 cv::boxFilter( src, dst, (int)ddepth, ksize ); 2042 return; 2043 } catch(const std::exception &e) { 2044 throwJavaException(env, &e, method_name); 2045 } catch (...) { 2046 throwJavaException(env, 0, method_name); 2047 } 2048 return; 2049 } 2050 2051 2052 2053 // 2054 // void sqrBoxFilter(Mat _src, Mat& _dst, int ddepth, Size ksize, Point anchor = Point(-1, -1), bool normalize = true, int borderType = BORDER_DEFAULT) 2055 // 2056 2057 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_sqrBoxFilter_10 (JNIEnv*, jclass, jlong, jlong, jint, jdouble, jdouble, jdouble, jdouble, jboolean, jint); 2058 2059 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_sqrBoxFilter_10 2060 (JNIEnv* env, jclass , jlong _src_nativeObj, jlong _dst_nativeObj, jint ddepth, jdouble ksize_width, jdouble ksize_height, jdouble anchor_x, jdouble anchor_y, jboolean normalize, jint borderType) 2061 { 2062 static const char method_name[] = "imgproc::sqrBoxFilter_10()"; 2063 try { 2064 LOGD("%s", method_name); 2065 Mat& _src = *((Mat*)_src_nativeObj); 2066 Mat& _dst = *((Mat*)_dst_nativeObj); 2067 Size ksize((int)ksize_width, (int)ksize_height); 2068 Point anchor((int)anchor_x, (int)anchor_y); 2069 cv::sqrBoxFilter( _src, _dst, (int)ddepth, ksize, anchor, (bool)normalize, (int)borderType ); 2070 return; 2071 } catch(const std::exception &e) { 2072 throwJavaException(env, &e, method_name); 2073 } catch (...) { 2074 throwJavaException(env, 0, method_name); 2075 } 2076 return; 2077 } 2078 2079 2080 2081 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_sqrBoxFilter_11 (JNIEnv*, jclass, jlong, jlong, jint, jdouble, jdouble, jdouble, jdouble, jboolean); 2082 2083 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_sqrBoxFilter_11 2084 (JNIEnv* env, jclass , jlong _src_nativeObj, jlong _dst_nativeObj, jint ddepth, jdouble ksize_width, jdouble ksize_height, jdouble anchor_x, jdouble anchor_y, jboolean normalize) 2085 { 2086 static const char method_name[] = "imgproc::sqrBoxFilter_11()"; 2087 try { 2088 LOGD("%s", method_name); 2089 Mat& _src = *((Mat*)_src_nativeObj); 2090 Mat& _dst = *((Mat*)_dst_nativeObj); 2091 Size ksize((int)ksize_width, (int)ksize_height); 2092 Point anchor((int)anchor_x, (int)anchor_y); 2093 cv::sqrBoxFilter( _src, _dst, (int)ddepth, ksize, anchor, (bool)normalize ); 2094 return; 2095 } catch(const std::exception &e) { 2096 throwJavaException(env, &e, method_name); 2097 } catch (...) { 2098 throwJavaException(env, 0, method_name); 2099 } 2100 return; 2101 } 2102 2103 2104 2105 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_sqrBoxFilter_12 (JNIEnv*, jclass, jlong, jlong, jint, jdouble, jdouble); 2106 2107 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_sqrBoxFilter_12 2108 (JNIEnv* env, jclass , jlong _src_nativeObj, jlong _dst_nativeObj, jint ddepth, jdouble ksize_width, jdouble ksize_height) 2109 { 2110 static const char method_name[] = "imgproc::sqrBoxFilter_12()"; 2111 try { 2112 LOGD("%s", method_name); 2113 Mat& _src = *((Mat*)_src_nativeObj); 2114 Mat& _dst = *((Mat*)_dst_nativeObj); 2115 Size ksize((int)ksize_width, (int)ksize_height); 2116 cv::sqrBoxFilter( _src, _dst, (int)ddepth, ksize ); 2117 return; 2118 } catch(const std::exception &e) { 2119 throwJavaException(env, &e, method_name); 2120 } catch (...) { 2121 throwJavaException(env, 0, method_name); 2122 } 2123 return; 2124 } 2125 2126 2127 2128 // 2129 // void blur(Mat src, Mat& dst, Size ksize, Point anchor = Point(-1,-1), int borderType = BORDER_DEFAULT) 2130 // 2131 2132 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_blur_10 (JNIEnv*, jclass, jlong, jlong, jdouble, jdouble, jdouble, jdouble, jint); 2133 2134 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_blur_10 2135 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jdouble ksize_width, jdouble ksize_height, jdouble anchor_x, jdouble anchor_y, jint borderType) 2136 { 2137 static const char method_name[] = "imgproc::blur_10()"; 2138 try { 2139 LOGD("%s", method_name); 2140 Mat& src = *((Mat*)src_nativeObj); 2141 Mat& dst = *((Mat*)dst_nativeObj); 2142 Size ksize((int)ksize_width, (int)ksize_height); 2143 Point anchor((int)anchor_x, (int)anchor_y); 2144 cv::blur( src, dst, ksize, anchor, (int)borderType ); 2145 return; 2146 } catch(const std::exception &e) { 2147 throwJavaException(env, &e, method_name); 2148 } catch (...) { 2149 throwJavaException(env, 0, method_name); 2150 } 2151 return; 2152 } 2153 2154 2155 2156 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_blur_11 (JNIEnv*, jclass, jlong, jlong, jdouble, jdouble, jdouble, jdouble); 2157 2158 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_blur_11 2159 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jdouble ksize_width, jdouble ksize_height, jdouble anchor_x, jdouble anchor_y) 2160 { 2161 static const char method_name[] = "imgproc::blur_11()"; 2162 try { 2163 LOGD("%s", method_name); 2164 Mat& src = *((Mat*)src_nativeObj); 2165 Mat& dst = *((Mat*)dst_nativeObj); 2166 Size ksize((int)ksize_width, (int)ksize_height); 2167 Point anchor((int)anchor_x, (int)anchor_y); 2168 cv::blur( src, dst, ksize, anchor ); 2169 return; 2170 } catch(const std::exception &e) { 2171 throwJavaException(env, &e, method_name); 2172 } catch (...) { 2173 throwJavaException(env, 0, method_name); 2174 } 2175 return; 2176 } 2177 2178 2179 2180 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_blur_12 (JNIEnv*, jclass, jlong, jlong, jdouble, jdouble); 2181 2182 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_blur_12 2183 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jdouble ksize_width, jdouble ksize_height) 2184 { 2185 static const char method_name[] = "imgproc::blur_12()"; 2186 try { 2187 LOGD("%s", method_name); 2188 Mat& src = *((Mat*)src_nativeObj); 2189 Mat& dst = *((Mat*)dst_nativeObj); 2190 Size ksize((int)ksize_width, (int)ksize_height); 2191 cv::blur( src, dst, ksize ); 2192 return; 2193 } catch(const std::exception &e) { 2194 throwJavaException(env, &e, method_name); 2195 } catch (...) { 2196 throwJavaException(env, 0, method_name); 2197 } 2198 return; 2199 } 2200 2201 2202 2203 // 2204 // void cornerHarris(Mat src, Mat& dst, int blockSize, int ksize, double k, int borderType = BORDER_DEFAULT) 2205 // 2206 2207 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_cornerHarris_10 (JNIEnv*, jclass, jlong, jlong, jint, jint, jdouble, jint); 2208 2209 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_cornerHarris_10 2210 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jint blockSize, jint ksize, jdouble k, jint borderType) 2211 { 2212 static const char method_name[] = "imgproc::cornerHarris_10()"; 2213 try { 2214 LOGD("%s", method_name); 2215 Mat& src = *((Mat*)src_nativeObj); 2216 Mat& dst = *((Mat*)dst_nativeObj); 2217 cv::cornerHarris( src, dst, (int)blockSize, (int)ksize, (double)k, (int)borderType ); 2218 return; 2219 } catch(const std::exception &e) { 2220 throwJavaException(env, &e, method_name); 2221 } catch (...) { 2222 throwJavaException(env, 0, method_name); 2223 } 2224 return; 2225 } 2226 2227 2228 2229 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_cornerHarris_11 (JNIEnv*, jclass, jlong, jlong, jint, jint, jdouble); 2230 2231 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_cornerHarris_11 2232 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jint blockSize, jint ksize, jdouble k) 2233 { 2234 static const char method_name[] = "imgproc::cornerHarris_11()"; 2235 try { 2236 LOGD("%s", method_name); 2237 Mat& src = *((Mat*)src_nativeObj); 2238 Mat& dst = *((Mat*)dst_nativeObj); 2239 cv::cornerHarris( src, dst, (int)blockSize, (int)ksize, (double)k ); 2240 return; 2241 } catch(const std::exception &e) { 2242 throwJavaException(env, &e, method_name); 2243 } catch (...) { 2244 throwJavaException(env, 0, method_name); 2245 } 2246 return; 2247 } 2248 2249 2250 2251 // 2252 // void cornerEigenValsAndVecs(Mat src, Mat& dst, int blockSize, int ksize, int borderType = BORDER_DEFAULT) 2253 // 2254 2255 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_cornerEigenValsAndVecs_10 (JNIEnv*, jclass, jlong, jlong, jint, jint, jint); 2256 2257 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_cornerEigenValsAndVecs_10 2258 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jint blockSize, jint ksize, jint borderType) 2259 { 2260 static const char method_name[] = "imgproc::cornerEigenValsAndVecs_10()"; 2261 try { 2262 LOGD("%s", method_name); 2263 Mat& src = *((Mat*)src_nativeObj); 2264 Mat& dst = *((Mat*)dst_nativeObj); 2265 cv::cornerEigenValsAndVecs( src, dst, (int)blockSize, (int)ksize, (int)borderType ); 2266 return; 2267 } catch(const std::exception &e) { 2268 throwJavaException(env, &e, method_name); 2269 } catch (...) { 2270 throwJavaException(env, 0, method_name); 2271 } 2272 return; 2273 } 2274 2275 2276 2277 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_cornerEigenValsAndVecs_11 (JNIEnv*, jclass, jlong, jlong, jint, jint); 2278 2279 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_cornerEigenValsAndVecs_11 2280 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jint blockSize, jint ksize) 2281 { 2282 static const char method_name[] = "imgproc::cornerEigenValsAndVecs_11()"; 2283 try { 2284 LOGD("%s", method_name); 2285 Mat& src = *((Mat*)src_nativeObj); 2286 Mat& dst = *((Mat*)dst_nativeObj); 2287 cv::cornerEigenValsAndVecs( src, dst, (int)blockSize, (int)ksize ); 2288 return; 2289 } catch(const std::exception &e) { 2290 throwJavaException(env, &e, method_name); 2291 } catch (...) { 2292 throwJavaException(env, 0, method_name); 2293 } 2294 return; 2295 } 2296 2297 2298 2299 // 2300 // void preCornerDetect(Mat src, Mat& dst, int ksize, int borderType = BORDER_DEFAULT) 2301 // 2302 2303 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_preCornerDetect_10 (JNIEnv*, jclass, jlong, jlong, jint, jint); 2304 2305 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_preCornerDetect_10 2306 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jint ksize, jint borderType) 2307 { 2308 static const char method_name[] = "imgproc::preCornerDetect_10()"; 2309 try { 2310 LOGD("%s", method_name); 2311 Mat& src = *((Mat*)src_nativeObj); 2312 Mat& dst = *((Mat*)dst_nativeObj); 2313 cv::preCornerDetect( src, dst, (int)ksize, (int)borderType ); 2314 return; 2315 } catch(const std::exception &e) { 2316 throwJavaException(env, &e, method_name); 2317 } catch (...) { 2318 throwJavaException(env, 0, method_name); 2319 } 2320 return; 2321 } 2322 2323 2324 2325 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_preCornerDetect_11 (JNIEnv*, jclass, jlong, jlong, jint); 2326 2327 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_preCornerDetect_11 2328 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jint ksize) 2329 { 2330 static const char method_name[] = "imgproc::preCornerDetect_11()"; 2331 try { 2332 LOGD("%s", method_name); 2333 Mat& src = *((Mat*)src_nativeObj); 2334 Mat& dst = *((Mat*)dst_nativeObj); 2335 cv::preCornerDetect( src, dst, (int)ksize ); 2336 return; 2337 } catch(const std::exception &e) { 2338 throwJavaException(env, &e, method_name); 2339 } catch (...) { 2340 throwJavaException(env, 0, method_name); 2341 } 2342 return; 2343 } 2344 2345 2346 2347 // 2348 // void cornerSubPix(Mat image, vector_Point2f& corners, Size winSize, Size zeroZone, TermCriteria criteria) 2349 // 2350 2351 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_cornerSubPix_10 (JNIEnv*, jclass, jlong, jlong, jdouble, jdouble, jdouble, jdouble, jint, jint, jdouble); 2352 2353 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_cornerSubPix_10 2354 (JNIEnv* env, jclass , jlong image_nativeObj, jlong corners_mat_nativeObj, jdouble winSize_width, jdouble winSize_height, jdouble zeroZone_width, jdouble zeroZone_height, jint criteria_type, jint criteria_maxCount, jdouble criteria_epsilon) 2355 { 2356 static const char method_name[] = "imgproc::cornerSubPix_10()"; 2357 try { 2358 LOGD("%s", method_name); 2359 std::vector<Point2f> corners; 2360 Mat& corners_mat = *((Mat*)corners_mat_nativeObj); 2361 Mat_to_vector_Point2f( corners_mat, corners ); 2362 Mat& image = *((Mat*)image_nativeObj); 2363 Size winSize((int)winSize_width, (int)winSize_height); 2364 Size zeroZone((int)zeroZone_width, (int)zeroZone_height); 2365 TermCriteria criteria(criteria_type, criteria_maxCount, criteria_epsilon); 2366 cv::cornerSubPix( image, corners, winSize, zeroZone, criteria ); 2367 vector_Point2f_to_Mat( corners, corners_mat ); 2368 return; 2369 } catch(const std::exception &e) { 2370 throwJavaException(env, &e, method_name); 2371 } catch (...) { 2372 throwJavaException(env, 0, method_name); 2373 } 2374 return; 2375 } 2376 2377 2378 2379 // 2380 // void goodFeaturesToTrack(Mat image, vector_Point& corners, int maxCorners, double qualityLevel, double minDistance, Mat mask = Mat(), int blockSize = 3, bool useHarrisDetector = false, double k = 0.04) 2381 // 2382 2383 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_goodFeaturesToTrack_10 (JNIEnv*, jclass, jlong, jlong, jint, jdouble, jdouble, jlong, jint, jboolean, jdouble); 2384 2385 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_goodFeaturesToTrack_10 2386 (JNIEnv* env, jclass , jlong image_nativeObj, jlong corners_mat_nativeObj, jint maxCorners, jdouble qualityLevel, jdouble minDistance, jlong mask_nativeObj, jint blockSize, jboolean useHarrisDetector, jdouble k) 2387 { 2388 static const char method_name[] = "imgproc::goodFeaturesToTrack_10()"; 2389 try { 2390 LOGD("%s", method_name); 2391 std::vector<Point> corners; 2392 Mat& corners_mat = *((Mat*)corners_mat_nativeObj); 2393 Mat& image = *((Mat*)image_nativeObj); 2394 Mat& mask = *((Mat*)mask_nativeObj); 2395 cv::goodFeaturesToTrack( image, corners, (int)maxCorners, (double)qualityLevel, (double)minDistance, mask, (int)blockSize, (bool)useHarrisDetector, (double)k ); 2396 vector_Point_to_Mat( corners, corners_mat ); 2397 return; 2398 } catch(const std::exception &e) { 2399 throwJavaException(env, &e, method_name); 2400 } catch (...) { 2401 throwJavaException(env, 0, method_name); 2402 } 2403 return; 2404 } 2405 2406 2407 2408 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_goodFeaturesToTrack_11 (JNIEnv*, jclass, jlong, jlong, jint, jdouble, jdouble); 2409 2410 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_goodFeaturesToTrack_11 2411 (JNIEnv* env, jclass , jlong image_nativeObj, jlong corners_mat_nativeObj, jint maxCorners, jdouble qualityLevel, jdouble minDistance) 2412 { 2413 static const char method_name[] = "imgproc::goodFeaturesToTrack_11()"; 2414 try { 2415 LOGD("%s", method_name); 2416 std::vector<Point> corners; 2417 Mat& corners_mat = *((Mat*)corners_mat_nativeObj); 2418 Mat& image = *((Mat*)image_nativeObj); 2419 cv::goodFeaturesToTrack( image, corners, (int)maxCorners, (double)qualityLevel, (double)minDistance ); 2420 vector_Point_to_Mat( corners, corners_mat ); 2421 return; 2422 } catch(const std::exception &e) { 2423 throwJavaException(env, &e, method_name); 2424 } catch (...) { 2425 throwJavaException(env, 0, method_name); 2426 } 2427 return; 2428 } 2429 2430 2431 2432 // 2433 // void HoughLines(Mat image, Mat& lines, double rho, double theta, int threshold, double srn = 0, double stn = 0, double min_theta = 0, double max_theta = CV_PI) 2434 // 2435 2436 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_HoughLines_10 (JNIEnv*, jclass, jlong, jlong, jdouble, jdouble, jint, jdouble, jdouble, jdouble, jdouble); 2437 2438 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_HoughLines_10 2439 (JNIEnv* env, jclass , jlong image_nativeObj, jlong lines_nativeObj, jdouble rho, jdouble theta, jint threshold, jdouble srn, jdouble stn, jdouble min_theta, jdouble max_theta) 2440 { 2441 static const char method_name[] = "imgproc::HoughLines_10()"; 2442 try { 2443 LOGD("%s", method_name); 2444 Mat& image = *((Mat*)image_nativeObj); 2445 Mat& lines = *((Mat*)lines_nativeObj); 2446 cv::HoughLines( image, lines, (double)rho, (double)theta, (int)threshold, (double)srn, (double)stn, (double)min_theta, (double)max_theta ); 2447 return; 2448 } catch(const std::exception &e) { 2449 throwJavaException(env, &e, method_name); 2450 } catch (...) { 2451 throwJavaException(env, 0, method_name); 2452 } 2453 return; 2454 } 2455 2456 2457 2458 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_HoughLines_11 (JNIEnv*, jclass, jlong, jlong, jdouble, jdouble, jint); 2459 2460 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_HoughLines_11 2461 (JNIEnv* env, jclass , jlong image_nativeObj, jlong lines_nativeObj, jdouble rho, jdouble theta, jint threshold) 2462 { 2463 static const char method_name[] = "imgproc::HoughLines_11()"; 2464 try { 2465 LOGD("%s", method_name); 2466 Mat& image = *((Mat*)image_nativeObj); 2467 Mat& lines = *((Mat*)lines_nativeObj); 2468 cv::HoughLines( image, lines, (double)rho, (double)theta, (int)threshold ); 2469 return; 2470 } catch(const std::exception &e) { 2471 throwJavaException(env, &e, method_name); 2472 } catch (...) { 2473 throwJavaException(env, 0, method_name); 2474 } 2475 return; 2476 } 2477 2478 2479 2480 // 2481 // void HoughLinesP(Mat image, Mat& lines, double rho, double theta, int threshold, double minLineLength = 0, double maxLineGap = 0) 2482 // 2483 2484 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_HoughLinesP_10 (JNIEnv*, jclass, jlong, jlong, jdouble, jdouble, jint, jdouble, jdouble); 2485 2486 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_HoughLinesP_10 2487 (JNIEnv* env, jclass , jlong image_nativeObj, jlong lines_nativeObj, jdouble rho, jdouble theta, jint threshold, jdouble minLineLength, jdouble maxLineGap) 2488 { 2489 static const char method_name[] = "imgproc::HoughLinesP_10()"; 2490 try { 2491 LOGD("%s", method_name); 2492 Mat& image = *((Mat*)image_nativeObj); 2493 Mat& lines = *((Mat*)lines_nativeObj); 2494 cv::HoughLinesP( image, lines, (double)rho, (double)theta, (int)threshold, (double)minLineLength, (double)maxLineGap ); 2495 return; 2496 } catch(const std::exception &e) { 2497 throwJavaException(env, &e, method_name); 2498 } catch (...) { 2499 throwJavaException(env, 0, method_name); 2500 } 2501 return; 2502 } 2503 2504 2505 2506 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_HoughLinesP_11 (JNIEnv*, jclass, jlong, jlong, jdouble, jdouble, jint); 2507 2508 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_HoughLinesP_11 2509 (JNIEnv* env, jclass , jlong image_nativeObj, jlong lines_nativeObj, jdouble rho, jdouble theta, jint threshold) 2510 { 2511 static const char method_name[] = "imgproc::HoughLinesP_11()"; 2512 try { 2513 LOGD("%s", method_name); 2514 Mat& image = *((Mat*)image_nativeObj); 2515 Mat& lines = *((Mat*)lines_nativeObj); 2516 cv::HoughLinesP( image, lines, (double)rho, (double)theta, (int)threshold ); 2517 return; 2518 } catch(const std::exception &e) { 2519 throwJavaException(env, &e, method_name); 2520 } catch (...) { 2521 throwJavaException(env, 0, method_name); 2522 } 2523 return; 2524 } 2525 2526 2527 2528 // 2529 // void HoughCircles(Mat image, Mat& circles, int method, double dp, double minDist, double param1 = 100, double param2 = 100, int minRadius = 0, int maxRadius = 0) 2530 // 2531 2532 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_HoughCircles_10 (JNIEnv*, jclass, jlong, jlong, jint, jdouble, jdouble, jdouble, jdouble, jint, jint); 2533 2534 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_HoughCircles_10 2535 (JNIEnv* env, jclass , jlong image_nativeObj, jlong circles_nativeObj, jint method, jdouble dp, jdouble minDist, jdouble param1, jdouble param2, jint minRadius, jint maxRadius) 2536 { 2537 static const char method_name[] = "imgproc::HoughCircles_10()"; 2538 try { 2539 LOGD("%s", method_name); 2540 Mat& image = *((Mat*)image_nativeObj); 2541 Mat& circles = *((Mat*)circles_nativeObj); 2542 cv::HoughCircles( image, circles, (int)method, (double)dp, (double)minDist, (double)param1, (double)param2, (int)minRadius, (int)maxRadius ); 2543 return; 2544 } catch(const std::exception &e) { 2545 throwJavaException(env, &e, method_name); 2546 } catch (...) { 2547 throwJavaException(env, 0, method_name); 2548 } 2549 return; 2550 } 2551 2552 2553 2554 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_HoughCircles_11 (JNIEnv*, jclass, jlong, jlong, jint, jdouble, jdouble); 2555 2556 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_HoughCircles_11 2557 (JNIEnv* env, jclass , jlong image_nativeObj, jlong circles_nativeObj, jint method, jdouble dp, jdouble minDist) 2558 { 2559 static const char method_name[] = "imgproc::HoughCircles_11()"; 2560 try { 2561 LOGD("%s", method_name); 2562 Mat& image = *((Mat*)image_nativeObj); 2563 Mat& circles = *((Mat*)circles_nativeObj); 2564 cv::HoughCircles( image, circles, (int)method, (double)dp, (double)minDist ); 2565 return; 2566 } catch(const std::exception &e) { 2567 throwJavaException(env, &e, method_name); 2568 } catch (...) { 2569 throwJavaException(env, 0, method_name); 2570 } 2571 return; 2572 } 2573 2574 2575 2576 // 2577 // void erode(Mat src, Mat& dst, Mat kernel, Point anchor = Point(-1,-1), int iterations = 1, int borderType = BORDER_CONSTANT, Scalar borderValue = morphologyDefaultBorderValue()) 2578 // 2579 2580 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_erode_10 (JNIEnv*, jclass, jlong, jlong, jlong, jdouble, jdouble, jint, jint, jdouble, jdouble, jdouble, jdouble); 2581 2582 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_erode_10 2583 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jlong kernel_nativeObj, jdouble anchor_x, jdouble anchor_y, jint iterations, jint borderType, jdouble borderValue_val0, jdouble borderValue_val1, jdouble borderValue_val2, jdouble borderValue_val3) 2584 { 2585 static const char method_name[] = "imgproc::erode_10()"; 2586 try { 2587 LOGD("%s", method_name); 2588 Mat& src = *((Mat*)src_nativeObj); 2589 Mat& dst = *((Mat*)dst_nativeObj); 2590 Mat& kernel = *((Mat*)kernel_nativeObj); 2591 Point anchor((int)anchor_x, (int)anchor_y); 2592 Scalar borderValue(borderValue_val0, borderValue_val1, borderValue_val2, borderValue_val3); 2593 cv::erode( src, dst, kernel, anchor, (int)iterations, (int)borderType, borderValue ); 2594 return; 2595 } catch(const std::exception &e) { 2596 throwJavaException(env, &e, method_name); 2597 } catch (...) { 2598 throwJavaException(env, 0, method_name); 2599 } 2600 return; 2601 } 2602 2603 2604 2605 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_erode_11 (JNIEnv*, jclass, jlong, jlong, jlong, jdouble, jdouble, jint); 2606 2607 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_erode_11 2608 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jlong kernel_nativeObj, jdouble anchor_x, jdouble anchor_y, jint iterations) 2609 { 2610 static const char method_name[] = "imgproc::erode_11()"; 2611 try { 2612 LOGD("%s", method_name); 2613 Mat& src = *((Mat*)src_nativeObj); 2614 Mat& dst = *((Mat*)dst_nativeObj); 2615 Mat& kernel = *((Mat*)kernel_nativeObj); 2616 Point anchor((int)anchor_x, (int)anchor_y); 2617 cv::erode( src, dst, kernel, anchor, (int)iterations ); 2618 return; 2619 } catch(const std::exception &e) { 2620 throwJavaException(env, &e, method_name); 2621 } catch (...) { 2622 throwJavaException(env, 0, method_name); 2623 } 2624 return; 2625 } 2626 2627 2628 2629 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_erode_12 (JNIEnv*, jclass, jlong, jlong, jlong); 2630 2631 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_erode_12 2632 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jlong kernel_nativeObj) 2633 { 2634 static const char method_name[] = "imgproc::erode_12()"; 2635 try { 2636 LOGD("%s", method_name); 2637 Mat& src = *((Mat*)src_nativeObj); 2638 Mat& dst = *((Mat*)dst_nativeObj); 2639 Mat& kernel = *((Mat*)kernel_nativeObj); 2640 cv::erode( src, dst, kernel ); 2641 return; 2642 } catch(const std::exception &e) { 2643 throwJavaException(env, &e, method_name); 2644 } catch (...) { 2645 throwJavaException(env, 0, method_name); 2646 } 2647 return; 2648 } 2649 2650 2651 2652 // 2653 // void dilate(Mat src, Mat& dst, Mat kernel, Point anchor = Point(-1,-1), int iterations = 1, int borderType = BORDER_CONSTANT, Scalar borderValue = morphologyDefaultBorderValue()) 2654 // 2655 2656 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_dilate_10 (JNIEnv*, jclass, jlong, jlong, jlong, jdouble, jdouble, jint, jint, jdouble, jdouble, jdouble, jdouble); 2657 2658 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_dilate_10 2659 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jlong kernel_nativeObj, jdouble anchor_x, jdouble anchor_y, jint iterations, jint borderType, jdouble borderValue_val0, jdouble borderValue_val1, jdouble borderValue_val2, jdouble borderValue_val3) 2660 { 2661 static const char method_name[] = "imgproc::dilate_10()"; 2662 try { 2663 LOGD("%s", method_name); 2664 Mat& src = *((Mat*)src_nativeObj); 2665 Mat& dst = *((Mat*)dst_nativeObj); 2666 Mat& kernel = *((Mat*)kernel_nativeObj); 2667 Point anchor((int)anchor_x, (int)anchor_y); 2668 Scalar borderValue(borderValue_val0, borderValue_val1, borderValue_val2, borderValue_val3); 2669 cv::dilate( src, dst, kernel, anchor, (int)iterations, (int)borderType, borderValue ); 2670 return; 2671 } catch(const std::exception &e) { 2672 throwJavaException(env, &e, method_name); 2673 } catch (...) { 2674 throwJavaException(env, 0, method_name); 2675 } 2676 return; 2677 } 2678 2679 2680 2681 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_dilate_11 (JNIEnv*, jclass, jlong, jlong, jlong, jdouble, jdouble, jint); 2682 2683 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_dilate_11 2684 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jlong kernel_nativeObj, jdouble anchor_x, jdouble anchor_y, jint iterations) 2685 { 2686 static const char method_name[] = "imgproc::dilate_11()"; 2687 try { 2688 LOGD("%s", method_name); 2689 Mat& src = *((Mat*)src_nativeObj); 2690 Mat& dst = *((Mat*)dst_nativeObj); 2691 Mat& kernel = *((Mat*)kernel_nativeObj); 2692 Point anchor((int)anchor_x, (int)anchor_y); 2693 cv::dilate( src, dst, kernel, anchor, (int)iterations ); 2694 return; 2695 } catch(const std::exception &e) { 2696 throwJavaException(env, &e, method_name); 2697 } catch (...) { 2698 throwJavaException(env, 0, method_name); 2699 } 2700 return; 2701 } 2702 2703 2704 2705 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_dilate_12 (JNIEnv*, jclass, jlong, jlong, jlong); 2706 2707 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_dilate_12 2708 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jlong kernel_nativeObj) 2709 { 2710 static const char method_name[] = "imgproc::dilate_12()"; 2711 try { 2712 LOGD("%s", method_name); 2713 Mat& src = *((Mat*)src_nativeObj); 2714 Mat& dst = *((Mat*)dst_nativeObj); 2715 Mat& kernel = *((Mat*)kernel_nativeObj); 2716 cv::dilate( src, dst, kernel ); 2717 return; 2718 } catch(const std::exception &e) { 2719 throwJavaException(env, &e, method_name); 2720 } catch (...) { 2721 throwJavaException(env, 0, method_name); 2722 } 2723 return; 2724 } 2725 2726 2727 2728 // 2729 // void morphologyEx(Mat src, Mat& dst, int op, Mat kernel, Point anchor = Point(-1,-1), int iterations = 1, int borderType = BORDER_CONSTANT, Scalar borderValue = morphologyDefaultBorderValue()) 2730 // 2731 2732 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_morphologyEx_10 (JNIEnv*, jclass, jlong, jlong, jint, jlong, jdouble, jdouble, jint, jint, jdouble, jdouble, jdouble, jdouble); 2733 2734 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_morphologyEx_10 2735 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jint op, jlong kernel_nativeObj, jdouble anchor_x, jdouble anchor_y, jint iterations, jint borderType, jdouble borderValue_val0, jdouble borderValue_val1, jdouble borderValue_val2, jdouble borderValue_val3) 2736 { 2737 static const char method_name[] = "imgproc::morphologyEx_10()"; 2738 try { 2739 LOGD("%s", method_name); 2740 Mat& src = *((Mat*)src_nativeObj); 2741 Mat& dst = *((Mat*)dst_nativeObj); 2742 Mat& kernel = *((Mat*)kernel_nativeObj); 2743 Point anchor((int)anchor_x, (int)anchor_y); 2744 Scalar borderValue(borderValue_val0, borderValue_val1, borderValue_val2, borderValue_val3); 2745 cv::morphologyEx( src, dst, (int)op, kernel, anchor, (int)iterations, (int)borderType, borderValue ); 2746 return; 2747 } catch(const std::exception &e) { 2748 throwJavaException(env, &e, method_name); 2749 } catch (...) { 2750 throwJavaException(env, 0, method_name); 2751 } 2752 return; 2753 } 2754 2755 2756 2757 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_morphologyEx_11 (JNIEnv*, jclass, jlong, jlong, jint, jlong, jdouble, jdouble, jint); 2758 2759 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_morphologyEx_11 2760 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jint op, jlong kernel_nativeObj, jdouble anchor_x, jdouble anchor_y, jint iterations) 2761 { 2762 static const char method_name[] = "imgproc::morphologyEx_11()"; 2763 try { 2764 LOGD("%s", method_name); 2765 Mat& src = *((Mat*)src_nativeObj); 2766 Mat& dst = *((Mat*)dst_nativeObj); 2767 Mat& kernel = *((Mat*)kernel_nativeObj); 2768 Point anchor((int)anchor_x, (int)anchor_y); 2769 cv::morphologyEx( src, dst, (int)op, kernel, anchor, (int)iterations ); 2770 return; 2771 } catch(const std::exception &e) { 2772 throwJavaException(env, &e, method_name); 2773 } catch (...) { 2774 throwJavaException(env, 0, method_name); 2775 } 2776 return; 2777 } 2778 2779 2780 2781 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_morphologyEx_12 (JNIEnv*, jclass, jlong, jlong, jint, jlong); 2782 2783 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_morphologyEx_12 2784 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jint op, jlong kernel_nativeObj) 2785 { 2786 static const char method_name[] = "imgproc::morphologyEx_12()"; 2787 try { 2788 LOGD("%s", method_name); 2789 Mat& src = *((Mat*)src_nativeObj); 2790 Mat& dst = *((Mat*)dst_nativeObj); 2791 Mat& kernel = *((Mat*)kernel_nativeObj); 2792 cv::morphologyEx( src, dst, (int)op, kernel ); 2793 return; 2794 } catch(const std::exception &e) { 2795 throwJavaException(env, &e, method_name); 2796 } catch (...) { 2797 throwJavaException(env, 0, method_name); 2798 } 2799 return; 2800 } 2801 2802 2803 2804 // 2805 // void resize(Mat src, Mat& dst, Size dsize, double fx = 0, double fy = 0, int interpolation = INTER_LINEAR) 2806 // 2807 2808 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_resize_10 (JNIEnv*, jclass, jlong, jlong, jdouble, jdouble, jdouble, jdouble, jint); 2809 2810 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_resize_10 2811 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jdouble dsize_width, jdouble dsize_height, jdouble fx, jdouble fy, jint interpolation) 2812 { 2813 static const char method_name[] = "imgproc::resize_10()"; 2814 try { 2815 LOGD("%s", method_name); 2816 Mat& src = *((Mat*)src_nativeObj); 2817 Mat& dst = *((Mat*)dst_nativeObj); 2818 Size dsize((int)dsize_width, (int)dsize_height); 2819 cv::resize( src, dst, dsize, (double)fx, (double)fy, (int)interpolation ); 2820 return; 2821 } catch(const std::exception &e) { 2822 throwJavaException(env, &e, method_name); 2823 } catch (...) { 2824 throwJavaException(env, 0, method_name); 2825 } 2826 return; 2827 } 2828 2829 2830 2831 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_resize_11 (JNIEnv*, jclass, jlong, jlong, jdouble, jdouble); 2832 2833 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_resize_11 2834 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jdouble dsize_width, jdouble dsize_height) 2835 { 2836 static const char method_name[] = "imgproc::resize_11()"; 2837 try { 2838 LOGD("%s", method_name); 2839 Mat& src = *((Mat*)src_nativeObj); 2840 Mat& dst = *((Mat*)dst_nativeObj); 2841 Size dsize((int)dsize_width, (int)dsize_height); 2842 cv::resize( src, dst, dsize ); 2843 return; 2844 } catch(const std::exception &e) { 2845 throwJavaException(env, &e, method_name); 2846 } catch (...) { 2847 throwJavaException(env, 0, method_name); 2848 } 2849 return; 2850 } 2851 2852 2853 2854 // 2855 // void warpAffine(Mat src, Mat& dst, Mat M, Size dsize, int flags = INTER_LINEAR, int borderMode = BORDER_CONSTANT, Scalar borderValue = Scalar()) 2856 // 2857 2858 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_warpAffine_10 (JNIEnv*, jclass, jlong, jlong, jlong, jdouble, jdouble, jint, jint, jdouble, jdouble, jdouble, jdouble); 2859 2860 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_warpAffine_10 2861 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jlong M_nativeObj, jdouble dsize_width, jdouble dsize_height, jint flags, jint borderMode, jdouble borderValue_val0, jdouble borderValue_val1, jdouble borderValue_val2, jdouble borderValue_val3) 2862 { 2863 static const char method_name[] = "imgproc::warpAffine_10()"; 2864 try { 2865 LOGD("%s", method_name); 2866 Mat& src = *((Mat*)src_nativeObj); 2867 Mat& dst = *((Mat*)dst_nativeObj); 2868 Mat& M = *((Mat*)M_nativeObj); 2869 Size dsize((int)dsize_width, (int)dsize_height); 2870 Scalar borderValue(borderValue_val0, borderValue_val1, borderValue_val2, borderValue_val3); 2871 cv::warpAffine( src, dst, M, dsize, (int)flags, (int)borderMode, borderValue ); 2872 return; 2873 } catch(const std::exception &e) { 2874 throwJavaException(env, &e, method_name); 2875 } catch (...) { 2876 throwJavaException(env, 0, method_name); 2877 } 2878 return; 2879 } 2880 2881 2882 2883 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_warpAffine_11 (JNIEnv*, jclass, jlong, jlong, jlong, jdouble, jdouble, jint); 2884 2885 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_warpAffine_11 2886 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jlong M_nativeObj, jdouble dsize_width, jdouble dsize_height, jint flags) 2887 { 2888 static const char method_name[] = "imgproc::warpAffine_11()"; 2889 try { 2890 LOGD("%s", method_name); 2891 Mat& src = *((Mat*)src_nativeObj); 2892 Mat& dst = *((Mat*)dst_nativeObj); 2893 Mat& M = *((Mat*)M_nativeObj); 2894 Size dsize((int)dsize_width, (int)dsize_height); 2895 cv::warpAffine( src, dst, M, dsize, (int)flags ); 2896 return; 2897 } catch(const std::exception &e) { 2898 throwJavaException(env, &e, method_name); 2899 } catch (...) { 2900 throwJavaException(env, 0, method_name); 2901 } 2902 return; 2903 } 2904 2905 2906 2907 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_warpAffine_12 (JNIEnv*, jclass, jlong, jlong, jlong, jdouble, jdouble); 2908 2909 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_warpAffine_12 2910 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jlong M_nativeObj, jdouble dsize_width, jdouble dsize_height) 2911 { 2912 static const char method_name[] = "imgproc::warpAffine_12()"; 2913 try { 2914 LOGD("%s", method_name); 2915 Mat& src = *((Mat*)src_nativeObj); 2916 Mat& dst = *((Mat*)dst_nativeObj); 2917 Mat& M = *((Mat*)M_nativeObj); 2918 Size dsize((int)dsize_width, (int)dsize_height); 2919 cv::warpAffine( src, dst, M, dsize ); 2920 return; 2921 } catch(const std::exception &e) { 2922 throwJavaException(env, &e, method_name); 2923 } catch (...) { 2924 throwJavaException(env, 0, method_name); 2925 } 2926 return; 2927 } 2928 2929 2930 2931 // 2932 // void warpPerspective(Mat src, Mat& dst, Mat M, Size dsize, int flags = INTER_LINEAR, int borderMode = BORDER_CONSTANT, Scalar borderValue = Scalar()) 2933 // 2934 2935 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_warpPerspective_10 (JNIEnv*, jclass, jlong, jlong, jlong, jdouble, jdouble, jint, jint, jdouble, jdouble, jdouble, jdouble); 2936 2937 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_warpPerspective_10 2938 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jlong M_nativeObj, jdouble dsize_width, jdouble dsize_height, jint flags, jint borderMode, jdouble borderValue_val0, jdouble borderValue_val1, jdouble borderValue_val2, jdouble borderValue_val3) 2939 { 2940 static const char method_name[] = "imgproc::warpPerspective_10()"; 2941 try { 2942 LOGD("%s", method_name); 2943 Mat& src = *((Mat*)src_nativeObj); 2944 Mat& dst = *((Mat*)dst_nativeObj); 2945 Mat& M = *((Mat*)M_nativeObj); 2946 Size dsize((int)dsize_width, (int)dsize_height); 2947 Scalar borderValue(borderValue_val0, borderValue_val1, borderValue_val2, borderValue_val3); 2948 cv::warpPerspective( src, dst, M, dsize, (int)flags, (int)borderMode, borderValue ); 2949 return; 2950 } catch(const std::exception &e) { 2951 throwJavaException(env, &e, method_name); 2952 } catch (...) { 2953 throwJavaException(env, 0, method_name); 2954 } 2955 return; 2956 } 2957 2958 2959 2960 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_warpPerspective_11 (JNIEnv*, jclass, jlong, jlong, jlong, jdouble, jdouble, jint); 2961 2962 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_warpPerspective_11 2963 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jlong M_nativeObj, jdouble dsize_width, jdouble dsize_height, jint flags) 2964 { 2965 static const char method_name[] = "imgproc::warpPerspective_11()"; 2966 try { 2967 LOGD("%s", method_name); 2968 Mat& src = *((Mat*)src_nativeObj); 2969 Mat& dst = *((Mat*)dst_nativeObj); 2970 Mat& M = *((Mat*)M_nativeObj); 2971 Size dsize((int)dsize_width, (int)dsize_height); 2972 cv::warpPerspective( src, dst, M, dsize, (int)flags ); 2973 return; 2974 } catch(const std::exception &e) { 2975 throwJavaException(env, &e, method_name); 2976 } catch (...) { 2977 throwJavaException(env, 0, method_name); 2978 } 2979 return; 2980 } 2981 2982 2983 2984 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_warpPerspective_12 (JNIEnv*, jclass, jlong, jlong, jlong, jdouble, jdouble); 2985 2986 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_warpPerspective_12 2987 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jlong M_nativeObj, jdouble dsize_width, jdouble dsize_height) 2988 { 2989 static const char method_name[] = "imgproc::warpPerspective_12()"; 2990 try { 2991 LOGD("%s", method_name); 2992 Mat& src = *((Mat*)src_nativeObj); 2993 Mat& dst = *((Mat*)dst_nativeObj); 2994 Mat& M = *((Mat*)M_nativeObj); 2995 Size dsize((int)dsize_width, (int)dsize_height); 2996 cv::warpPerspective( src, dst, M, dsize ); 2997 return; 2998 } catch(const std::exception &e) { 2999 throwJavaException(env, &e, method_name); 3000 } catch (...) { 3001 throwJavaException(env, 0, method_name); 3002 } 3003 return; 3004 } 3005 3006 3007 3008 // 3009 // void integral(Mat src, Mat& sum, Mat& sqsum, int sdepth = -1, int sqdepth = -1) 3010 // 3011 3012 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_integral2_10 (JNIEnv*, jclass, jlong, jlong, jlong, jint, jint); 3013 3014 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_integral2_10 3015 (JNIEnv* env, jclass , jlong src_nativeObj, jlong sum_nativeObj, jlong sqsum_nativeObj, jint sdepth, jint sqdepth) 3016 { 3017 static const char method_name[] = "imgproc::integral2_10()"; 3018 try { 3019 LOGD("%s", method_name); 3020 Mat& src = *((Mat*)src_nativeObj); 3021 Mat& sum = *((Mat*)sum_nativeObj); 3022 Mat& sqsum = *((Mat*)sqsum_nativeObj); 3023 cv::integral( src, sum, sqsum, (int)sdepth, (int)sqdepth ); 3024 return; 3025 } catch(const std::exception &e) { 3026 throwJavaException(env, &e, method_name); 3027 } catch (...) { 3028 throwJavaException(env, 0, method_name); 3029 } 3030 return; 3031 } 3032 3033 3034 3035 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_integral2_11 (JNIEnv*, jclass, jlong, jlong, jlong); 3036 3037 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_integral2_11 3038 (JNIEnv* env, jclass , jlong src_nativeObj, jlong sum_nativeObj, jlong sqsum_nativeObj) 3039 { 3040 static const char method_name[] = "imgproc::integral2_11()"; 3041 try { 3042 LOGD("%s", method_name); 3043 Mat& src = *((Mat*)src_nativeObj); 3044 Mat& sum = *((Mat*)sum_nativeObj); 3045 Mat& sqsum = *((Mat*)sqsum_nativeObj); 3046 cv::integral( src, sum, sqsum ); 3047 return; 3048 } catch(const std::exception &e) { 3049 throwJavaException(env, &e, method_name); 3050 } catch (...) { 3051 throwJavaException(env, 0, method_name); 3052 } 3053 return; 3054 } 3055 3056 3057 3058 // 3059 // void integral(Mat src, Mat& sum, Mat& sqsum, Mat& tilted, int sdepth = -1, int sqdepth = -1) 3060 // 3061 3062 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_integral3_10 (JNIEnv*, jclass, jlong, jlong, jlong, jlong, jint, jint); 3063 3064 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_integral3_10 3065 (JNIEnv* env, jclass , jlong src_nativeObj, jlong sum_nativeObj, jlong sqsum_nativeObj, jlong tilted_nativeObj, jint sdepth, jint sqdepth) 3066 { 3067 static const char method_name[] = "imgproc::integral3_10()"; 3068 try { 3069 LOGD("%s", method_name); 3070 Mat& src = *((Mat*)src_nativeObj); 3071 Mat& sum = *((Mat*)sum_nativeObj); 3072 Mat& sqsum = *((Mat*)sqsum_nativeObj); 3073 Mat& tilted = *((Mat*)tilted_nativeObj); 3074 cv::integral( src, sum, sqsum, tilted, (int)sdepth, (int)sqdepth ); 3075 return; 3076 } catch(const std::exception &e) { 3077 throwJavaException(env, &e, method_name); 3078 } catch (...) { 3079 throwJavaException(env, 0, method_name); 3080 } 3081 return; 3082 } 3083 3084 3085 3086 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_integral3_11 (JNIEnv*, jclass, jlong, jlong, jlong, jlong); 3087 3088 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_integral3_11 3089 (JNIEnv* env, jclass , jlong src_nativeObj, jlong sum_nativeObj, jlong sqsum_nativeObj, jlong tilted_nativeObj) 3090 { 3091 static const char method_name[] = "imgproc::integral3_11()"; 3092 try { 3093 LOGD("%s", method_name); 3094 Mat& src = *((Mat*)src_nativeObj); 3095 Mat& sum = *((Mat*)sum_nativeObj); 3096 Mat& sqsum = *((Mat*)sqsum_nativeObj); 3097 Mat& tilted = *((Mat*)tilted_nativeObj); 3098 cv::integral( src, sum, sqsum, tilted ); 3099 return; 3100 } catch(const std::exception &e) { 3101 throwJavaException(env, &e, method_name); 3102 } catch (...) { 3103 throwJavaException(env, 0, method_name); 3104 } 3105 return; 3106 } 3107 3108 3109 3110 // 3111 // void accumulate(Mat src, Mat& dst, Mat mask = Mat()) 3112 // 3113 3114 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_accumulate_10 (JNIEnv*, jclass, jlong, jlong, jlong); 3115 3116 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_accumulate_10 3117 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jlong mask_nativeObj) 3118 { 3119 static const char method_name[] = "imgproc::accumulate_10()"; 3120 try { 3121 LOGD("%s", method_name); 3122 Mat& src = *((Mat*)src_nativeObj); 3123 Mat& dst = *((Mat*)dst_nativeObj); 3124 Mat& mask = *((Mat*)mask_nativeObj); 3125 cv::accumulate( src, dst, mask ); 3126 return; 3127 } catch(const std::exception &e) { 3128 throwJavaException(env, &e, method_name); 3129 } catch (...) { 3130 throwJavaException(env, 0, method_name); 3131 } 3132 return; 3133 } 3134 3135 3136 3137 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_accumulate_11 (JNIEnv*, jclass, jlong, jlong); 3138 3139 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_accumulate_11 3140 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj) 3141 { 3142 static const char method_name[] = "imgproc::accumulate_11()"; 3143 try { 3144 LOGD("%s", method_name); 3145 Mat& src = *((Mat*)src_nativeObj); 3146 Mat& dst = *((Mat*)dst_nativeObj); 3147 cv::accumulate( src, dst ); 3148 return; 3149 } catch(const std::exception &e) { 3150 throwJavaException(env, &e, method_name); 3151 } catch (...) { 3152 throwJavaException(env, 0, method_name); 3153 } 3154 return; 3155 } 3156 3157 3158 3159 // 3160 // void accumulateSquare(Mat src, Mat& dst, Mat mask = Mat()) 3161 // 3162 3163 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_accumulateSquare_10 (JNIEnv*, jclass, jlong, jlong, jlong); 3164 3165 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_accumulateSquare_10 3166 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jlong mask_nativeObj) 3167 { 3168 static const char method_name[] = "imgproc::accumulateSquare_10()"; 3169 try { 3170 LOGD("%s", method_name); 3171 Mat& src = *((Mat*)src_nativeObj); 3172 Mat& dst = *((Mat*)dst_nativeObj); 3173 Mat& mask = *((Mat*)mask_nativeObj); 3174 cv::accumulateSquare( src, dst, mask ); 3175 return; 3176 } catch(const std::exception &e) { 3177 throwJavaException(env, &e, method_name); 3178 } catch (...) { 3179 throwJavaException(env, 0, method_name); 3180 } 3181 return; 3182 } 3183 3184 3185 3186 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_accumulateSquare_11 (JNIEnv*, jclass, jlong, jlong); 3187 3188 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_accumulateSquare_11 3189 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj) 3190 { 3191 static const char method_name[] = "imgproc::accumulateSquare_11()"; 3192 try { 3193 LOGD("%s", method_name); 3194 Mat& src = *((Mat*)src_nativeObj); 3195 Mat& dst = *((Mat*)dst_nativeObj); 3196 cv::accumulateSquare( src, dst ); 3197 return; 3198 } catch(const std::exception &e) { 3199 throwJavaException(env, &e, method_name); 3200 } catch (...) { 3201 throwJavaException(env, 0, method_name); 3202 } 3203 return; 3204 } 3205 3206 3207 3208 // 3209 // void accumulateProduct(Mat src1, Mat src2, Mat& dst, Mat mask = Mat()) 3210 // 3211 3212 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_accumulateProduct_10 (JNIEnv*, jclass, jlong, jlong, jlong, jlong); 3213 3214 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_accumulateProduct_10 3215 (JNIEnv* env, jclass , jlong src1_nativeObj, jlong src2_nativeObj, jlong dst_nativeObj, jlong mask_nativeObj) 3216 { 3217 static const char method_name[] = "imgproc::accumulateProduct_10()"; 3218 try { 3219 LOGD("%s", method_name); 3220 Mat& src1 = *((Mat*)src1_nativeObj); 3221 Mat& src2 = *((Mat*)src2_nativeObj); 3222 Mat& dst = *((Mat*)dst_nativeObj); 3223 Mat& mask = *((Mat*)mask_nativeObj); 3224 cv::accumulateProduct( src1, src2, dst, mask ); 3225 return; 3226 } catch(const std::exception &e) { 3227 throwJavaException(env, &e, method_name); 3228 } catch (...) { 3229 throwJavaException(env, 0, method_name); 3230 } 3231 return; 3232 } 3233 3234 3235 3236 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_accumulateProduct_11 (JNIEnv*, jclass, jlong, jlong, jlong); 3237 3238 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_accumulateProduct_11 3239 (JNIEnv* env, jclass , jlong src1_nativeObj, jlong src2_nativeObj, jlong dst_nativeObj) 3240 { 3241 static const char method_name[] = "imgproc::accumulateProduct_11()"; 3242 try { 3243 LOGD("%s", method_name); 3244 Mat& src1 = *((Mat*)src1_nativeObj); 3245 Mat& src2 = *((Mat*)src2_nativeObj); 3246 Mat& dst = *((Mat*)dst_nativeObj); 3247 cv::accumulateProduct( src1, src2, dst ); 3248 return; 3249 } catch(const std::exception &e) { 3250 throwJavaException(env, &e, method_name); 3251 } catch (...) { 3252 throwJavaException(env, 0, method_name); 3253 } 3254 return; 3255 } 3256 3257 3258 3259 // 3260 // void accumulateWeighted(Mat src, Mat& dst, double alpha, Mat mask = Mat()) 3261 // 3262 3263 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_accumulateWeighted_10 (JNIEnv*, jclass, jlong, jlong, jdouble, jlong); 3264 3265 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_accumulateWeighted_10 3266 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jdouble alpha, jlong mask_nativeObj) 3267 { 3268 static const char method_name[] = "imgproc::accumulateWeighted_10()"; 3269 try { 3270 LOGD("%s", method_name); 3271 Mat& src = *((Mat*)src_nativeObj); 3272 Mat& dst = *((Mat*)dst_nativeObj); 3273 Mat& mask = *((Mat*)mask_nativeObj); 3274 cv::accumulateWeighted( src, dst, (double)alpha, mask ); 3275 return; 3276 } catch(const std::exception &e) { 3277 throwJavaException(env, &e, method_name); 3278 } catch (...) { 3279 throwJavaException(env, 0, method_name); 3280 } 3281 return; 3282 } 3283 3284 3285 3286 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_accumulateWeighted_11 (JNIEnv*, jclass, jlong, jlong, jdouble); 3287 3288 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_accumulateWeighted_11 3289 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jdouble alpha) 3290 { 3291 static const char method_name[] = "imgproc::accumulateWeighted_11()"; 3292 try { 3293 LOGD("%s", method_name); 3294 Mat& src = *((Mat*)src_nativeObj); 3295 Mat& dst = *((Mat*)dst_nativeObj); 3296 cv::accumulateWeighted( src, dst, (double)alpha ); 3297 return; 3298 } catch(const std::exception &e) { 3299 throwJavaException(env, &e, method_name); 3300 } catch (...) { 3301 throwJavaException(env, 0, method_name); 3302 } 3303 return; 3304 } 3305 3306 3307 3308 // 3309 // Point2d phaseCorrelate(Mat src1, Mat src2, Mat window = Mat(), double* response = 0) 3310 // 3311 3312 JNIEXPORT jdoubleArray JNICALL Java_org_opencv_imgproc_Imgproc_phaseCorrelate_10 (JNIEnv*, jclass, jlong, jlong, jlong, jdoubleArray); 3313 3314 JNIEXPORT jdoubleArray JNICALL Java_org_opencv_imgproc_Imgproc_phaseCorrelate_10 3315 (JNIEnv* env, jclass , jlong src1_nativeObj, jlong src2_nativeObj, jlong window_nativeObj, jdoubleArray response_out) 3316 { 3317 static const char method_name[] = "imgproc::phaseCorrelate_10()"; 3318 try { 3319 LOGD("%s", method_name); 3320 Mat& src1 = *((Mat*)src1_nativeObj); 3321 Mat& src2 = *((Mat*)src2_nativeObj); 3322 Mat& window = *((Mat*)window_nativeObj); 3323 double response; 3324 Point2d _retval_ = cv::phaseCorrelate( src1, src2, window, &response ); 3325 jdoubleArray _da_retval_ = env->NewDoubleArray(2); jdouble _tmp_retval_[2] = {_retval_.x, _retval_.y}; env->SetDoubleArrayRegion(_da_retval_, 0, 2, _tmp_retval_); jdouble tmp_response[1] = {response}; env->SetDoubleArrayRegion(response_out, 0, 1, tmp_response); 3326 return _da_retval_; 3327 } catch(const std::exception &e) { 3328 throwJavaException(env, &e, method_name); 3329 } catch (...) { 3330 throwJavaException(env, 0, method_name); 3331 } 3332 return 0; 3333 } 3334 3335 3336 3337 JNIEXPORT jdoubleArray JNICALL Java_org_opencv_imgproc_Imgproc_phaseCorrelate_11 (JNIEnv*, jclass, jlong, jlong); 3338 3339 JNIEXPORT jdoubleArray JNICALL Java_org_opencv_imgproc_Imgproc_phaseCorrelate_11 3340 (JNIEnv* env, jclass , jlong src1_nativeObj, jlong src2_nativeObj) 3341 { 3342 static const char method_name[] = "imgproc::phaseCorrelate_11()"; 3343 try { 3344 LOGD("%s", method_name); 3345 Mat& src1 = *((Mat*)src1_nativeObj); 3346 Mat& src2 = *((Mat*)src2_nativeObj); 3347 Point2d _retval_ = cv::phaseCorrelate( src1, src2 ); 3348 jdoubleArray _da_retval_ = env->NewDoubleArray(2); jdouble _tmp_retval_[2] = {_retval_.x, _retval_.y}; env->SetDoubleArrayRegion(_da_retval_, 0, 2, _tmp_retval_); 3349 return _da_retval_; 3350 } catch(const std::exception &e) { 3351 throwJavaException(env, &e, method_name); 3352 } catch (...) { 3353 throwJavaException(env, 0, method_name); 3354 } 3355 return 0; 3356 } 3357 3358 3359 3360 // 3361 // void createHanningWindow(Mat& dst, Size winSize, int type) 3362 // 3363 3364 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_createHanningWindow_10 (JNIEnv*, jclass, jlong, jdouble, jdouble, jint); 3365 3366 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_createHanningWindow_10 3367 (JNIEnv* env, jclass , jlong dst_nativeObj, jdouble winSize_width, jdouble winSize_height, jint type) 3368 { 3369 static const char method_name[] = "imgproc::createHanningWindow_10()"; 3370 try { 3371 LOGD("%s", method_name); 3372 Mat& dst = *((Mat*)dst_nativeObj); 3373 Size winSize((int)winSize_width, (int)winSize_height); 3374 cv::createHanningWindow( dst, winSize, (int)type ); 3375 return; 3376 } catch(const std::exception &e) { 3377 throwJavaException(env, &e, method_name); 3378 } catch (...) { 3379 throwJavaException(env, 0, method_name); 3380 } 3381 return; 3382 } 3383 3384 3385 3386 // 3387 // double threshold(Mat src, Mat& dst, double thresh, double maxval, int type) 3388 // 3389 3390 JNIEXPORT jdouble JNICALL Java_org_opencv_imgproc_Imgproc_threshold_10 (JNIEnv*, jclass, jlong, jlong, jdouble, jdouble, jint); 3391 3392 JNIEXPORT jdouble JNICALL Java_org_opencv_imgproc_Imgproc_threshold_10 3393 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jdouble thresh, jdouble maxval, jint type) 3394 { 3395 static const char method_name[] = "imgproc::threshold_10()"; 3396 try { 3397 LOGD("%s", method_name); 3398 Mat& src = *((Mat*)src_nativeObj); 3399 Mat& dst = *((Mat*)dst_nativeObj); 3400 double _retval_ = cv::threshold( src, dst, (double)thresh, (double)maxval, (int)type ); 3401 return _retval_; 3402 } catch(const std::exception &e) { 3403 throwJavaException(env, &e, method_name); 3404 } catch (...) { 3405 throwJavaException(env, 0, method_name); 3406 } 3407 return 0; 3408 } 3409 3410 3411 3412 // 3413 // void adaptiveThreshold(Mat src, Mat& dst, double maxValue, int adaptiveMethod, int thresholdType, int blockSize, double C) 3414 // 3415 3416 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_adaptiveThreshold_10 (JNIEnv*, jclass, jlong, jlong, jdouble, jint, jint, jint, jdouble); 3417 3418 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_adaptiveThreshold_10 3419 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jdouble maxValue, jint adaptiveMethod, jint thresholdType, jint blockSize, jdouble C) 3420 { 3421 static const char method_name[] = "imgproc::adaptiveThreshold_10()"; 3422 try { 3423 LOGD("%s", method_name); 3424 Mat& src = *((Mat*)src_nativeObj); 3425 Mat& dst = *((Mat*)dst_nativeObj); 3426 cv::adaptiveThreshold( src, dst, (double)maxValue, (int)adaptiveMethod, (int)thresholdType, (int)blockSize, (double)C ); 3427 return; 3428 } catch(const std::exception &e) { 3429 throwJavaException(env, &e, method_name); 3430 } catch (...) { 3431 throwJavaException(env, 0, method_name); 3432 } 3433 return; 3434 } 3435 3436 3437 3438 // 3439 // void pyrDown(Mat src, Mat& dst, Size dstsize = Size(), int borderType = BORDER_DEFAULT) 3440 // 3441 3442 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_pyrDown_10 (JNIEnv*, jclass, jlong, jlong, jdouble, jdouble, jint); 3443 3444 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_pyrDown_10 3445 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jdouble dstsize_width, jdouble dstsize_height, jint borderType) 3446 { 3447 static const char method_name[] = "imgproc::pyrDown_10()"; 3448 try { 3449 LOGD("%s", method_name); 3450 Mat& src = *((Mat*)src_nativeObj); 3451 Mat& dst = *((Mat*)dst_nativeObj); 3452 Size dstsize((int)dstsize_width, (int)dstsize_height); 3453 cv::pyrDown( src, dst, dstsize, (int)borderType ); 3454 return; 3455 } catch(const std::exception &e) { 3456 throwJavaException(env, &e, method_name); 3457 } catch (...) { 3458 throwJavaException(env, 0, method_name); 3459 } 3460 return; 3461 } 3462 3463 3464 3465 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_pyrDown_11 (JNIEnv*, jclass, jlong, jlong, jdouble, jdouble); 3466 3467 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_pyrDown_11 3468 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jdouble dstsize_width, jdouble dstsize_height) 3469 { 3470 static const char method_name[] = "imgproc::pyrDown_11()"; 3471 try { 3472 LOGD("%s", method_name); 3473 Mat& src = *((Mat*)src_nativeObj); 3474 Mat& dst = *((Mat*)dst_nativeObj); 3475 Size dstsize((int)dstsize_width, (int)dstsize_height); 3476 cv::pyrDown( src, dst, dstsize ); 3477 return; 3478 } catch(const std::exception &e) { 3479 throwJavaException(env, &e, method_name); 3480 } catch (...) { 3481 throwJavaException(env, 0, method_name); 3482 } 3483 return; 3484 } 3485 3486 3487 3488 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_pyrDown_12 (JNIEnv*, jclass, jlong, jlong); 3489 3490 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_pyrDown_12 3491 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj) 3492 { 3493 static const char method_name[] = "imgproc::pyrDown_12()"; 3494 try { 3495 LOGD("%s", method_name); 3496 Mat& src = *((Mat*)src_nativeObj); 3497 Mat& dst = *((Mat*)dst_nativeObj); 3498 cv::pyrDown( src, dst ); 3499 return; 3500 } catch(const std::exception &e) { 3501 throwJavaException(env, &e, method_name); 3502 } catch (...) { 3503 throwJavaException(env, 0, method_name); 3504 } 3505 return; 3506 } 3507 3508 3509 3510 // 3511 // void pyrUp(Mat src, Mat& dst, Size dstsize = Size(), int borderType = BORDER_DEFAULT) 3512 // 3513 3514 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_pyrUp_10 (JNIEnv*, jclass, jlong, jlong, jdouble, jdouble, jint); 3515 3516 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_pyrUp_10 3517 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jdouble dstsize_width, jdouble dstsize_height, jint borderType) 3518 { 3519 static const char method_name[] = "imgproc::pyrUp_10()"; 3520 try { 3521 LOGD("%s", method_name); 3522 Mat& src = *((Mat*)src_nativeObj); 3523 Mat& dst = *((Mat*)dst_nativeObj); 3524 Size dstsize((int)dstsize_width, (int)dstsize_height); 3525 cv::pyrUp( src, dst, dstsize, (int)borderType ); 3526 return; 3527 } catch(const std::exception &e) { 3528 throwJavaException(env, &e, method_name); 3529 } catch (...) { 3530 throwJavaException(env, 0, method_name); 3531 } 3532 return; 3533 } 3534 3535 3536 3537 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_pyrUp_11 (JNIEnv*, jclass, jlong, jlong, jdouble, jdouble); 3538 3539 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_pyrUp_11 3540 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jdouble dstsize_width, jdouble dstsize_height) 3541 { 3542 static const char method_name[] = "imgproc::pyrUp_11()"; 3543 try { 3544 LOGD("%s", method_name); 3545 Mat& src = *((Mat*)src_nativeObj); 3546 Mat& dst = *((Mat*)dst_nativeObj); 3547 Size dstsize((int)dstsize_width, (int)dstsize_height); 3548 cv::pyrUp( src, dst, dstsize ); 3549 return; 3550 } catch(const std::exception &e) { 3551 throwJavaException(env, &e, method_name); 3552 } catch (...) { 3553 throwJavaException(env, 0, method_name); 3554 } 3555 return; 3556 } 3557 3558 3559 3560 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_pyrUp_12 (JNIEnv*, jclass, jlong, jlong); 3561 3562 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_pyrUp_12 3563 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj) 3564 { 3565 static const char method_name[] = "imgproc::pyrUp_12()"; 3566 try { 3567 LOGD("%s", method_name); 3568 Mat& src = *((Mat*)src_nativeObj); 3569 Mat& dst = *((Mat*)dst_nativeObj); 3570 cv::pyrUp( src, dst ); 3571 return; 3572 } catch(const std::exception &e) { 3573 throwJavaException(env, &e, method_name); 3574 } catch (...) { 3575 throwJavaException(env, 0, method_name); 3576 } 3577 return; 3578 } 3579 3580 3581 3582 // 3583 // void undistort(Mat src, Mat& dst, Mat cameraMatrix, Mat distCoeffs, Mat newCameraMatrix = Mat()) 3584 // 3585 3586 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_undistort_10 (JNIEnv*, jclass, jlong, jlong, jlong, jlong, jlong); 3587 3588 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_undistort_10 3589 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jlong cameraMatrix_nativeObj, jlong distCoeffs_nativeObj, jlong newCameraMatrix_nativeObj) 3590 { 3591 static const char method_name[] = "imgproc::undistort_10()"; 3592 try { 3593 LOGD("%s", method_name); 3594 Mat& src = *((Mat*)src_nativeObj); 3595 Mat& dst = *((Mat*)dst_nativeObj); 3596 Mat& cameraMatrix = *((Mat*)cameraMatrix_nativeObj); 3597 Mat& distCoeffs = *((Mat*)distCoeffs_nativeObj); 3598 Mat& newCameraMatrix = *((Mat*)newCameraMatrix_nativeObj); 3599 cv::undistort( src, dst, cameraMatrix, distCoeffs, newCameraMatrix ); 3600 return; 3601 } catch(const std::exception &e) { 3602 throwJavaException(env, &e, method_name); 3603 } catch (...) { 3604 throwJavaException(env, 0, method_name); 3605 } 3606 return; 3607 } 3608 3609 3610 3611 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_undistort_11 (JNIEnv*, jclass, jlong, jlong, jlong, jlong); 3612 3613 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_undistort_11 3614 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jlong cameraMatrix_nativeObj, jlong distCoeffs_nativeObj) 3615 { 3616 static const char method_name[] = "imgproc::undistort_11()"; 3617 try { 3618 LOGD("%s", method_name); 3619 Mat& src = *((Mat*)src_nativeObj); 3620 Mat& dst = *((Mat*)dst_nativeObj); 3621 Mat& cameraMatrix = *((Mat*)cameraMatrix_nativeObj); 3622 Mat& distCoeffs = *((Mat*)distCoeffs_nativeObj); 3623 cv::undistort( src, dst, cameraMatrix, distCoeffs ); 3624 return; 3625 } catch(const std::exception &e) { 3626 throwJavaException(env, &e, method_name); 3627 } catch (...) { 3628 throwJavaException(env, 0, method_name); 3629 } 3630 return; 3631 } 3632 3633 3634 3635 // 3636 // void initUndistortRectifyMap(Mat cameraMatrix, Mat distCoeffs, Mat R, Mat newCameraMatrix, Size size, int m1type, Mat& map1, Mat& map2) 3637 // 3638 3639 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_initUndistortRectifyMap_10 (JNIEnv*, jclass, jlong, jlong, jlong, jlong, jdouble, jdouble, jint, jlong, jlong); 3640 3641 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_initUndistortRectifyMap_10 3642 (JNIEnv* env, jclass , jlong cameraMatrix_nativeObj, jlong distCoeffs_nativeObj, jlong R_nativeObj, jlong newCameraMatrix_nativeObj, jdouble size_width, jdouble size_height, jint m1type, jlong map1_nativeObj, jlong map2_nativeObj) 3643 { 3644 static const char method_name[] = "imgproc::initUndistortRectifyMap_10()"; 3645 try { 3646 LOGD("%s", method_name); 3647 Mat& cameraMatrix = *((Mat*)cameraMatrix_nativeObj); 3648 Mat& distCoeffs = *((Mat*)distCoeffs_nativeObj); 3649 Mat& R = *((Mat*)R_nativeObj); 3650 Mat& newCameraMatrix = *((Mat*)newCameraMatrix_nativeObj); 3651 Size size((int)size_width, (int)size_height); 3652 Mat& map1 = *((Mat*)map1_nativeObj); 3653 Mat& map2 = *((Mat*)map2_nativeObj); 3654 cv::initUndistortRectifyMap( cameraMatrix, distCoeffs, R, newCameraMatrix, size, (int)m1type, map1, map2 ); 3655 return; 3656 } catch(const std::exception &e) { 3657 throwJavaException(env, &e, method_name); 3658 } catch (...) { 3659 throwJavaException(env, 0, method_name); 3660 } 3661 return; 3662 } 3663 3664 3665 3666 // 3667 // float initWideAngleProjMap(Mat cameraMatrix, Mat distCoeffs, Size imageSize, int destImageWidth, int m1type, Mat& map1, Mat& map2, int projType = PROJ_SPHERICAL_EQRECT, double alpha = 0) 3668 // 3669 3670 JNIEXPORT jfloat JNICALL Java_org_opencv_imgproc_Imgproc_initWideAngleProjMap_10 (JNIEnv*, jclass, jlong, jlong, jdouble, jdouble, jint, jint, jlong, jlong, jint, jdouble); 3671 3672 JNIEXPORT jfloat JNICALL Java_org_opencv_imgproc_Imgproc_initWideAngleProjMap_10 3673 (JNIEnv* env, jclass , jlong cameraMatrix_nativeObj, jlong distCoeffs_nativeObj, jdouble imageSize_width, jdouble imageSize_height, jint destImageWidth, jint m1type, jlong map1_nativeObj, jlong map2_nativeObj, jint projType, jdouble alpha) 3674 { 3675 static const char method_name[] = "imgproc::initWideAngleProjMap_10()"; 3676 try { 3677 LOGD("%s", method_name); 3678 Mat& cameraMatrix = *((Mat*)cameraMatrix_nativeObj); 3679 Mat& distCoeffs = *((Mat*)distCoeffs_nativeObj); 3680 Size imageSize((int)imageSize_width, (int)imageSize_height); 3681 Mat& map1 = *((Mat*)map1_nativeObj); 3682 Mat& map2 = *((Mat*)map2_nativeObj); 3683 float _retval_ = cv::initWideAngleProjMap( cameraMatrix, distCoeffs, imageSize, (int)destImageWidth, (int)m1type, map1, map2, (int)projType, (double)alpha ); 3684 return _retval_; 3685 } catch(const std::exception &e) { 3686 throwJavaException(env, &e, method_name); 3687 } catch (...) { 3688 throwJavaException(env, 0, method_name); 3689 } 3690 return 0; 3691 } 3692 3693 3694 3695 JNIEXPORT jfloat JNICALL Java_org_opencv_imgproc_Imgproc_initWideAngleProjMap_11 (JNIEnv*, jclass, jlong, jlong, jdouble, jdouble, jint, jint, jlong, jlong); 3696 3697 JNIEXPORT jfloat JNICALL Java_org_opencv_imgproc_Imgproc_initWideAngleProjMap_11 3698 (JNIEnv* env, jclass , jlong cameraMatrix_nativeObj, jlong distCoeffs_nativeObj, jdouble imageSize_width, jdouble imageSize_height, jint destImageWidth, jint m1type, jlong map1_nativeObj, jlong map2_nativeObj) 3699 { 3700 static const char method_name[] = "imgproc::initWideAngleProjMap_11()"; 3701 try { 3702 LOGD("%s", method_name); 3703 Mat& cameraMatrix = *((Mat*)cameraMatrix_nativeObj); 3704 Mat& distCoeffs = *((Mat*)distCoeffs_nativeObj); 3705 Size imageSize((int)imageSize_width, (int)imageSize_height); 3706 Mat& map1 = *((Mat*)map1_nativeObj); 3707 Mat& map2 = *((Mat*)map2_nativeObj); 3708 float _retval_ = cv::initWideAngleProjMap( cameraMatrix, distCoeffs, imageSize, (int)destImageWidth, (int)m1type, map1, map2 ); 3709 return _retval_; 3710 } catch(const std::exception &e) { 3711 throwJavaException(env, &e, method_name); 3712 } catch (...) { 3713 throwJavaException(env, 0, method_name); 3714 } 3715 return 0; 3716 } 3717 3718 3719 3720 // 3721 // Mat getDefaultNewCameraMatrix(Mat cameraMatrix, Size imgsize = Size(), bool centerPrincipalPoint = false) 3722 // 3723 3724 JNIEXPORT jlong JNICALL Java_org_opencv_imgproc_Imgproc_getDefaultNewCameraMatrix_10 (JNIEnv*, jclass, jlong, jdouble, jdouble, jboolean); 3725 3726 JNIEXPORT jlong JNICALL Java_org_opencv_imgproc_Imgproc_getDefaultNewCameraMatrix_10 3727 (JNIEnv* env, jclass , jlong cameraMatrix_nativeObj, jdouble imgsize_width, jdouble imgsize_height, jboolean centerPrincipalPoint) 3728 { 3729 static const char method_name[] = "imgproc::getDefaultNewCameraMatrix_10()"; 3730 try { 3731 LOGD("%s", method_name); 3732 Mat& cameraMatrix = *((Mat*)cameraMatrix_nativeObj); 3733 Size imgsize((int)imgsize_width, (int)imgsize_height); 3734 ::Mat _retval_ = cv::getDefaultNewCameraMatrix( cameraMatrix, imgsize, (bool)centerPrincipalPoint ); 3735 return (jlong) new ::Mat(_retval_); 3736 } catch(const std::exception &e) { 3737 throwJavaException(env, &e, method_name); 3738 } catch (...) { 3739 throwJavaException(env, 0, method_name); 3740 } 3741 return 0; 3742 } 3743 3744 3745 3746 JNIEXPORT jlong JNICALL Java_org_opencv_imgproc_Imgproc_getDefaultNewCameraMatrix_11 (JNIEnv*, jclass, jlong); 3747 3748 JNIEXPORT jlong JNICALL Java_org_opencv_imgproc_Imgproc_getDefaultNewCameraMatrix_11 3749 (JNIEnv* env, jclass , jlong cameraMatrix_nativeObj) 3750 { 3751 static const char method_name[] = "imgproc::getDefaultNewCameraMatrix_11()"; 3752 try { 3753 LOGD("%s", method_name); 3754 Mat& cameraMatrix = *((Mat*)cameraMatrix_nativeObj); 3755 ::Mat _retval_ = cv::getDefaultNewCameraMatrix( cameraMatrix ); 3756 return (jlong) new ::Mat(_retval_); 3757 } catch(const std::exception &e) { 3758 throwJavaException(env, &e, method_name); 3759 } catch (...) { 3760 throwJavaException(env, 0, method_name); 3761 } 3762 return 0; 3763 } 3764 3765 3766 3767 // 3768 // void undistortPoints(vector_Point2f src, vector_Point2f& dst, Mat cameraMatrix, Mat distCoeffs, Mat R = Mat(), Mat P = Mat()) 3769 // 3770 3771 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_undistortPoints_10 (JNIEnv*, jclass, jlong, jlong, jlong, jlong, jlong, jlong); 3772 3773 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_undistortPoints_10 3774 (JNIEnv* env, jclass , jlong src_mat_nativeObj, jlong dst_mat_nativeObj, jlong cameraMatrix_nativeObj, jlong distCoeffs_nativeObj, jlong R_nativeObj, jlong P_nativeObj) 3775 { 3776 static const char method_name[] = "imgproc::undistortPoints_10()"; 3777 try { 3778 LOGD("%s", method_name); 3779 std::vector<Point2f> src; 3780 Mat& src_mat = *((Mat*)src_mat_nativeObj); 3781 Mat_to_vector_Point2f( src_mat, src ); 3782 std::vector<Point2f> dst; 3783 Mat& dst_mat = *((Mat*)dst_mat_nativeObj); 3784 Mat& cameraMatrix = *((Mat*)cameraMatrix_nativeObj); 3785 Mat& distCoeffs = *((Mat*)distCoeffs_nativeObj); 3786 Mat& R = *((Mat*)R_nativeObj); 3787 Mat& P = *((Mat*)P_nativeObj); 3788 cv::undistortPoints( src, dst, cameraMatrix, distCoeffs, R, P ); 3789 vector_Point2f_to_Mat( dst, dst_mat ); 3790 return; 3791 } catch(const std::exception &e) { 3792 throwJavaException(env, &e, method_name); 3793 } catch (...) { 3794 throwJavaException(env, 0, method_name); 3795 } 3796 return; 3797 } 3798 3799 3800 3801 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_undistortPoints_11 (JNIEnv*, jclass, jlong, jlong, jlong, jlong); 3802 3803 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_undistortPoints_11 3804 (JNIEnv* env, jclass , jlong src_mat_nativeObj, jlong dst_mat_nativeObj, jlong cameraMatrix_nativeObj, jlong distCoeffs_nativeObj) 3805 { 3806 static const char method_name[] = "imgproc::undistortPoints_11()"; 3807 try { 3808 LOGD("%s", method_name); 3809 std::vector<Point2f> src; 3810 Mat& src_mat = *((Mat*)src_mat_nativeObj); 3811 Mat_to_vector_Point2f( src_mat, src ); 3812 std::vector<Point2f> dst; 3813 Mat& dst_mat = *((Mat*)dst_mat_nativeObj); 3814 Mat& cameraMatrix = *((Mat*)cameraMatrix_nativeObj); 3815 Mat& distCoeffs = *((Mat*)distCoeffs_nativeObj); 3816 cv::undistortPoints( src, dst, cameraMatrix, distCoeffs ); 3817 vector_Point2f_to_Mat( dst, dst_mat ); 3818 return; 3819 } catch(const std::exception &e) { 3820 throwJavaException(env, &e, method_name); 3821 } catch (...) { 3822 throwJavaException(env, 0, method_name); 3823 } 3824 return; 3825 } 3826 3827 3828 3829 // 3830 // void calcHist(vector_Mat images, vector_int channels, Mat mask, Mat& hist, vector_int histSize, vector_float ranges, bool accumulate = false) 3831 // 3832 3833 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_calcHist_10 (JNIEnv*, jclass, jlong, jlong, jlong, jlong, jlong, jlong, jboolean); 3834 3835 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_calcHist_10 3836 (JNIEnv* env, jclass , jlong images_mat_nativeObj, jlong channels_mat_nativeObj, jlong mask_nativeObj, jlong hist_nativeObj, jlong histSize_mat_nativeObj, jlong ranges_mat_nativeObj, jboolean accumulate) 3837 { 3838 static const char method_name[] = "imgproc::calcHist_10()"; 3839 try { 3840 LOGD("%s", method_name); 3841 std::vector<Mat> images; 3842 Mat& images_mat = *((Mat*)images_mat_nativeObj); 3843 Mat_to_vector_Mat( images_mat, images ); 3844 std::vector<int> channels; 3845 Mat& channels_mat = *((Mat*)channels_mat_nativeObj); 3846 Mat_to_vector_int( channels_mat, channels ); 3847 std::vector<int> histSize; 3848 Mat& histSize_mat = *((Mat*)histSize_mat_nativeObj); 3849 Mat_to_vector_int( histSize_mat, histSize ); 3850 std::vector<float> ranges; 3851 Mat& ranges_mat = *((Mat*)ranges_mat_nativeObj); 3852 Mat_to_vector_float( ranges_mat, ranges ); 3853 Mat& mask = *((Mat*)mask_nativeObj); 3854 Mat& hist = *((Mat*)hist_nativeObj); 3855 cv::calcHist( images, channels, mask, hist, histSize, ranges, (bool)accumulate ); 3856 return; 3857 } catch(const std::exception &e) { 3858 throwJavaException(env, &e, method_name); 3859 } catch (...) { 3860 throwJavaException(env, 0, method_name); 3861 } 3862 return; 3863 } 3864 3865 3866 3867 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_calcHist_11 (JNIEnv*, jclass, jlong, jlong, jlong, jlong, jlong, jlong); 3868 3869 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_calcHist_11 3870 (JNIEnv* env, jclass , jlong images_mat_nativeObj, jlong channels_mat_nativeObj, jlong mask_nativeObj, jlong hist_nativeObj, jlong histSize_mat_nativeObj, jlong ranges_mat_nativeObj) 3871 { 3872 static const char method_name[] = "imgproc::calcHist_11()"; 3873 try { 3874 LOGD("%s", method_name); 3875 std::vector<Mat> images; 3876 Mat& images_mat = *((Mat*)images_mat_nativeObj); 3877 Mat_to_vector_Mat( images_mat, images ); 3878 std::vector<int> channels; 3879 Mat& channels_mat = *((Mat*)channels_mat_nativeObj); 3880 Mat_to_vector_int( channels_mat, channels ); 3881 std::vector<int> histSize; 3882 Mat& histSize_mat = *((Mat*)histSize_mat_nativeObj); 3883 Mat_to_vector_int( histSize_mat, histSize ); 3884 std::vector<float> ranges; 3885 Mat& ranges_mat = *((Mat*)ranges_mat_nativeObj); 3886 Mat_to_vector_float( ranges_mat, ranges ); 3887 Mat& mask = *((Mat*)mask_nativeObj); 3888 Mat& hist = *((Mat*)hist_nativeObj); 3889 cv::calcHist( images, channels, mask, hist, histSize, ranges ); 3890 return; 3891 } catch(const std::exception &e) { 3892 throwJavaException(env, &e, method_name); 3893 } catch (...) { 3894 throwJavaException(env, 0, method_name); 3895 } 3896 return; 3897 } 3898 3899 3900 3901 // 3902 // void calcBackProject(vector_Mat images, vector_int channels, Mat hist, Mat& dst, vector_float ranges, double scale) 3903 // 3904 3905 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_calcBackProject_10 (JNIEnv*, jclass, jlong, jlong, jlong, jlong, jlong, jdouble); 3906 3907 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_calcBackProject_10 3908 (JNIEnv* env, jclass , jlong images_mat_nativeObj, jlong channels_mat_nativeObj, jlong hist_nativeObj, jlong dst_nativeObj, jlong ranges_mat_nativeObj, jdouble scale) 3909 { 3910 static const char method_name[] = "imgproc::calcBackProject_10()"; 3911 try { 3912 LOGD("%s", method_name); 3913 std::vector<Mat> images; 3914 Mat& images_mat = *((Mat*)images_mat_nativeObj); 3915 Mat_to_vector_Mat( images_mat, images ); 3916 std::vector<int> channels; 3917 Mat& channels_mat = *((Mat*)channels_mat_nativeObj); 3918 Mat_to_vector_int( channels_mat, channels ); 3919 std::vector<float> ranges; 3920 Mat& ranges_mat = *((Mat*)ranges_mat_nativeObj); 3921 Mat_to_vector_float( ranges_mat, ranges ); 3922 Mat& hist = *((Mat*)hist_nativeObj); 3923 Mat& dst = *((Mat*)dst_nativeObj); 3924 cv::calcBackProject( images, channels, hist, dst, ranges, (double)scale ); 3925 return; 3926 } catch(const std::exception &e) { 3927 throwJavaException(env, &e, method_name); 3928 } catch (...) { 3929 throwJavaException(env, 0, method_name); 3930 } 3931 return; 3932 } 3933 3934 3935 3936 // 3937 // double compareHist(Mat H1, Mat H2, int method) 3938 // 3939 3940 JNIEXPORT jdouble JNICALL Java_org_opencv_imgproc_Imgproc_compareHist_10 (JNIEnv*, jclass, jlong, jlong, jint); 3941 3942 JNIEXPORT jdouble JNICALL Java_org_opencv_imgproc_Imgproc_compareHist_10 3943 (JNIEnv* env, jclass , jlong H1_nativeObj, jlong H2_nativeObj, jint method) 3944 { 3945 static const char method_name[] = "imgproc::compareHist_10()"; 3946 try { 3947 LOGD("%s", method_name); 3948 Mat& H1 = *((Mat*)H1_nativeObj); 3949 Mat& H2 = *((Mat*)H2_nativeObj); 3950 double _retval_ = cv::compareHist( H1, H2, (int)method ); 3951 return _retval_; 3952 } catch(const std::exception &e) { 3953 throwJavaException(env, &e, method_name); 3954 } catch (...) { 3955 throwJavaException(env, 0, method_name); 3956 } 3957 return 0; 3958 } 3959 3960 3961 3962 // 3963 // void equalizeHist(Mat src, Mat& dst) 3964 // 3965 3966 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_equalizeHist_10 (JNIEnv*, jclass, jlong, jlong); 3967 3968 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_equalizeHist_10 3969 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj) 3970 { 3971 static const char method_name[] = "imgproc::equalizeHist_10()"; 3972 try { 3973 LOGD("%s", method_name); 3974 Mat& src = *((Mat*)src_nativeObj); 3975 Mat& dst = *((Mat*)dst_nativeObj); 3976 cv::equalizeHist( src, dst ); 3977 return; 3978 } catch(const std::exception &e) { 3979 throwJavaException(env, &e, method_name); 3980 } catch (...) { 3981 throwJavaException(env, 0, method_name); 3982 } 3983 return; 3984 } 3985 3986 3987 3988 // 3989 // void watershed(Mat image, Mat& markers) 3990 // 3991 3992 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_watershed_10 (JNIEnv*, jclass, jlong, jlong); 3993 3994 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_watershed_10 3995 (JNIEnv* env, jclass , jlong image_nativeObj, jlong markers_nativeObj) 3996 { 3997 static const char method_name[] = "imgproc::watershed_10()"; 3998 try { 3999 LOGD("%s", method_name); 4000 Mat& image = *((Mat*)image_nativeObj); 4001 Mat& markers = *((Mat*)markers_nativeObj); 4002 cv::watershed( image, markers ); 4003 return; 4004 } catch(const std::exception &e) { 4005 throwJavaException(env, &e, method_name); 4006 } catch (...) { 4007 throwJavaException(env, 0, method_name); 4008 } 4009 return; 4010 } 4011 4012 4013 4014 // 4015 // void pyrMeanShiftFiltering(Mat src, Mat& dst, double sp, double sr, int maxLevel = 1, TermCriteria termcrit = TermCriteria(TermCriteria::MAX_ITER+TermCriteria::EPS,5,1)) 4016 // 4017 4018 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_pyrMeanShiftFiltering_10 (JNIEnv*, jclass, jlong, jlong, jdouble, jdouble, jint, jint, jint, jdouble); 4019 4020 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_pyrMeanShiftFiltering_10 4021 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jdouble sp, jdouble sr, jint maxLevel, jint termcrit_type, jint termcrit_maxCount, jdouble termcrit_epsilon) 4022 { 4023 static const char method_name[] = "imgproc::pyrMeanShiftFiltering_10()"; 4024 try { 4025 LOGD("%s", method_name); 4026 Mat& src = *((Mat*)src_nativeObj); 4027 Mat& dst = *((Mat*)dst_nativeObj); 4028 TermCriteria termcrit(termcrit_type, termcrit_maxCount, termcrit_epsilon); 4029 cv::pyrMeanShiftFiltering( src, dst, (double)sp, (double)sr, (int)maxLevel, termcrit ); 4030 return; 4031 } catch(const std::exception &e) { 4032 throwJavaException(env, &e, method_name); 4033 } catch (...) { 4034 throwJavaException(env, 0, method_name); 4035 } 4036 return; 4037 } 4038 4039 4040 4041 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_pyrMeanShiftFiltering_11 (JNIEnv*, jclass, jlong, jlong, jdouble, jdouble); 4042 4043 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_pyrMeanShiftFiltering_11 4044 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jdouble sp, jdouble sr) 4045 { 4046 static const char method_name[] = "imgproc::pyrMeanShiftFiltering_11()"; 4047 try { 4048 LOGD("%s", method_name); 4049 Mat& src = *((Mat*)src_nativeObj); 4050 Mat& dst = *((Mat*)dst_nativeObj); 4051 cv::pyrMeanShiftFiltering( src, dst, (double)sp, (double)sr ); 4052 return; 4053 } catch(const std::exception &e) { 4054 throwJavaException(env, &e, method_name); 4055 } catch (...) { 4056 throwJavaException(env, 0, method_name); 4057 } 4058 return; 4059 } 4060 4061 4062 4063 // 4064 // void grabCut(Mat img, Mat& mask, Rect rect, Mat& bgdModel, Mat& fgdModel, int iterCount, int mode = GC_EVAL) 4065 // 4066 4067 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_grabCut_10 (JNIEnv*, jclass, jlong, jlong, jint, jint, jint, jint, jlong, jlong, jint, jint); 4068 4069 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_grabCut_10 4070 (JNIEnv* env, jclass , jlong img_nativeObj, jlong mask_nativeObj, jint rect_x, jint rect_y, jint rect_width, jint rect_height, jlong bgdModel_nativeObj, jlong fgdModel_nativeObj, jint iterCount, jint mode) 4071 { 4072 static const char method_name[] = "imgproc::grabCut_10()"; 4073 try { 4074 LOGD("%s", method_name); 4075 Mat& img = *((Mat*)img_nativeObj); 4076 Mat& mask = *((Mat*)mask_nativeObj); 4077 Rect rect(rect_x, rect_y, rect_width, rect_height); 4078 Mat& bgdModel = *((Mat*)bgdModel_nativeObj); 4079 Mat& fgdModel = *((Mat*)fgdModel_nativeObj); 4080 cv::grabCut( img, mask, rect, bgdModel, fgdModel, (int)iterCount, (int)mode ); 4081 return; 4082 } catch(const std::exception &e) { 4083 throwJavaException(env, &e, method_name); 4084 } catch (...) { 4085 throwJavaException(env, 0, method_name); 4086 } 4087 return; 4088 } 4089 4090 4091 4092 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_grabCut_11 (JNIEnv*, jclass, jlong, jlong, jint, jint, jint, jint, jlong, jlong, jint); 4093 4094 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_grabCut_11 4095 (JNIEnv* env, jclass , jlong img_nativeObj, jlong mask_nativeObj, jint rect_x, jint rect_y, jint rect_width, jint rect_height, jlong bgdModel_nativeObj, jlong fgdModel_nativeObj, jint iterCount) 4096 { 4097 static const char method_name[] = "imgproc::grabCut_11()"; 4098 try { 4099 LOGD("%s", method_name); 4100 Mat& img = *((Mat*)img_nativeObj); 4101 Mat& mask = *((Mat*)mask_nativeObj); 4102 Rect rect(rect_x, rect_y, rect_width, rect_height); 4103 Mat& bgdModel = *((Mat*)bgdModel_nativeObj); 4104 Mat& fgdModel = *((Mat*)fgdModel_nativeObj); 4105 cv::grabCut( img, mask, rect, bgdModel, fgdModel, (int)iterCount ); 4106 return; 4107 } catch(const std::exception &e) { 4108 throwJavaException(env, &e, method_name); 4109 } catch (...) { 4110 throwJavaException(env, 0, method_name); 4111 } 4112 return; 4113 } 4114 4115 4116 4117 // 4118 // void distanceTransform(Mat src, Mat& dst, Mat& labels, int distanceType, int maskSize, int labelType = DIST_LABEL_CCOMP) 4119 // 4120 4121 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_distanceTransformWithLabels_10 (JNIEnv*, jclass, jlong, jlong, jlong, jint, jint, jint); 4122 4123 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_distanceTransformWithLabels_10 4124 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jlong labels_nativeObj, jint distanceType, jint maskSize, jint labelType) 4125 { 4126 static const char method_name[] = "imgproc::distanceTransformWithLabels_10()"; 4127 try { 4128 LOGD("%s", method_name); 4129 Mat& src = *((Mat*)src_nativeObj); 4130 Mat& dst = *((Mat*)dst_nativeObj); 4131 Mat& labels = *((Mat*)labels_nativeObj); 4132 cv::distanceTransform( src, dst, labels, (int)distanceType, (int)maskSize, (int)labelType ); 4133 return; 4134 } catch(const std::exception &e) { 4135 throwJavaException(env, &e, method_name); 4136 } catch (...) { 4137 throwJavaException(env, 0, method_name); 4138 } 4139 return; 4140 } 4141 4142 4143 4144 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_distanceTransformWithLabels_11 (JNIEnv*, jclass, jlong, jlong, jlong, jint, jint); 4145 4146 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_distanceTransformWithLabels_11 4147 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jlong labels_nativeObj, jint distanceType, jint maskSize) 4148 { 4149 static const char method_name[] = "imgproc::distanceTransformWithLabels_11()"; 4150 try { 4151 LOGD("%s", method_name); 4152 Mat& src = *((Mat*)src_nativeObj); 4153 Mat& dst = *((Mat*)dst_nativeObj); 4154 Mat& labels = *((Mat*)labels_nativeObj); 4155 cv::distanceTransform( src, dst, labels, (int)distanceType, (int)maskSize ); 4156 return; 4157 } catch(const std::exception &e) { 4158 throwJavaException(env, &e, method_name); 4159 } catch (...) { 4160 throwJavaException(env, 0, method_name); 4161 } 4162 return; 4163 } 4164 4165 4166 4167 // 4168 // void distanceTransform(Mat src, Mat& dst, int distanceType, int maskSize, int dstType = CV_32F) 4169 // 4170 4171 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_distanceTransform_10 (JNIEnv*, jclass, jlong, jlong, jint, jint, jint); 4172 4173 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_distanceTransform_10 4174 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jint distanceType, jint maskSize, jint dstType) 4175 { 4176 static const char method_name[] = "imgproc::distanceTransform_10()"; 4177 try { 4178 LOGD("%s", method_name); 4179 Mat& src = *((Mat*)src_nativeObj); 4180 Mat& dst = *((Mat*)dst_nativeObj); 4181 cv::distanceTransform( src, dst, (int)distanceType, (int)maskSize, (int)dstType ); 4182 return; 4183 } catch(const std::exception &e) { 4184 throwJavaException(env, &e, method_name); 4185 } catch (...) { 4186 throwJavaException(env, 0, method_name); 4187 } 4188 return; 4189 } 4190 4191 4192 4193 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_distanceTransform_11 (JNIEnv*, jclass, jlong, jlong, jint, jint); 4194 4195 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_distanceTransform_11 4196 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jint distanceType, jint maskSize) 4197 { 4198 static const char method_name[] = "imgproc::distanceTransform_11()"; 4199 try { 4200 LOGD("%s", method_name); 4201 Mat& src = *((Mat*)src_nativeObj); 4202 Mat& dst = *((Mat*)dst_nativeObj); 4203 cv::distanceTransform( src, dst, (int)distanceType, (int)maskSize ); 4204 return; 4205 } catch(const std::exception &e) { 4206 throwJavaException(env, &e, method_name); 4207 } catch (...) { 4208 throwJavaException(env, 0, method_name); 4209 } 4210 return; 4211 } 4212 4213 4214 4215 // 4216 // int floodFill(Mat& image, Mat& mask, Point seedPoint, Scalar newVal, Rect* rect = 0, Scalar loDiff = Scalar(), Scalar upDiff = Scalar(), int flags = 4) 4217 // 4218 4219 JNIEXPORT jint JNICALL Java_org_opencv_imgproc_Imgproc_floodFill_10 (JNIEnv*, jclass, jlong, jlong, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdoubleArray, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jint); 4220 4221 JNIEXPORT jint JNICALL Java_org_opencv_imgproc_Imgproc_floodFill_10 4222 (JNIEnv* env, jclass , jlong image_nativeObj, jlong mask_nativeObj, jdouble seedPoint_x, jdouble seedPoint_y, jdouble newVal_val0, jdouble newVal_val1, jdouble newVal_val2, jdouble newVal_val3, jdoubleArray rect_out, jdouble loDiff_val0, jdouble loDiff_val1, jdouble loDiff_val2, jdouble loDiff_val3, jdouble upDiff_val0, jdouble upDiff_val1, jdouble upDiff_val2, jdouble upDiff_val3, jint flags) 4223 { 4224 static const char method_name[] = "imgproc::floodFill_10()"; 4225 try { 4226 LOGD("%s", method_name); 4227 Mat& image = *((Mat*)image_nativeObj); 4228 Mat& mask = *((Mat*)mask_nativeObj); 4229 Point seedPoint((int)seedPoint_x, (int)seedPoint_y); 4230 Scalar newVal(newVal_val0, newVal_val1, newVal_val2, newVal_val3); 4231 Rect rect; 4232 Scalar loDiff(loDiff_val0, loDiff_val1, loDiff_val2, loDiff_val3); 4233 Scalar upDiff(upDiff_val0, upDiff_val1, upDiff_val2, upDiff_val3); 4234 int _retval_ = cv::floodFill( image, mask, seedPoint, newVal, &rect, loDiff, upDiff, (int)flags ); 4235 jdouble tmp_rect[4] = {rect.x, rect.y, rect.width, rect.height}; env->SetDoubleArrayRegion(rect_out, 0, 4, tmp_rect); 4236 return _retval_; 4237 } catch(const std::exception &e) { 4238 throwJavaException(env, &e, method_name); 4239 } catch (...) { 4240 throwJavaException(env, 0, method_name); 4241 } 4242 return 0; 4243 } 4244 4245 4246 4247 JNIEXPORT jint JNICALL Java_org_opencv_imgproc_Imgproc_floodFill_11 (JNIEnv*, jclass, jlong, jlong, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble); 4248 4249 JNIEXPORT jint JNICALL Java_org_opencv_imgproc_Imgproc_floodFill_11 4250 (JNIEnv* env, jclass , jlong image_nativeObj, jlong mask_nativeObj, jdouble seedPoint_x, jdouble seedPoint_y, jdouble newVal_val0, jdouble newVal_val1, jdouble newVal_val2, jdouble newVal_val3) 4251 { 4252 static const char method_name[] = "imgproc::floodFill_11()"; 4253 try { 4254 LOGD("%s", method_name); 4255 Mat& image = *((Mat*)image_nativeObj); 4256 Mat& mask = *((Mat*)mask_nativeObj); 4257 Point seedPoint((int)seedPoint_x, (int)seedPoint_y); 4258 Scalar newVal(newVal_val0, newVal_val1, newVal_val2, newVal_val3); 4259 int _retval_ = cv::floodFill( image, mask, seedPoint, newVal ); 4260 return _retval_; 4261 } catch(const std::exception &e) { 4262 throwJavaException(env, &e, method_name); 4263 } catch (...) { 4264 throwJavaException(env, 0, method_name); 4265 } 4266 return 0; 4267 } 4268 4269 4270 4271 // 4272 // void cvtColor(Mat src, Mat& dst, int code, int dstCn = 0) 4273 // 4274 4275 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_cvtColor_10 (JNIEnv*, jclass, jlong, jlong, jint, jint); 4276 4277 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_cvtColor_10 4278 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jint code, jint dstCn) 4279 { 4280 static const char method_name[] = "imgproc::cvtColor_10()"; 4281 try { 4282 LOGD("%s", method_name); 4283 Mat& src = *((Mat*)src_nativeObj); 4284 Mat& dst = *((Mat*)dst_nativeObj); 4285 cv::cvtColor( src, dst, (int)code, (int)dstCn ); 4286 return; 4287 } catch(const std::exception &e) { 4288 throwJavaException(env, &e, method_name); 4289 } catch (...) { 4290 throwJavaException(env, 0, method_name); 4291 } 4292 return; 4293 } 4294 4295 4296 4297 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_cvtColor_11 (JNIEnv*, jclass, jlong, jlong, jint); 4298 4299 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_cvtColor_11 4300 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jint code) 4301 { 4302 static const char method_name[] = "imgproc::cvtColor_11()"; 4303 try { 4304 LOGD("%s", method_name); 4305 Mat& src = *((Mat*)src_nativeObj); 4306 Mat& dst = *((Mat*)dst_nativeObj); 4307 cv::cvtColor( src, dst, (int)code ); 4308 return; 4309 } catch(const std::exception &e) { 4310 throwJavaException(env, &e, method_name); 4311 } catch (...) { 4312 throwJavaException(env, 0, method_name); 4313 } 4314 return; 4315 } 4316 4317 4318 4319 // 4320 // void demosaicing(Mat _src, Mat& _dst, int code, int dcn = 0) 4321 // 4322 4323 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_demosaicing_10 (JNIEnv*, jclass, jlong, jlong, jint, jint); 4324 4325 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_demosaicing_10 4326 (JNIEnv* env, jclass , jlong _src_nativeObj, jlong _dst_nativeObj, jint code, jint dcn) 4327 { 4328 static const char method_name[] = "imgproc::demosaicing_10()"; 4329 try { 4330 LOGD("%s", method_name); 4331 Mat& _src = *((Mat*)_src_nativeObj); 4332 Mat& _dst = *((Mat*)_dst_nativeObj); 4333 cv::demosaicing( _src, _dst, (int)code, (int)dcn ); 4334 return; 4335 } catch(const std::exception &e) { 4336 throwJavaException(env, &e, method_name); 4337 } catch (...) { 4338 throwJavaException(env, 0, method_name); 4339 } 4340 return; 4341 } 4342 4343 4344 4345 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_demosaicing_11 (JNIEnv*, jclass, jlong, jlong, jint); 4346 4347 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_demosaicing_11 4348 (JNIEnv* env, jclass , jlong _src_nativeObj, jlong _dst_nativeObj, jint code) 4349 { 4350 static const char method_name[] = "imgproc::demosaicing_11()"; 4351 try { 4352 LOGD("%s", method_name); 4353 Mat& _src = *((Mat*)_src_nativeObj); 4354 Mat& _dst = *((Mat*)_dst_nativeObj); 4355 cv::demosaicing( _src, _dst, (int)code ); 4356 return; 4357 } catch(const std::exception &e) { 4358 throwJavaException(env, &e, method_name); 4359 } catch (...) { 4360 throwJavaException(env, 0, method_name); 4361 } 4362 return; 4363 } 4364 4365 4366 4367 // 4368 // void matchTemplate(Mat image, Mat templ, Mat& result, int method, Mat mask = Mat()) 4369 // 4370 4371 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_matchTemplate_10 (JNIEnv*, jclass, jlong, jlong, jlong, jint, jlong); 4372 4373 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_matchTemplate_10 4374 (JNIEnv* env, jclass , jlong image_nativeObj, jlong templ_nativeObj, jlong result_nativeObj, jint method, jlong mask_nativeObj) 4375 { 4376 static const char method_name[] = "imgproc::matchTemplate_10()"; 4377 try { 4378 LOGD("%s", method_name); 4379 Mat& image = *((Mat*)image_nativeObj); 4380 Mat& templ = *((Mat*)templ_nativeObj); 4381 Mat& result = *((Mat*)result_nativeObj); 4382 Mat& mask = *((Mat*)mask_nativeObj); 4383 cv::matchTemplate( image, templ, result, (int)method, mask ); 4384 return; 4385 } catch(const std::exception &e) { 4386 throwJavaException(env, &e, method_name); 4387 } catch (...) { 4388 throwJavaException(env, 0, method_name); 4389 } 4390 return; 4391 } 4392 4393 4394 4395 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_matchTemplate_11 (JNIEnv*, jclass, jlong, jlong, jlong, jint); 4396 4397 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_matchTemplate_11 4398 (JNIEnv* env, jclass , jlong image_nativeObj, jlong templ_nativeObj, jlong result_nativeObj, jint method) 4399 { 4400 static const char method_name[] = "imgproc::matchTemplate_11()"; 4401 try { 4402 LOGD("%s", method_name); 4403 Mat& image = *((Mat*)image_nativeObj); 4404 Mat& templ = *((Mat*)templ_nativeObj); 4405 Mat& result = *((Mat*)result_nativeObj); 4406 cv::matchTemplate( image, templ, result, (int)method ); 4407 return; 4408 } catch(const std::exception &e) { 4409 throwJavaException(env, &e, method_name); 4410 } catch (...) { 4411 throwJavaException(env, 0, method_name); 4412 } 4413 return; 4414 } 4415 4416 4417 4418 // 4419 // int connectedComponents(Mat image, Mat& labels, int connectivity = 8, int ltype = CV_32S) 4420 // 4421 4422 JNIEXPORT jint JNICALL Java_org_opencv_imgproc_Imgproc_connectedComponents_10 (JNIEnv*, jclass, jlong, jlong, jint, jint); 4423 4424 JNIEXPORT jint JNICALL Java_org_opencv_imgproc_Imgproc_connectedComponents_10 4425 (JNIEnv* env, jclass , jlong image_nativeObj, jlong labels_nativeObj, jint connectivity, jint ltype) 4426 { 4427 static const char method_name[] = "imgproc::connectedComponents_10()"; 4428 try { 4429 LOGD("%s", method_name); 4430 Mat& image = *((Mat*)image_nativeObj); 4431 Mat& labels = *((Mat*)labels_nativeObj); 4432 int _retval_ = cv::connectedComponents( image, labels, (int)connectivity, (int)ltype ); 4433 return _retval_; 4434 } catch(const std::exception &e) { 4435 throwJavaException(env, &e, method_name); 4436 } catch (...) { 4437 throwJavaException(env, 0, method_name); 4438 } 4439 return 0; 4440 } 4441 4442 4443 4444 JNIEXPORT jint JNICALL Java_org_opencv_imgproc_Imgproc_connectedComponents_11 (JNIEnv*, jclass, jlong, jlong); 4445 4446 JNIEXPORT jint JNICALL Java_org_opencv_imgproc_Imgproc_connectedComponents_11 4447 (JNIEnv* env, jclass , jlong image_nativeObj, jlong labels_nativeObj) 4448 { 4449 static const char method_name[] = "imgproc::connectedComponents_11()"; 4450 try { 4451 LOGD("%s", method_name); 4452 Mat& image = *((Mat*)image_nativeObj); 4453 Mat& labels = *((Mat*)labels_nativeObj); 4454 int _retval_ = cv::connectedComponents( image, labels ); 4455 return _retval_; 4456 } catch(const std::exception &e) { 4457 throwJavaException(env, &e, method_name); 4458 } catch (...) { 4459 throwJavaException(env, 0, method_name); 4460 } 4461 return 0; 4462 } 4463 4464 4465 4466 // 4467 // int connectedComponentsWithStats(Mat image, Mat& labels, Mat& stats, Mat& centroids, int connectivity = 8, int ltype = CV_32S) 4468 // 4469 4470 JNIEXPORT jint JNICALL Java_org_opencv_imgproc_Imgproc_connectedComponentsWithStats_10 (JNIEnv*, jclass, jlong, jlong, jlong, jlong, jint, jint); 4471 4472 JNIEXPORT jint JNICALL Java_org_opencv_imgproc_Imgproc_connectedComponentsWithStats_10 4473 (JNIEnv* env, jclass , jlong image_nativeObj, jlong labels_nativeObj, jlong stats_nativeObj, jlong centroids_nativeObj, jint connectivity, jint ltype) 4474 { 4475 static const char method_name[] = "imgproc::connectedComponentsWithStats_10()"; 4476 try { 4477 LOGD("%s", method_name); 4478 Mat& image = *((Mat*)image_nativeObj); 4479 Mat& labels = *((Mat*)labels_nativeObj); 4480 Mat& stats = *((Mat*)stats_nativeObj); 4481 Mat& centroids = *((Mat*)centroids_nativeObj); 4482 int _retval_ = cv::connectedComponentsWithStats( image, labels, stats, centroids, (int)connectivity, (int)ltype ); 4483 return _retval_; 4484 } catch(const std::exception &e) { 4485 throwJavaException(env, &e, method_name); 4486 } catch (...) { 4487 throwJavaException(env, 0, method_name); 4488 } 4489 return 0; 4490 } 4491 4492 4493 4494 JNIEXPORT jint JNICALL Java_org_opencv_imgproc_Imgproc_connectedComponentsWithStats_11 (JNIEnv*, jclass, jlong, jlong, jlong, jlong); 4495 4496 JNIEXPORT jint JNICALL Java_org_opencv_imgproc_Imgproc_connectedComponentsWithStats_11 4497 (JNIEnv* env, jclass , jlong image_nativeObj, jlong labels_nativeObj, jlong stats_nativeObj, jlong centroids_nativeObj) 4498 { 4499 static const char method_name[] = "imgproc::connectedComponentsWithStats_11()"; 4500 try { 4501 LOGD("%s", method_name); 4502 Mat& image = *((Mat*)image_nativeObj); 4503 Mat& labels = *((Mat*)labels_nativeObj); 4504 Mat& stats = *((Mat*)stats_nativeObj); 4505 Mat& centroids = *((Mat*)centroids_nativeObj); 4506 int _retval_ = cv::connectedComponentsWithStats( image, labels, stats, centroids ); 4507 return _retval_; 4508 } catch(const std::exception &e) { 4509 throwJavaException(env, &e, method_name); 4510 } catch (...) { 4511 throwJavaException(env, 0, method_name); 4512 } 4513 return 0; 4514 } 4515 4516 4517 4518 // 4519 // void findContours(Mat& image, vector_vector_Point& contours, Mat& hierarchy, int mode, int method, Point offset = Point()) 4520 // 4521 4522 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_findContours_10 (JNIEnv*, jclass, jlong, jlong, jlong, jint, jint, jdouble, jdouble); 4523 4524 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_findContours_10 4525 (JNIEnv* env, jclass , jlong image_nativeObj, jlong contours_mat_nativeObj, jlong hierarchy_nativeObj, jint mode, jint method, jdouble offset_x, jdouble offset_y) 4526 { 4527 static const char method_name[] = "imgproc::findContours_10()"; 4528 try { 4529 LOGD("%s", method_name); 4530 std::vector< std::vector<Point> > contours; 4531 Mat& contours_mat = *((Mat*)contours_mat_nativeObj); 4532 Mat& image = *((Mat*)image_nativeObj); 4533 Mat& hierarchy = *((Mat*)hierarchy_nativeObj); 4534 Point offset((int)offset_x, (int)offset_y); 4535 cv::findContours( image, contours, hierarchy, (int)mode, (int)method, offset ); 4536 vector_vector_Point_to_Mat( contours, contours_mat ); 4537 return; 4538 } catch(const std::exception &e) { 4539 throwJavaException(env, &e, method_name); 4540 } catch (...) { 4541 throwJavaException(env, 0, method_name); 4542 } 4543 return; 4544 } 4545 4546 4547 4548 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_findContours_11 (JNIEnv*, jclass, jlong, jlong, jlong, jint, jint); 4549 4550 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_findContours_11 4551 (JNIEnv* env, jclass , jlong image_nativeObj, jlong contours_mat_nativeObj, jlong hierarchy_nativeObj, jint mode, jint method) 4552 { 4553 static const char method_name[] = "imgproc::findContours_11()"; 4554 try { 4555 LOGD("%s", method_name); 4556 std::vector< std::vector<Point> > contours; 4557 Mat& contours_mat = *((Mat*)contours_mat_nativeObj); 4558 Mat& image = *((Mat*)image_nativeObj); 4559 Mat& hierarchy = *((Mat*)hierarchy_nativeObj); 4560 cv::findContours( image, contours, hierarchy, (int)mode, (int)method ); 4561 vector_vector_Point_to_Mat( contours, contours_mat ); 4562 return; 4563 } catch(const std::exception &e) { 4564 throwJavaException(env, &e, method_name); 4565 } catch (...) { 4566 throwJavaException(env, 0, method_name); 4567 } 4568 return; 4569 } 4570 4571 4572 4573 // 4574 // void approxPolyDP(vector_Point2f curve, vector_Point2f& approxCurve, double epsilon, bool closed) 4575 // 4576 4577 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_approxPolyDP_10 (JNIEnv*, jclass, jlong, jlong, jdouble, jboolean); 4578 4579 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_approxPolyDP_10 4580 (JNIEnv* env, jclass , jlong curve_mat_nativeObj, jlong approxCurve_mat_nativeObj, jdouble epsilon, jboolean closed) 4581 { 4582 static const char method_name[] = "imgproc::approxPolyDP_10()"; 4583 try { 4584 LOGD("%s", method_name); 4585 std::vector<Point2f> curve; 4586 Mat& curve_mat = *((Mat*)curve_mat_nativeObj); 4587 Mat_to_vector_Point2f( curve_mat, curve ); 4588 std::vector<Point2f> approxCurve; 4589 Mat& approxCurve_mat = *((Mat*)approxCurve_mat_nativeObj); 4590 cv::approxPolyDP( curve, approxCurve, (double)epsilon, (bool)closed ); 4591 vector_Point2f_to_Mat( approxCurve, approxCurve_mat ); 4592 return; 4593 } catch(const std::exception &e) { 4594 throwJavaException(env, &e, method_name); 4595 } catch (...) { 4596 throwJavaException(env, 0, method_name); 4597 } 4598 return; 4599 } 4600 4601 4602 4603 // 4604 // double arcLength(vector_Point2f curve, bool closed) 4605 // 4606 4607 JNIEXPORT jdouble JNICALL Java_org_opencv_imgproc_Imgproc_arcLength_10 (JNIEnv*, jclass, jlong, jboolean); 4608 4609 JNIEXPORT jdouble JNICALL Java_org_opencv_imgproc_Imgproc_arcLength_10 4610 (JNIEnv* env, jclass , jlong curve_mat_nativeObj, jboolean closed) 4611 { 4612 static const char method_name[] = "imgproc::arcLength_10()"; 4613 try { 4614 LOGD("%s", method_name); 4615 std::vector<Point2f> curve; 4616 Mat& curve_mat = *((Mat*)curve_mat_nativeObj); 4617 Mat_to_vector_Point2f( curve_mat, curve ); 4618 double _retval_ = cv::arcLength( curve, (bool)closed ); 4619 return _retval_; 4620 } catch(const std::exception &e) { 4621 throwJavaException(env, &e, method_name); 4622 } catch (...) { 4623 throwJavaException(env, 0, method_name); 4624 } 4625 return 0; 4626 } 4627 4628 4629 4630 // 4631 // Rect boundingRect(vector_Point points) 4632 // 4633 4634 JNIEXPORT jdoubleArray JNICALL Java_org_opencv_imgproc_Imgproc_boundingRect_10 (JNIEnv*, jclass, jlong); 4635 4636 JNIEXPORT jdoubleArray JNICALL Java_org_opencv_imgproc_Imgproc_boundingRect_10 4637 (JNIEnv* env, jclass , jlong points_mat_nativeObj) 4638 { 4639 static const char method_name[] = "imgproc::boundingRect_10()"; 4640 try { 4641 LOGD("%s", method_name); 4642 std::vector<Point> points; 4643 Mat& points_mat = *((Mat*)points_mat_nativeObj); 4644 Mat_to_vector_Point( points_mat, points ); 4645 Rect _retval_ = cv::boundingRect( points ); 4646 jdoubleArray _da_retval_ = env->NewDoubleArray(4); jdouble _tmp_retval_[4] = {_retval_.x, _retval_.y, _retval_.width, _retval_.height}; env->SetDoubleArrayRegion(_da_retval_, 0, 4, _tmp_retval_); 4647 return _da_retval_; 4648 } catch(const std::exception &e) { 4649 throwJavaException(env, &e, method_name); 4650 } catch (...) { 4651 throwJavaException(env, 0, method_name); 4652 } 4653 return 0; 4654 } 4655 4656 4657 4658 // 4659 // double contourArea(Mat contour, bool oriented = false) 4660 // 4661 4662 JNIEXPORT jdouble JNICALL Java_org_opencv_imgproc_Imgproc_contourArea_10 (JNIEnv*, jclass, jlong, jboolean); 4663 4664 JNIEXPORT jdouble JNICALL Java_org_opencv_imgproc_Imgproc_contourArea_10 4665 (JNIEnv* env, jclass , jlong contour_nativeObj, jboolean oriented) 4666 { 4667 static const char method_name[] = "imgproc::contourArea_10()"; 4668 try { 4669 LOGD("%s", method_name); 4670 Mat& contour = *((Mat*)contour_nativeObj); 4671 double _retval_ = cv::contourArea( contour, (bool)oriented ); 4672 return _retval_; 4673 } catch(const std::exception &e) { 4674 throwJavaException(env, &e, method_name); 4675 } catch (...) { 4676 throwJavaException(env, 0, method_name); 4677 } 4678 return 0; 4679 } 4680 4681 4682 4683 JNIEXPORT jdouble JNICALL Java_org_opencv_imgproc_Imgproc_contourArea_11 (JNIEnv*, jclass, jlong); 4684 4685 JNIEXPORT jdouble JNICALL Java_org_opencv_imgproc_Imgproc_contourArea_11 4686 (JNIEnv* env, jclass , jlong contour_nativeObj) 4687 { 4688 static const char method_name[] = "imgproc::contourArea_11()"; 4689 try { 4690 LOGD("%s", method_name); 4691 Mat& contour = *((Mat*)contour_nativeObj); 4692 double _retval_ = cv::contourArea( contour ); 4693 return _retval_; 4694 } catch(const std::exception &e) { 4695 throwJavaException(env, &e, method_name); 4696 } catch (...) { 4697 throwJavaException(env, 0, method_name); 4698 } 4699 return 0; 4700 } 4701 4702 4703 4704 // 4705 // RotatedRect minAreaRect(vector_Point2f points) 4706 // 4707 4708 JNIEXPORT jdoubleArray JNICALL Java_org_opencv_imgproc_Imgproc_minAreaRect_10 (JNIEnv*, jclass, jlong); 4709 4710 JNIEXPORT jdoubleArray JNICALL Java_org_opencv_imgproc_Imgproc_minAreaRect_10 4711 (JNIEnv* env, jclass , jlong points_mat_nativeObj) 4712 { 4713 static const char method_name[] = "imgproc::minAreaRect_10()"; 4714 try { 4715 LOGD("%s", method_name); 4716 std::vector<Point2f> points; 4717 Mat& points_mat = *((Mat*)points_mat_nativeObj); 4718 Mat_to_vector_Point2f( points_mat, points ); 4719 RotatedRect _retval_ = cv::minAreaRect( points ); 4720 jdoubleArray _da_retval_ = env->NewDoubleArray(5); jdouble _tmp_retval_[5] = {_retval_.center.x, _retval_.center.y, _retval_.size.width, _retval_.size.height, _retval_.angle}; env->SetDoubleArrayRegion(_da_retval_, 0, 5, _tmp_retval_); 4721 return _da_retval_; 4722 } catch(const std::exception &e) { 4723 throwJavaException(env, &e, method_name); 4724 } catch (...) { 4725 throwJavaException(env, 0, method_name); 4726 } 4727 return 0; 4728 } 4729 4730 4731 4732 // 4733 // void boxPoints(RotatedRect box, Mat& points) 4734 // 4735 4736 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_boxPoints_10 (JNIEnv*, jclass, jdouble, jdouble, jdouble, jdouble, jdouble, jlong); 4737 4738 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_boxPoints_10 4739 (JNIEnv* env, jclass , jdouble box_center_x, jdouble box_center_y, jdouble box_size_width, jdouble box_size_height, jdouble box_angle, jlong points_nativeObj) 4740 { 4741 static const char method_name[] = "imgproc::boxPoints_10()"; 4742 try { 4743 LOGD("%s", method_name); 4744 RotatedRect box(cv::Point2f(box_center_x, box_center_y), cv::Size2f(box_size_width, box_size_height), box_angle); 4745 Mat& points = *((Mat*)points_nativeObj); 4746 cv::boxPoints( box, points ); 4747 return; 4748 } catch(const std::exception &e) { 4749 throwJavaException(env, &e, method_name); 4750 } catch (...) { 4751 throwJavaException(env, 0, method_name); 4752 } 4753 return; 4754 } 4755 4756 4757 4758 // 4759 // void minEnclosingCircle(vector_Point2f points, Point2f& center, float& radius) 4760 // 4761 4762 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_minEnclosingCircle_10 (JNIEnv*, jclass, jlong, jdoubleArray, jdoubleArray); 4763 4764 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_minEnclosingCircle_10 4765 (JNIEnv* env, jclass , jlong points_mat_nativeObj, jdoubleArray center_out, jdoubleArray radius_out) 4766 { 4767 static const char method_name[] = "imgproc::minEnclosingCircle_10()"; 4768 try { 4769 LOGD("%s", method_name); 4770 std::vector<Point2f> points; 4771 Mat& points_mat = *((Mat*)points_mat_nativeObj); 4772 Mat_to_vector_Point2f( points_mat, points ); 4773 Point2f center; 4774 float radius; 4775 cv::minEnclosingCircle( points, center, radius ); 4776 jdouble tmp_center[2] = {center.x, center.y}; env->SetDoubleArrayRegion(center_out, 0, 2, tmp_center); jdouble tmp_radius[1] = {radius}; env->SetDoubleArrayRegion(radius_out, 0, 1, tmp_radius); 4777 return; 4778 } catch(const std::exception &e) { 4779 throwJavaException(env, &e, method_name); 4780 } catch (...) { 4781 throwJavaException(env, 0, method_name); 4782 } 4783 return; 4784 } 4785 4786 4787 4788 // 4789 // double minEnclosingTriangle(Mat points, Mat& triangle) 4790 // 4791 4792 JNIEXPORT jdouble JNICALL Java_org_opencv_imgproc_Imgproc_minEnclosingTriangle_10 (JNIEnv*, jclass, jlong, jlong); 4793 4794 JNIEXPORT jdouble JNICALL Java_org_opencv_imgproc_Imgproc_minEnclosingTriangle_10 4795 (JNIEnv* env, jclass , jlong points_nativeObj, jlong triangle_nativeObj) 4796 { 4797 static const char method_name[] = "imgproc::minEnclosingTriangle_10()"; 4798 try { 4799 LOGD("%s", method_name); 4800 Mat& points = *((Mat*)points_nativeObj); 4801 Mat& triangle = *((Mat*)triangle_nativeObj); 4802 double _retval_ = cv::minEnclosingTriangle( points, triangle ); 4803 return _retval_; 4804 } catch(const std::exception &e) { 4805 throwJavaException(env, &e, method_name); 4806 } catch (...) { 4807 throwJavaException(env, 0, method_name); 4808 } 4809 return 0; 4810 } 4811 4812 4813 4814 // 4815 // double matchShapes(Mat contour1, Mat contour2, int method, double parameter) 4816 // 4817 4818 JNIEXPORT jdouble JNICALL Java_org_opencv_imgproc_Imgproc_matchShapes_10 (JNIEnv*, jclass, jlong, jlong, jint, jdouble); 4819 4820 JNIEXPORT jdouble JNICALL Java_org_opencv_imgproc_Imgproc_matchShapes_10 4821 (JNIEnv* env, jclass , jlong contour1_nativeObj, jlong contour2_nativeObj, jint method, jdouble parameter) 4822 { 4823 static const char method_name[] = "imgproc::matchShapes_10()"; 4824 try { 4825 LOGD("%s", method_name); 4826 Mat& contour1 = *((Mat*)contour1_nativeObj); 4827 Mat& contour2 = *((Mat*)contour2_nativeObj); 4828 double _retval_ = cv::matchShapes( contour1, contour2, (int)method, (double)parameter ); 4829 return _retval_; 4830 } catch(const std::exception &e) { 4831 throwJavaException(env, &e, method_name); 4832 } catch (...) { 4833 throwJavaException(env, 0, method_name); 4834 } 4835 return 0; 4836 } 4837 4838 4839 4840 // 4841 // void convexHull(vector_Point points, vector_int& hull, bool clockwise = false, _hidden_ returnPoints = true) 4842 // 4843 4844 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_convexHull_10 (JNIEnv*, jclass, jlong, jlong, jboolean); 4845 4846 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_convexHull_10 4847 (JNIEnv* env, jclass , jlong points_mat_nativeObj, jlong hull_mat_nativeObj, jboolean clockwise) 4848 { 4849 static const char method_name[] = "imgproc::convexHull_10()"; 4850 try { 4851 LOGD("%s", method_name); 4852 std::vector<Point> points; 4853 Mat& points_mat = *((Mat*)points_mat_nativeObj); 4854 Mat_to_vector_Point( points_mat, points ); 4855 std::vector<int> hull; 4856 Mat& hull_mat = *((Mat*)hull_mat_nativeObj); 4857 cv::convexHull( points, hull, (bool)clockwise, true ); 4858 vector_int_to_Mat( hull, hull_mat ); 4859 return; 4860 } catch(const std::exception &e) { 4861 throwJavaException(env, &e, method_name); 4862 } catch (...) { 4863 throwJavaException(env, 0, method_name); 4864 } 4865 return; 4866 } 4867 4868 4869 4870 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_convexHull_11 (JNIEnv*, jclass, jlong, jlong); 4871 4872 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_convexHull_11 4873 (JNIEnv* env, jclass , jlong points_mat_nativeObj, jlong hull_mat_nativeObj) 4874 { 4875 static const char method_name[] = "imgproc::convexHull_11()"; 4876 try { 4877 LOGD("%s", method_name); 4878 std::vector<Point> points; 4879 Mat& points_mat = *((Mat*)points_mat_nativeObj); 4880 Mat_to_vector_Point( points_mat, points ); 4881 std::vector<int> hull; 4882 Mat& hull_mat = *((Mat*)hull_mat_nativeObj); 4883 cv::convexHull( points, hull ); 4884 vector_int_to_Mat( hull, hull_mat ); 4885 return; 4886 } catch(const std::exception &e) { 4887 throwJavaException(env, &e, method_name); 4888 } catch (...) { 4889 throwJavaException(env, 0, method_name); 4890 } 4891 return; 4892 } 4893 4894 4895 4896 // 4897 // void convexityDefects(vector_Point contour, vector_int convexhull, vector_Vec4i& convexityDefects) 4898 // 4899 4900 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_convexityDefects_10 (JNIEnv*, jclass, jlong, jlong, jlong); 4901 4902 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_convexityDefects_10 4903 (JNIEnv* env, jclass , jlong contour_mat_nativeObj, jlong convexhull_mat_nativeObj, jlong convexityDefects_mat_nativeObj) 4904 { 4905 static const char method_name[] = "imgproc::convexityDefects_10()"; 4906 try { 4907 LOGD("%s", method_name); 4908 std::vector<Point> contour; 4909 Mat& contour_mat = *((Mat*)contour_mat_nativeObj); 4910 Mat_to_vector_Point( contour_mat, contour ); 4911 std::vector<int> convexhull; 4912 Mat& convexhull_mat = *((Mat*)convexhull_mat_nativeObj); 4913 Mat_to_vector_int( convexhull_mat, convexhull ); 4914 std::vector<Vec4i> convexityDefects; 4915 Mat& convexityDefects_mat = *((Mat*)convexityDefects_mat_nativeObj); 4916 cv::convexityDefects( contour, convexhull, convexityDefects ); 4917 vector_Vec4i_to_Mat( convexityDefects, convexityDefects_mat ); 4918 return; 4919 } catch(const std::exception &e) { 4920 throwJavaException(env, &e, method_name); 4921 } catch (...) { 4922 throwJavaException(env, 0, method_name); 4923 } 4924 return; 4925 } 4926 4927 4928 4929 // 4930 // bool isContourConvex(vector_Point contour) 4931 // 4932 4933 JNIEXPORT jboolean JNICALL Java_org_opencv_imgproc_Imgproc_isContourConvex_10 (JNIEnv*, jclass, jlong); 4934 4935 JNIEXPORT jboolean JNICALL Java_org_opencv_imgproc_Imgproc_isContourConvex_10 4936 (JNIEnv* env, jclass , jlong contour_mat_nativeObj) 4937 { 4938 static const char method_name[] = "imgproc::isContourConvex_10()"; 4939 try { 4940 LOGD("%s", method_name); 4941 std::vector<Point> contour; 4942 Mat& contour_mat = *((Mat*)contour_mat_nativeObj); 4943 Mat_to_vector_Point( contour_mat, contour ); 4944 bool _retval_ = cv::isContourConvex( contour ); 4945 return _retval_; 4946 } catch(const std::exception &e) { 4947 throwJavaException(env, &e, method_name); 4948 } catch (...) { 4949 throwJavaException(env, 0, method_name); 4950 } 4951 return 0; 4952 } 4953 4954 4955 4956 // 4957 // float intersectConvexConvex(Mat _p1, Mat _p2, Mat& _p12, bool handleNested = true) 4958 // 4959 4960 JNIEXPORT jfloat JNICALL Java_org_opencv_imgproc_Imgproc_intersectConvexConvex_10 (JNIEnv*, jclass, jlong, jlong, jlong, jboolean); 4961 4962 JNIEXPORT jfloat JNICALL Java_org_opencv_imgproc_Imgproc_intersectConvexConvex_10 4963 (JNIEnv* env, jclass , jlong _p1_nativeObj, jlong _p2_nativeObj, jlong _p12_nativeObj, jboolean handleNested) 4964 { 4965 static const char method_name[] = "imgproc::intersectConvexConvex_10()"; 4966 try { 4967 LOGD("%s", method_name); 4968 Mat& _p1 = *((Mat*)_p1_nativeObj); 4969 Mat& _p2 = *((Mat*)_p2_nativeObj); 4970 Mat& _p12 = *((Mat*)_p12_nativeObj); 4971 float _retval_ = cv::intersectConvexConvex( _p1, _p2, _p12, (bool)handleNested ); 4972 return _retval_; 4973 } catch(const std::exception &e) { 4974 throwJavaException(env, &e, method_name); 4975 } catch (...) { 4976 throwJavaException(env, 0, method_name); 4977 } 4978 return 0; 4979 } 4980 4981 4982 4983 JNIEXPORT jfloat JNICALL Java_org_opencv_imgproc_Imgproc_intersectConvexConvex_11 (JNIEnv*, jclass, jlong, jlong, jlong); 4984 4985 JNIEXPORT jfloat JNICALL Java_org_opencv_imgproc_Imgproc_intersectConvexConvex_11 4986 (JNIEnv* env, jclass , jlong _p1_nativeObj, jlong _p2_nativeObj, jlong _p12_nativeObj) 4987 { 4988 static const char method_name[] = "imgproc::intersectConvexConvex_11()"; 4989 try { 4990 LOGD("%s", method_name); 4991 Mat& _p1 = *((Mat*)_p1_nativeObj); 4992 Mat& _p2 = *((Mat*)_p2_nativeObj); 4993 Mat& _p12 = *((Mat*)_p12_nativeObj); 4994 float _retval_ = cv::intersectConvexConvex( _p1, _p2, _p12 ); 4995 return _retval_; 4996 } catch(const std::exception &e) { 4997 throwJavaException(env, &e, method_name); 4998 } catch (...) { 4999 throwJavaException(env, 0, method_name); 5000 } 5001 return 0; 5002 } 5003 5004 5005 5006 // 5007 // RotatedRect fitEllipse(vector_Point2f points) 5008 // 5009 5010 JNIEXPORT jdoubleArray JNICALL Java_org_opencv_imgproc_Imgproc_fitEllipse_10 (JNIEnv*, jclass, jlong); 5011 5012 JNIEXPORT jdoubleArray JNICALL Java_org_opencv_imgproc_Imgproc_fitEllipse_10 5013 (JNIEnv* env, jclass , jlong points_mat_nativeObj) 5014 { 5015 static const char method_name[] = "imgproc::fitEllipse_10()"; 5016 try { 5017 LOGD("%s", method_name); 5018 std::vector<Point2f> points; 5019 Mat& points_mat = *((Mat*)points_mat_nativeObj); 5020 Mat_to_vector_Point2f( points_mat, points ); 5021 RotatedRect _retval_ = cv::fitEllipse( points ); 5022 jdoubleArray _da_retval_ = env->NewDoubleArray(5); jdouble _tmp_retval_[5] = {_retval_.center.x, _retval_.center.y, _retval_.size.width, _retval_.size.height, _retval_.angle}; env->SetDoubleArrayRegion(_da_retval_, 0, 5, _tmp_retval_); 5023 return _da_retval_; 5024 } catch(const std::exception &e) { 5025 throwJavaException(env, &e, method_name); 5026 } catch (...) { 5027 throwJavaException(env, 0, method_name); 5028 } 5029 return 0; 5030 } 5031 5032 5033 5034 // 5035 // void fitLine(Mat points, Mat& line, int distType, double param, double reps, double aeps) 5036 // 5037 5038 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_fitLine_10 (JNIEnv*, jclass, jlong, jlong, jint, jdouble, jdouble, jdouble); 5039 5040 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_fitLine_10 5041 (JNIEnv* env, jclass , jlong points_nativeObj, jlong line_nativeObj, jint distType, jdouble param, jdouble reps, jdouble aeps) 5042 { 5043 static const char method_name[] = "imgproc::fitLine_10()"; 5044 try { 5045 LOGD("%s", method_name); 5046 Mat& points = *((Mat*)points_nativeObj); 5047 Mat& line = *((Mat*)line_nativeObj); 5048 cv::fitLine( points, line, (int)distType, (double)param, (double)reps, (double)aeps ); 5049 return; 5050 } catch(const std::exception &e) { 5051 throwJavaException(env, &e, method_name); 5052 } catch (...) { 5053 throwJavaException(env, 0, method_name); 5054 } 5055 return; 5056 } 5057 5058 5059 5060 // 5061 // double pointPolygonTest(vector_Point2f contour, Point2f pt, bool measureDist) 5062 // 5063 5064 JNIEXPORT jdouble JNICALL Java_org_opencv_imgproc_Imgproc_pointPolygonTest_10 (JNIEnv*, jclass, jlong, jdouble, jdouble, jboolean); 5065 5066 JNIEXPORT jdouble JNICALL Java_org_opencv_imgproc_Imgproc_pointPolygonTest_10 5067 (JNIEnv* env, jclass , jlong contour_mat_nativeObj, jdouble pt_x, jdouble pt_y, jboolean measureDist) 5068 { 5069 static const char method_name[] = "imgproc::pointPolygonTest_10()"; 5070 try { 5071 LOGD("%s", method_name); 5072 std::vector<Point2f> contour; 5073 Mat& contour_mat = *((Mat*)contour_mat_nativeObj); 5074 Mat_to_vector_Point2f( contour_mat, contour ); 5075 Point2f pt((float)pt_x, (float)pt_y); 5076 double _retval_ = cv::pointPolygonTest( contour, pt, (bool)measureDist ); 5077 return _retval_; 5078 } catch(const std::exception &e) { 5079 throwJavaException(env, &e, method_name); 5080 } catch (...) { 5081 throwJavaException(env, 0, method_name); 5082 } 5083 return 0; 5084 } 5085 5086 5087 5088 // 5089 // int rotatedRectangleIntersection(RotatedRect rect1, RotatedRect rect2, Mat& intersectingRegion) 5090 // 5091 5092 JNIEXPORT jint JNICALL Java_org_opencv_imgproc_Imgproc_rotatedRectangleIntersection_10 (JNIEnv*, jclass, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jlong); 5093 5094 JNIEXPORT jint JNICALL Java_org_opencv_imgproc_Imgproc_rotatedRectangleIntersection_10 5095 (JNIEnv* env, jclass , jdouble rect1_center_x, jdouble rect1_center_y, jdouble rect1_size_width, jdouble rect1_size_height, jdouble rect1_angle, jdouble rect2_center_x, jdouble rect2_center_y, jdouble rect2_size_width, jdouble rect2_size_height, jdouble rect2_angle, jlong intersectingRegion_nativeObj) 5096 { 5097 static const char method_name[] = "imgproc::rotatedRectangleIntersection_10()"; 5098 try { 5099 LOGD("%s", method_name); 5100 RotatedRect rect1(cv::Point2f(rect1_center_x, rect1_center_y), cv::Size2f(rect1_size_width, rect1_size_height), rect1_angle); 5101 RotatedRect rect2(cv::Point2f(rect2_center_x, rect2_center_y), cv::Size2f(rect2_size_width, rect2_size_height), rect2_angle); 5102 Mat& intersectingRegion = *((Mat*)intersectingRegion_nativeObj); 5103 int _retval_ = cv::rotatedRectangleIntersection( rect1, rect2, intersectingRegion ); 5104 return _retval_; 5105 } catch(const std::exception &e) { 5106 throwJavaException(env, &e, method_name); 5107 } catch (...) { 5108 throwJavaException(env, 0, method_name); 5109 } 5110 return 0; 5111 } 5112 5113 5114 5115 // 5116 // Ptr_CLAHE createCLAHE(double clipLimit = 40.0, Size tileGridSize = Size(8, 8)) 5117 // 5118 5119 JNIEXPORT jlong JNICALL Java_org_opencv_imgproc_Imgproc_createCLAHE_10 (JNIEnv*, jclass, jdouble, jdouble, jdouble); 5120 5121 JNIEXPORT jlong JNICALL Java_org_opencv_imgproc_Imgproc_createCLAHE_10 5122 (JNIEnv* env, jclass , jdouble clipLimit, jdouble tileGridSize_width, jdouble tileGridSize_height) 5123 { 5124 static const char method_name[] = "imgproc::createCLAHE_10()"; 5125 try { 5126 LOGD("%s", method_name); 5127 typedef Ptr<cv::CLAHE> Ptr_CLAHE; 5128 Size tileGridSize((int)tileGridSize_width, (int)tileGridSize_height); 5129 Ptr_CLAHE _retval_ = cv::createCLAHE( (double)clipLimit, tileGridSize ); 5130 return (jlong)(new Ptr_CLAHE(_retval_)); 5131 } catch(const std::exception &e) { 5132 throwJavaException(env, &e, method_name); 5133 } catch (...) { 5134 throwJavaException(env, 0, method_name); 5135 } 5136 return 0; 5137 } 5138 5139 5140 5141 JNIEXPORT jlong JNICALL Java_org_opencv_imgproc_Imgproc_createCLAHE_11 (JNIEnv*, jclass); 5142 5143 JNIEXPORT jlong JNICALL Java_org_opencv_imgproc_Imgproc_createCLAHE_11 5144 (JNIEnv* env, jclass ) 5145 { 5146 static const char method_name[] = "imgproc::createCLAHE_11()"; 5147 try { 5148 LOGD("%s", method_name); 5149 typedef Ptr<cv::CLAHE> Ptr_CLAHE; 5150 Ptr_CLAHE _retval_ = cv::createCLAHE( ); 5151 return (jlong)(new Ptr_CLAHE(_retval_)); 5152 } catch(const std::exception &e) { 5153 throwJavaException(env, &e, method_name); 5154 } catch (...) { 5155 throwJavaException(env, 0, method_name); 5156 } 5157 return 0; 5158 } 5159 5160 5161 5162 // 5163 // void applyColorMap(Mat src, Mat& dst, int colormap) 5164 // 5165 5166 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_applyColorMap_10 (JNIEnv*, jclass, jlong, jlong, jint); 5167 5168 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_applyColorMap_10 5169 (JNIEnv* env, jclass , jlong src_nativeObj, jlong dst_nativeObj, jint colormap) 5170 { 5171 static const char method_name[] = "imgproc::applyColorMap_10()"; 5172 try { 5173 LOGD("%s", method_name); 5174 Mat& src = *((Mat*)src_nativeObj); 5175 Mat& dst = *((Mat*)dst_nativeObj); 5176 cv::applyColorMap( src, dst, (int)colormap ); 5177 return; 5178 } catch(const std::exception &e) { 5179 throwJavaException(env, &e, method_name); 5180 } catch (...) { 5181 throwJavaException(env, 0, method_name); 5182 } 5183 return; 5184 } 5185 5186 5187 5188 // 5189 // void line(Mat& img, Point pt1, Point pt2, Scalar color, int thickness = 1, int lineType = LINE_8, int shift = 0) 5190 // 5191 5192 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_line_10 (JNIEnv*, jclass, jlong, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jint, jint, jint); 5193 5194 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_line_10 5195 (JNIEnv* env, jclass , jlong img_nativeObj, jdouble pt1_x, jdouble pt1_y, jdouble pt2_x, jdouble pt2_y, jdouble color_val0, jdouble color_val1, jdouble color_val2, jdouble color_val3, jint thickness, jint lineType, jint shift) 5196 { 5197 static const char method_name[] = "imgproc::line_10()"; 5198 try { 5199 LOGD("%s", method_name); 5200 Mat& img = *((Mat*)img_nativeObj); 5201 Point pt1((int)pt1_x, (int)pt1_y); 5202 Point pt2((int)pt2_x, (int)pt2_y); 5203 Scalar color(color_val0, color_val1, color_val2, color_val3); 5204 cv::line( img, pt1, pt2, color, (int)thickness, (int)lineType, (int)shift ); 5205 return; 5206 } catch(const std::exception &e) { 5207 throwJavaException(env, &e, method_name); 5208 } catch (...) { 5209 throwJavaException(env, 0, method_name); 5210 } 5211 return; 5212 } 5213 5214 5215 5216 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_line_11 (JNIEnv*, jclass, jlong, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jint); 5217 5218 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_line_11 5219 (JNIEnv* env, jclass , jlong img_nativeObj, jdouble pt1_x, jdouble pt1_y, jdouble pt2_x, jdouble pt2_y, jdouble color_val0, jdouble color_val1, jdouble color_val2, jdouble color_val3, jint thickness) 5220 { 5221 static const char method_name[] = "imgproc::line_11()"; 5222 try { 5223 LOGD("%s", method_name); 5224 Mat& img = *((Mat*)img_nativeObj); 5225 Point pt1((int)pt1_x, (int)pt1_y); 5226 Point pt2((int)pt2_x, (int)pt2_y); 5227 Scalar color(color_val0, color_val1, color_val2, color_val3); 5228 cv::line( img, pt1, pt2, color, (int)thickness ); 5229 return; 5230 } catch(const std::exception &e) { 5231 throwJavaException(env, &e, method_name); 5232 } catch (...) { 5233 throwJavaException(env, 0, method_name); 5234 } 5235 return; 5236 } 5237 5238 5239 5240 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_line_12 (JNIEnv*, jclass, jlong, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble); 5241 5242 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_line_12 5243 (JNIEnv* env, jclass , jlong img_nativeObj, jdouble pt1_x, jdouble pt1_y, jdouble pt2_x, jdouble pt2_y, jdouble color_val0, jdouble color_val1, jdouble color_val2, jdouble color_val3) 5244 { 5245 static const char method_name[] = "imgproc::line_12()"; 5246 try { 5247 LOGD("%s", method_name); 5248 Mat& img = *((Mat*)img_nativeObj); 5249 Point pt1((int)pt1_x, (int)pt1_y); 5250 Point pt2((int)pt2_x, (int)pt2_y); 5251 Scalar color(color_val0, color_val1, color_val2, color_val3); 5252 cv::line( img, pt1, pt2, color ); 5253 return; 5254 } catch(const std::exception &e) { 5255 throwJavaException(env, &e, method_name); 5256 } catch (...) { 5257 throwJavaException(env, 0, method_name); 5258 } 5259 return; 5260 } 5261 5262 5263 5264 // 5265 // void arrowedLine(Mat& img, Point pt1, Point pt2, Scalar color, int thickness = 1, int line_type = 8, int shift = 0, double tipLength = 0.1) 5266 // 5267 5268 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_arrowedLine_10 (JNIEnv*, jclass, jlong, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jint, jint, jint, jdouble); 5269 5270 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_arrowedLine_10 5271 (JNIEnv* env, jclass , jlong img_nativeObj, jdouble pt1_x, jdouble pt1_y, jdouble pt2_x, jdouble pt2_y, jdouble color_val0, jdouble color_val1, jdouble color_val2, jdouble color_val3, jint thickness, jint line_type, jint shift, jdouble tipLength) 5272 { 5273 static const char method_name[] = "imgproc::arrowedLine_10()"; 5274 try { 5275 LOGD("%s", method_name); 5276 Mat& img = *((Mat*)img_nativeObj); 5277 Point pt1((int)pt1_x, (int)pt1_y); 5278 Point pt2((int)pt2_x, (int)pt2_y); 5279 Scalar color(color_val0, color_val1, color_val2, color_val3); 5280 cv::arrowedLine( img, pt1, pt2, color, (int)thickness, (int)line_type, (int)shift, (double)tipLength ); 5281 return; 5282 } catch(const std::exception &e) { 5283 throwJavaException(env, &e, method_name); 5284 } catch (...) { 5285 throwJavaException(env, 0, method_name); 5286 } 5287 return; 5288 } 5289 5290 5291 5292 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_arrowedLine_11 (JNIEnv*, jclass, jlong, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble); 5293 5294 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_arrowedLine_11 5295 (JNIEnv* env, jclass , jlong img_nativeObj, jdouble pt1_x, jdouble pt1_y, jdouble pt2_x, jdouble pt2_y, jdouble color_val0, jdouble color_val1, jdouble color_val2, jdouble color_val3) 5296 { 5297 static const char method_name[] = "imgproc::arrowedLine_11()"; 5298 try { 5299 LOGD("%s", method_name); 5300 Mat& img = *((Mat*)img_nativeObj); 5301 Point pt1((int)pt1_x, (int)pt1_y); 5302 Point pt2((int)pt2_x, (int)pt2_y); 5303 Scalar color(color_val0, color_val1, color_val2, color_val3); 5304 cv::arrowedLine( img, pt1, pt2, color ); 5305 return; 5306 } catch(const std::exception &e) { 5307 throwJavaException(env, &e, method_name); 5308 } catch (...) { 5309 throwJavaException(env, 0, method_name); 5310 } 5311 return; 5312 } 5313 5314 5315 5316 // 5317 // void rectangle(Mat& img, Point pt1, Point pt2, Scalar color, int thickness = 1, int lineType = LINE_8, int shift = 0) 5318 // 5319 5320 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_rectangle_10 (JNIEnv*, jclass, jlong, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jint, jint, jint); 5321 5322 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_rectangle_10 5323 (JNIEnv* env, jclass , jlong img_nativeObj, jdouble pt1_x, jdouble pt1_y, jdouble pt2_x, jdouble pt2_y, jdouble color_val0, jdouble color_val1, jdouble color_val2, jdouble color_val3, jint thickness, jint lineType, jint shift) 5324 { 5325 static const char method_name[] = "imgproc::rectangle_10()"; 5326 try { 5327 LOGD("%s", method_name); 5328 Mat& img = *((Mat*)img_nativeObj); 5329 Point pt1((int)pt1_x, (int)pt1_y); 5330 Point pt2((int)pt2_x, (int)pt2_y); 5331 Scalar color(color_val0, color_val1, color_val2, color_val3); 5332 cv::rectangle( img, pt1, pt2, color, (int)thickness, (int)lineType, (int)shift ); 5333 return; 5334 } catch(const std::exception &e) { 5335 throwJavaException(env, &e, method_name); 5336 } catch (...) { 5337 throwJavaException(env, 0, method_name); 5338 } 5339 return; 5340 } 5341 5342 5343 5344 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_rectangle_11 (JNIEnv*, jclass, jlong, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jint); 5345 5346 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_rectangle_11 5347 (JNIEnv* env, jclass , jlong img_nativeObj, jdouble pt1_x, jdouble pt1_y, jdouble pt2_x, jdouble pt2_y, jdouble color_val0, jdouble color_val1, jdouble color_val2, jdouble color_val3, jint thickness) 5348 { 5349 static const char method_name[] = "imgproc::rectangle_11()"; 5350 try { 5351 LOGD("%s", method_name); 5352 Mat& img = *((Mat*)img_nativeObj); 5353 Point pt1((int)pt1_x, (int)pt1_y); 5354 Point pt2((int)pt2_x, (int)pt2_y); 5355 Scalar color(color_val0, color_val1, color_val2, color_val3); 5356 cv::rectangle( img, pt1, pt2, color, (int)thickness ); 5357 return; 5358 } catch(const std::exception &e) { 5359 throwJavaException(env, &e, method_name); 5360 } catch (...) { 5361 throwJavaException(env, 0, method_name); 5362 } 5363 return; 5364 } 5365 5366 5367 5368 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_rectangle_12 (JNIEnv*, jclass, jlong, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble); 5369 5370 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_rectangle_12 5371 (JNIEnv* env, jclass , jlong img_nativeObj, jdouble pt1_x, jdouble pt1_y, jdouble pt2_x, jdouble pt2_y, jdouble color_val0, jdouble color_val1, jdouble color_val2, jdouble color_val3) 5372 { 5373 static const char method_name[] = "imgproc::rectangle_12()"; 5374 try { 5375 LOGD("%s", method_name); 5376 Mat& img = *((Mat*)img_nativeObj); 5377 Point pt1((int)pt1_x, (int)pt1_y); 5378 Point pt2((int)pt2_x, (int)pt2_y); 5379 Scalar color(color_val0, color_val1, color_val2, color_val3); 5380 cv::rectangle( img, pt1, pt2, color ); 5381 return; 5382 } catch(const std::exception &e) { 5383 throwJavaException(env, &e, method_name); 5384 } catch (...) { 5385 throwJavaException(env, 0, method_name); 5386 } 5387 return; 5388 } 5389 5390 5391 5392 // 5393 // void circle(Mat& img, Point center, int radius, Scalar color, int thickness = 1, int lineType = LINE_8, int shift = 0) 5394 // 5395 5396 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_circle_10 (JNIEnv*, jclass, jlong, jdouble, jdouble, jint, jdouble, jdouble, jdouble, jdouble, jint, jint, jint); 5397 5398 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_circle_10 5399 (JNIEnv* env, jclass , jlong img_nativeObj, jdouble center_x, jdouble center_y, jint radius, jdouble color_val0, jdouble color_val1, jdouble color_val2, jdouble color_val3, jint thickness, jint lineType, jint shift) 5400 { 5401 static const char method_name[] = "imgproc::circle_10()"; 5402 try { 5403 LOGD("%s", method_name); 5404 Mat& img = *((Mat*)img_nativeObj); 5405 Point center((int)center_x, (int)center_y); 5406 Scalar color(color_val0, color_val1, color_val2, color_val3); 5407 cv::circle( img, center, (int)radius, color, (int)thickness, (int)lineType, (int)shift ); 5408 return; 5409 } catch(const std::exception &e) { 5410 throwJavaException(env, &e, method_name); 5411 } catch (...) { 5412 throwJavaException(env, 0, method_name); 5413 } 5414 return; 5415 } 5416 5417 5418 5419 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_circle_11 (JNIEnv*, jclass, jlong, jdouble, jdouble, jint, jdouble, jdouble, jdouble, jdouble, jint); 5420 5421 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_circle_11 5422 (JNIEnv* env, jclass , jlong img_nativeObj, jdouble center_x, jdouble center_y, jint radius, jdouble color_val0, jdouble color_val1, jdouble color_val2, jdouble color_val3, jint thickness) 5423 { 5424 static const char method_name[] = "imgproc::circle_11()"; 5425 try { 5426 LOGD("%s", method_name); 5427 Mat& img = *((Mat*)img_nativeObj); 5428 Point center((int)center_x, (int)center_y); 5429 Scalar color(color_val0, color_val1, color_val2, color_val3); 5430 cv::circle( img, center, (int)radius, color, (int)thickness ); 5431 return; 5432 } catch(const std::exception &e) { 5433 throwJavaException(env, &e, method_name); 5434 } catch (...) { 5435 throwJavaException(env, 0, method_name); 5436 } 5437 return; 5438 } 5439 5440 5441 5442 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_circle_12 (JNIEnv*, jclass, jlong, jdouble, jdouble, jint, jdouble, jdouble, jdouble, jdouble); 5443 5444 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_circle_12 5445 (JNIEnv* env, jclass , jlong img_nativeObj, jdouble center_x, jdouble center_y, jint radius, jdouble color_val0, jdouble color_val1, jdouble color_val2, jdouble color_val3) 5446 { 5447 static const char method_name[] = "imgproc::circle_12()"; 5448 try { 5449 LOGD("%s", method_name); 5450 Mat& img = *((Mat*)img_nativeObj); 5451 Point center((int)center_x, (int)center_y); 5452 Scalar color(color_val0, color_val1, color_val2, color_val3); 5453 cv::circle( img, center, (int)radius, color ); 5454 return; 5455 } catch(const std::exception &e) { 5456 throwJavaException(env, &e, method_name); 5457 } catch (...) { 5458 throwJavaException(env, 0, method_name); 5459 } 5460 return; 5461 } 5462 5463 5464 5465 // 5466 // void ellipse(Mat& img, Point center, Size axes, double angle, double startAngle, double endAngle, Scalar color, int thickness = 1, int lineType = LINE_8, int shift = 0) 5467 // 5468 5469 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_ellipse_10 (JNIEnv*, jclass, jlong, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jint, jint, jint); 5470 5471 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_ellipse_10 5472 (JNIEnv* env, jclass , jlong img_nativeObj, jdouble center_x, jdouble center_y, jdouble axes_width, jdouble axes_height, jdouble angle, jdouble startAngle, jdouble endAngle, jdouble color_val0, jdouble color_val1, jdouble color_val2, jdouble color_val3, jint thickness, jint lineType, jint shift) 5473 { 5474 static const char method_name[] = "imgproc::ellipse_10()"; 5475 try { 5476 LOGD("%s", method_name); 5477 Mat& img = *((Mat*)img_nativeObj); 5478 Point center((int)center_x, (int)center_y); 5479 Size axes((int)axes_width, (int)axes_height); 5480 Scalar color(color_val0, color_val1, color_val2, color_val3); 5481 cv::ellipse( img, center, axes, (double)angle, (double)startAngle, (double)endAngle, color, (int)thickness, (int)lineType, (int)shift ); 5482 return; 5483 } catch(const std::exception &e) { 5484 throwJavaException(env, &e, method_name); 5485 } catch (...) { 5486 throwJavaException(env, 0, method_name); 5487 } 5488 return; 5489 } 5490 5491 5492 5493 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_ellipse_11 (JNIEnv*, jclass, jlong, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jint); 5494 5495 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_ellipse_11 5496 (JNIEnv* env, jclass , jlong img_nativeObj, jdouble center_x, jdouble center_y, jdouble axes_width, jdouble axes_height, jdouble angle, jdouble startAngle, jdouble endAngle, jdouble color_val0, jdouble color_val1, jdouble color_val2, jdouble color_val3, jint thickness) 5497 { 5498 static const char method_name[] = "imgproc::ellipse_11()"; 5499 try { 5500 LOGD("%s", method_name); 5501 Mat& img = *((Mat*)img_nativeObj); 5502 Point center((int)center_x, (int)center_y); 5503 Size axes((int)axes_width, (int)axes_height); 5504 Scalar color(color_val0, color_val1, color_val2, color_val3); 5505 cv::ellipse( img, center, axes, (double)angle, (double)startAngle, (double)endAngle, color, (int)thickness ); 5506 return; 5507 } catch(const std::exception &e) { 5508 throwJavaException(env, &e, method_name); 5509 } catch (...) { 5510 throwJavaException(env, 0, method_name); 5511 } 5512 return; 5513 } 5514 5515 5516 5517 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_ellipse_12 (JNIEnv*, jclass, jlong, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble); 5518 5519 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_ellipse_12 5520 (JNIEnv* env, jclass , jlong img_nativeObj, jdouble center_x, jdouble center_y, jdouble axes_width, jdouble axes_height, jdouble angle, jdouble startAngle, jdouble endAngle, jdouble color_val0, jdouble color_val1, jdouble color_val2, jdouble color_val3) 5521 { 5522 static const char method_name[] = "imgproc::ellipse_12()"; 5523 try { 5524 LOGD("%s", method_name); 5525 Mat& img = *((Mat*)img_nativeObj); 5526 Point center((int)center_x, (int)center_y); 5527 Size axes((int)axes_width, (int)axes_height); 5528 Scalar color(color_val0, color_val1, color_val2, color_val3); 5529 cv::ellipse( img, center, axes, (double)angle, (double)startAngle, (double)endAngle, color ); 5530 return; 5531 } catch(const std::exception &e) { 5532 throwJavaException(env, &e, method_name); 5533 } catch (...) { 5534 throwJavaException(env, 0, method_name); 5535 } 5536 return; 5537 } 5538 5539 5540 5541 // 5542 // void ellipse(Mat& img, RotatedRect box, Scalar color, int thickness = 1, int lineType = LINE_8) 5543 // 5544 5545 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_ellipse_13 (JNIEnv*, jclass, jlong, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jint, jint); 5546 5547 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_ellipse_13 5548 (JNIEnv* env, jclass , jlong img_nativeObj, jdouble box_center_x, jdouble box_center_y, jdouble box_size_width, jdouble box_size_height, jdouble box_angle, jdouble color_val0, jdouble color_val1, jdouble color_val2, jdouble color_val3, jint thickness, jint lineType) 5549 { 5550 static const char method_name[] = "imgproc::ellipse_13()"; 5551 try { 5552 LOGD("%s", method_name); 5553 Mat& img = *((Mat*)img_nativeObj); 5554 RotatedRect box(cv::Point2f(box_center_x, box_center_y), cv::Size2f(box_size_width, box_size_height), box_angle); 5555 Scalar color(color_val0, color_val1, color_val2, color_val3); 5556 cv::ellipse( img, box, color, (int)thickness, (int)lineType ); 5557 return; 5558 } catch(const std::exception &e) { 5559 throwJavaException(env, &e, method_name); 5560 } catch (...) { 5561 throwJavaException(env, 0, method_name); 5562 } 5563 return; 5564 } 5565 5566 5567 5568 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_ellipse_14 (JNIEnv*, jclass, jlong, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jint); 5569 5570 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_ellipse_14 5571 (JNIEnv* env, jclass , jlong img_nativeObj, jdouble box_center_x, jdouble box_center_y, jdouble box_size_width, jdouble box_size_height, jdouble box_angle, jdouble color_val0, jdouble color_val1, jdouble color_val2, jdouble color_val3, jint thickness) 5572 { 5573 static const char method_name[] = "imgproc::ellipse_14()"; 5574 try { 5575 LOGD("%s", method_name); 5576 Mat& img = *((Mat*)img_nativeObj); 5577 RotatedRect box(cv::Point2f(box_center_x, box_center_y), cv::Size2f(box_size_width, box_size_height), box_angle); 5578 Scalar color(color_val0, color_val1, color_val2, color_val3); 5579 cv::ellipse( img, box, color, (int)thickness ); 5580 return; 5581 } catch(const std::exception &e) { 5582 throwJavaException(env, &e, method_name); 5583 } catch (...) { 5584 throwJavaException(env, 0, method_name); 5585 } 5586 return; 5587 } 5588 5589 5590 5591 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_ellipse_15 (JNIEnv*, jclass, jlong, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble); 5592 5593 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_ellipse_15 5594 (JNIEnv* env, jclass , jlong img_nativeObj, jdouble box_center_x, jdouble box_center_y, jdouble box_size_width, jdouble box_size_height, jdouble box_angle, jdouble color_val0, jdouble color_val1, jdouble color_val2, jdouble color_val3) 5595 { 5596 static const char method_name[] = "imgproc::ellipse_15()"; 5597 try { 5598 LOGD("%s", method_name); 5599 Mat& img = *((Mat*)img_nativeObj); 5600 RotatedRect box(cv::Point2f(box_center_x, box_center_y), cv::Size2f(box_size_width, box_size_height), box_angle); 5601 Scalar color(color_val0, color_val1, color_val2, color_val3); 5602 cv::ellipse( img, box, color ); 5603 return; 5604 } catch(const std::exception &e) { 5605 throwJavaException(env, &e, method_name); 5606 } catch (...) { 5607 throwJavaException(env, 0, method_name); 5608 } 5609 return; 5610 } 5611 5612 5613 5614 // 5615 // void fillConvexPoly(Mat& img, vector_Point points, Scalar color, int lineType = LINE_8, int shift = 0) 5616 // 5617 5618 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_fillConvexPoly_10 (JNIEnv*, jclass, jlong, jlong, jdouble, jdouble, jdouble, jdouble, jint, jint); 5619 5620 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_fillConvexPoly_10 5621 (JNIEnv* env, jclass , jlong img_nativeObj, jlong points_mat_nativeObj, jdouble color_val0, jdouble color_val1, jdouble color_val2, jdouble color_val3, jint lineType, jint shift) 5622 { 5623 static const char method_name[] = "imgproc::fillConvexPoly_10()"; 5624 try { 5625 LOGD("%s", method_name); 5626 std::vector<Point> points; 5627 Mat& points_mat = *((Mat*)points_mat_nativeObj); 5628 Mat_to_vector_Point( points_mat, points ); 5629 Mat& img = *((Mat*)img_nativeObj); 5630 Scalar color(color_val0, color_val1, color_val2, color_val3); 5631 cv::fillConvexPoly( img, points, color, (int)lineType, (int)shift ); 5632 return; 5633 } catch(const std::exception &e) { 5634 throwJavaException(env, &e, method_name); 5635 } catch (...) { 5636 throwJavaException(env, 0, method_name); 5637 } 5638 return; 5639 } 5640 5641 5642 5643 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_fillConvexPoly_11 (JNIEnv*, jclass, jlong, jlong, jdouble, jdouble, jdouble, jdouble); 5644 5645 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_fillConvexPoly_11 5646 (JNIEnv* env, jclass , jlong img_nativeObj, jlong points_mat_nativeObj, jdouble color_val0, jdouble color_val1, jdouble color_val2, jdouble color_val3) 5647 { 5648 static const char method_name[] = "imgproc::fillConvexPoly_11()"; 5649 try { 5650 LOGD("%s", method_name); 5651 std::vector<Point> points; 5652 Mat& points_mat = *((Mat*)points_mat_nativeObj); 5653 Mat_to_vector_Point( points_mat, points ); 5654 Mat& img = *((Mat*)img_nativeObj); 5655 Scalar color(color_val0, color_val1, color_val2, color_val3); 5656 cv::fillConvexPoly( img, points, color ); 5657 return; 5658 } catch(const std::exception &e) { 5659 throwJavaException(env, &e, method_name); 5660 } catch (...) { 5661 throwJavaException(env, 0, method_name); 5662 } 5663 return; 5664 } 5665 5666 5667 5668 // 5669 // void fillPoly(Mat& img, vector_vector_Point pts, Scalar color, int lineType = LINE_8, int shift = 0, Point offset = Point()) 5670 // 5671 5672 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_fillPoly_10 (JNIEnv*, jclass, jlong, jlong, jdouble, jdouble, jdouble, jdouble, jint, jint, jdouble, jdouble); 5673 5674 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_fillPoly_10 5675 (JNIEnv* env, jclass , jlong img_nativeObj, jlong pts_mat_nativeObj, jdouble color_val0, jdouble color_val1, jdouble color_val2, jdouble color_val3, jint lineType, jint shift, jdouble offset_x, jdouble offset_y) 5676 { 5677 static const char method_name[] = "imgproc::fillPoly_10()"; 5678 try { 5679 LOGD("%s", method_name); 5680 std::vector< std::vector<Point> > pts; 5681 Mat& pts_mat = *((Mat*)pts_mat_nativeObj); 5682 Mat_to_vector_vector_Point( pts_mat, pts ); 5683 Mat& img = *((Mat*)img_nativeObj); 5684 Scalar color(color_val0, color_val1, color_val2, color_val3); 5685 Point offset((int)offset_x, (int)offset_y); 5686 cv::fillPoly( img, pts, color, (int)lineType, (int)shift, offset ); 5687 return; 5688 } catch(const std::exception &e) { 5689 throwJavaException(env, &e, method_name); 5690 } catch (...) { 5691 throwJavaException(env, 0, method_name); 5692 } 5693 return; 5694 } 5695 5696 5697 5698 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_fillPoly_11 (JNIEnv*, jclass, jlong, jlong, jdouble, jdouble, jdouble, jdouble); 5699 5700 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_fillPoly_11 5701 (JNIEnv* env, jclass , jlong img_nativeObj, jlong pts_mat_nativeObj, jdouble color_val0, jdouble color_val1, jdouble color_val2, jdouble color_val3) 5702 { 5703 static const char method_name[] = "imgproc::fillPoly_11()"; 5704 try { 5705 LOGD("%s", method_name); 5706 std::vector< std::vector<Point> > pts; 5707 Mat& pts_mat = *((Mat*)pts_mat_nativeObj); 5708 Mat_to_vector_vector_Point( pts_mat, pts ); 5709 Mat& img = *((Mat*)img_nativeObj); 5710 Scalar color(color_val0, color_val1, color_val2, color_val3); 5711 cv::fillPoly( img, pts, color ); 5712 return; 5713 } catch(const std::exception &e) { 5714 throwJavaException(env, &e, method_name); 5715 } catch (...) { 5716 throwJavaException(env, 0, method_name); 5717 } 5718 return; 5719 } 5720 5721 5722 5723 // 5724 // void polylines(Mat& img, vector_vector_Point pts, bool isClosed, Scalar color, int thickness = 1, int lineType = LINE_8, int shift = 0) 5725 // 5726 5727 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_polylines_10 (JNIEnv*, jclass, jlong, jlong, jboolean, jdouble, jdouble, jdouble, jdouble, jint, jint, jint); 5728 5729 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_polylines_10 5730 (JNIEnv* env, jclass , jlong img_nativeObj, jlong pts_mat_nativeObj, jboolean isClosed, jdouble color_val0, jdouble color_val1, jdouble color_val2, jdouble color_val3, jint thickness, jint lineType, jint shift) 5731 { 5732 static const char method_name[] = "imgproc::polylines_10()"; 5733 try { 5734 LOGD("%s", method_name); 5735 std::vector< std::vector<Point> > pts; 5736 Mat& pts_mat = *((Mat*)pts_mat_nativeObj); 5737 Mat_to_vector_vector_Point( pts_mat, pts ); 5738 Mat& img = *((Mat*)img_nativeObj); 5739 Scalar color(color_val0, color_val1, color_val2, color_val3); 5740 cv::polylines( img, pts, (bool)isClosed, color, (int)thickness, (int)lineType, (int)shift ); 5741 return; 5742 } catch(const std::exception &e) { 5743 throwJavaException(env, &e, method_name); 5744 } catch (...) { 5745 throwJavaException(env, 0, method_name); 5746 } 5747 return; 5748 } 5749 5750 5751 5752 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_polylines_11 (JNIEnv*, jclass, jlong, jlong, jboolean, jdouble, jdouble, jdouble, jdouble, jint); 5753 5754 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_polylines_11 5755 (JNIEnv* env, jclass , jlong img_nativeObj, jlong pts_mat_nativeObj, jboolean isClosed, jdouble color_val0, jdouble color_val1, jdouble color_val2, jdouble color_val3, jint thickness) 5756 { 5757 static const char method_name[] = "imgproc::polylines_11()"; 5758 try { 5759 LOGD("%s", method_name); 5760 std::vector< std::vector<Point> > pts; 5761 Mat& pts_mat = *((Mat*)pts_mat_nativeObj); 5762 Mat_to_vector_vector_Point( pts_mat, pts ); 5763 Mat& img = *((Mat*)img_nativeObj); 5764 Scalar color(color_val0, color_val1, color_val2, color_val3); 5765 cv::polylines( img, pts, (bool)isClosed, color, (int)thickness ); 5766 return; 5767 } catch(const std::exception &e) { 5768 throwJavaException(env, &e, method_name); 5769 } catch (...) { 5770 throwJavaException(env, 0, method_name); 5771 } 5772 return; 5773 } 5774 5775 5776 5777 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_polylines_12 (JNIEnv*, jclass, jlong, jlong, jboolean, jdouble, jdouble, jdouble, jdouble); 5778 5779 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_polylines_12 5780 (JNIEnv* env, jclass , jlong img_nativeObj, jlong pts_mat_nativeObj, jboolean isClosed, jdouble color_val0, jdouble color_val1, jdouble color_val2, jdouble color_val3) 5781 { 5782 static const char method_name[] = "imgproc::polylines_12()"; 5783 try { 5784 LOGD("%s", method_name); 5785 std::vector< std::vector<Point> > pts; 5786 Mat& pts_mat = *((Mat*)pts_mat_nativeObj); 5787 Mat_to_vector_vector_Point( pts_mat, pts ); 5788 Mat& img = *((Mat*)img_nativeObj); 5789 Scalar color(color_val0, color_val1, color_val2, color_val3); 5790 cv::polylines( img, pts, (bool)isClosed, color ); 5791 return; 5792 } catch(const std::exception &e) { 5793 throwJavaException(env, &e, method_name); 5794 } catch (...) { 5795 throwJavaException(env, 0, method_name); 5796 } 5797 return; 5798 } 5799 5800 5801 5802 // 5803 // void drawContours(Mat& image, vector_vector_Point contours, int contourIdx, Scalar color, int thickness = 1, int lineType = LINE_8, Mat hierarchy = Mat(), int maxLevel = INT_MAX, Point offset = Point()) 5804 // 5805 5806 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_drawContours_10 (JNIEnv*, jclass, jlong, jlong, jint, jdouble, jdouble, jdouble, jdouble, jint, jint, jlong, jint, jdouble, jdouble); 5807 5808 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_drawContours_10 5809 (JNIEnv* env, jclass , jlong image_nativeObj, jlong contours_mat_nativeObj, jint contourIdx, jdouble color_val0, jdouble color_val1, jdouble color_val2, jdouble color_val3, jint thickness, jint lineType, jlong hierarchy_nativeObj, jint maxLevel, jdouble offset_x, jdouble offset_y) 5810 { 5811 static const char method_name[] = "imgproc::drawContours_10()"; 5812 try { 5813 LOGD("%s", method_name); 5814 std::vector< std::vector<Point> > contours; 5815 Mat& contours_mat = *((Mat*)contours_mat_nativeObj); 5816 Mat_to_vector_vector_Point( contours_mat, contours ); 5817 Mat& image = *((Mat*)image_nativeObj); 5818 Scalar color(color_val0, color_val1, color_val2, color_val3); 5819 Mat& hierarchy = *((Mat*)hierarchy_nativeObj); 5820 Point offset((int)offset_x, (int)offset_y); 5821 cv::drawContours( image, contours, (int)contourIdx, color, (int)thickness, (int)lineType, hierarchy, (int)maxLevel, offset ); 5822 return; 5823 } catch(const std::exception &e) { 5824 throwJavaException(env, &e, method_name); 5825 } catch (...) { 5826 throwJavaException(env, 0, method_name); 5827 } 5828 return; 5829 } 5830 5831 5832 5833 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_drawContours_11 (JNIEnv*, jclass, jlong, jlong, jint, jdouble, jdouble, jdouble, jdouble, jint); 5834 5835 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_drawContours_11 5836 (JNIEnv* env, jclass , jlong image_nativeObj, jlong contours_mat_nativeObj, jint contourIdx, jdouble color_val0, jdouble color_val1, jdouble color_val2, jdouble color_val3, jint thickness) 5837 { 5838 static const char method_name[] = "imgproc::drawContours_11()"; 5839 try { 5840 LOGD("%s", method_name); 5841 std::vector< std::vector<Point> > contours; 5842 Mat& contours_mat = *((Mat*)contours_mat_nativeObj); 5843 Mat_to_vector_vector_Point( contours_mat, contours ); 5844 Mat& image = *((Mat*)image_nativeObj); 5845 Scalar color(color_val0, color_val1, color_val2, color_val3); 5846 cv::drawContours( image, contours, (int)contourIdx, color, (int)thickness ); 5847 return; 5848 } catch(const std::exception &e) { 5849 throwJavaException(env, &e, method_name); 5850 } catch (...) { 5851 throwJavaException(env, 0, method_name); 5852 } 5853 return; 5854 } 5855 5856 5857 5858 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_drawContours_12 (JNIEnv*, jclass, jlong, jlong, jint, jdouble, jdouble, jdouble, jdouble); 5859 5860 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_drawContours_12 5861 (JNIEnv* env, jclass , jlong image_nativeObj, jlong contours_mat_nativeObj, jint contourIdx, jdouble color_val0, jdouble color_val1, jdouble color_val2, jdouble color_val3) 5862 { 5863 static const char method_name[] = "imgproc::drawContours_12()"; 5864 try { 5865 LOGD("%s", method_name); 5866 std::vector< std::vector<Point> > contours; 5867 Mat& contours_mat = *((Mat*)contours_mat_nativeObj); 5868 Mat_to_vector_vector_Point( contours_mat, contours ); 5869 Mat& image = *((Mat*)image_nativeObj); 5870 Scalar color(color_val0, color_val1, color_val2, color_val3); 5871 cv::drawContours( image, contours, (int)contourIdx, color ); 5872 return; 5873 } catch(const std::exception &e) { 5874 throwJavaException(env, &e, method_name); 5875 } catch (...) { 5876 throwJavaException(env, 0, method_name); 5877 } 5878 return; 5879 } 5880 5881 5882 5883 // 5884 // bool clipLine(Rect imgRect, Point& pt1, Point& pt2) 5885 // 5886 5887 JNIEXPORT jboolean JNICALL Java_org_opencv_imgproc_Imgproc_clipLine_10 (JNIEnv*, jclass, jint, jint, jint, jint, jdouble, jdouble, jdoubleArray, jdouble, jdouble, jdoubleArray); 5888 5889 JNIEXPORT jboolean JNICALL Java_org_opencv_imgproc_Imgproc_clipLine_10 5890 (JNIEnv* env, jclass , jint imgRect_x, jint imgRect_y, jint imgRect_width, jint imgRect_height, jdouble pt1_x, jdouble pt1_y, jdoubleArray pt1_out, jdouble pt2_x, jdouble pt2_y, jdoubleArray pt2_out) 5891 { 5892 static const char method_name[] = "imgproc::clipLine_10()"; 5893 try { 5894 LOGD("%s", method_name); 5895 Rect imgRect(imgRect_x, imgRect_y, imgRect_width, imgRect_height); 5896 Point pt1((int)pt1_x, (int)pt1_y); 5897 Point pt2((int)pt2_x, (int)pt2_y); 5898 bool _retval_ = cv::clipLine( imgRect, pt1, pt2 ); 5899 jdouble tmp_pt1[2] = {pt1.x, pt1.y}; env->SetDoubleArrayRegion(pt1_out, 0, 2, tmp_pt1); jdouble tmp_pt2[2] = {pt2.x, pt2.y}; env->SetDoubleArrayRegion(pt2_out, 0, 2, tmp_pt2); 5900 return _retval_; 5901 } catch(const std::exception &e) { 5902 throwJavaException(env, &e, method_name); 5903 } catch (...) { 5904 throwJavaException(env, 0, method_name); 5905 } 5906 return 0; 5907 } 5908 5909 5910 5911 // 5912 // void ellipse2Poly(Point center, Size axes, int angle, int arcStart, int arcEnd, int delta, vector_Point& pts) 5913 // 5914 5915 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_ellipse2Poly_10 (JNIEnv*, jclass, jdouble, jdouble, jdouble, jdouble, jint, jint, jint, jint, jlong); 5916 5917 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_ellipse2Poly_10 5918 (JNIEnv* env, jclass , jdouble center_x, jdouble center_y, jdouble axes_width, jdouble axes_height, jint angle, jint arcStart, jint arcEnd, jint delta, jlong pts_mat_nativeObj) 5919 { 5920 static const char method_name[] = "imgproc::ellipse2Poly_10()"; 5921 try { 5922 LOGD("%s", method_name); 5923 std::vector<Point> pts; 5924 Mat& pts_mat = *((Mat*)pts_mat_nativeObj); 5925 Point center((int)center_x, (int)center_y); 5926 Size axes((int)axes_width, (int)axes_height); 5927 cv::ellipse2Poly( center, axes, (int)angle, (int)arcStart, (int)arcEnd, (int)delta, pts ); 5928 vector_Point_to_Mat( pts, pts_mat ); 5929 return; 5930 } catch(const std::exception &e) { 5931 throwJavaException(env, &e, method_name); 5932 } catch (...) { 5933 throwJavaException(env, 0, method_name); 5934 } 5935 return; 5936 } 5937 5938 5939 5940 // 5941 // void putText(Mat& img, String text, Point org, int fontFace, double fontScale, Scalar color, int thickness = 1, int lineType = LINE_8, bool bottomLeftOrigin = false) 5942 // 5943 5944 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_putText_10 (JNIEnv*, jclass, jlong, jstring, jdouble, jdouble, jint, jdouble, jdouble, jdouble, jdouble, jdouble, jint, jint, jboolean); 5945 5946 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_putText_10 5947 (JNIEnv* env, jclass , jlong img_nativeObj, jstring text, jdouble org_x, jdouble org_y, jint fontFace, jdouble fontScale, jdouble color_val0, jdouble color_val1, jdouble color_val2, jdouble color_val3, jint thickness, jint lineType, jboolean bottomLeftOrigin) 5948 { 5949 static const char method_name[] = "imgproc::putText_10()"; 5950 try { 5951 LOGD("%s", method_name); 5952 Mat& img = *((Mat*)img_nativeObj); 5953 const char* utf_text = env->GetStringUTFChars(text, 0); String n_text( utf_text ? utf_text : "" ); env->ReleaseStringUTFChars(text, utf_text); 5954 Point org((int)org_x, (int)org_y); 5955 Scalar color(color_val0, color_val1, color_val2, color_val3); 5956 cv::putText( img, n_text, org, (int)fontFace, (double)fontScale, color, (int)thickness, (int)lineType, (bool)bottomLeftOrigin ); 5957 return; 5958 } catch(const std::exception &e) { 5959 throwJavaException(env, &e, method_name); 5960 } catch (...) { 5961 throwJavaException(env, 0, method_name); 5962 } 5963 return; 5964 } 5965 5966 5967 5968 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_putText_11 (JNIEnv*, jclass, jlong, jstring, jdouble, jdouble, jint, jdouble, jdouble, jdouble, jdouble, jdouble, jint); 5969 5970 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_putText_11 5971 (JNIEnv* env, jclass , jlong img_nativeObj, jstring text, jdouble org_x, jdouble org_y, jint fontFace, jdouble fontScale, jdouble color_val0, jdouble color_val1, jdouble color_val2, jdouble color_val3, jint thickness) 5972 { 5973 static const char method_name[] = "imgproc::putText_11()"; 5974 try { 5975 LOGD("%s", method_name); 5976 Mat& img = *((Mat*)img_nativeObj); 5977 const char* utf_text = env->GetStringUTFChars(text, 0); String n_text( utf_text ? utf_text : "" ); env->ReleaseStringUTFChars(text, utf_text); 5978 Point org((int)org_x, (int)org_y); 5979 Scalar color(color_val0, color_val1, color_val2, color_val3); 5980 cv::putText( img, n_text, org, (int)fontFace, (double)fontScale, color, (int)thickness ); 5981 return; 5982 } catch(const std::exception &e) { 5983 throwJavaException(env, &e, method_name); 5984 } catch (...) { 5985 throwJavaException(env, 0, method_name); 5986 } 5987 return; 5988 } 5989 5990 5991 5992 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_putText_12 (JNIEnv*, jclass, jlong, jstring, jdouble, jdouble, jint, jdouble, jdouble, jdouble, jdouble, jdouble); 5993 5994 JNIEXPORT void JNICALL Java_org_opencv_imgproc_Imgproc_putText_12 5995 (JNIEnv* env, jclass , jlong img_nativeObj, jstring text, jdouble org_x, jdouble org_y, jint fontFace, jdouble fontScale, jdouble color_val0, jdouble color_val1, jdouble color_val2, jdouble color_val3) 5996 { 5997 static const char method_name[] = "imgproc::putText_12()"; 5998 try { 5999 LOGD("%s", method_name); 6000 Mat& img = *((Mat*)img_nativeObj); 6001 const char* utf_text = env->GetStringUTFChars(text, 0); String n_text( utf_text ? utf_text : "" ); env->ReleaseStringUTFChars(text, utf_text); 6002 Point org((int)org_x, (int)org_y); 6003 Scalar color(color_val0, color_val1, color_val2, color_val3); 6004 cv::putText( img, n_text, org, (int)fontFace, (double)fontScale, color ); 6005 return; 6006 } catch(const std::exception &e) { 6007 throwJavaException(env, &e, method_name); 6008 } catch (...) { 6009 throwJavaException(env, 0, method_name); 6010 } 6011 return; 6012 } 6013 6014 6015 6016 // C++: Size getTextSize(const String& text, int fontFace, double fontScale, int thickness, int* baseLine); 6017 JNIEXPORT jdoubleArray JNICALL Java_org_opencv_imgproc_Imgproc_n_1getTextSize (JNIEnv*, jclass, jstring, jint, jdouble, jint, jintArray); 6018 6019 JNIEXPORT jdoubleArray JNICALL Java_org_opencv_imgproc_Imgproc_n_1getTextSize 6020 (JNIEnv* env, jclass, jstring text, jint fontFace, jdouble fontScale, jint thickness, jintArray baseLine) 6021 { 6022 try { 6023 LOGD("Core::n_1getTextSize()"); 6024 jdoubleArray result; 6025 result = env->NewDoubleArray(2); 6026 if (result == NULL) { 6027 return NULL; /* out of memory error thrown */ 6028 } 6029 6030 const char* utf_text = env->GetStringUTFChars(text, 0); 6031 String n_text( utf_text ? utf_text : "" ); 6032 env->ReleaseStringUTFChars(text, utf_text); 6033 6034 int _baseLine; 6035 int* pbaseLine = 0; 6036 6037 if (baseLine != NULL) 6038 pbaseLine = &_baseLine; 6039 6040 cv::Size rsize = cv::getTextSize(n_text, (int)fontFace, (double)fontScale, (int)thickness, pbaseLine); 6041 6042 jdouble fill[2]; 6043 fill[0]=rsize.width; 6044 fill[1]=rsize.height; 6045 6046 env->SetDoubleArrayRegion(result, 0, 2, fill); 6047 6048 if (baseLine != NULL) { 6049 jint jbaseLine = (jint)(*pbaseLine); 6050 env->SetIntArrayRegion(baseLine, 0, 1, &jbaseLine); 6051 } 6052 6053 return result; 6054 6055 } catch(const cv::Exception& e) { 6056 LOGD("Imgproc::n_1getTextSize() catched cv::Exception: %s", e.what()); 6057 jclass je = env->FindClass("org/opencv/core/CvException"); 6058 if(!je) je = env->FindClass("java/lang/Exception"); 6059 env->ThrowNew(je, e.what()); 6060 return NULL; 6061 } catch (...) { 6062 LOGD("Imgproc::n_1getTextSize() catched unknown exception (...)"); 6063 jclass je = env->FindClass("java/lang/Exception"); 6064 env->ThrowNew(je, "Unknown exception in JNI code {core::getTextSize()}"); 6065 return NULL; 6066 } 6067 } 6068 6069 // 6070 // void apply(Mat src, Mat& dst) 6071 // 6072 6073 JNIEXPORT void JNICALL Java_org_opencv_imgproc_CLAHE_apply_10 (JNIEnv*, jclass, jlong, jlong, jlong); 6074 6075 JNIEXPORT void JNICALL Java_org_opencv_imgproc_CLAHE_apply_10 6076 (JNIEnv* env, jclass , jlong self, jlong src_nativeObj, jlong dst_nativeObj) 6077 { 6078 static const char method_name[] = "imgproc::apply_10()"; 6079 try { 6080 LOGD("%s", method_name); 6081 Ptr<cv::CLAHE>* me = (Ptr<cv::CLAHE>*) self; //TODO: check for NULL 6082 Mat& src = *((Mat*)src_nativeObj); 6083 Mat& dst = *((Mat*)dst_nativeObj); 6084 (*me)->apply( src, dst ); 6085 return; 6086 } catch(const std::exception &e) { 6087 throwJavaException(env, &e, method_name); 6088 } catch (...) { 6089 throwJavaException(env, 0, method_name); 6090 } 6091 return; 6092 } 6093 6094 6095 6096 // 6097 // void setClipLimit(double clipLimit) 6098 // 6099 6100 JNIEXPORT void JNICALL Java_org_opencv_imgproc_CLAHE_setClipLimit_10 (JNIEnv*, jclass, jlong, jdouble); 6101 6102 JNIEXPORT void JNICALL Java_org_opencv_imgproc_CLAHE_setClipLimit_10 6103 (JNIEnv* env, jclass , jlong self, jdouble clipLimit) 6104 { 6105 static const char method_name[] = "imgproc::setClipLimit_10()"; 6106 try { 6107 LOGD("%s", method_name); 6108 Ptr<cv::CLAHE>* me = (Ptr<cv::CLAHE>*) self; //TODO: check for NULL 6109 (*me)->setClipLimit( (double)clipLimit ); 6110 return; 6111 } catch(const std::exception &e) { 6112 throwJavaException(env, &e, method_name); 6113 } catch (...) { 6114 throwJavaException(env, 0, method_name); 6115 } 6116 return; 6117 } 6118 6119 6120 6121 // 6122 // double getClipLimit() 6123 // 6124 6125 JNIEXPORT jdouble JNICALL Java_org_opencv_imgproc_CLAHE_getClipLimit_10 (JNIEnv*, jclass, jlong); 6126 6127 JNIEXPORT jdouble JNICALL Java_org_opencv_imgproc_CLAHE_getClipLimit_10 6128 (JNIEnv* env, jclass , jlong self) 6129 { 6130 static const char method_name[] = "imgproc::getClipLimit_10()"; 6131 try { 6132 LOGD("%s", method_name); 6133 Ptr<cv::CLAHE>* me = (Ptr<cv::CLAHE>*) self; //TODO: check for NULL 6134 double _retval_ = (*me)->getClipLimit( ); 6135 return _retval_; 6136 } catch(const std::exception &e) { 6137 throwJavaException(env, &e, method_name); 6138 } catch (...) { 6139 throwJavaException(env, 0, method_name); 6140 } 6141 return 0; 6142 } 6143 6144 6145 6146 // 6147 // void setTilesGridSize(Size tileGridSize) 6148 // 6149 6150 JNIEXPORT void JNICALL Java_org_opencv_imgproc_CLAHE_setTilesGridSize_10 (JNIEnv*, jclass, jlong, jdouble, jdouble); 6151 6152 JNIEXPORT void JNICALL Java_org_opencv_imgproc_CLAHE_setTilesGridSize_10 6153 (JNIEnv* env, jclass , jlong self, jdouble tileGridSize_width, jdouble tileGridSize_height) 6154 { 6155 static const char method_name[] = "imgproc::setTilesGridSize_10()"; 6156 try { 6157 LOGD("%s", method_name); 6158 Ptr<cv::CLAHE>* me = (Ptr<cv::CLAHE>*) self; //TODO: check for NULL 6159 Size tileGridSize((int)tileGridSize_width, (int)tileGridSize_height); 6160 (*me)->setTilesGridSize( tileGridSize ); 6161 return; 6162 } catch(const std::exception &e) { 6163 throwJavaException(env, &e, method_name); 6164 } catch (...) { 6165 throwJavaException(env, 0, method_name); 6166 } 6167 return; 6168 } 6169 6170 6171 6172 // 6173 // Size getTilesGridSize() 6174 // 6175 6176 JNIEXPORT jdoubleArray JNICALL Java_org_opencv_imgproc_CLAHE_getTilesGridSize_10 (JNIEnv*, jclass, jlong); 6177 6178 JNIEXPORT jdoubleArray JNICALL Java_org_opencv_imgproc_CLAHE_getTilesGridSize_10 6179 (JNIEnv* env, jclass , jlong self) 6180 { 6181 static const char method_name[] = "imgproc::getTilesGridSize_10()"; 6182 try { 6183 LOGD("%s", method_name); 6184 Ptr<cv::CLAHE>* me = (Ptr<cv::CLAHE>*) self; //TODO: check for NULL 6185 Size _retval_ = (*me)->getTilesGridSize( ); 6186 jdoubleArray _da_retval_ = env->NewDoubleArray(2); jdouble _tmp_retval_[2] = {_retval_.width, _retval_.height}; env->SetDoubleArrayRegion(_da_retval_, 0, 2, _tmp_retval_); 6187 return _da_retval_; 6188 } catch(const std::exception &e) { 6189 throwJavaException(env, &e, method_name); 6190 } catch (...) { 6191 throwJavaException(env, 0, method_name); 6192 } 6193 return 0; 6194 } 6195 6196 6197 6198 // 6199 // void collectGarbage() 6200 // 6201 6202 JNIEXPORT void JNICALL Java_org_opencv_imgproc_CLAHE_collectGarbage_10 (JNIEnv*, jclass, jlong); 6203 6204 JNIEXPORT void JNICALL Java_org_opencv_imgproc_CLAHE_collectGarbage_10 6205 (JNIEnv* env, jclass , jlong self) 6206 { 6207 static const char method_name[] = "imgproc::collectGarbage_10()"; 6208 try { 6209 LOGD("%s", method_name); 6210 Ptr<cv::CLAHE>* me = (Ptr<cv::CLAHE>*) self; //TODO: check for NULL 6211 (*me)->collectGarbage( ); 6212 return; 6213 } catch(const std::exception &e) { 6214 throwJavaException(env, &e, method_name); 6215 } catch (...) { 6216 throwJavaException(env, 0, method_name); 6217 } 6218 return; 6219 } 6220 6221 6222 6223 // 6224 // native support for java finalize() 6225 // static void Ptr<cv::CLAHE>::delete( __int64 self ) 6226 // 6227 JNIEXPORT void JNICALL Java_org_opencv_imgproc_CLAHE_delete(JNIEnv*, jclass, jlong); 6228 6229 JNIEXPORT void JNICALL Java_org_opencv_imgproc_CLAHE_delete 6230 (JNIEnv*, jclass, jlong self) 6231 { 6232 delete (Ptr<cv::CLAHE>*) self; 6233 } 6234 6235 6236 6237 } // extern "C" 6238 6239 #endif // HAVE_OPENCV_IMGPROC 6240
