Class 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).
    • 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
      • setMaxFeatures

        public void setMaxFeatures​(int maxFeatures)
      • getMaxFeatures

        public int getMaxFeatures()
      • setScaleFactor

        public void setScaleFactor​(double scaleFactor)
      • getScaleFactor

        public double getScaleFactor()
      • setNLevels

        public void setNLevels​(int nlevels)
      • getNLevels

        public int getNLevels()
      • setEdgeThreshold

        public void setEdgeThreshold​(int edgeThreshold)
      • getEdgeThreshold

        public int getEdgeThreshold()
      • setFirstLevel

        public void setFirstLevel​(int firstLevel)
      • getFirstLevel

        public int getFirstLevel()
      • setWTA_K

        public void setWTA_K​(int wta_k)
      • getWTA_K

        public int getWTA_K()
      • setScoreType

        public void setScoreType​(int scoreType)
      • getScoreType

        public int getScoreType()
      • setPatchSize

        public void setPatchSize​(int patchSize)
      • getPatchSize

        public int getPatchSize()
      • setFastThreshold

        public void setFastThreshold​(int fastThreshold)
      • getFastThreshold

        public int getFastThreshold()
      • 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