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    @Override
368    protected void finalize() throws Throwable {
369        delete(nativeObj);
370    }
371
372
373
374    // C++:   cv::SimpleBlobDetector::Params::Params()
375    private static native long SimpleBlobDetector_Params_0();
376
377    // C++: float SimpleBlobDetector_Params::thresholdStep
378    private static native float get_thresholdStep_0(long nativeObj);
379
380    // C++: void SimpleBlobDetector_Params::thresholdStep
381    private static native void set_thresholdStep_0(long nativeObj, float thresholdStep);
382
383    // C++: float SimpleBlobDetector_Params::minThreshold
384    private static native float get_minThreshold_0(long nativeObj);
385
386    // C++: void SimpleBlobDetector_Params::minThreshold
387    private static native void set_minThreshold_0(long nativeObj, float minThreshold);
388
389    // C++: float SimpleBlobDetector_Params::maxThreshold
390    private static native float get_maxThreshold_0(long nativeObj);
391
392    // C++: void SimpleBlobDetector_Params::maxThreshold
393    private static native void set_maxThreshold_0(long nativeObj, float maxThreshold);
394
395    // C++: size_t SimpleBlobDetector_Params::minRepeatability
396    private static native long get_minRepeatability_0(long nativeObj);
397
398    // C++: void SimpleBlobDetector_Params::minRepeatability
399    private static native void set_minRepeatability_0(long nativeObj, long minRepeatability);
400
401    // C++: float SimpleBlobDetector_Params::minDistBetweenBlobs
402    private static native float get_minDistBetweenBlobs_0(long nativeObj);
403
404    // C++: void SimpleBlobDetector_Params::minDistBetweenBlobs
405    private static native void set_minDistBetweenBlobs_0(long nativeObj, float minDistBetweenBlobs);
406
407    // C++: bool SimpleBlobDetector_Params::filterByColor
408    private static native boolean get_filterByColor_0(long nativeObj);
409
410    // C++: void SimpleBlobDetector_Params::filterByColor
411    private static native void set_filterByColor_0(long nativeObj, boolean filterByColor);
412
413    // C++: bool SimpleBlobDetector_Params::filterByArea
414    private static native boolean get_filterByArea_0(long nativeObj);
415
416    // C++: void SimpleBlobDetector_Params::filterByArea
417    private static native void set_filterByArea_0(long nativeObj, boolean filterByArea);
418
419    // C++: float SimpleBlobDetector_Params::minArea
420    private static native float get_minArea_0(long nativeObj);
421
422    // C++: void SimpleBlobDetector_Params::minArea
423    private static native void set_minArea_0(long nativeObj, float minArea);
424
425    // C++: float SimpleBlobDetector_Params::maxArea
426    private static native float get_maxArea_0(long nativeObj);
427
428    // C++: void SimpleBlobDetector_Params::maxArea
429    private static native void set_maxArea_0(long nativeObj, float maxArea);
430
431    // C++: bool SimpleBlobDetector_Params::filterByCircularity
432    private static native boolean get_filterByCircularity_0(long nativeObj);
433
434    // C++: void SimpleBlobDetector_Params::filterByCircularity
435    private static native void set_filterByCircularity_0(long nativeObj, boolean filterByCircularity);
436
437    // C++: float SimpleBlobDetector_Params::minCircularity
438    private static native float get_minCircularity_0(long nativeObj);
439
440    // C++: void SimpleBlobDetector_Params::minCircularity
441    private static native void set_minCircularity_0(long nativeObj, float minCircularity);
442
443    // C++: float SimpleBlobDetector_Params::maxCircularity
444    private static native float get_maxCircularity_0(long nativeObj);
445
446    // C++: void SimpleBlobDetector_Params::maxCircularity
447    private static native void set_maxCircularity_0(long nativeObj, float maxCircularity);
448
449    // C++: bool SimpleBlobDetector_Params::filterByInertia
450    private static native boolean get_filterByInertia_0(long nativeObj);
451
452    // C++: void SimpleBlobDetector_Params::filterByInertia
453    private static native void set_filterByInertia_0(long nativeObj, boolean filterByInertia);
454
455    // C++: float SimpleBlobDetector_Params::minInertiaRatio
456    private static native float get_minInertiaRatio_0(long nativeObj);
457
458    // C++: void SimpleBlobDetector_Params::minInertiaRatio
459    private static native void set_minInertiaRatio_0(long nativeObj, float minInertiaRatio);
460
461    // C++: float SimpleBlobDetector_Params::maxInertiaRatio
462    private static native float get_maxInertiaRatio_0(long nativeObj);
463
464    // C++: void SimpleBlobDetector_Params::maxInertiaRatio
465    private static native void set_maxInertiaRatio_0(long nativeObj, float maxInertiaRatio);
466
467    // C++: bool SimpleBlobDetector_Params::filterByConvexity
468    private static native boolean get_filterByConvexity_0(long nativeObj);
469
470    // C++: void SimpleBlobDetector_Params::filterByConvexity
471    private static native void set_filterByConvexity_0(long nativeObj, boolean filterByConvexity);
472
473    // C++: float SimpleBlobDetector_Params::minConvexity
474    private static native float get_minConvexity_0(long nativeObj);
475
476    // C++: void SimpleBlobDetector_Params::minConvexity
477    private static native void set_minConvexity_0(long nativeObj, float minConvexity);
478
479    // C++: float SimpleBlobDetector_Params::maxConvexity
480    private static native float get_maxConvexity_0(long nativeObj);
481
482    // C++: void SimpleBlobDetector_Params::maxConvexity
483    private static native void set_maxConvexity_0(long nativeObj, float maxConvexity);
484
485    // native support for java finalize()
486    private static native void delete(long nativeObj);
487
488}