org.opencv.features2d

## Class ORB

- java.lang.Object
- - org.opencv.core.Algorithm
  - - org.opencv.features2d.Feature2D
    - - org.opencv.features2d.ORB

-     public class ORB
      extends Feature2D

  Class implementing the ORB (*oriented BRIEF*) keypoint detector and descriptor extractor described in CITE: RRKB11 . The algorithm uses FAST in pyramids to detect stable keypoints, selects the strongest features using FAST or Harris response, finds their orientation using first-order moments and computes the descriptors using BRIEF (where the coordinates of random point pairs (or k-tuples) are rotated according to the measured orientation).

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static int` | `FAST_SCORE`
    `static int` | `HARRIS_SCORE`
    `static int` | `kBytes`

    - ### Fields inherited from class org.opencv.core.Algorithm

      `nativeObj`

  - ### Constructor Summary

    Constructors
    Modifier | Constructor and Description
    --- | ---
    `protected` | `ORB(long addr)`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `static ORB` | `__fromPtr__(long addr)`
    `static ORB` | `create()` The ORB constructor pyramid, where each next level has 4x less pixels than the previous, but such a big scale factor will degrade feature matching scores dramatically.
    `static ORB` | `create(int nfeatures)` The ORB constructor
    `static ORB` | `create(int nfeatures, float scaleFactor)` The ORB constructor
    `static ORB` | `create(int nfeatures, float scaleFactor, int nlevels)` The ORB constructor
    `static ORB` | `create(int nfeatures, float scaleFactor, int nlevels, int edgeThreshold)` The ORB constructor
    `static ORB` | `create(int nfeatures, float scaleFactor, int nlevels, int edgeThreshold, int firstLevel)` The ORB constructor
    `static ORB` | `create(int nfeatures, float scaleFactor, int nlevels, int edgeThreshold, int firstLevel, int WTA_K)` The ORB constructor
    `static ORB` | `create(int nfeatures, float scaleFactor, int nlevels, int edgeThreshold, int firstLevel, int WTA_K, int scoreType)` The ORB constructor
    `static ORB` | `create(int nfeatures, float scaleFactor, int nlevels, int edgeThreshold, int firstLevel, int WTA_K, int scoreType, int patchSize)` The ORB constructor
    `static ORB` | `create(int nfeatures, float scaleFactor, int nlevels, int edgeThreshold, int firstLevel, int WTA_K, int scoreType, int patchSize, int fastThreshold)` The ORB constructor
    `protected void` | `finalize()`
    `String` | `getDefaultName()` Returns the algorithm string identifier.
    `int` | `getEdgeThreshold()`
    `int` | `getFastThreshold()`
    `int` | `getFirstLevel()`
    `int` | `getMaxFeatures()`
    `int` | `getNLevels()`
    `int` | `getPatchSize()`
    `double` | `getScaleFactor()`
    `int` | `getScoreType()`
    `int` | `getWTA_K()`
    `void` | `setEdgeThreshold(int edgeThreshold)`
    `void` | `setFastThreshold(int fastThreshold)`
    `void` | `setFirstLevel(int firstLevel)`
    `void` | `setMaxFeatures(int maxFeatures)`
    `void` | `setNLevels(int nlevels)`
    `void` | `setPatchSize(int patchSize)`
    `void` | `setScaleFactor(double scaleFactor)`
    `void` | `setScoreType(int scoreType)`
    `void` | `setWTA_K(int wta_k)`

    - ### Methods inherited from class org.opencv.features2d.Feature2D

      `compute, compute, defaultNorm, descriptorSize, descriptorType, detect, detect, detect, detect, detectAndCompute, detectAndCompute, empty, read, write`

    - ### Methods inherited from class org.opencv.core.Algorithm

      `clear, getNativeObjAddr, save`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### kBytes

          public static final int kBytes

      See Also:
        Constant Field Values

    - #### HARRIS_SCORE

          public static final int HARRIS_SCORE

      See Also:
        Constant Field Values

    - #### FAST_SCORE

          public static final int FAST_SCORE

      See Also:
        Constant Field Values

  - ### Constructor Detail

    - #### ORB

          protected ORB(long addr)

  - ### Method Detail

    - #### __fromPtr__

          public static ORB __fromPtr__(long addr)

    - #### create

          public static ORB create(int nfeatures,
                                   float scaleFactor,
                                   int nlevels,
                                   int edgeThreshold,
                                   int firstLevel,
                                   int WTA_K,
                                   int scoreType,
                                   int patchSize,
                                   int fastThreshold)

      The ORB constructor
      Parameters:
        `nfeatures` - The maximum number of features to retain.
        `scaleFactor` - Pyramid decimation ratio, greater than 1. scaleFactor==2 means the classical pyramid, where each next level has 4x less pixels than the previous, but such a big scale factor will degrade feature matching scores dramatically. On the other hand, too close to 1 scale factor will mean that to cover certain scale range you will need more pyramid levels and so the speed will suffer.
        `nlevels` - The number of pyramid levels. The smallest level will have linear size equal to input_image_linear_size/pow(scaleFactor, nlevels - firstLevel).
        `edgeThreshold` - This is size of the border where the features are not detected. It should roughly match the patchSize parameter.
        `firstLevel` - The level of pyramid to put source image to. Previous layers are filled with upscaled source image.
        `WTA_K` - The number of points that produce each element of the oriented BRIEF descriptor. The default value 2 means the BRIEF where we take a random point pair and compare their brightnesses, so we get 0/1 response. Other possible values are 3 and 4. For example, 3 means that we take 3 random points (of course, those point coordinates are random, but they are generated from the pre-defined seed, so each element of BRIEF descriptor is computed deterministically from the pixel rectangle), find point of maximum brightness and output index of the winner (0, 1 or 2). Such output will occupy 2 bits, and therefore it will need a special variant of Hamming distance, denoted as NORM_HAMMING2 (2 bits per bin). When WTA_K=4, we take 4 random points to compute each bin (that will also occupy 2 bits with possible values 0, 1, 2 or 3).
        `scoreType` - The default HARRIS_SCORE means that Harris algorithm is used to rank features (the score is written to KeyPoint::score and is used to retain best nfeatures features); FAST_SCORE is alternative value of the parameter that produces slightly less stable keypoints, but it is a little faster to compute.
        `patchSize` - size of the patch used by the oriented BRIEF descriptor. Of course, on smaller pyramid layers the perceived image area covered by a feature will be larger.
        `fastThreshold` - the fast threshold
      Returns:
        automatically generated

    - #### create

          public static ORB create(int nfeatures,
                                   float scaleFactor,
                                   int nlevels,
                                   int edgeThreshold,
                                   int firstLevel,
                                   int WTA_K,
                                   int scoreType,
                                   int patchSize)

      The ORB constructor
      Parameters:
        `nfeatures` - The maximum number of features to retain.
        `scaleFactor` - Pyramid decimation ratio, greater than 1. scaleFactor==2 means the classical pyramid, where each next level has 4x less pixels than the previous, but such a big scale factor will degrade feature matching scores dramatically. On the other hand, too close to 1 scale factor will mean that to cover certain scale range you will need more pyramid levels and so the speed will suffer.
        `nlevels` - The number of pyramid levels. The smallest level will have linear size equal to input_image_linear_size/pow(scaleFactor, nlevels - firstLevel).
        `edgeThreshold` - This is size of the border where the features are not detected. It should roughly match the patchSize parameter.
        `firstLevel` - The level of pyramid to put source image to. Previous layers are filled with upscaled source image.
        `WTA_K` - The number of points that produce each element of the oriented BRIEF descriptor. The default value 2 means the BRIEF where we take a random point pair and compare their brightnesses, so we get 0/1 response. Other possible values are 3 and 4. For example, 3 means that we take 3 random points (of course, those point coordinates are random, but they are generated from the pre-defined seed, so each element of BRIEF descriptor is computed deterministically from the pixel rectangle), find point of maximum brightness and output index of the winner (0, 1 or 2). Such output will occupy 2 bits, and therefore it will need a special variant of Hamming distance, denoted as NORM_HAMMING2 (2 bits per bin). When WTA_K=4, we take 4 random points to compute each bin (that will also occupy 2 bits with possible values 0, 1, 2 or 3).
        `scoreType` - The default HARRIS_SCORE means that Harris algorithm is used to rank features (the score is written to KeyPoint::score and is used to retain best nfeatures features); FAST_SCORE is alternative value of the parameter that produces slightly less stable keypoints, but it is a little faster to compute.
        `patchSize` - size of the patch used by the oriented BRIEF descriptor. Of course, on smaller pyramid layers the perceived image area covered by a feature will be larger.
      Returns:
        automatically generated

    - #### create

          public static ORB create(int nfeatures,
                                   float scaleFactor,
                                   int nlevels,
                                   int edgeThreshold,
                                   int firstLevel,
                                   int WTA_K,
                                   int scoreType)

      The ORB constructor
      Parameters:
        `nfeatures` - The maximum number of features to retain.
        `scaleFactor` - Pyramid decimation ratio, greater than 1. scaleFactor==2 means the classical pyramid, where each next level has 4x less pixels than the previous, but such a big scale factor will degrade feature matching scores dramatically. On the other hand, too close to 1 scale factor will mean that to cover certain scale range you will need more pyramid levels and so the speed will suffer.
        `nlevels` - The number of pyramid levels. The smallest level will have linear size equal to input_image_linear_size/pow(scaleFactor, nlevels - firstLevel).
        `edgeThreshold` - This is size of the border where the features are not detected. It should roughly match the patchSize parameter.
        `firstLevel` - The level of pyramid to put source image to. Previous layers are filled with upscaled source image.
        `WTA_K` - The number of points that produce each element of the oriented BRIEF descriptor. The default value 2 means the BRIEF where we take a random point pair and compare their brightnesses, so we get 0/1 response. Other possible values are 3 and 4. For example, 3 means that we take 3 random points (of course, those point coordinates are random, but they are generated from the pre-defined seed, so each element of BRIEF descriptor is computed deterministically from the pixel rectangle), find point of maximum brightness and output index of the winner (0, 1 or 2). Such output will occupy 2 bits, and therefore it will need a special variant of Hamming distance, denoted as NORM_HAMMING2 (2 bits per bin). When WTA_K=4, we take 4 random points to compute each bin (that will also occupy 2 bits with possible values 0, 1, 2 or 3).
        `scoreType` - The default HARRIS_SCORE means that Harris algorithm is used to rank features (the score is written to KeyPoint::score and is used to retain best nfeatures features); FAST_SCORE is alternative value of the parameter that produces slightly less stable keypoints, but it is a little faster to compute. pyramid layers the perceived image area covered by a feature will be larger.
      Returns:
        automatically generated

    - #### create

          public static ORB create(int nfeatures,
                                   float scaleFactor,
                                   int nlevels,
                                   int edgeThreshold,
                                   int firstLevel,
                                   int WTA_K)

      The ORB constructor
      Parameters:
        `nfeatures` - The maximum number of features to retain.
        `scaleFactor` - Pyramid decimation ratio, greater than 1. scaleFactor==2 means the classical pyramid, where each next level has 4x less pixels than the previous, but such a big scale factor will degrade feature matching scores dramatically. On the other hand, too close to 1 scale factor will mean that to cover certain scale range you will need more pyramid levels and so the speed will suffer.
        `nlevels` - The number of pyramid levels. The smallest level will have linear size equal to input_image_linear_size/pow(scaleFactor, nlevels - firstLevel).
        `edgeThreshold` - This is size of the border where the features are not detected. It should roughly match the patchSize parameter.
        `firstLevel` - The level of pyramid to put source image to. Previous layers are filled with upscaled source image.
        `WTA_K` - The number of points that produce each element of the oriented BRIEF descriptor. The default value 2 means the BRIEF where we take a random point pair and compare their brightnesses, so we get 0/1 response. Other possible values are 3 and 4. For example, 3 means that we take 3 random points (of course, those point coordinates are random, but they are generated from the pre-defined seed, so each element of BRIEF descriptor is computed deterministically from the pixel rectangle), find point of maximum brightness and output index of the winner (0, 1 or 2). Such output will occupy 2 bits, and therefore it will need a special variant of Hamming distance, denoted as NORM_HAMMING2 (2 bits per bin). When WTA_K=4, we take 4 random points to compute each bin (that will also occupy 2 bits with possible values 0, 1, 2 or 3). (the score is written to KeyPoint::score and is used to retain best nfeatures features); FAST_SCORE is alternative value of the parameter that produces slightly less stable keypoints, but it is a little faster to compute. pyramid layers the perceived image area covered by a feature will be larger.
      Returns:
        automatically generated

    - #### create

          public static ORB create(int nfeatures,
                                   float scaleFactor,
                                   int nlevels,
                                   int edgeThreshold,
                                   int firstLevel)

      The ORB constructor
      Parameters:
        `nfeatures` - The maximum number of features to retain.
        `scaleFactor` - Pyramid decimation ratio, greater than 1. scaleFactor==2 means the classical pyramid, where each next level has 4x less pixels than the previous, but such a big scale factor will degrade feature matching scores dramatically. On the other hand, too close to 1 scale factor will mean that to cover certain scale range you will need more pyramid levels and so the speed will suffer.
        `nlevels` - The number of pyramid levels. The smallest level will have linear size equal to input_image_linear_size/pow(scaleFactor, nlevels - firstLevel).
        `edgeThreshold` - This is size of the border where the features are not detected. It should roughly match the patchSize parameter.
        `firstLevel` - The level of pyramid to put source image to. Previous layers are filled with upscaled source image. default value 2 means the BRIEF where we take a random point pair and compare their brightnesses, so we get 0/1 response. Other possible values are 3 and 4. For example, 3 means that we take 3 random points (of course, those point coordinates are random, but they are generated from the pre-defined seed, so each element of BRIEF descriptor is computed deterministically from the pixel rectangle), find point of maximum brightness and output index of the winner (0, 1 or 2). Such output will occupy 2 bits, and therefore it will need a special variant of Hamming distance, denoted as NORM_HAMMING2 (2 bits per bin). When WTA_K=4, we take 4 random points to compute each bin (that will also occupy 2 bits with possible values 0, 1, 2 or 3). (the score is written to KeyPoint::score and is used to retain best nfeatures features); FAST_SCORE is alternative value of the parameter that produces slightly less stable keypoints, but it is a little faster to compute. pyramid layers the perceived image area covered by a feature will be larger.
      Returns:
        automatically generated

    - #### create

          public static ORB create(int nfeatures,
                                   float scaleFactor,
                                   int nlevels,
                                   int edgeThreshold)

      The ORB constructor
      Parameters:
        `nfeatures` - The maximum number of features to retain.
        `scaleFactor` - Pyramid decimation ratio, greater than 1. scaleFactor==2 means the classical pyramid, where each next level has 4x less pixels than the previous, but such a big scale factor will degrade feature matching scores dramatically. On the other hand, too close to 1 scale factor will mean that to cover certain scale range you will need more pyramid levels and so the speed will suffer.
        `nlevels` - The number of pyramid levels. The smallest level will have linear size equal to input_image_linear_size/pow(scaleFactor, nlevels - firstLevel).
        `edgeThreshold` - This is size of the border where the features are not detected. It should roughly match the patchSize parameter. with upscaled source image. default value 2 means the BRIEF where we take a random point pair and compare their brightnesses, so we get 0/1 response. Other possible values are 3 and 4. For example, 3 means that we take 3 random points (of course, those point coordinates are random, but they are generated from the pre-defined seed, so each element of BRIEF descriptor is computed deterministically from the pixel rectangle), find point of maximum brightness and output index of the winner (0, 1 or 2). Such output will occupy 2 bits, and therefore it will need a special variant of Hamming distance, denoted as NORM_HAMMING2 (2 bits per bin). When WTA_K=4, we take 4 random points to compute each bin (that will also occupy 2 bits with possible values 0, 1, 2 or 3). (the score is written to KeyPoint::score and is used to retain best nfeatures features); FAST_SCORE is alternative value of the parameter that produces slightly less stable keypoints, but it is a little faster to compute. pyramid layers the perceived image area covered by a feature will be larger.
      Returns:
        automatically generated

    - #### create

          public static ORB create(int nfeatures,
                                   float scaleFactor,
                                   int nlevels)

      The ORB constructor
      Parameters:
        `nfeatures` - The maximum number of features to retain.
        `scaleFactor` - Pyramid decimation ratio, greater than 1. scaleFactor==2 means the classical pyramid, where each next level has 4x less pixels than the previous, but such a big scale factor will degrade feature matching scores dramatically. On the other hand, too close to 1 scale factor will mean that to cover certain scale range you will need more pyramid levels and so the speed will suffer.
        `nlevels` - The number of pyramid levels. The smallest level will have linear size equal to input_image_linear_size/pow(scaleFactor, nlevels - firstLevel). roughly match the patchSize parameter. with upscaled source image. default value 2 means the BRIEF where we take a random point pair and compare their brightnesses, so we get 0/1 response. Other possible values are 3 and 4. For example, 3 means that we take 3 random points (of course, those point coordinates are random, but they are generated from the pre-defined seed, so each element of BRIEF descriptor is computed deterministically from the pixel rectangle), find point of maximum brightness and output index of the winner (0, 1 or 2). Such output will occupy 2 bits, and therefore it will need a special variant of Hamming distance, denoted as NORM_HAMMING2 (2 bits per bin). When WTA_K=4, we take 4 random points to compute each bin (that will also occupy 2 bits with possible values 0, 1, 2 or 3). (the score is written to KeyPoint::score and is used to retain best nfeatures features); FAST_SCORE is alternative value of the parameter that produces slightly less stable keypoints, but it is a little faster to compute. pyramid layers the perceived image area covered by a feature will be larger.
      Returns:
        automatically generated

    - #### create

          public static ORB create(int nfeatures,
                                   float scaleFactor)

      The ORB constructor
      Parameters:
        `nfeatures` - The maximum number of features to retain.
        `scaleFactor` - Pyramid decimation ratio, greater than 1. scaleFactor==2 means the classical pyramid, where each next level has 4x less pixels than the previous, but such a big scale factor will degrade feature matching scores dramatically. On the other hand, too close to 1 scale factor will mean that to cover certain scale range you will need more pyramid levels and so the speed will suffer. input_image_linear_size/pow(scaleFactor, nlevels - firstLevel). roughly match the patchSize parameter. with upscaled source image. default value 2 means the BRIEF where we take a random point pair and compare their brightnesses, so we get 0/1 response. Other possible values are 3 and 4. For example, 3 means that we take 3 random points (of course, those point coordinates are random, but they are generated from the pre-defined seed, so each element of BRIEF descriptor is computed deterministically from the pixel rectangle), find point of maximum brightness and output index of the winner (0, 1 or 2). Such output will occupy 2 bits, and therefore it will need a special variant of Hamming distance, denoted as NORM_HAMMING2 (2 bits per bin). When WTA_K=4, we take 4 random points to compute each bin (that will also occupy 2 bits with possible values 0, 1, 2 or 3). (the score is written to KeyPoint::score and is used to retain best nfeatures features); FAST_SCORE is alternative value of the parameter that produces slightly less stable keypoints, but it is a little faster to compute. pyramid layers the perceived image area covered by a feature will be larger.
      Returns:
        automatically generated

    - #### create

          public static ORB create(int nfeatures)

      The ORB constructor
      Parameters:
        `nfeatures` - The maximum number of features to retain. pyramid, where each next level has 4x less pixels than the previous, but such a big scale factor will degrade feature matching scores dramatically. On the other hand, too close to 1 scale factor will mean that to cover certain scale range you will need more pyramid levels and so the speed will suffer. input_image_linear_size/pow(scaleFactor, nlevels - firstLevel). roughly match the patchSize parameter. with upscaled source image. default value 2 means the BRIEF where we take a random point pair and compare their brightnesses, so we get 0/1 response. Other possible values are 3 and 4. For example, 3 means that we take 3 random points (of course, those point coordinates are random, but they are generated from the pre-defined seed, so each element of BRIEF descriptor is computed deterministically from the pixel rectangle), find point of maximum brightness and output index of the winner (0, 1 or 2). Such output will occupy 2 bits, and therefore it will need a special variant of Hamming distance, denoted as NORM_HAMMING2 (2 bits per bin). When WTA_K=4, we take 4 random points to compute each bin (that will also occupy 2 bits with possible values 0, 1, 2 or 3). (the score is written to KeyPoint::score and is used to retain best nfeatures features); FAST_SCORE is alternative value of the parameter that produces slightly less stable keypoints, but it is a little faster to compute. pyramid layers the perceived image area covered by a feature will be larger.
      Returns:
        automatically generated

    - #### create

          public static ORB create()

      The ORB constructor pyramid, where each next level has 4x less pixels than the previous, but such a big scale factor will degrade feature matching scores dramatically. On the other hand, too close to 1 scale factor will mean that to cover certain scale range you will need more pyramid levels and so the speed will suffer. input_image_linear_size/pow(scaleFactor, nlevels - firstLevel). roughly match the patchSize parameter. with upscaled source image. default value 2 means the BRIEF where we take a random point pair and compare their brightnesses, so we get 0/1 response. Other possible values are 3 and 4. For example, 3 means that we take 3 random points (of course, those point coordinates are random, but they are generated from the pre-defined seed, so each element of BRIEF descriptor is computed deterministically from the pixel rectangle), find point of maximum brightness and output index of the winner (0, 1 or 2). Such output will occupy 2 bits, and therefore it will need a special variant of Hamming distance, denoted as NORM_HAMMING2 (2 bits per bin). When WTA_K=4, we take 4 random points to compute each bin (that will also occupy 2 bits with possible values 0, 1, 2 or 3). (the score is written to KeyPoint::score and is used to retain best nfeatures features); FAST_SCORE is alternative value of the parameter that produces slightly less stable keypoints, but it is a little faster to compute. pyramid layers the perceived image area covered by a feature will be larger.
      Returns:
        automatically generated

    - #### getDefaultName

          public String getDefaultName()

      Description copied from class: `Algorithm`
      Returns the algorithm string identifier. This string is used as top level xml/yml node tag when the object is saved to a file or string.
      Overrides:
        `getDefaultName` in class `Feature2D`
      Returns:
        automatically generated

    - #### getScaleFactor

          public double getScaleFactor()

    - #### getEdgeThreshold

          public int getEdgeThreshold()

    - #### getFastThreshold

          public int getFastThreshold()

    - #### getFirstLevel

          public int getFirstLevel()

    - #### getMaxFeatures

          public int getMaxFeatures()

    - #### getNLevels

          public int getNLevels()

    - #### getPatchSize

          public int getPatchSize()

    - #### getScoreType

          public int getScoreType()

    - #### getWTA_K

          public int getWTA_K()

    - #### setEdgeThreshold

          public void setEdgeThreshold(int edgeThreshold)

    - #### setFastThreshold

          public void setFastThreshold(int fastThreshold)

    - #### setFirstLevel

          public void setFirstLevel(int firstLevel)

    - #### setMaxFeatures

          public void setMaxFeatures(int maxFeatures)

    - #### setNLevels

          public void setNLevels(int nlevels)

    - #### setPatchSize

          public void setPatchSize(int patchSize)

    - #### setScaleFactor

          public void setScaleFactor(double scaleFactor)

    - #### setScoreType

          public void setScoreType(int scoreType)

    - #### setWTA_K

          public void setWTA_K(int wta_k)

    - #### finalize

          protected void finalize()
                           throws Throwable

      Overrides:
        `finalize` in class `Feature2D`
      Throws:
        `Throwable`

Generated on Thu Jul 25 2019 21:39:44 UTC / OpenCV 3.4.7