//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)));
}
