/// <summary>
/// Writes data to a file storage.
/// </summary>
/// <param name="val"></param>
public FileStorage Add(IEnumerable <KeyPoint> val)
{
if (val == null)
{
throw new ArgumentNullException(nameof(val));
}
ThrowIfDisposed();
using (var valVec = new VectorOfKeyPoint(val))
{
NativeMethods.HandleException(
NativeMethods.core_FileStorage_shift_vectorOfKeyPoint(ptr, valVec.CvPtr));
}
GC.KeepAlive(this);
return(this);
}
/// <summary>
/// Detects corners using the FAST algorithm
/// </summary>
/// <param name="image">grayscale image where keypoints (corners) are detected.</param>
/// <param name="threshold">threshold on difference between intensity of the central pixel
/// and pixels of a circle around this pixel.</param>
/// <param name="nonmaxSupression">if true, non-maximum suppression is applied to
/// detected corners (keypoints).</param>
/// <param name="type">one of the three neighborhoods as defined in the paper</param>
/// <returns>keypoints detected on the image.</returns>
public static KeyPoint[] FAST(InputArray image, int threshold, bool nonmaxSupression, FASTType type)
{
if (image == null)
{
throw new ArgumentNullException("nameof(image)");
}
image.ThrowIfDisposed();
using (var kp = new VectorOfKeyPoint())
{
NativeMethods.features2d_FAST2(image.CvPtr, kp.CvPtr, threshold, nonmaxSupression ? 1 : 0, (int)type);
GC.KeepAlive(image);
return(kp.ToArray());
}
}
/// <summary>
/// Remove keypoints of sizes out of range.
/// </summary>
/// <param name="keypoints"></param>
/// <param name="minSize"></param>
/// <param name="maxSize"></param>
/// <returns></returns>
public static KeyPoint[] RunByKeypointSize(IEnumerable <KeyPoint> keypoints, float minSize,
float maxSize = Single.MaxValue)
{
if (keypoints == null)
{
throw new ArgumentNullException("nameof(keypoints)");
}
using (var keypointsVec = new VectorOfKeyPoint(keypoints))
{
NativeMethods.features2d_KeyPointsFilter_runByKeypointSize(
keypointsVec.CvPtr, minSize, maxSize);
return(keypointsVec.ToArray());
}
}
/// <summary>
///
/// </summary>
/// <param name="name"></param>
/// <param name="value"></param>
public void Write(string name, IEnumerable <KeyPoint> value)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
using (var valueVector = new VectorOfKeyPoint(value))
{
NativeMethods.core_FileStorage_write_vectorOfKeyPoint(ptr, name, valueVector.CvPtr);
}
}
/// <summary>
/// Detects corners using the AGAST algorithm
/// </summary>
/// <param name="image">grayscale image where keypoints (corners) are detected.</param>
/// <param name="threshold">threshold on difference between intensity of the central pixel
/// and pixels of a circle around this pixel.</param>
/// <param name="nonmaxSuppression">if true, non-maximum suppression is applied to
/// detected corners (keypoints).</param>
/// <param name="type">one of the four neighborhoods as defined in the paper</param>
/// <returns>keypoints detected on the image.</returns>
public static KeyPoint[] AGAST(InputArray image, int threshold, bool nonmaxSuppression, AgastFeatureDetector.DetectorType type)
{
if (image == null)
{
throw new ArgumentNullException(nameof(image));
}
image.ThrowIfDisposed();
using (var vector = new VectorOfKeyPoint())
{
NativeMethods.features2d_AGAST(image.CvPtr, vector.CvPtr, threshold, nonmaxSuppression ? 1 : 0,
(int)type);
GC.KeepAlive(image);
return(vector.ToArray());
}
}
/// <summary>
///
/// </summary>
/// <param name="name"></param>
/// <param name="value"></param>
public void Write(string name, IEnumerable <KeyPoint> value)
{
ThrowIfDisposed();
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
using var valueVector = new VectorOfKeyPoint(value);
NativeMethods.HandleException(
NativeMethods.core_FileStorage_write_vectorOfKeyPoint(ptr, name, valueVector.CvPtr));
GC.KeepAlive(this);
}
/// <summary>
/// Compute the descriptors for a set of keypoints in an image.
/// </summary>
/// <param name="image">The image.</param>
/// <param name="keypoints">The input keypoints. Keypoints for which a descriptor cannot be computed are removed.</param>
/// <param name="descriptors">Copmputed descriptors. Row i is the descriptor for keypoint i.</param>param>
public virtual void Compute(InputArray image, ref KeyPoint[] keypoints, OutputArray descriptors)
{
if (image == null)
{
throw new ArgumentNullException(nameof(image));
}
ThrowIfDisposed();
using (var keypointsVec = new VectorOfKeyPoint(keypoints))
{
NativeMethods.features2d_Feature2D_compute1(ptr, image.CvPtr, keypointsVec.CvPtr, descriptors.CvPtr);
keypoints = keypointsVec.ToArray();
}
GC.KeepAlive(this);
GC.KeepAlive(image);
GC.KeepAlive(descriptors);
}
/// <summary>
/// Compute the descriptors for a set of keypoints in an image.
/// </summary>
/// <param name="image">The image.</param>
/// <param name="keypoints">The input keypoints. Keypoints for which a descriptor cannot be computed are removed.</param>
/// <param name="descriptors">Copmputed descriptors. Row i is the descriptor for keypoint i.</param>param>
public virtual void Compute(InputArray image, ref KeyPoint[] keypoints, OutputArray descriptors)
{
if (image == null)
{
throw new ArgumentNullException("image");
}
if (disposed)
{
throw new ObjectDisposedException(GetType().Name);
}
using (var keypointsVec = new VectorOfKeyPoint(keypoints))
{
NativeMethods.features2d_Feature2D_compute1(ptr, image.CvPtr, keypointsVec.CvPtr, descriptors.CvPtr);
keypoints = keypointsVec.ToArray();
}
}
/// <summary>
/// Remove keypoints from some image by mask for pixels of this image.
/// </summary>
/// <param name="keypoints"></param>
/// <param name="mask"></param>
/// <returns></returns>
public static KeyPoint[] RunByPixelsMask(IEnumerable <KeyPoint> keypoints, Mat mask)
{
if (keypoints == null)
{
throw new ArgumentNullException(nameof(keypoints));
}
if (mask == null)
{
throw new ArgumentNullException(nameof(mask));
}
mask.ThrowIfDisposed();
using var keypointsVec = new VectorOfKeyPoint(keypoints);
NativeMethods.HandleException(
NativeMethods.features2d_KeyPointsFilter_runByPixelsMask(keypointsVec.CvPtr, mask.CvPtr));
GC.KeepAlive(mask);
return(keypointsVec.ToArray());
}
/// <summary>
/// Computes an image descriptor using the set visual vocabulary.
/// </summary>
/// <param name="image">Image, for which the descriptor is computed.</param>
/// <param name="keypoints">Keypoints detected in the input image.</param>
/// <param name="imgDescriptor">Computed output image descriptor.</param>
public void Compute2(Mat image, ref KeyPoint[] keypoints, Mat imgDescriptor)
{
ThrowIfDisposed();
if (image == null)
{
throw new ArgumentNullException(nameof(image));
}
if (imgDescriptor == null)
{
throw new ArgumentNullException(nameof(imgDescriptor));
}
using (var keypointsVec = new VectorOfKeyPoint(keypoints))
{
NativeMethods.features2d_BOWImgDescriptorExtractor_compute2(
ptr, image.CvPtr, keypointsVec.CvPtr, imgDescriptor.CvPtr);
keypoints = keypointsVec.ToArray();
}
GC.KeepAlive(image);
GC.KeepAlive(imgDescriptor);
}
/// <summary>
///
/// </summary>
/// <param name="img1"></param>
/// <param name="img2"></param>
/// <param name="H1to2"></param>
/// <param name="keypoints1"></param>
/// <param name="keypoints2"></param>
/// <param name="repeatability"></param>
/// <param name="correspCount"></param>
public static void EvaluateFeatureDetector(
Mat img1, Mat img2, Mat H1to2,
ref KeyPoint[] keypoints1, ref KeyPoint[] keypoints2,
out float repeatability, out int correspCount)
{
if (img1 == null)
{
throw new ArgumentNullException(nameof(img1));
}
if (img2 == null)
{
throw new ArgumentNullException(nameof(img2));
}
if (H1to2 == null)
{
throw new ArgumentNullException(nameof(H1to2));
}
if (keypoints1 == null)
{
throw new ArgumentNullException(nameof(keypoints1));
}
if (keypoints2 == null)
{
throw new ArgumentNullException(nameof(keypoints2));
}
using (var keypoints1Vec = new VectorOfKeyPoint(keypoints1))
using (var keypoints2Vec = new VectorOfKeyPoint(keypoints2))
{
NativeMethods.features2d_evaluateFeatureDetector(
img1.CvPtr, img2.CvPtr, H1to2.CvPtr,
keypoints1Vec.CvPtr, keypoints2Vec.CvPtr,
out repeatability, out correspCount);
GC.KeepAlive(img1);
GC.KeepAlive(img2);
GC.KeepAlive(H1to2);
keypoints1 = keypoints1Vec.ToArray();
keypoints2 = keypoints2Vec.ToArray();
}
}
/// <summary>
/// Detect keypoints in an image.
/// </summary>
/// <param name="image">The image.</param>
/// <param name="mask">Mask specifying where to look for keypoints (optional).
/// Must be a char matrix with non-zero values in the region of interest.</param>
/// <returns>The detected keypoints.</returns>
public KeyPoint[] Detect(Mat image, Mat?mask = null)
{
if (image == null)
{
throw new ArgumentNullException(nameof(image));
}
ThrowIfDisposed();
image.ThrowIfDisposed();
try
{
using var keyPoints = new VectorOfKeyPoint();
NativeMethods.HandleException(
NativeMethods.features2d_Feature2D_detect_Mat1(ptr, image.CvPtr, keyPoints.CvPtr, Cv2.ToPtr(mask)));
return(keyPoints.ToArray());
}
finally
{
GC.KeepAlive(this);
GC.KeepAlive(image);
GC.KeepAlive(mask);
}
}
/// <summary>
/// Detects keypoints and computes the descriptors
/// </summary>
/// <param name="image"></param>
/// <param name="mask"></param>
/// <param name="keypoints"></param>
/// <param name="descriptors"></param>
/// <param name="useProvidedKeypoints"></param>
public virtual void DetectAndCompute(
InputArray image,
InputArray mask,
out KeyPoint[] keypoints,
OutputArray descriptors,
bool useProvidedKeypoints = false)
{
if (disposed)
{
throw new ObjectDisposedException(GetType().Name);
}
if (image == null)
{
throw new ArgumentNullException("image");
}
if (descriptors == null)
{
throw new ArgumentNullException("descriptors");
}
image.ThrowIfDisposed();
if (mask != null)
{
mask.ThrowIfDisposed();
}
using (var keypointsVec = new VectorOfKeyPoint())
{
NativeMethods.features2d_Feature2D_detectAndCompute(
ptr, image.CvPtr, Cv2.ToPtr(mask), keypointsVec.CvPtr, descriptors.CvPtr, useProvidedKeypoints ? 1 : 0);
keypoints = keypointsVec.ToArray();
}
GC.KeepAlive(image);
GC.KeepAlive(mask);
descriptors.Fix();
}
