opencv41/src/main/java/org/opencv/features2d/Params.java

   1 //
   2 // This file is auto-generated. Please don't modify it!
   3 //
   4 package org.opencv.features2d;
   5
   6
   7
   8 // C++: class Params
   9 //javadoc: Params
  10
  11 public class Params {
  12
  13     protected final long nativeObj;
  14     protected Params(long addr) { nativeObj = addr; }
  15
  16     public long getNativeObjAddr() { return nativeObj; }
  17
  18     // internal usage only
  19     public static Params __fromPtr__(long addr) { return new Params(addr); }
  20
  21     //
  22     // C++:   cv::SimpleBlobDetector::Params::Params()
  23     //
  24
  25     //javadoc: Params::Params()
  26     public   Params()
  27     {
  28
  29         nativeObj = Params_0();
  30
  31         return;
  32     }
  33
  34
  35     //
  36     // C++: float Params::thresholdStep
  37     //
  38
  39     //javadoc: Params::get_thresholdStep()
  40     public  float get_thresholdStep()
  41     {
  42
  43         float retVal = get_thresholdStep_0(nativeObj);
  44
  45         return retVal;
  46     }
  47
  48
  49     //
  50     // C++: void Params::thresholdStep
  51     //
  52
  53     //javadoc: Params::set_thresholdStep(thresholdStep)
  54     public  void set_thresholdStep(float thresholdStep)
  55     {
  56
  57         set_thresholdStep_0(nativeObj, thresholdStep);
  58
  59         return;
  60     }
  61
  62
  63     //
  64     // C++: float Params::minThreshold
  65     //
  66
  67     //javadoc: Params::get_minThreshold()
  68     public  float get_minThreshold()
  69     {
  70
  71         float retVal = get_minThreshold_0(nativeObj);
  72
  73         return retVal;
  74     }
  75
  76
  77     //
  78     // C++: void Params::minThreshold
  79     //
  80
  81     //javadoc: Params::set_minThreshold(minThreshold)
  82     public  void set_minThreshold(float minThreshold)
  83     {
  84
  85         set_minThreshold_0(nativeObj, minThreshold);
  86
  87         return;
  88     }
  89
  90
  91     //
  92     // C++: float Params::maxThreshold
  93     //
  94
  95     //javadoc: Params::get_maxThreshold()
  96     public  float get_maxThreshold()
  97     {
  98
  99         float retVal = get_maxThreshold_0(nativeObj);
 100
 101         return retVal;
 102     }
 103
 104
 105     //
 106     // C++: void Params::maxThreshold
 107     //
 108
 109     //javadoc: Params::set_maxThreshold(maxThreshold)
 110     public  void set_maxThreshold(float maxThreshold)
 111     {
 112
 113         set_maxThreshold_0(nativeObj, maxThreshold);
 114
 115         return;
 116     }
 117
 118
 119     //
 120     // C++: size_t Params::minRepeatability
 121     //
 122
 123     //javadoc: Params::get_minRepeatability()
 124     public  long get_minRepeatability()
 125     {
 126
 127         long retVal = get_minRepeatability_0(nativeObj);
 128
 129         return retVal;
 130     }
 131
 132
 133     //
 134     // C++: void Params::minRepeatability
 135     //
 136
 137     //javadoc: Params::set_minRepeatability(minRepeatability)
 138     public  void set_minRepeatability(long minRepeatability)
 139     {
 140
 141         set_minRepeatability_0(nativeObj, minRepeatability);
 142
 143         return;
 144     }
 145
 146
 147     //
 148     // C++: float Params::minDistBetweenBlobs
 149     //
 150
 151     //javadoc: Params::get_minDistBetweenBlobs()
 152     public  float get_minDistBetweenBlobs()
 153     {
 154
 155         float retVal = get_minDistBetweenBlobs_0(nativeObj);
 156
 157         return retVal;
 158     }
 159
 160
 161     //
 162     // C++: void Params::minDistBetweenBlobs
 163     //
 164
 165     //javadoc: Params::set_minDistBetweenBlobs(minDistBetweenBlobs)
 166     public  void set_minDistBetweenBlobs(float minDistBetweenBlobs)
 167     {
 168
 169         set_minDistBetweenBlobs_0(nativeObj, minDistBetweenBlobs);
 170
 171         return;
 172     }
 173
 174
 175     //
 176     // C++: bool Params::filterByColor
 177     //
 178
 179     //javadoc: Params::get_filterByColor()
 180     public  boolean get_filterByColor()
 181     {
 182
 183         boolean retVal = get_filterByColor_0(nativeObj);
 184
 185         return retVal;
 186     }
 187
 188
 189     //
 190     // C++: void Params::filterByColor
 191     //
 192
 193     //javadoc: Params::set_filterByColor(filterByColor)
 194     public  void set_filterByColor(boolean filterByColor)
 195     {
 196
 197         set_filterByColor_0(nativeObj, filterByColor);
 198
 199         return;
 200     }
 201
 202
 203     //
 204     // C++: uchar Params::blobColor
 205     //
 206
 207     // Return type 'uchar' is not supported, skipping the function
 208
 209
 210     //
 211     // C++: void Params::blobColor
 212     //
 213
 214     // Unknown type 'uchar' (I), skipping the function
 215
 216
 217     //
 218     // C++: bool Params::filterByArea
 219     //
 220
 221     //javadoc: Params::get_filterByArea()
 222     public  boolean get_filterByArea()
 223     {
 224
 225         boolean retVal = get_filterByArea_0(nativeObj);
 226
 227         return retVal;
 228     }
 229
 230
 231     //
 232     // C++: void Params::filterByArea
 233     //
 234
 235     //javadoc: Params::set_filterByArea(filterByArea)
 236     public  void set_filterByArea(boolean filterByArea)
 237     {
 238
 239         set_filterByArea_0(nativeObj, filterByArea);
 240
 241         return;
 242     }
 243
 244
 245     //
 246     // C++: float Params::minArea
 247     //
 248
 249     //javadoc: Params::get_minArea()
 250     public  float get_minArea()
 251     {
 252
 253         float retVal = get_minArea_0(nativeObj);
 254
 255         return retVal;
 256     }
 257
 258
 259     //
 260     // C++: void Params::minArea
 261     //
 262
 263     //javadoc: Params::set_minArea(minArea)
 264     public  void set_minArea(float minArea)
 265     {
 266
 267         set_minArea_0(nativeObj, minArea);
 268
 269         return;
 270     }
 271
 272
 273     //
 274     // C++: float Params::maxArea
 275     //
 276
 277     //javadoc: Params::get_maxArea()
 278     public  float get_maxArea()
 279     {
 280
 281         float retVal = get_maxArea_0(nativeObj);
 282
 283         return retVal;
 284     }
 285
 286
 287     //
 288     // C++: void Params::maxArea
 289     //
 290
 291     //javadoc: Params::set_maxArea(maxArea)
 292     public  void set_maxArea(float maxArea)
 293     {
 294
 295         set_maxArea_0(nativeObj, maxArea);
 296
 297         return;
 298     }
 299
 300
 301     //
 302     // C++: bool Params::filterByCircularity
 303     //
 304
 305     //javadoc: Params::get_filterByCircularity()
 306     public  boolean get_filterByCircularity()
 307     {
 308
 309         boolean retVal = get_filterByCircularity_0(nativeObj);
 310
 311         return retVal;
 312     }
 313
 314
 315     //
 316     // C++: void Params::filterByCircularity
 317     //
 318
 319     //javadoc: Params::set_filterByCircularity(filterByCircularity)
 320     public  void set_filterByCircularity(boolean filterByCircularity)
 321     {
 322
 323         set_filterByCircularity_0(nativeObj, filterByCircularity);
 324
 325         return;
 326     }
 327
 328
 329     //
 330     // C++: float Params::minCircularity
 331     //
 332
 333     //javadoc: Params::get_minCircularity()
 334     public  float get_minCircularity()
 335     {
 336
 337         float retVal = get_minCircularity_0(nativeObj);
 338
 339         return retVal;
 340     }
 341
 342
 343     //
 344     // C++: void Params::minCircularity
 345     //
 346
 347     //javadoc: Params::set_minCircularity(minCircularity)
 348     public  void set_minCircularity(float minCircularity)
 349     {
 350
 351         set_minCircularity_0(nativeObj, minCircularity);
 352
 353         return;
 354     }
 355
 356
 357     //
 358     // C++: float Params::maxCircularity
 359     //
 360
 361     //javadoc: Params::get_maxCircularity()
 362     public  float get_maxCircularity()
 363     {
 364
 365         float retVal = get_maxCircularity_0(nativeObj);
 366
 367         return retVal;
 368     }
 369
 370
 371     //
 372     // C++: void Params::maxCircularity
 373     //
 374
 375     //javadoc: Params::set_maxCircularity(maxCircularity)
 376     public  void set_maxCircularity(float maxCircularity)
 377     {
 378
 379         set_maxCircularity_0(nativeObj, maxCircularity);
 380
 381         return;
 382     }
 383
 384
 385     //
 386     // C++: bool Params::filterByInertia
 387     //
 388
 389     //javadoc: Params::get_filterByInertia()
 390     public  boolean get_filterByInertia()
 391     {
 392
 393         boolean retVal = get_filterByInertia_0(nativeObj);
 394
 395         return retVal;
 396     }
 397
 398
 399     //
 400     // C++: void Params::filterByInertia
 401     //
 402
 403     //javadoc: Params::set_filterByInertia(filterByInertia)
 404     public  void set_filterByInertia(boolean filterByInertia)
 405     {
 406
 407         set_filterByInertia_0(nativeObj, filterByInertia);
 408
 409         return;
 410     }
 411
 412
 413     //
 414     // C++: float Params::minInertiaRatio
 415     //
 416
 417     //javadoc: Params::get_minInertiaRatio()
 418     public  float get_minInertiaRatio()
 419     {
 420
 421         float retVal = get_minInertiaRatio_0(nativeObj);
 422
 423         return retVal;
 424     }
 425
 426
 427     //
 428     // C++: void Params::minInertiaRatio
 429     //
 430
 431     //javadoc: Params::set_minInertiaRatio(minInertiaRatio)
 432     public  void set_minInertiaRatio(float minInertiaRatio)
 433     {
 434
 435         set_minInertiaRatio_0(nativeObj, minInertiaRatio);
 436
 437         return;
 438     }
 439
 440
 441     //
 442     // C++: float Params::maxInertiaRatio
 443     //
 444
 445     //javadoc: Params::get_maxInertiaRatio()
 446     public  float get_maxInertiaRatio()
 447     {
 448
 449         float retVal = get_maxInertiaRatio_0(nativeObj);
 450
 451         return retVal;
 452     }
 453
 454
 455     //
 456     // C++: void Params::maxInertiaRatio
 457     //
 458
 459     //javadoc: Params::set_maxInertiaRatio(maxInertiaRatio)
 460     public  void set_maxInertiaRatio(float maxInertiaRatio)
 461     {
 462
 463         set_maxInertiaRatio_0(nativeObj, maxInertiaRatio);
 464
 465         return;
 466     }
 467
 468
 469     //
 470     // C++: bool Params::filterByConvexity
 471     //
 472
 473     //javadoc: Params::get_filterByConvexity()
 474     public  boolean get_filterByConvexity()
 475     {
 476
 477         boolean retVal = get_filterByConvexity_0(nativeObj);
 478
 479         return retVal;
 480     }
 481
 482
 483     //
 484     // C++: void Params::filterByConvexity
 485     //
 486
 487     //javadoc: Params::set_filterByConvexity(filterByConvexity)
 488     public  void set_filterByConvexity(boolean filterByConvexity)
 489     {
 490
 491         set_filterByConvexity_0(nativeObj, filterByConvexity);
 492
 493         return;
 494     }
 495
 496
 497     //
 498     // C++: float Params::minConvexity
 499     //
 500
 501     //javadoc: Params::get_minConvexity()
 502     public  float get_minConvexity()
 503     {
 504
 505         float retVal = get_minConvexity_0(nativeObj);
 506
 507         return retVal;
 508     }
 509
 510
 511     //
 512     // C++: void Params::minConvexity
 513     //
 514
 515     //javadoc: Params::set_minConvexity(minConvexity)
 516     public  void set_minConvexity(float minConvexity)
 517     {
 518
 519         set_minConvexity_0(nativeObj, minConvexity);
 520
 521         return;
 522     }
 523
 524
 525     //
 526     // C++: float Params::maxConvexity
 527     //
 528
 529     //javadoc: Params::get_maxConvexity()
 530     public  float get_maxConvexity()
 531     {
 532
 533         float retVal = get_maxConvexity_0(nativeObj);
 534
 535         return retVal;
 536     }
 537
 538
 539     //
 540     // C++: void Params::maxConvexity
 541     //
 542
 543     //javadoc: Params::set_maxConvexity(maxConvexity)
 544     public  void set_maxConvexity(float maxConvexity)
 545     {
 546
 547         set_maxConvexity_0(nativeObj, maxConvexity);
 548
 549         return;
 550     }
 551
 552
 553     @Override
 554     protected void finalize() throws Throwable {
 555         delete(nativeObj);
 556     }
 557
 558
 559
 560     // C++:   cv::SimpleBlobDetector::Params::Params()
 561     private static native long Params_0();
 562
 563     // C++: float Params::thresholdStep
 564     private static native float get_thresholdStep_0(long nativeObj);
 565
 566     // C++: void Params::thresholdStep
 567     private static native void set_thresholdStep_0(long nativeObj, float thresholdStep);
 568
 569     // C++: float Params::minThreshold
 570     private static native float get_minThreshold_0(long nativeObj);
 571
 572     // C++: void Params::minThreshold
 573     private static native void set_minThreshold_0(long nativeObj, float minThreshold);
 574
 575     // C++: float Params::maxThreshold
 576     private static native float get_maxThreshold_0(long nativeObj);
 577
 578     // C++: void Params::maxThreshold
 579     private static native void set_maxThreshold_0(long nativeObj, float maxThreshold);
 580
 581     // C++: size_t Params::minRepeatability
 582     private static native long get_minRepeatability_0(long nativeObj);
 583
 584     // C++: void Params::minRepeatability
 585     private static native void set_minRepeatability_0(long nativeObj, long minRepeatability);
 586
 587     // C++: float Params::minDistBetweenBlobs
 588     private static native float get_minDistBetweenBlobs_0(long nativeObj);
 589
 590     // C++: void Params::minDistBetweenBlobs
 591     private static native void set_minDistBetweenBlobs_0(long nativeObj, float minDistBetweenBlobs);
 592
 593     // C++: bool Params::filterByColor
 594     private static native boolean get_filterByColor_0(long nativeObj);
 595
 596     // C++: void Params::filterByColor
 597     private static native void set_filterByColor_0(long nativeObj, boolean filterByColor);
 598
 599     // C++: bool Params::filterByArea
 600     private static native boolean get_filterByArea_0(long nativeObj);
 601
 602     // C++: void Params::filterByArea
 603     private static native void set_filterByArea_0(long nativeObj, boolean filterByArea);
 604
 605     // C++: float Params::minArea
 606     private static native float get_minArea_0(long nativeObj);
 607
 608     // C++: void Params::minArea
 609     private static native void set_minArea_0(long nativeObj, float minArea);
 610
 611     // C++: float Params::maxArea
 612     private static native float get_maxArea_0(long nativeObj);
 613
 614     // C++: void Params::maxArea
 615     private static native void set_maxArea_0(long nativeObj, float maxArea);
 616
 617     // C++: bool Params::filterByCircularity
 618     private static native boolean get_filterByCircularity_0(long nativeObj);
 619
 620     // C++: void Params::filterByCircularity
 621     private static native void set_filterByCircularity_0(long nativeObj, boolean filterByCircularity);
 622
 623     // C++: float Params::minCircularity
 624     private static native float get_minCircularity_0(long nativeObj);
 625
 626     // C++: void Params::minCircularity
 627     private static native void set_minCircularity_0(long nativeObj, float minCircularity);
 628
 629     // C++: float Params::maxCircularity
 630     private static native float get_maxCircularity_0(long nativeObj);
 631
 632     // C++: void Params::maxCircularity
 633     private static native void set_maxCircularity_0(long nativeObj, float maxCircularity);
 634
 635     // C++: bool Params::filterByInertia
 636     private static native boolean get_filterByInertia_0(long nativeObj);
 637
 638     // C++: void Params::filterByInertia
 639     private static native void set_filterByInertia_0(long nativeObj, boolean filterByInertia);
 640
 641     // C++: float Params::minInertiaRatio
 642     private static native float get_minInertiaRatio_0(long nativeObj);
 643
 644     // C++: void Params::minInertiaRatio
 645     private static native void set_minInertiaRatio_0(long nativeObj, float minInertiaRatio);
 646
 647     // C++: float Params::maxInertiaRatio
 648     private static native float get_maxInertiaRatio_0(long nativeObj);
 649
 650     // C++: void Params::maxInertiaRatio
 651     private static native void set_maxInertiaRatio_0(long nativeObj, float maxInertiaRatio);
 652
 653     // C++: bool Params::filterByConvexity
 654     private static native boolean get_filterByConvexity_0(long nativeObj);
 655
 656     // C++: void Params::filterByConvexity
 657     private static native void set_filterByConvexity_0(long nativeObj, boolean filterByConvexity);
 658
 659     // C++: float Params::minConvexity
 660     private static native float get_minConvexity_0(long nativeObj);
 661
 662     // C++: void Params::minConvexity
 663     private static native void set_minConvexity_0(long nativeObj, float minConvexity);
 664
 665     // C++: float Params::maxConvexity
 666     private static native float get_maxConvexity_0(long nativeObj);
 667
 668     // C++: void Params::maxConvexity
 669     private static native void set_maxConvexity_0(long nativeObj, float maxConvexity);
 670
 671     // native support for java finalize()
 672     private static native void delete(long nativeObj);
 673
 674 }