//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 }
void DoProcess() { if (!(owner.Value is OpenCVForUnityPlayMakerActions.ORB)) { LogError("owner is not initialized. Add Action \"newORB\"."); return; } OpenCVForUnity.Features2dModule.ORB wrapped_owner = OpenCVForUnityPlayMakerActionsUtils.GetWrappedObject <OpenCVForUnityPlayMakerActions.ORB, OpenCVForUnity.Features2dModule.ORB>(owner); storeResult.Value = (float)wrapped_owner.getScaleFactor(); }
void DoProcess() { if (!(owner.Value is OpenCVForUnityPlayMakerActions.ORB)) { LogError("owner is not initialized. Add Action \"newORB\"."); return; } OpenCVForUnity.Features2dModule.ORB wrapped_owner = OpenCVForUnityPlayMakerActionsUtils.GetWrappedObject <OpenCVForUnityPlayMakerActions.ORB, OpenCVForUnity.Features2dModule.ORB>(owner); wrapped_owner.setEdgeThreshold(edgeThreshold.Value); }
void DoProcess() { if (!(owner.Value is OpenCVForUnityPlayMakerActions.ORB)) { LogError("owner is not initialized. Add Action \"newORB\"."); return; } OpenCVForUnity.Features2dModule.ORB wrapped_owner = OpenCVForUnityPlayMakerActionsUtils.GetWrappedObject <OpenCVForUnityPlayMakerActions.ORB, OpenCVForUnity.Features2dModule.ORB>(owner); if (!(scaleFactor.Value is OpenCVForUnityPlayMakerActions.Double)) { LogError("scaleFactor is not initialized. Add Action \"newDouble\"."); return; } System.Double wrapped_scaleFactor = OpenCVForUnityPlayMakerActionsUtils.GetWrappedObject <OpenCVForUnityPlayMakerActions.Double, System.Double>(scaleFactor); wrapped_owner.setScaleFactor(wrapped_scaleFactor); }
public ORB(OpenCVForUnity.Features2dModule.ORB nativeObj) : base(nativeObj) { }
/** * 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))); }