001// 002// This file is auto-generated. Please don't modify it! 003// 004package org.opencv.features2d; 005 006 007 008// C++: class Params 009 010public class SimpleBlobDetector_Params { 011 012 protected final long nativeObj; 013 protected SimpleBlobDetector_Params(long addr) { nativeObj = addr; } 014 015 public long getNativeObjAddr() { return nativeObj; } 016 017 // internal usage only 018 public static SimpleBlobDetector_Params __fromPtr__(long addr) { return new SimpleBlobDetector_Params(addr); } 019 020 // 021 // C++: cv::SimpleBlobDetector::Params::Params() 022 // 023 024 public SimpleBlobDetector_Params() { 025 nativeObj = SimpleBlobDetector_Params_0(); 026 } 027 028 029 // 030 // C++: float SimpleBlobDetector_Params::thresholdStep 031 // 032 033 public float get_thresholdStep() { 034 return get_thresholdStep_0(nativeObj); 035 } 036 037 038 // 039 // C++: void SimpleBlobDetector_Params::thresholdStep 040 // 041 042 public void set_thresholdStep(float thresholdStep) { 043 set_thresholdStep_0(nativeObj, thresholdStep); 044 } 045 046 047 // 048 // C++: float SimpleBlobDetector_Params::minThreshold 049 // 050 051 public float get_minThreshold() { 052 return get_minThreshold_0(nativeObj); 053 } 054 055 056 // 057 // C++: void SimpleBlobDetector_Params::minThreshold 058 // 059 060 public void set_minThreshold(float minThreshold) { 061 set_minThreshold_0(nativeObj, minThreshold); 062 } 063 064 065 // 066 // C++: float SimpleBlobDetector_Params::maxThreshold 067 // 068 069 public float get_maxThreshold() { 070 return get_maxThreshold_0(nativeObj); 071 } 072 073 074 // 075 // C++: void SimpleBlobDetector_Params::maxThreshold 076 // 077 078 public void set_maxThreshold(float maxThreshold) { 079 set_maxThreshold_0(nativeObj, maxThreshold); 080 } 081 082 083 // 084 // C++: size_t SimpleBlobDetector_Params::minRepeatability 085 // 086 087 public long get_minRepeatability() { 088 return get_minRepeatability_0(nativeObj); 089 } 090 091 092 // 093 // C++: void SimpleBlobDetector_Params::minRepeatability 094 // 095 096 public void set_minRepeatability(long minRepeatability) { 097 set_minRepeatability_0(nativeObj, minRepeatability); 098 } 099 100 101 // 102 // C++: float SimpleBlobDetector_Params::minDistBetweenBlobs 103 // 104 105 public float get_minDistBetweenBlobs() { 106 return get_minDistBetweenBlobs_0(nativeObj); 107 } 108 109 110 // 111 // C++: void SimpleBlobDetector_Params::minDistBetweenBlobs 112 // 113 114 public void set_minDistBetweenBlobs(float minDistBetweenBlobs) { 115 set_minDistBetweenBlobs_0(nativeObj, minDistBetweenBlobs); 116 } 117 118 119 // 120 // C++: bool SimpleBlobDetector_Params::filterByColor 121 // 122 123 public boolean get_filterByColor() { 124 return get_filterByColor_0(nativeObj); 125 } 126 127 128 // 129 // C++: void SimpleBlobDetector_Params::filterByColor 130 // 131 132 public void set_filterByColor(boolean filterByColor) { 133 set_filterByColor_0(nativeObj, filterByColor); 134 } 135 136 137 // 138 // C++: uchar SimpleBlobDetector_Params::blobColor 139 // 140 141 // Return type 'uchar' is not supported, skipping the function 142 143 144 // 145 // C++: void SimpleBlobDetector_Params::blobColor 146 // 147 148 // Unknown type 'uchar' (I), skipping the function 149 150 151 // 152 // C++: bool SimpleBlobDetector_Params::filterByArea 153 // 154 155 public boolean get_filterByArea() { 156 return get_filterByArea_0(nativeObj); 157 } 158 159 160 // 161 // C++: void SimpleBlobDetector_Params::filterByArea 162 // 163 164 public void set_filterByArea(boolean filterByArea) { 165 set_filterByArea_0(nativeObj, filterByArea); 166 } 167 168 169 // 170 // C++: float SimpleBlobDetector_Params::minArea 171 // 172 173 public float get_minArea() { 174 return get_minArea_0(nativeObj); 175 } 176 177 178 // 179 // C++: void SimpleBlobDetector_Params::minArea 180 // 181 182 public void set_minArea(float minArea) { 183 set_minArea_0(nativeObj, minArea); 184 } 185 186 187 // 188 // C++: float SimpleBlobDetector_Params::maxArea 189 // 190 191 public float get_maxArea() { 192 return get_maxArea_0(nativeObj); 193 } 194 195 196 // 197 // C++: void SimpleBlobDetector_Params::maxArea 198 // 199 200 public void set_maxArea(float maxArea) { 201 set_maxArea_0(nativeObj, maxArea); 202 } 203 204 205 // 206 // C++: bool SimpleBlobDetector_Params::filterByCircularity 207 // 208 209 public boolean get_filterByCircularity() { 210 return get_filterByCircularity_0(nativeObj); 211 } 212 213 214 // 215 // C++: void SimpleBlobDetector_Params::filterByCircularity 216 // 217 218 public void set_filterByCircularity(boolean filterByCircularity) { 219 set_filterByCircularity_0(nativeObj, filterByCircularity); 220 } 221 222 223 // 224 // C++: float SimpleBlobDetector_Params::minCircularity 225 // 226 227 public float get_minCircularity() { 228 return get_minCircularity_0(nativeObj); 229 } 230 231 232 // 233 // C++: void SimpleBlobDetector_Params::minCircularity 234 // 235 236 public void set_minCircularity(float minCircularity) { 237 set_minCircularity_0(nativeObj, minCircularity); 238 } 239 240 241 // 242 // C++: float SimpleBlobDetector_Params::maxCircularity 243 // 244 245 public float get_maxCircularity() { 246 return get_maxCircularity_0(nativeObj); 247 } 248 249 250 // 251 // C++: void SimpleBlobDetector_Params::maxCircularity 252 // 253 254 public void set_maxCircularity(float maxCircularity) { 255 set_maxCircularity_0(nativeObj, maxCircularity); 256 } 257 258 259 // 260 // C++: bool SimpleBlobDetector_Params::filterByInertia 261 // 262 263 public boolean get_filterByInertia() { 264 return get_filterByInertia_0(nativeObj); 265 } 266 267 268 // 269 // C++: void SimpleBlobDetector_Params::filterByInertia 270 // 271 272 public void set_filterByInertia(boolean filterByInertia) { 273 set_filterByInertia_0(nativeObj, filterByInertia); 274 } 275 276 277 // 278 // C++: float SimpleBlobDetector_Params::minInertiaRatio 279 // 280 281 public float get_minInertiaRatio() { 282 return get_minInertiaRatio_0(nativeObj); 283 } 284 285 286 // 287 // C++: void SimpleBlobDetector_Params::minInertiaRatio 288 // 289 290 public void set_minInertiaRatio(float minInertiaRatio) { 291 set_minInertiaRatio_0(nativeObj, minInertiaRatio); 292 } 293 294 295 // 296 // C++: float SimpleBlobDetector_Params::maxInertiaRatio 297 // 298 299 public float get_maxInertiaRatio() { 300 return get_maxInertiaRatio_0(nativeObj); 301 } 302 303 304 // 305 // C++: void SimpleBlobDetector_Params::maxInertiaRatio 306 // 307 308 public void set_maxInertiaRatio(float maxInertiaRatio) { 309 set_maxInertiaRatio_0(nativeObj, maxInertiaRatio); 310 } 311 312 313 // 314 // C++: bool SimpleBlobDetector_Params::filterByConvexity 315 // 316 317 public boolean get_filterByConvexity() { 318 return get_filterByConvexity_0(nativeObj); 319 } 320 321 322 // 323 // C++: void SimpleBlobDetector_Params::filterByConvexity 324 // 325 326 public void set_filterByConvexity(boolean filterByConvexity) { 327 set_filterByConvexity_0(nativeObj, filterByConvexity); 328 } 329 330 331 // 332 // C++: float SimpleBlobDetector_Params::minConvexity 333 // 334 335 public float get_minConvexity() { 336 return get_minConvexity_0(nativeObj); 337 } 338 339 340 // 341 // C++: void SimpleBlobDetector_Params::minConvexity 342 // 343 344 public void set_minConvexity(float minConvexity) { 345 set_minConvexity_0(nativeObj, minConvexity); 346 } 347 348 349 // 350 // C++: float SimpleBlobDetector_Params::maxConvexity 351 // 352 353 public float get_maxConvexity() { 354 return get_maxConvexity_0(nativeObj); 355 } 356 357 358 // 359 // C++: void SimpleBlobDetector_Params::maxConvexity 360 // 361 362 public void set_maxConvexity(float maxConvexity) { 363 set_maxConvexity_0(nativeObj, maxConvexity); 364 } 365 366 367 // 368 // C++: bool SimpleBlobDetector_Params::collectContours 369 // 370 371 public boolean get_collectContours() { 372 return get_collectContours_0(nativeObj); 373 } 374 375 376 // 377 // C++: void SimpleBlobDetector_Params::collectContours 378 // 379 380 public void set_collectContours(boolean collectContours) { 381 set_collectContours_0(nativeObj, collectContours); 382 } 383 384 385 @Override 386 protected void finalize() throws Throwable { 387 delete(nativeObj); 388 } 389 390 391 392 // C++: cv::SimpleBlobDetector::Params::Params() 393 private static native long SimpleBlobDetector_Params_0(); 394 395 // C++: float SimpleBlobDetector_Params::thresholdStep 396 private static native float get_thresholdStep_0(long nativeObj); 397 398 // C++: void SimpleBlobDetector_Params::thresholdStep 399 private static native void set_thresholdStep_0(long nativeObj, float thresholdStep); 400 401 // C++: float SimpleBlobDetector_Params::minThreshold 402 private static native float get_minThreshold_0(long nativeObj); 403 404 // C++: void SimpleBlobDetector_Params::minThreshold 405 private static native void set_minThreshold_0(long nativeObj, float minThreshold); 406 407 // C++: float SimpleBlobDetector_Params::maxThreshold 408 private static native float get_maxThreshold_0(long nativeObj); 409 410 // C++: void SimpleBlobDetector_Params::maxThreshold 411 private static native void set_maxThreshold_0(long nativeObj, float maxThreshold); 412 413 // C++: size_t SimpleBlobDetector_Params::minRepeatability 414 private static native long get_minRepeatability_0(long nativeObj); 415 416 // C++: void SimpleBlobDetector_Params::minRepeatability 417 private static native void set_minRepeatability_0(long nativeObj, long minRepeatability); 418 419 // C++: float SimpleBlobDetector_Params::minDistBetweenBlobs 420 private static native float get_minDistBetweenBlobs_0(long nativeObj); 421 422 // C++: void SimpleBlobDetector_Params::minDistBetweenBlobs 423 private static native void set_minDistBetweenBlobs_0(long nativeObj, float minDistBetweenBlobs); 424 425 // C++: bool SimpleBlobDetector_Params::filterByColor 426 private static native boolean get_filterByColor_0(long nativeObj); 427 428 // C++: void SimpleBlobDetector_Params::filterByColor 429 private static native void set_filterByColor_0(long nativeObj, boolean filterByColor); 430 431 // C++: bool SimpleBlobDetector_Params::filterByArea 432 private static native boolean get_filterByArea_0(long nativeObj); 433 434 // C++: void SimpleBlobDetector_Params::filterByArea 435 private static native void set_filterByArea_0(long nativeObj, boolean filterByArea); 436 437 // C++: float SimpleBlobDetector_Params::minArea 438 private static native float get_minArea_0(long nativeObj); 439 440 // C++: void SimpleBlobDetector_Params::minArea 441 private static native void set_minArea_0(long nativeObj, float minArea); 442 443 // C++: float SimpleBlobDetector_Params::maxArea 444 private static native float get_maxArea_0(long nativeObj); 445 446 // C++: void SimpleBlobDetector_Params::maxArea 447 private static native void set_maxArea_0(long nativeObj, float maxArea); 448 449 // C++: bool SimpleBlobDetector_Params::filterByCircularity 450 private static native boolean get_filterByCircularity_0(long nativeObj); 451 452 // C++: void SimpleBlobDetector_Params::filterByCircularity 453 private static native void set_filterByCircularity_0(long nativeObj, boolean filterByCircularity); 454 455 // C++: float SimpleBlobDetector_Params::minCircularity 456 private static native float get_minCircularity_0(long nativeObj); 457 458 // C++: void SimpleBlobDetector_Params::minCircularity 459 private static native void set_minCircularity_0(long nativeObj, float minCircularity); 460 461 // C++: float SimpleBlobDetector_Params::maxCircularity 462 private static native float get_maxCircularity_0(long nativeObj); 463 464 // C++: void SimpleBlobDetector_Params::maxCircularity 465 private static native void set_maxCircularity_0(long nativeObj, float maxCircularity); 466 467 // C++: bool SimpleBlobDetector_Params::filterByInertia 468 private static native boolean get_filterByInertia_0(long nativeObj); 469 470 // C++: void SimpleBlobDetector_Params::filterByInertia 471 private static native void set_filterByInertia_0(long nativeObj, boolean filterByInertia); 472 473 // C++: float SimpleBlobDetector_Params::minInertiaRatio 474 private static native float get_minInertiaRatio_0(long nativeObj); 475 476 // C++: void SimpleBlobDetector_Params::minInertiaRatio 477 private static native void set_minInertiaRatio_0(long nativeObj, float minInertiaRatio); 478 479 // C++: float SimpleBlobDetector_Params::maxInertiaRatio 480 private static native float get_maxInertiaRatio_0(long nativeObj); 481 482 // C++: void SimpleBlobDetector_Params::maxInertiaRatio 483 private static native void set_maxInertiaRatio_0(long nativeObj, float maxInertiaRatio); 484 485 // C++: bool SimpleBlobDetector_Params::filterByConvexity 486 private static native boolean get_filterByConvexity_0(long nativeObj); 487 488 // C++: void SimpleBlobDetector_Params::filterByConvexity 489 private static native void set_filterByConvexity_0(long nativeObj, boolean filterByConvexity); 490 491 // C++: float SimpleBlobDetector_Params::minConvexity 492 private static native float get_minConvexity_0(long nativeObj); 493 494 // C++: void SimpleBlobDetector_Params::minConvexity 495 private static native void set_minConvexity_0(long nativeObj, float minConvexity); 496 497 // C++: float SimpleBlobDetector_Params::maxConvexity 498 private static native float get_maxConvexity_0(long nativeObj); 499 500 // C++: void SimpleBlobDetector_Params::maxConvexity 501 private static native void set_maxConvexity_0(long nativeObj, float maxConvexity); 502 503 // C++: bool SimpleBlobDetector_Params::collectContours 504 private static native boolean get_collectContours_0(long nativeObj); 505 506 // C++: void SimpleBlobDetector_Params::collectContours 507 private static native void set_collectContours_0(long nativeObj, boolean collectContours); 508 509 // native support for java finalize() 510 private static native void delete(long nativeObj); 511 512}