Package 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 | Description
    --- | --- | ---
    `static int` | `FAST_SCORE` |
    `static int` | `HARRIS_SCORE` |

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

      `nativeObj`

  - ### Constructor Summary

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

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method | 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()` |
    `java.lang.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

    - #### 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)

    - #### getScoreType

          public int getScoreType()

    - #### 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 java.lang.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()

    - #### 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 java.lang.Throwable

      Overrides:
        `finalize` in class `Feature2D`
      Throws:
        `java.lang.Throwable`