//javadoc: ORB::create(nfeatures, scaleFactor, nlevels, edgeThreshold, firstLevel, WTA_K, scoreType) public static ORB create(int nfeatures, float scaleFactor, int nlevels, int edgeThreshold, int firstLevel, int WTA_K, int scoreType) { #if ((UNITY_ANDROID || UNITY_IOS || UNITY_WEBGL) && !UNITY_EDITOR) || UNITY_5 || UNITY_5_3_OR_NEWER ORB retVal = ORB.__fromPtr__(features2d_ORB_create_12(nfeatures, scaleFactor, nlevels, edgeThreshold, firstLevel, WTA_K, scoreType)); return(retVal); #else return(null); #endif }
//javadoc: ORB::create() public static ORB create() { #if ((UNITY_ANDROID || UNITY_IOS || UNITY_WEBGL) && !UNITY_EDITOR) || UNITY_5 || UNITY_5_3_OR_NEWER ORB retVal = ORB.__fromPtr__(features2d_ORB_create_19()); return(retVal); #else return(null); #endif }
//javadoc: ORB::create(nfeatures, scaleFactor) public static ORB create(int nfeatures, float scaleFactor) { #if ((UNITY_ANDROID || UNITY_IOS || UNITY_WEBGL) && !UNITY_EDITOR) || UNITY_5 || UNITY_5_3_OR_NEWER ORB retVal = ORB.__fromPtr__(features2d_ORB_create_17(nfeatures, scaleFactor)); return(retVal); #else return(null); #endif }
/** * 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. * return automatically generated */ public static ORB create() { return(ORB.__fromPtr__(features2d_ORB_create_19())); }
/** * The ORB constructor * * param 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. * return automatically generated */ public static ORB create(int nfeatures) { return(ORB.__fromPtr__(features2d_ORB_create_18(nfeatures))); }
/** * The ORB constructor * * param nfeatures The maximum number of features to retain. * param 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. * return automatically generated */ public static ORB create(int nfeatures, float scaleFactor) { return(ORB.__fromPtr__(features2d_ORB_create_17(nfeatures, scaleFactor))); }
/** * The ORB constructor * * param nfeatures The maximum number of features to retain. * param 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. * param 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. * return automatically generated */ public static ORB create(int nfeatures, float scaleFactor, int nlevels) { return(ORB.__fromPtr__(features2d_ORB_create_16(nfeatures, scaleFactor, nlevels))); }
/** * The ORB constructor * * param nfeatures The maximum number of features to retain. * param 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. * param nlevels The number of pyramid levels. The smallest level will have linear size equal to * input_image_linear_size/pow(scaleFactor, nlevels - firstLevel). * param 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. * return automatically generated */ public static ORB create(int nfeatures, float scaleFactor, int nlevels, int edgeThreshold) { return(ORB.__fromPtr__(features2d_ORB_create_15(nfeatures, scaleFactor, nlevels, edgeThreshold))); }
/** * The ORB constructor * * param nfeatures The maximum number of features to retain. * param 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. * param nlevels The number of pyramid levels. The smallest level will have linear size equal to * input_image_linear_size/pow(scaleFactor, nlevels - firstLevel). * param edgeThreshold This is size of the border where the features are not detected. It should * roughly match the patchSize parameter. * param firstLevel The level of pyramid to put source image to. Previous layers are filled * with upscaled source image. * param 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. * return automatically generated */ public static ORB create(int nfeatures, float scaleFactor, int nlevels, int edgeThreshold, int firstLevel, int WTA_K) { return(ORB.__fromPtr__(features2d_ORB_create_13(nfeatures, scaleFactor, nlevels, edgeThreshold, firstLevel, WTA_K))); }
/** * The ORB constructor * * param nfeatures The maximum number of features to retain. * param 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. * param nlevels The number of pyramid levels. The smallest level will have linear size equal to * input_image_linear_size/pow(scaleFactor, nlevels - firstLevel). * param edgeThreshold This is size of the border where the features are not detected. It should * roughly match the patchSize parameter. * param firstLevel The level of pyramid to put source image to. Previous layers are filled * with upscaled source image. * param 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). * param 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. * param 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. * return automatically generated */ public static ORB create(int nfeatures, float scaleFactor, int nlevels, int edgeThreshold, int firstLevel, int WTA_K, int scoreType, int patchSize) { return(ORB.__fromPtr__(features2d_ORB_create_11(nfeatures, scaleFactor, nlevels, edgeThreshold, firstLevel, WTA_K, scoreType, patchSize))); }