001//
002// This file is auto-generated. Please don't modify it!
003//
004package org.opencv.features2d;
005
006import org.opencv.features2d.Feature2D;
007import org.opencv.features2d.ORB;
008
009// C++: class ORB
010/**
011 * Class implementing the ORB (*oriented BRIEF*) keypoint detector and descriptor extractor
012 *
013 * described in CITE: RRKB11 . The algorithm uses FAST in pyramids to detect stable keypoints, selects
014 * the strongest features using FAST or Harris response, finds their orientation using first-order
015 * moments and computes the descriptors using BRIEF (where the coordinates of random point pairs (or
016 * k-tuples) are rotated according to the measured orientation).
017 */
018public class ORB extends Feature2D {
019
020    protected ORB(long addr) { super(addr); }
021
022    // internal usage only
023    public static ORB __fromPtr__(long addr) { return new ORB(addr); }
024
025    // C++: enum ScoreType (cv.ORB.ScoreType)
026    public static final int
027            HARRIS_SCORE = 0,
028            FAST_SCORE = 1;
029
030
031    //
032    // C++: static Ptr_ORB cv::ORB::create(int nfeatures = 500, float scaleFactor = 1.2f, int nlevels = 8, int edgeThreshold = 31, int firstLevel = 0, int WTA_K = 2, ORB_ScoreType scoreType = ORB::HARRIS_SCORE, int patchSize = 31, int fastThreshold = 20)
033    //
034
035    /**
036     * The ORB constructor
037     *
038     *     @param nfeatures The maximum number of features to retain.
039     *     @param scaleFactor Pyramid decimation ratio, greater than 1. scaleFactor==2 means the classical
040     *     pyramid, where each next level has 4x less pixels than the previous, but such a big scale factor
041     *     will degrade feature matching scores dramatically. On the other hand, too close to 1 scale factor
042     *     will mean that to cover certain scale range you will need more pyramid levels and so the speed
043     *     will suffer.
044     *     @param nlevels The number of pyramid levels. The smallest level will have linear size equal to
045     *     input_image_linear_size/pow(scaleFactor, nlevels - firstLevel).
046     *     @param edgeThreshold This is size of the border where the features are not detected. It should
047     *     roughly match the patchSize parameter.
048     *     @param firstLevel The level of pyramid to put source image to. Previous layers are filled
049     *     with upscaled source image.
050     *     @param WTA_K The number of points that produce each element of the oriented BRIEF descriptor. The
051     *     default value 2 means the BRIEF where we take a random point pair and compare their brightnesses,
052     *     so we get 0/1 response. Other possible values are 3 and 4. For example, 3 means that we take 3
053     *     random points (of course, those point coordinates are random, but they are generated from the
054     *     pre-defined seed, so each element of BRIEF descriptor is computed deterministically from the pixel
055     *     rectangle), find point of maximum brightness and output index of the winner (0, 1 or 2). Such
056     *     output will occupy 2 bits, and therefore it will need a special variant of Hamming distance,
057     *     denoted as NORM_HAMMING2 (2 bits per bin). When WTA_K=4, we take 4 random points to compute each
058     *     bin (that will also occupy 2 bits with possible values 0, 1, 2 or 3).
059     *     @param scoreType The default HARRIS_SCORE means that Harris algorithm is used to rank features
060     *     (the score is written to KeyPoint::score and is used to retain best nfeatures features);
061     *     FAST_SCORE is alternative value of the parameter that produces slightly less stable keypoints,
062     *     but it is a little faster to compute.
063     *     @param patchSize size of the patch used by the oriented BRIEF descriptor. Of course, on smaller
064     *     pyramid layers the perceived image area covered by a feature will be larger.
065     *     @param fastThreshold the fast threshold
066     * @return automatically generated
067     */
068    public static ORB create(int nfeatures, float scaleFactor, int nlevels, int edgeThreshold, int firstLevel, int WTA_K, int scoreType, int patchSize, int fastThreshold) {
069        return ORB.__fromPtr__(create_0(nfeatures, scaleFactor, nlevels, edgeThreshold, firstLevel, WTA_K, scoreType, patchSize, fastThreshold));
070    }
071
072    /**
073     * The ORB constructor
074     *
075     *     @param nfeatures The maximum number of features to retain.
076     *     @param scaleFactor Pyramid decimation ratio, greater than 1. scaleFactor==2 means the classical
077     *     pyramid, where each next level has 4x less pixels than the previous, but such a big scale factor
078     *     will degrade feature matching scores dramatically. On the other hand, too close to 1 scale factor
079     *     will mean that to cover certain scale range you will need more pyramid levels and so the speed
080     *     will suffer.
081     *     @param nlevels The number of pyramid levels. The smallest level will have linear size equal to
082     *     input_image_linear_size/pow(scaleFactor, nlevels - firstLevel).
083     *     @param edgeThreshold This is size of the border where the features are not detected. It should
084     *     roughly match the patchSize parameter.
085     *     @param firstLevel The level of pyramid to put source image to. Previous layers are filled
086     *     with upscaled source image.
087     *     @param WTA_K The number of points that produce each element of the oriented BRIEF descriptor. The
088     *     default value 2 means the BRIEF where we take a random point pair and compare their brightnesses,
089     *     so we get 0/1 response. Other possible values are 3 and 4. For example, 3 means that we take 3
090     *     random points (of course, those point coordinates are random, but they are generated from the
091     *     pre-defined seed, so each element of BRIEF descriptor is computed deterministically from the pixel
092     *     rectangle), find point of maximum brightness and output index of the winner (0, 1 or 2). Such
093     *     output will occupy 2 bits, and therefore it will need a special variant of Hamming distance,
094     *     denoted as NORM_HAMMING2 (2 bits per bin). When WTA_K=4, we take 4 random points to compute each
095     *     bin (that will also occupy 2 bits with possible values 0, 1, 2 or 3).
096     *     @param scoreType The default HARRIS_SCORE means that Harris algorithm is used to rank features
097     *     (the score is written to KeyPoint::score and is used to retain best nfeatures features);
098     *     FAST_SCORE is alternative value of the parameter that produces slightly less stable keypoints,
099     *     but it is a little faster to compute.
100     *     @param patchSize size of the patch used by the oriented BRIEF descriptor. Of course, on smaller
101     *     pyramid layers the perceived image area covered by a feature will be larger.
102     * @return automatically generated
103     */
104    public static ORB create(int nfeatures, float scaleFactor, int nlevels, int edgeThreshold, int firstLevel, int WTA_K, int scoreType, int patchSize) {
105        return ORB.__fromPtr__(create_1(nfeatures, scaleFactor, nlevels, edgeThreshold, firstLevel, WTA_K, scoreType, patchSize));
106    }
107
108    /**
109     * The ORB constructor
110     *
111     *     @param nfeatures The maximum number of features to retain.
112     *     @param scaleFactor Pyramid decimation ratio, greater than 1. scaleFactor==2 means the classical
113     *     pyramid, where each next level has 4x less pixels than the previous, but such a big scale factor
114     *     will degrade feature matching scores dramatically. On the other hand, too close to 1 scale factor
115     *     will mean that to cover certain scale range you will need more pyramid levels and so the speed
116     *     will suffer.
117     *     @param nlevels The number of pyramid levels. The smallest level will have linear size equal to
118     *     input_image_linear_size/pow(scaleFactor, nlevels - firstLevel).
119     *     @param edgeThreshold This is size of the border where the features are not detected. It should
120     *     roughly match the patchSize parameter.
121     *     @param firstLevel The level of pyramid to put source image to. Previous layers are filled
122     *     with upscaled source image.
123     *     @param WTA_K The number of points that produce each element of the oriented BRIEF descriptor. The
124     *     default value 2 means the BRIEF where we take a random point pair and compare their brightnesses,
125     *     so we get 0/1 response. Other possible values are 3 and 4. For example, 3 means that we take 3
126     *     random points (of course, those point coordinates are random, but they are generated from the
127     *     pre-defined seed, so each element of BRIEF descriptor is computed deterministically from the pixel
128     *     rectangle), find point of maximum brightness and output index of the winner (0, 1 or 2). Such
129     *     output will occupy 2 bits, and therefore it will need a special variant of Hamming distance,
130     *     denoted as NORM_HAMMING2 (2 bits per bin). When WTA_K=4, we take 4 random points to compute each
131     *     bin (that will also occupy 2 bits with possible values 0, 1, 2 or 3).
132     *     @param scoreType The default HARRIS_SCORE means that Harris algorithm is used to rank features
133     *     (the score is written to KeyPoint::score and is used to retain best nfeatures features);
134     *     FAST_SCORE is alternative value of the parameter that produces slightly less stable keypoints,
135     *     but it is a little faster to compute.
136     *     pyramid layers the perceived image area covered by a feature will be larger.
137     * @return automatically generated
138     */
139    public static ORB create(int nfeatures, float scaleFactor, int nlevels, int edgeThreshold, int firstLevel, int WTA_K, int scoreType) {
140        return ORB.__fromPtr__(create_2(nfeatures, scaleFactor, nlevels, edgeThreshold, firstLevel, WTA_K, scoreType));
141    }
142
143    /**
144     * The ORB constructor
145     *
146     *     @param nfeatures The maximum number of features to retain.
147     *     @param scaleFactor Pyramid decimation ratio, greater than 1. scaleFactor==2 means the classical
148     *     pyramid, where each next level has 4x less pixels than the previous, but such a big scale factor
149     *     will degrade feature matching scores dramatically. On the other hand, too close to 1 scale factor
150     *     will mean that to cover certain scale range you will need more pyramid levels and so the speed
151     *     will suffer.
152     *     @param nlevels The number of pyramid levels. The smallest level will have linear size equal to
153     *     input_image_linear_size/pow(scaleFactor, nlevels - firstLevel).
154     *     @param edgeThreshold This is size of the border where the features are not detected. It should
155     *     roughly match the patchSize parameter.
156     *     @param firstLevel The level of pyramid to put source image to. Previous layers are filled
157     *     with upscaled source image.
158     *     @param WTA_K The number of points that produce each element of the oriented BRIEF descriptor. The
159     *     default value 2 means the BRIEF where we take a random point pair and compare their brightnesses,
160     *     so we get 0/1 response. Other possible values are 3 and 4. For example, 3 means that we take 3
161     *     random points (of course, those point coordinates are random, but they are generated from the
162     *     pre-defined seed, so each element of BRIEF descriptor is computed deterministically from the pixel
163     *     rectangle), find point of maximum brightness and output index of the winner (0, 1 or 2). Such
164     *     output will occupy 2 bits, and therefore it will need a special variant of Hamming distance,
165     *     denoted as NORM_HAMMING2 (2 bits per bin). When WTA_K=4, we take 4 random points to compute each
166     *     bin (that will also occupy 2 bits with possible values 0, 1, 2 or 3).
167     *     (the score is written to KeyPoint::score and is used to retain best nfeatures features);
168     *     FAST_SCORE is alternative value of the parameter that produces slightly less stable keypoints,
169     *     but it is a little faster to compute.
170     *     pyramid layers the perceived image area covered by a feature will be larger.
171     * @return automatically generated
172     */
173    public static ORB create(int nfeatures, float scaleFactor, int nlevels, int edgeThreshold, int firstLevel, int WTA_K) {
174        return ORB.__fromPtr__(create_3(nfeatures, scaleFactor, nlevels, edgeThreshold, firstLevel, WTA_K));
175    }
176
177    /**
178     * The ORB constructor
179     *
180     *     @param nfeatures The maximum number of features to retain.
181     *     @param scaleFactor Pyramid decimation ratio, greater than 1. scaleFactor==2 means the classical
182     *     pyramid, where each next level has 4x less pixels than the previous, but such a big scale factor
183     *     will degrade feature matching scores dramatically. On the other hand, too close to 1 scale factor
184     *     will mean that to cover certain scale range you will need more pyramid levels and so the speed
185     *     will suffer.
186     *     @param nlevels The number of pyramid levels. The smallest level will have linear size equal to
187     *     input_image_linear_size/pow(scaleFactor, nlevels - firstLevel).
188     *     @param edgeThreshold This is size of the border where the features are not detected. It should
189     *     roughly match the patchSize parameter.
190     *     @param firstLevel The level of pyramid to put source image to. Previous layers are filled
191     *     with upscaled source image.
192     *     default value 2 means the BRIEF where we take a random point pair and compare their brightnesses,
193     *     so we get 0/1 response. Other possible values are 3 and 4. For example, 3 means that we take 3
194     *     random points (of course, those point coordinates are random, but they are generated from the
195     *     pre-defined seed, so each element of BRIEF descriptor is computed deterministically from the pixel
196     *     rectangle), find point of maximum brightness and output index of the winner (0, 1 or 2). Such
197     *     output will occupy 2 bits, and therefore it will need a special variant of Hamming distance,
198     *     denoted as NORM_HAMMING2 (2 bits per bin). When WTA_K=4, we take 4 random points to compute each
199     *     bin (that will also occupy 2 bits with possible values 0, 1, 2 or 3).
200     *     (the score is written to KeyPoint::score and is used to retain best nfeatures features);
201     *     FAST_SCORE is alternative value of the parameter that produces slightly less stable keypoints,
202     *     but it is a little faster to compute.
203     *     pyramid layers the perceived image area covered by a feature will be larger.
204     * @return automatically generated
205     */
206    public static ORB create(int nfeatures, float scaleFactor, int nlevels, int edgeThreshold, int firstLevel) {
207        return ORB.__fromPtr__(create_4(nfeatures, scaleFactor, nlevels, edgeThreshold, firstLevel));
208    }
209
210    /**
211     * The ORB constructor
212     *
213     *     @param nfeatures The maximum number of features to retain.
214     *     @param scaleFactor Pyramid decimation ratio, greater than 1. scaleFactor==2 means the classical
215     *     pyramid, where each next level has 4x less pixels than the previous, but such a big scale factor
216     *     will degrade feature matching scores dramatically. On the other hand, too close to 1 scale factor
217     *     will mean that to cover certain scale range you will need more pyramid levels and so the speed
218     *     will suffer.
219     *     @param nlevels The number of pyramid levels. The smallest level will have linear size equal to
220     *     input_image_linear_size/pow(scaleFactor, nlevels - firstLevel).
221     *     @param edgeThreshold This is size of the border where the features are not detected. It should
222     *     roughly match the patchSize parameter.
223     *     with upscaled source image.
224     *     default value 2 means the BRIEF where we take a random point pair and compare their brightnesses,
225     *     so we get 0/1 response. Other possible values are 3 and 4. For example, 3 means that we take 3
226     *     random points (of course, those point coordinates are random, but they are generated from the
227     *     pre-defined seed, so each element of BRIEF descriptor is computed deterministically from the pixel
228     *     rectangle), find point of maximum brightness and output index of the winner (0, 1 or 2). Such
229     *     output will occupy 2 bits, and therefore it will need a special variant of Hamming distance,
230     *     denoted as NORM_HAMMING2 (2 bits per bin). When WTA_K=4, we take 4 random points to compute each
231     *     bin (that will also occupy 2 bits with possible values 0, 1, 2 or 3).
232     *     (the score is written to KeyPoint::score and is used to retain best nfeatures features);
233     *     FAST_SCORE is alternative value of the parameter that produces slightly less stable keypoints,
234     *     but it is a little faster to compute.
235     *     pyramid layers the perceived image area covered by a feature will be larger.
236     * @return automatically generated
237     */
238    public static ORB create(int nfeatures, float scaleFactor, int nlevels, int edgeThreshold) {
239        return ORB.__fromPtr__(create_5(nfeatures, scaleFactor, nlevels, edgeThreshold));
240    }
241
242    /**
243     * The ORB constructor
244     *
245     *     @param nfeatures The maximum number of features to retain.
246     *     @param scaleFactor Pyramid decimation ratio, greater than 1. scaleFactor==2 means the classical
247     *     pyramid, where each next level has 4x less pixels than the previous, but such a big scale factor
248     *     will degrade feature matching scores dramatically. On the other hand, too close to 1 scale factor
249     *     will mean that to cover certain scale range you will need more pyramid levels and so the speed
250     *     will suffer.
251     *     @param nlevels The number of pyramid levels. The smallest level will have linear size equal to
252     *     input_image_linear_size/pow(scaleFactor, nlevels - firstLevel).
253     *     roughly match the patchSize parameter.
254     *     with upscaled source image.
255     *     default value 2 means the BRIEF where we take a random point pair and compare their brightnesses,
256     *     so we get 0/1 response. Other possible values are 3 and 4. For example, 3 means that we take 3
257     *     random points (of course, those point coordinates are random, but they are generated from the
258     *     pre-defined seed, so each element of BRIEF descriptor is computed deterministically from the pixel
259     *     rectangle), find point of maximum brightness and output index of the winner (0, 1 or 2). Such
260     *     output will occupy 2 bits, and therefore it will need a special variant of Hamming distance,
261     *     denoted as NORM_HAMMING2 (2 bits per bin). When WTA_K=4, we take 4 random points to compute each
262     *     bin (that will also occupy 2 bits with possible values 0, 1, 2 or 3).
263     *     (the score is written to KeyPoint::score and is used to retain best nfeatures features);
264     *     FAST_SCORE is alternative value of the parameter that produces slightly less stable keypoints,
265     *     but it is a little faster to compute.
266     *     pyramid layers the perceived image area covered by a feature will be larger.
267     * @return automatically generated
268     */
269    public static ORB create(int nfeatures, float scaleFactor, int nlevels) {
270        return ORB.__fromPtr__(create_6(nfeatures, scaleFactor, nlevels));
271    }
272
273    /**
274     * The ORB constructor
275     *
276     *     @param nfeatures The maximum number of features to retain.
277     *     @param scaleFactor Pyramid decimation ratio, greater than 1. scaleFactor==2 means the classical
278     *     pyramid, where each next level has 4x less pixels than the previous, but such a big scale factor
279     *     will degrade feature matching scores dramatically. On the other hand, too close to 1 scale factor
280     *     will mean that to cover certain scale range you will need more pyramid levels and so the speed
281     *     will suffer.
282     *     input_image_linear_size/pow(scaleFactor, nlevels - firstLevel).
283     *     roughly match the patchSize parameter.
284     *     with upscaled source image.
285     *     default value 2 means the BRIEF where we take a random point pair and compare their brightnesses,
286     *     so we get 0/1 response. Other possible values are 3 and 4. For example, 3 means that we take 3
287     *     random points (of course, those point coordinates are random, but they are generated from the
288     *     pre-defined seed, so each element of BRIEF descriptor is computed deterministically from the pixel
289     *     rectangle), find point of maximum brightness and output index of the winner (0, 1 or 2). Such
290     *     output will occupy 2 bits, and therefore it will need a special variant of Hamming distance,
291     *     denoted as NORM_HAMMING2 (2 bits per bin). When WTA_K=4, we take 4 random points to compute each
292     *     bin (that will also occupy 2 bits with possible values 0, 1, 2 or 3).
293     *     (the score is written to KeyPoint::score and is used to retain best nfeatures features);
294     *     FAST_SCORE is alternative value of the parameter that produces slightly less stable keypoints,
295     *     but it is a little faster to compute.
296     *     pyramid layers the perceived image area covered by a feature will be larger.
297     * @return automatically generated
298     */
299    public static ORB create(int nfeatures, float scaleFactor) {
300        return ORB.__fromPtr__(create_7(nfeatures, scaleFactor));
301    }
302
303    /**
304     * The ORB constructor
305     *
306     *     @param nfeatures The maximum number of features to retain.
307     *     pyramid, where each next level has 4x less pixels than the previous, but such a big scale factor
308     *     will degrade feature matching scores dramatically. On the other hand, too close to 1 scale factor
309     *     will mean that to cover certain scale range you will need more pyramid levels and so the speed
310     *     will suffer.
311     *     input_image_linear_size/pow(scaleFactor, nlevels - firstLevel).
312     *     roughly match the patchSize parameter.
313     *     with upscaled source image.
314     *     default value 2 means the BRIEF where we take a random point pair and compare their brightnesses,
315     *     so we get 0/1 response. Other possible values are 3 and 4. For example, 3 means that we take 3
316     *     random points (of course, those point coordinates are random, but they are generated from the
317     *     pre-defined seed, so each element of BRIEF descriptor is computed deterministically from the pixel
318     *     rectangle), find point of maximum brightness and output index of the winner (0, 1 or 2). Such
319     *     output will occupy 2 bits, and therefore it will need a special variant of Hamming distance,
320     *     denoted as NORM_HAMMING2 (2 bits per bin). When WTA_K=4, we take 4 random points to compute each
321     *     bin (that will also occupy 2 bits with possible values 0, 1, 2 or 3).
322     *     (the score is written to KeyPoint::score and is used to retain best nfeatures features);
323     *     FAST_SCORE is alternative value of the parameter that produces slightly less stable keypoints,
324     *     but it is a little faster to compute.
325     *     pyramid layers the perceived image area covered by a feature will be larger.
326     * @return automatically generated
327     */
328    public static ORB create(int nfeatures) {
329        return ORB.__fromPtr__(create_8(nfeatures));
330    }
331
332    /**
333     * The ORB constructor
334     *
335     *     pyramid, where each next level has 4x less pixels than the previous, but such a big scale factor
336     *     will degrade feature matching scores dramatically. On the other hand, too close to 1 scale factor
337     *     will mean that to cover certain scale range you will need more pyramid levels and so the speed
338     *     will suffer.
339     *     input_image_linear_size/pow(scaleFactor, nlevels - firstLevel).
340     *     roughly match the patchSize parameter.
341     *     with upscaled source image.
342     *     default value 2 means the BRIEF where we take a random point pair and compare their brightnesses,
343     *     so we get 0/1 response. Other possible values are 3 and 4. For example, 3 means that we take 3
344     *     random points (of course, those point coordinates are random, but they are generated from the
345     *     pre-defined seed, so each element of BRIEF descriptor is computed deterministically from the pixel
346     *     rectangle), find point of maximum brightness and output index of the winner (0, 1 or 2). Such
347     *     output will occupy 2 bits, and therefore it will need a special variant of Hamming distance,
348     *     denoted as NORM_HAMMING2 (2 bits per bin). When WTA_K=4, we take 4 random points to compute each
349     *     bin (that will also occupy 2 bits with possible values 0, 1, 2 or 3).
350     *     (the score is written to KeyPoint::score and is used to retain best nfeatures features);
351     *     FAST_SCORE is alternative value of the parameter that produces slightly less stable keypoints,
352     *     but it is a little faster to compute.
353     *     pyramid layers the perceived image area covered by a feature will be larger.
354     * @return automatically generated
355     */
356    public static ORB create() {
357        return ORB.__fromPtr__(create_9());
358    }
359
360
361    //
362    // C++:  void cv::ORB::setMaxFeatures(int maxFeatures)
363    //
364
365    public void setMaxFeatures(int maxFeatures) {
366        setMaxFeatures_0(nativeObj, maxFeatures);
367    }
368
369
370    //
371    // C++:  int cv::ORB::getMaxFeatures()
372    //
373
374    public int getMaxFeatures() {
375        return getMaxFeatures_0(nativeObj);
376    }
377
378
379    //
380    // C++:  void cv::ORB::setScaleFactor(double scaleFactor)
381    //
382
383    public void setScaleFactor(double scaleFactor) {
384        setScaleFactor_0(nativeObj, scaleFactor);
385    }
386
387
388    //
389    // C++:  double cv::ORB::getScaleFactor()
390    //
391
392    public double getScaleFactor() {
393        return getScaleFactor_0(nativeObj);
394    }
395
396
397    //
398    // C++:  void cv::ORB::setNLevels(int nlevels)
399    //
400
401    public void setNLevels(int nlevels) {
402        setNLevels_0(nativeObj, nlevels);
403    }
404
405
406    //
407    // C++:  int cv::ORB::getNLevels()
408    //
409
410    public int getNLevels() {
411        return getNLevels_0(nativeObj);
412    }
413
414
415    //
416    // C++:  void cv::ORB::setEdgeThreshold(int edgeThreshold)
417    //
418
419    public void setEdgeThreshold(int edgeThreshold) {
420        setEdgeThreshold_0(nativeObj, edgeThreshold);
421    }
422
423
424    //
425    // C++:  int cv::ORB::getEdgeThreshold()
426    //
427
428    public int getEdgeThreshold() {
429        return getEdgeThreshold_0(nativeObj);
430    }
431
432
433    //
434    // C++:  void cv::ORB::setFirstLevel(int firstLevel)
435    //
436
437    public void setFirstLevel(int firstLevel) {
438        setFirstLevel_0(nativeObj, firstLevel);
439    }
440
441
442    //
443    // C++:  int cv::ORB::getFirstLevel()
444    //
445
446    public int getFirstLevel() {
447        return getFirstLevel_0(nativeObj);
448    }
449
450
451    //
452    // C++:  void cv::ORB::setWTA_K(int wta_k)
453    //
454
455    public void setWTA_K(int wta_k) {
456        setWTA_K_0(nativeObj, wta_k);
457    }
458
459
460    //
461    // C++:  int cv::ORB::getWTA_K()
462    //
463
464    public int getWTA_K() {
465        return getWTA_K_0(nativeObj);
466    }
467
468
469    //
470    // C++:  void cv::ORB::setScoreType(ORB_ScoreType scoreType)
471    //
472
473    public void setScoreType(int scoreType) {
474        setScoreType_0(nativeObj, scoreType);
475    }
476
477
478    //
479    // C++:  ORB_ScoreType cv::ORB::getScoreType()
480    //
481
482    public int getScoreType() {
483        return getScoreType_0(nativeObj);
484    }
485
486
487    //
488    // C++:  void cv::ORB::setPatchSize(int patchSize)
489    //
490
491    public void setPatchSize(int patchSize) {
492        setPatchSize_0(nativeObj, patchSize);
493    }
494
495
496    //
497    // C++:  int cv::ORB::getPatchSize()
498    //
499
500    public int getPatchSize() {
501        return getPatchSize_0(nativeObj);
502    }
503
504
505    //
506    // C++:  void cv::ORB::setFastThreshold(int fastThreshold)
507    //
508
509    public void setFastThreshold(int fastThreshold) {
510        setFastThreshold_0(nativeObj, fastThreshold);
511    }
512
513
514    //
515    // C++:  int cv::ORB::getFastThreshold()
516    //
517
518    public int getFastThreshold() {
519        return getFastThreshold_0(nativeObj);
520    }
521
522
523    //
524    // C++:  String cv::ORB::getDefaultName()
525    //
526
527    public String getDefaultName() {
528        return getDefaultName_0(nativeObj);
529    }
530
531
532    @Override
533    protected void finalize() throws Throwable {
534        delete(nativeObj);
535    }
536
537
538
539    // C++: static Ptr_ORB cv::ORB::create(int nfeatures = 500, float scaleFactor = 1.2f, int nlevels = 8, int edgeThreshold = 31, int firstLevel = 0, int WTA_K = 2, ORB_ScoreType scoreType = ORB::HARRIS_SCORE, int patchSize = 31, int fastThreshold = 20)
540    private static native long create_0(int nfeatures, float scaleFactor, int nlevels, int edgeThreshold, int firstLevel, int WTA_K, int scoreType, int patchSize, int fastThreshold);
541    private static native long create_1(int nfeatures, float scaleFactor, int nlevels, int edgeThreshold, int firstLevel, int WTA_K, int scoreType, int patchSize);
542    private static native long create_2(int nfeatures, float scaleFactor, int nlevels, int edgeThreshold, int firstLevel, int WTA_K, int scoreType);
543    private static native long create_3(int nfeatures, float scaleFactor, int nlevels, int edgeThreshold, int firstLevel, int WTA_K);
544    private static native long create_4(int nfeatures, float scaleFactor, int nlevels, int edgeThreshold, int firstLevel);
545    private static native long create_5(int nfeatures, float scaleFactor, int nlevels, int edgeThreshold);
546    private static native long create_6(int nfeatures, float scaleFactor, int nlevels);
547    private static native long create_7(int nfeatures, float scaleFactor);
548    private static native long create_8(int nfeatures);
549    private static native long create_9();
550
551    // C++:  void cv::ORB::setMaxFeatures(int maxFeatures)
552    private static native void setMaxFeatures_0(long nativeObj, int maxFeatures);
553
554    // C++:  int cv::ORB::getMaxFeatures()
555    private static native int getMaxFeatures_0(long nativeObj);
556
557    // C++:  void cv::ORB::setScaleFactor(double scaleFactor)
558    private static native void setScaleFactor_0(long nativeObj, double scaleFactor);
559
560    // C++:  double cv::ORB::getScaleFactor()
561    private static native double getScaleFactor_0(long nativeObj);
562
563    // C++:  void cv::ORB::setNLevels(int nlevels)
564    private static native void setNLevels_0(long nativeObj, int nlevels);
565
566    // C++:  int cv::ORB::getNLevels()
567    private static native int getNLevels_0(long nativeObj);
568
569    // C++:  void cv::ORB::setEdgeThreshold(int edgeThreshold)
570    private static native void setEdgeThreshold_0(long nativeObj, int edgeThreshold);
571
572    // C++:  int cv::ORB::getEdgeThreshold()
573    private static native int getEdgeThreshold_0(long nativeObj);
574
575    // C++:  void cv::ORB::setFirstLevel(int firstLevel)
576    private static native void setFirstLevel_0(long nativeObj, int firstLevel);
577
578    // C++:  int cv::ORB::getFirstLevel()
579    private static native int getFirstLevel_0(long nativeObj);
580
581    // C++:  void cv::ORB::setWTA_K(int wta_k)
582    private static native void setWTA_K_0(long nativeObj, int wta_k);
583
584    // C++:  int cv::ORB::getWTA_K()
585    private static native int getWTA_K_0(long nativeObj);
586
587    // C++:  void cv::ORB::setScoreType(ORB_ScoreType scoreType)
588    private static native void setScoreType_0(long nativeObj, int scoreType);
589
590    // C++:  ORB_ScoreType cv::ORB::getScoreType()
591    private static native int getScoreType_0(long nativeObj);
592
593    // C++:  void cv::ORB::setPatchSize(int patchSize)
594    private static native void setPatchSize_0(long nativeObj, int patchSize);
595
596    // C++:  int cv::ORB::getPatchSize()
597    private static native int getPatchSize_0(long nativeObj);
598
599    // C++:  void cv::ORB::setFastThreshold(int fastThreshold)
600    private static native void setFastThreshold_0(long nativeObj, int fastThreshold);
601
602    // C++:  int cv::ORB::getFastThreshold()
603    private static native int getFastThreshold_0(long nativeObj);
604
605    // C++:  String cv::ORB::getDefaultName()
606    private static native String getDefaultName_0(long nativeObj);
607
608    // native support for java finalize()
609    private static native void delete(long nativeObj);
610
611}