812 lines
37 KiB
C#
812 lines
37 KiB
C#
|
|
||
|
|
using OpenCVForUnity.CoreModule;
|
||
|
|
using OpenCVForUnity.UtilsModule;
|
||
|
|
using System;
|
||
|
|
using System.Collections.Generic;
|
||
|
|
using System.Runtime.InteropServices;
|
||
|
|
|
||
|
|
namespace OpenCVForUnity.Features2dModule
|
||
|
|
{
|
||
|
|
|
||
|
|
// C++: class ORB
|
||
|
|
/**
|
||
|
|
* 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).
|
||
|
|
*/
|
||
|
|
|
||
|
|
public class ORB : Feature2D
|
||
|
|
{
|
||
|
|
|
||
|
|
protected override void Dispose(bool disposing)
|
||
|
|
{
|
||
|
|
|
||
|
|
try
|
||
|
|
{
|
||
|
|
if (disposing)
|
||
|
|
{
|
||
|
|
}
|
||
|
|
if (IsEnabledDispose)
|
||
|
|
{
|
||
|
|
if (nativeObj != IntPtr.Zero)
|
||
|
|
features2d_ORB_delete(nativeObj);
|
||
|
|
nativeObj = IntPtr.Zero;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
finally
|
||
|
|
{
|
||
|
|
base.Dispose(disposing);
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
protected internal ORB(IntPtr addr) : base(addr) { }
|
||
|
|
|
||
|
|
// internal usage only
|
||
|
|
public static new ORB __fromPtr__(IntPtr addr) { return new ORB(addr); }
|
||
|
|
|
||
|
|
// C++: enum cv.ORB.ScoreType
|
||
|
|
public const int HARRIS_SCORE = 0;
|
||
|
|
public const int FAST_SCORE = 1;
|
||
|
|
//
|
||
|
|
// C++: static Ptr_ORB cv::ORB::create(int nfeatures = 500, float scaleFactor = 1.2f, int nlevels = 8, int edgeThreshold = 31, int firstLevel = 0, int WTA_K = 2, ORB_ScoreType scoreType = ORB::HARRIS_SCORE, int patchSize = 31, int fastThreshold = 20)
|
||
|
|
//
|
||
|
|
|
||
|
|
/**
|
||
|
|
* 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.
|
||
|
|
* param fastThreshold the fast threshold
|
||
|
|
* return automatically generated
|
||
|
|
*/
|
||
|
|
public static ORB create(int nfeatures, float scaleFactor, int nlevels, int edgeThreshold, int firstLevel, int WTA_K, int scoreType, int patchSize, int fastThreshold)
|
||
|
|
{
|
||
|
|
|
||
|
|
|
||
|
|
return ORB.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(features2d_ORB_create_10(nfeatures, scaleFactor, nlevels, edgeThreshold, firstLevel, WTA_K, scoreType, patchSize, fastThreshold)));
|
||
|
|
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* 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__(DisposableObject.ThrowIfNullIntPtr(features2d_ORB_create_11(nfeatures, scaleFactor, nlevels, edgeThreshold, firstLevel, WTA_K, scoreType, patchSize)));
|
||
|
|
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* 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.
|
||
|
|
* 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)
|
||
|
|
{
|
||
|
|
|
||
|
|
|
||
|
|
return ORB.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(features2d_ORB_create_12(nfeatures, scaleFactor, nlevels, edgeThreshold, firstLevel, WTA_K, scoreType)));
|
||
|
|
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* 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__(DisposableObject.ThrowIfNullIntPtr(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.
|
||
|
|
* 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)
|
||
|
|
{
|
||
|
|
|
||
|
|
|
||
|
|
return ORB.__fromPtr__(DisposableObject.ThrowIfNullIntPtr(features2d_ORB_create_14(nfeatures, scaleFactor, nlevels, edgeThreshold, firstLevel)));
|
||
|
|
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* 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__(DisposableObject.ThrowIfNullIntPtr(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).
|
||
|
|
* 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__(DisposableObject.ThrowIfNullIntPtr(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.
|
||
|
|
* 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__(DisposableObject.ThrowIfNullIntPtr(features2d_ORB_create_17(nfeatures, scaleFactor)));
|
||
|
|
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* 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__(DisposableObject.ThrowIfNullIntPtr(features2d_ORB_create_18(nfeatures)));
|
||
|
|
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* 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__(DisposableObject.ThrowIfNullIntPtr(features2d_ORB_create_19()));
|
||
|
|
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//
|
||
|
|
// C++: void cv::ORB::setMaxFeatures(int maxFeatures)
|
||
|
|
//
|
||
|
|
|
||
|
|
public void setMaxFeatures(int maxFeatures)
|
||
|
|
{
|
||
|
|
ThrowIfDisposed();
|
||
|
|
|
||
|
|
features2d_ORB_setMaxFeatures_10(nativeObj, maxFeatures);
|
||
|
|
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//
|
||
|
|
// C++: int cv::ORB::getMaxFeatures()
|
||
|
|
//
|
||
|
|
|
||
|
|
public int getMaxFeatures()
|
||
|
|
{
|
||
|
|
ThrowIfDisposed();
|
||
|
|
|
||
|
|
return features2d_ORB_getMaxFeatures_10(nativeObj);
|
||
|
|
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//
|
||
|
|
// C++: void cv::ORB::setScaleFactor(double scaleFactor)
|
||
|
|
//
|
||
|
|
|
||
|
|
public void setScaleFactor(double scaleFactor)
|
||
|
|
{
|
||
|
|
ThrowIfDisposed();
|
||
|
|
|
||
|
|
features2d_ORB_setScaleFactor_10(nativeObj, scaleFactor);
|
||
|
|
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//
|
||
|
|
// C++: double cv::ORB::getScaleFactor()
|
||
|
|
//
|
||
|
|
|
||
|
|
public double getScaleFactor()
|
||
|
|
{
|
||
|
|
ThrowIfDisposed();
|
||
|
|
|
||
|
|
return features2d_ORB_getScaleFactor_10(nativeObj);
|
||
|
|
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//
|
||
|
|
// C++: void cv::ORB::setNLevels(int nlevels)
|
||
|
|
//
|
||
|
|
|
||
|
|
public void setNLevels(int nlevels)
|
||
|
|
{
|
||
|
|
ThrowIfDisposed();
|
||
|
|
|
||
|
|
features2d_ORB_setNLevels_10(nativeObj, nlevels);
|
||
|
|
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//
|
||
|
|
// C++: int cv::ORB::getNLevels()
|
||
|
|
//
|
||
|
|
|
||
|
|
public int getNLevels()
|
||
|
|
{
|
||
|
|
ThrowIfDisposed();
|
||
|
|
|
||
|
|
return features2d_ORB_getNLevels_10(nativeObj);
|
||
|
|
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//
|
||
|
|
// C++: void cv::ORB::setEdgeThreshold(int edgeThreshold)
|
||
|
|
//
|
||
|
|
|
||
|
|
public void setEdgeThreshold(int edgeThreshold)
|
||
|
|
{
|
||
|
|
ThrowIfDisposed();
|
||
|
|
|
||
|
|
features2d_ORB_setEdgeThreshold_10(nativeObj, edgeThreshold);
|
||
|
|
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//
|
||
|
|
// C++: int cv::ORB::getEdgeThreshold()
|
||
|
|
//
|
||
|
|
|
||
|
|
public int getEdgeThreshold()
|
||
|
|
{
|
||
|
|
ThrowIfDisposed();
|
||
|
|
|
||
|
|
return features2d_ORB_getEdgeThreshold_10(nativeObj);
|
||
|
|
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//
|
||
|
|
// C++: void cv::ORB::setFirstLevel(int firstLevel)
|
||
|
|
//
|
||
|
|
|
||
|
|
public void setFirstLevel(int firstLevel)
|
||
|
|
{
|
||
|
|
ThrowIfDisposed();
|
||
|
|
|
||
|
|
features2d_ORB_setFirstLevel_10(nativeObj, firstLevel);
|
||
|
|
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//
|
||
|
|
// C++: int cv::ORB::getFirstLevel()
|
||
|
|
//
|
||
|
|
|
||
|
|
public int getFirstLevel()
|
||
|
|
{
|
||
|
|
ThrowIfDisposed();
|
||
|
|
|
||
|
|
return features2d_ORB_getFirstLevel_10(nativeObj);
|
||
|
|
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//
|
||
|
|
// C++: void cv::ORB::setWTA_K(int wta_k)
|
||
|
|
//
|
||
|
|
|
||
|
|
public void setWTA_K(int wta_k)
|
||
|
|
{
|
||
|
|
ThrowIfDisposed();
|
||
|
|
|
||
|
|
features2d_ORB_setWTA_1K_10(nativeObj, wta_k);
|
||
|
|
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//
|
||
|
|
// C++: int cv::ORB::getWTA_K()
|
||
|
|
//
|
||
|
|
|
||
|
|
public int getWTA_K()
|
||
|
|
{
|
||
|
|
ThrowIfDisposed();
|
||
|
|
|
||
|
|
return features2d_ORB_getWTA_1K_10(nativeObj);
|
||
|
|
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//
|
||
|
|
// C++: void cv::ORB::setScoreType(ORB_ScoreType scoreType)
|
||
|
|
//
|
||
|
|
|
||
|
|
public void setScoreType(int scoreType)
|
||
|
|
{
|
||
|
|
ThrowIfDisposed();
|
||
|
|
|
||
|
|
features2d_ORB_setScoreType_10(nativeObj, scoreType);
|
||
|
|
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//
|
||
|
|
// C++: ORB_ScoreType cv::ORB::getScoreType()
|
||
|
|
//
|
||
|
|
|
||
|
|
public int getScoreType()
|
||
|
|
{
|
||
|
|
ThrowIfDisposed();
|
||
|
|
|
||
|
|
return features2d_ORB_getScoreType_10(nativeObj);
|
||
|
|
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//
|
||
|
|
// C++: void cv::ORB::setPatchSize(int patchSize)
|
||
|
|
//
|
||
|
|
|
||
|
|
public void setPatchSize(int patchSize)
|
||
|
|
{
|
||
|
|
ThrowIfDisposed();
|
||
|
|
|
||
|
|
features2d_ORB_setPatchSize_10(nativeObj, patchSize);
|
||
|
|
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//
|
||
|
|
// C++: int cv::ORB::getPatchSize()
|
||
|
|
//
|
||
|
|
|
||
|
|
public int getPatchSize()
|
||
|
|
{
|
||
|
|
ThrowIfDisposed();
|
||
|
|
|
||
|
|
return features2d_ORB_getPatchSize_10(nativeObj);
|
||
|
|
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//
|
||
|
|
// C++: void cv::ORB::setFastThreshold(int fastThreshold)
|
||
|
|
//
|
||
|
|
|
||
|
|
public void setFastThreshold(int fastThreshold)
|
||
|
|
{
|
||
|
|
ThrowIfDisposed();
|
||
|
|
|
||
|
|
features2d_ORB_setFastThreshold_10(nativeObj, fastThreshold);
|
||
|
|
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//
|
||
|
|
// C++: int cv::ORB::getFastThreshold()
|
||
|
|
//
|
||
|
|
|
||
|
|
public int getFastThreshold()
|
||
|
|
{
|
||
|
|
ThrowIfDisposed();
|
||
|
|
|
||
|
|
return features2d_ORB_getFastThreshold_10(nativeObj);
|
||
|
|
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//
|
||
|
|
// C++: String cv::ORB::getDefaultName()
|
||
|
|
//
|
||
|
|
|
||
|
|
public override string getDefaultName()
|
||
|
|
{
|
||
|
|
ThrowIfDisposed();
|
||
|
|
|
||
|
|
string retVal = Marshal.PtrToStringAnsi(DisposableObject.ThrowIfNullIntPtr(features2d_ORB_getDefaultName_10(nativeObj)));
|
||
|
|
|
||
|
|
return retVal;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
#if (UNITY_IOS || UNITY_WEBGL) && !UNITY_EDITOR
|
||
|
|
const string LIBNAME = "__Internal";
|
||
|
|
#else
|
||
|
|
const string LIBNAME = "opencvforunity";
|
||
|
|
#endif
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
// C++: static Ptr_ORB cv::ORB::create(int nfeatures = 500, float scaleFactor = 1.2f, int nlevels = 8, int edgeThreshold = 31, int firstLevel = 0, int WTA_K = 2, ORB_ScoreType scoreType = ORB::HARRIS_SCORE, int patchSize = 31, int fastThreshold = 20)
|
||
|
|
[DllImport(LIBNAME)]
|
||
|
|
private static extern IntPtr features2d_ORB_create_10(int nfeatures, float scaleFactor, int nlevels, int edgeThreshold, int firstLevel, int WTA_K, int scoreType, int patchSize, int fastThreshold);
|
||
|
|
[DllImport(LIBNAME)]
|
||
|
|
private static extern IntPtr features2d_ORB_create_11(int nfeatures, float scaleFactor, int nlevels, int edgeThreshold, int firstLevel, int WTA_K, int scoreType, int patchSize);
|
||
|
|
[DllImport(LIBNAME)]
|
||
|
|
private static extern IntPtr features2d_ORB_create_12(int nfeatures, float scaleFactor, int nlevels, int edgeThreshold, int firstLevel, int WTA_K, int scoreType);
|
||
|
|
[DllImport(LIBNAME)]
|
||
|
|
private static extern IntPtr features2d_ORB_create_13(int nfeatures, float scaleFactor, int nlevels, int edgeThreshold, int firstLevel, int WTA_K);
|
||
|
|
[DllImport(LIBNAME)]
|
||
|
|
private static extern IntPtr features2d_ORB_create_14(int nfeatures, float scaleFactor, int nlevels, int edgeThreshold, int firstLevel);
|
||
|
|
[DllImport(LIBNAME)]
|
||
|
|
private static extern IntPtr features2d_ORB_create_15(int nfeatures, float scaleFactor, int nlevels, int edgeThreshold);
|
||
|
|
[DllImport(LIBNAME)]
|
||
|
|
private static extern IntPtr features2d_ORB_create_16(int nfeatures, float scaleFactor, int nlevels);
|
||
|
|
[DllImport(LIBNAME)]
|
||
|
|
private static extern IntPtr features2d_ORB_create_17(int nfeatures, float scaleFactor);
|
||
|
|
[DllImport(LIBNAME)]
|
||
|
|
private static extern IntPtr features2d_ORB_create_18(int nfeatures);
|
||
|
|
[DllImport(LIBNAME)]
|
||
|
|
private static extern IntPtr features2d_ORB_create_19();
|
||
|
|
|
||
|
|
// C++: void cv::ORB::setMaxFeatures(int maxFeatures)
|
||
|
|
[DllImport(LIBNAME)]
|
||
|
|
private static extern void features2d_ORB_setMaxFeatures_10(IntPtr nativeObj, int maxFeatures);
|
||
|
|
|
||
|
|
// C++: int cv::ORB::getMaxFeatures()
|
||
|
|
[DllImport(LIBNAME)]
|
||
|
|
private static extern int features2d_ORB_getMaxFeatures_10(IntPtr nativeObj);
|
||
|
|
|
||
|
|
// C++: void cv::ORB::setScaleFactor(double scaleFactor)
|
||
|
|
[DllImport(LIBNAME)]
|
||
|
|
private static extern void features2d_ORB_setScaleFactor_10(IntPtr nativeObj, double scaleFactor);
|
||
|
|
|
||
|
|
// C++: double cv::ORB::getScaleFactor()
|
||
|
|
[DllImport(LIBNAME)]
|
||
|
|
private static extern double features2d_ORB_getScaleFactor_10(IntPtr nativeObj);
|
||
|
|
|
||
|
|
// C++: void cv::ORB::setNLevels(int nlevels)
|
||
|
|
[DllImport(LIBNAME)]
|
||
|
|
private static extern void features2d_ORB_setNLevels_10(IntPtr nativeObj, int nlevels);
|
||
|
|
|
||
|
|
// C++: int cv::ORB::getNLevels()
|
||
|
|
[DllImport(LIBNAME)]
|
||
|
|
private static extern int features2d_ORB_getNLevels_10(IntPtr nativeObj);
|
||
|
|
|
||
|
|
// C++: void cv::ORB::setEdgeThreshold(int edgeThreshold)
|
||
|
|
[DllImport(LIBNAME)]
|
||
|
|
private static extern void features2d_ORB_setEdgeThreshold_10(IntPtr nativeObj, int edgeThreshold);
|
||
|
|
|
||
|
|
// C++: int cv::ORB::getEdgeThreshold()
|
||
|
|
[DllImport(LIBNAME)]
|
||
|
|
private static extern int features2d_ORB_getEdgeThreshold_10(IntPtr nativeObj);
|
||
|
|
|
||
|
|
// C++: void cv::ORB::setFirstLevel(int firstLevel)
|
||
|
|
[DllImport(LIBNAME)]
|
||
|
|
private static extern void features2d_ORB_setFirstLevel_10(IntPtr nativeObj, int firstLevel);
|
||
|
|
|
||
|
|
// C++: int cv::ORB::getFirstLevel()
|
||
|
|
[DllImport(LIBNAME)]
|
||
|
|
private static extern int features2d_ORB_getFirstLevel_10(IntPtr nativeObj);
|
||
|
|
|
||
|
|
// C++: void cv::ORB::setWTA_K(int wta_k)
|
||
|
|
[DllImport(LIBNAME)]
|
||
|
|
private static extern void features2d_ORB_setWTA_1K_10(IntPtr nativeObj, int wta_k);
|
||
|
|
|
||
|
|
// C++: int cv::ORB::getWTA_K()
|
||
|
|
[DllImport(LIBNAME)]
|
||
|
|
private static extern int features2d_ORB_getWTA_1K_10(IntPtr nativeObj);
|
||
|
|
|
||
|
|
// C++: void cv::ORB::setScoreType(ORB_ScoreType scoreType)
|
||
|
|
[DllImport(LIBNAME)]
|
||
|
|
private static extern void features2d_ORB_setScoreType_10(IntPtr nativeObj, int scoreType);
|
||
|
|
|
||
|
|
// C++: ORB_ScoreType cv::ORB::getScoreType()
|
||
|
|
[DllImport(LIBNAME)]
|
||
|
|
private static extern int features2d_ORB_getScoreType_10(IntPtr nativeObj);
|
||
|
|
|
||
|
|
// C++: void cv::ORB::setPatchSize(int patchSize)
|
||
|
|
[DllImport(LIBNAME)]
|
||
|
|
private static extern void features2d_ORB_setPatchSize_10(IntPtr nativeObj, int patchSize);
|
||
|
|
|
||
|
|
// C++: int cv::ORB::getPatchSize()
|
||
|
|
[DllImport(LIBNAME)]
|
||
|
|
private static extern int features2d_ORB_getPatchSize_10(IntPtr nativeObj);
|
||
|
|
|
||
|
|
// C++: void cv::ORB::setFastThreshold(int fastThreshold)
|
||
|
|
[DllImport(LIBNAME)]
|
||
|
|
private static extern void features2d_ORB_setFastThreshold_10(IntPtr nativeObj, int fastThreshold);
|
||
|
|
|
||
|
|
// C++: int cv::ORB::getFastThreshold()
|
||
|
|
[DllImport(LIBNAME)]
|
||
|
|
private static extern int features2d_ORB_getFastThreshold_10(IntPtr nativeObj);
|
||
|
|
|
||
|
|
// C++: String cv::ORB::getDefaultName()
|
||
|
|
[DllImport(LIBNAME)]
|
||
|
|
private static extern IntPtr features2d_ORB_getDefaultName_10(IntPtr nativeObj);
|
||
|
|
|
||
|
|
// native support for java finalize()
|
||
|
|
[DllImport(LIBNAME)]
|
||
|
|
private static extern void features2d_ORB_delete(IntPtr nativeObj);
|
||
|
|
|
||
|
|
}
|
||
|
|
}
|