Package org.opencv.features

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

      • finalize

        protected void finalize()
                 throws java.lang.Throwable
        Overrides:
        finalize in class Feature2D
        Throws:
        java.lang.Throwable