public void Bootstrap(Mat img)
{
ValidateImages(null, img);
_bootstrapKp.Clear();
_detector.DetectRaw(img, _bootstrapKp);
_trackedFeatures = new VectorOfKeyPoint(_bootstrapKp.ToArray());
_trackedFeatures3D.Clear();
CvInvoke.CvtColor(img, _prevGray, ColorConversion.Bgr2Gray);
}
/// <summary>
/// Convert the raw keypoints and descriptors to ImageFeature
/// </summary>
/// <param name="keyPointsVec">The raw keypoints vector</param>
/// <param name="descriptors">The raw descriptor matrix</param>
/// <returns>An array of image features</returns>
public static ImageFeature <TDescriptor>[] ConvertFromRaw(VectorOfKeyPoint keyPointsVec, Matrix <TDescriptor> descriptors)
{
if (keyPointsVec.Size == 0)
{
return(new ImageFeature <TDescriptor> [0]);
}
Debug.Assert(keyPointsVec.Size == descriptors.Rows, "Size of keypoints vector do not match the rows of the descriptors matrix.");
int sizeOfdescriptor = descriptors.Cols;
MKeyPoint[] keyPoints = keyPointsVec.ToArray();
ImageFeature <TDescriptor>[] features = new ImageFeature <TDescriptor> [keyPoints.Length];
MCvMat header = descriptors.MCvMat;
long address = header.data.ToInt64();
int rowSizeInByte = sizeOfdescriptor * Marshal.SizeOf(typeof(TDescriptor));
for (int i = 0; i < keyPoints.Length; i++, address += header.step)
{
features[i].KeyPoint = keyPoints[i];
TDescriptor[] desc = new TDescriptor[sizeOfdescriptor];
GCHandle handler = GCHandle.Alloc(desc, GCHandleType.Pinned);
Toolbox.memcpy(handler.AddrOfPinnedObject(), new IntPtr(address), rowSizeInByte);
handler.Free();
features[i].Descriptor = desc;
}
return(features);
}
private void button_Detect_Click(object sender, EventArgs e)
{
Mat scr = imagemat;
Mat result = imagemat.Clone();
#region Detect()代码
/*
* GFTTDetector _gftd = new GFTTDetector();//以默认参数创建 GFTTDetector 类。
* MKeyPoint[] keypoints = _gftd.Detect(scr, null);//检测关键点，返回 MKeyPoint[]。
* foreach (MKeyPoint keypoint in keypoints)//遍历 MKeyPoint[]数组。
* {
* Point point = Point.Truncate(keypoint.Point);//获得关键点的坐 标位置，以 Point 类型。
* CvInvoke.Circle(result, point, 3, new MCvScalar(0, 0, 255), 1);//绘 制关键点的位置，以 Circle 形式。
* }
*/
#endregion
#region DetectRaw() code
GFTTDetector _gftd = new GFTTDetector(); //以默认参数创建 GFTTDetector 类。
VectorOfKeyPoint vector_keypoints = new VectorOfKeyPoint(); //创建 VectorOfKeyPoint 类型，存储关键点集合。
_gftd.DetectRaw(scr, vector_keypoints, null); //检测关键点。
foreach (MKeyPoint keypoint in vector_keypoints.ToArray()) //遍历 MKeyPoint[]数组。
{
Point point = Point.Truncate(keypoint.Point); //获得关键点的坐 标位置，以 Point 类型。
CvInvoke.Circle(result, point, 3, new MCvScalar(255, 255, 0), 1); //绘制关键点的位置，以 Circle 形式。
}
#endregion
imageBox1.Image = scr; //显示输入图像。
imageBox2.Image = result; //显示角点检测图像。
}
/// <summary>
/// Detect the keypoints in the image
/// </summary>
/// <param name="image">The image from which the key point will be detected from</param>
/// <returns>The key pionts in the image</returns>
public MKeyPoint[] DetectKeyPoints(Image <Gray, Byte> image)
{
using (VectorOfKeyPoint kpts = DetectKeyPointsRaw(image, null))
{
return(kpts.ToArray());
}
}
/// <summary>
/// Detect the SURF keypoints from the image
/// </summary>
/// <param name="image">The image to extract SURF features from</param>
/// <param name="mask">The optional mask, can be null if not needed</param>
/// <returns>An array of SURF key points</returns>
public MKeyPoint[] DetectKeyPoints(Image <Gray, Byte> image, Image <Gray, byte> mask)
{
using (VectorOfKeyPoint keypoints = DetectKeyPointsRaw(image, mask))
{
return(keypoints.ToArray());
}
}
/// <summary>
/// Detect the Lepetit keypoints from the image
/// </summary>
/// <param name="image">The image to extract Lepetit keypoints</param>
/// <param name="maxCount">The maximum number of keypoints to be extracted, use 0 to ignore the max count</param>
/// <param name="scaleCoords">Indicates if the coordinates should be scaled</param>
/// <returns>The array of Lepetit keypoints</returns>
public MKeyPoint[] DetectKeyPoints(Image <Gray, Byte> image, int maxCount, bool scaleCoords)
{
using (VectorOfKeyPoint kpts = DetectKeyPointsRaw(image, maxCount, scaleCoords))
{
return(kpts.ToArray());
}
}
/// <summary>
/// Detects keypoints and computes descriptors for them.
/// </summary>
/// <param name="image">Image where keypoints (corners) are detected.
/// Only 8-bit grayscale images are supported.</param>
/// <param name="mask">Optional input mask that marks the regions where we should detect features.</param>
/// <param name="keypoints">The output vector of keypoints.</param>
/// <param name="descriptors"></param>
public void Run(GpuMat image, GpuMat mask, out KeyPoint[] keypoints, GpuMat descriptors)
{
if (disposed)
{
throw new ObjectDisposedException(GetType().Name);
}
if (image == null)
{
throw new ArgumentNullException("image");
}
if (mask == null)
{
throw new ArgumentNullException("mask");
}
if (descriptors == null)
{
throw new ArgumentNullException("descriptors");
}
using (var keypointsVec = new VectorOfKeyPoint())
{
NativeMethods.gpu_ORB_GPU_operator4(ptr, image.CvPtr, mask.CvPtr, keypointsVec.CvPtr, descriptors.CvPtr);
keypoints = keypointsVec.ToArray();
}
GC.KeepAlive(image);
GC.KeepAlive(mask);
GC.KeepAlive(descriptors);
}
public void TestCudaOrbDetector()
{
if (!CudaInvoke.HasCuda)
{
return;
}
using (Image <Bgr, Byte> img = new Image <Bgr, byte>("box.png"))
using (GpuMat cudaImage = new GpuMat(img))
using (GpuMat grayCudaImage = new GpuMat())
using (CudaORBDetector detector = new CudaORBDetector(500))
using (VectorOfKeyPoint kpts = new VectorOfKeyPoint())
using (GpuMat keyPointMat = new GpuMat())
using (GpuMat descriptorMat = new GpuMat())
{
CudaInvoke.CvtColor(cudaImage, grayCudaImage, ColorConversion.Bgr2Gray);
detector.DetectAsync(grayCudaImage, keyPointMat);
detector.Convert(keyPointMat, kpts);
//detector.ComputeRaw(grayCudaImage, null, keyPointMat, descriptorMat);
//detector.DownloadKeypoints(keyPointMat, kpts);
foreach (MKeyPoint kpt in kpts.ToArray())
{
img.Draw(new CircleF(kpt.Point, 3.0f), new Bgr(0, 255, 0), 1);
}
//ImageViewer.Show(img);
}
}
/// <summary>
/// Detect the keypoints from the image
/// </summary>
/// <param name="detector">The keypoint detector</param>
/// <param name="image">The image to extract keypoints from</param>
/// <param name="mask">The optional mask, can be null if not needed</param>
/// <returns>An array of key points</returns>
public static MKeyPoint[] DetectKeyPoints(this IKeyPointDetector detector, Image <Gray, Byte> image, Image <Gray, byte> mask)
{
using (VectorOfKeyPoint keypoints = detector.DetectKeyPointsRaw(image, mask))
{
return(keypoints.ToArray());
}
}
public void TestCudaFASTDetector()
{
if (!CudaInvoke.HasCuda)
{
return;
}
using (Image <Bgr, Byte> img = new Image <Bgr, byte>("box.png"))
using (CudaImage <Bgr, Byte> CudaImage = new CudaImage <Bgr, byte>(img))
using (CudaImage <Gray, Byte> grayCudaImage = CudaImage.Convert <Gray, Byte>())
using (CudaFastFeatureDetector featureDetector = new CudaFastFeatureDetector(10, true, FastDetector.DetectorType.Type9_16, 1000))
using (VectorOfKeyPoint kpts = new VectorOfKeyPoint())
using (GpuMat keyPointsMat = new GpuMat())
{
featureDetector.DetectAsync(grayCudaImage, keyPointsMat);
featureDetector.Convert(keyPointsMat, kpts);
//featureDetector.DetectKeyPointsRaw(grayCudaImage, null, keyPointsMat);
//featureDetector.DownloadKeypoints(keyPointsMat, kpts);
foreach (MKeyPoint kpt in kpts.ToArray())
{
img.Draw(new CircleF(kpt.Point, 3.0f), new Bgr(0, 255, 0), 1);
}
//ImageViewer.Show(img);
}
}
/// <summary>
/// Detect the SURF keypoints from the image
/// </summary>
/// <param name="image">The image to extract SURF features from</param>
/// <param name="mask">The optional mask, can be null if not needed</param>
/// <returns>An array of SURF key points</returns>
public MKeyPoint[] DetectKeyPoints(Image <Gray, Byte> image, Image <Gray, byte> mask)
{
using (VectorOfKeyPoint keypoints = new VectorOfKeyPoint())
{
CvSURFDetectorDetectKeyPoints(ref this, image, mask, keypoints);
return(keypoints.ToArray());
}
}
/// <summary>
/// Detect the keypoints in the image
/// </summary>
/// <param name="image">The image from which the key point will be detected from</param>
/// <returns>The key pionts in the image</returns>
public MKeyPoint[] DetectKeyPoints(Image <Gray, Byte> image)
{
using (VectorOfKeyPoint kpts = new VectorOfKeyPoint())
{
CvStarDetectorDetectKeyPoints(ref this, image, kpts);
return(kpts.ToArray());
}
}
/// <summary>
/// Detect the Fast keypoints from the image
/// </summary>
/// <param name="image">The image to extract keypoints from</param>
/// <returns>The array of fast keypoints</returns>
public MKeyPoint[] DetectKeyPoints(Image <Gray, byte> image)
{
using (VectorOfKeyPoint keypoints = new VectorOfKeyPoint())
{
CvFASTKeyPoints(image, keypoints, Threshold, NonmaxSupression);
return(keypoints.ToArray());
}
}
/// <summary>
/// Detect the MSER keypoints from the image
/// </summary>
/// <param name="image">The image to extract MSER keypoints from</param>
/// <param name="mask">The optional mask, can be null if not needed</param>
/// <returns>An array of MSER key points</returns>
public MKeyPoint[] DetectKeyPoints(Image <Gray, Byte> image, Image <Gray, byte> mask)
{
using (VectorOfKeyPoint kpts = new VectorOfKeyPoint())
{
CvMSERKeyPoints(image, mask, kpts, ref this);
return(kpts.ToArray());
}
}
/// <summary>
/// Detect the Lepetit keypoints from the image
/// </summary>
/// <param name="image">The image to extract Lepetit keypoints</param>
/// <param name="maxCount">The maximum number of keypoints to be extracted, use 0 to ignore the max count</param>
/// <param name="scaleCoords">Indicates if the coordinates should be scaled</param>
/// <returns>The array of Lepetit keypoints</returns>
public MKeyPoint[] DetectKeyPoints(Image <Gray, Byte> image, int maxCount, bool scaleCoords)
{
using (VectorOfKeyPoint kpts = new VectorOfKeyPoint())
{
CvLDetectorDetectKeyPoints(ref this, image, kpts, maxCount, scaleCoords);
return(kpts.ToArray());
}
}
/// <summary>
/// Detect the keypoints from the image
/// </summary>
/// <param name="image">The image to extract keypoints from</param>
/// <param name="mask">The optional mask.</param>
/// <returns>An array of key points</returns>
public MKeyPoint[] Detect(IInputArray image, IInputArray mask = null)
{
using (VectorOfKeyPoint keypoints = new VectorOfKeyPoint())
{
DetectRaw(image, keypoints, mask);
return(keypoints.ToArray());
}
}
private static VectorOfKeyPoint GetBestKeypointsCount(VectorOfKeyPoint keyPoints, int count)
{
List <MKeyPoint> kpList = keyPoints.ToArray().ToList();
kpList.Sort((x, y) => x.Response > y.Response ? 1 : x.Response < y.Response ? -1 : 0);
kpList = kpList.Take(count).ToList();
return(new VectorOfKeyPoint(kpList.ToArray()));
}
/// <summary>
/// Detect the SURF keypoints from the image
/// </summary>
/// <param name="image">The image to extract SURF features from</param>
/// <param name="mask">The optional mask, can be null if not needed</param>
/// <returns>An array of SURF key points</returns>
public MKeyPoint[] DetectKeyPoints(Image <Gray, Byte> image, Image <Gray, byte> mask)
{
using (VectorOfKeyPoint kpts = new VectorOfKeyPoint())
{
CvSIFTDetectorDetectKeyPoints(_ptr, image, mask, kpts);
return(kpts.ToArray());
}
}
/// <summary>
/// Detect the keypoints from the image
/// </summary>
/// <param name="detector">The keypoint detector</param>
/// <param name="image">The image to extract keypoints from</param>
/// <param name="mask">The optional mask.</param>
/// <returns>An array of key points</returns>
public static MKeyPoint[] Detect(this IFeatureDetector detector, IInputArray image, IInputArray mask = null)
{
using (VectorOfKeyPoint keypoints = new VectorOfKeyPoint())
{
detector.DetectRaw(image, keypoints, mask);
return(keypoints.ToArray());
}
}
/// <summary>
/// Detect keypoints in the GpuImage
/// </summary>
/// <param name="img">The image where keypoints will be detected from</param>
/// <param name="mask">The optional mask, can be null if not needed</param>
/// <returns>An array of keypoints</returns>
public MKeyPoint[] DetectKeyPoints(GpuImage <Gray, Byte> img, GpuImage <Gray, Byte> mask)
{
using (GpuMat <float> tmp = DetectKeyPointsRaw(img, mask))
using (VectorOfKeyPoint kpts = new VectorOfKeyPoint())
{
DownloadKeypoints(tmp, kpts);
return(kpts.ToArray());
}
}
/// <summary>
/// Detect keypoints in the CudaImage
/// </summary>
/// <param name="img">The image where keypoints will be detected from</param>
/// <param name="mask">The optional mask, can be null if not needed</param>
/// <returns>An array of keypoints</returns>
public MKeyPoint[] DetectKeyPoints(GpuMat img, GpuMat mask)
{
using (GpuMat tmp = DetectKeyPointsRaw(img, mask))
using (VectorOfKeyPoint kpts = new VectorOfKeyPoint())
{
DownloadKeypoints(tmp, kpts);
return(kpts.ToArray());
}
}
/// <summary>
/// detects corners using FAST algorithm by E. Rosten
/// </summary>
/// <param name="image"></param>
/// <param name="keypoints"></param>
/// <param name="threshold"></param>
/// <param name="nonmaxSupression"></param>
/// <param name="type"></param>
public static void FASTX(InputArray image, out KeyPoint[] keypoints, int threshold, bool nonmaxSupression, int type)
{
if (image == null)
throw new ArgumentNullException("image");
image.ThrowIfDisposed();
using (var kp = new VectorOfKeyPoint())
{
NativeMethods.features2d_FASTX(image.CvPtr, kp.CvPtr, threshold, nonmaxSupression ? 1 : 0, type);
keypoints = kp.ToArray();
}
}
/// <summary>
/// Remove keypoints within borderPixels of an image edge.
/// </summary>
/// <param name="keypoints"></param>
/// <param name="imageSize"></param>
/// <param name="borderSize"></param>
/// <returns></returns>
public static KeyPoint[] RunByImageBorder(IEnumerable<KeyPoint> keypoints, Size imageSize, int borderSize)
{
if (keypoints == null)
throw new ArgumentNullException("keypoints");
using (var keypointsVec = new VectorOfKeyPoint(keypoints))
{
NativeMethods.features2d_KeyPointsFilter_runByImageBorder(
keypointsVec.CvPtr, imageSize, borderSize);
return keypointsVec.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("keypoints");
using (var keypointsVec = new VectorOfKeyPoint(keypoints))
{
NativeMethods.features2d_KeyPointsFilter_runByKeypointSize(
keypointsVec.CvPtr, minSize, maxSize);
return keypointsVec.ToArray();
}
}
/// <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>
/// 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, AGASTType type)
{
if (image == null)
throw new ArgumentNullException("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();
}
}
public static Bitmap VisualizeFeatures(Image <Bgr, byte> img, VectorOfKeyPoint features, Color color)
{
Bitmap bmp = new Bitmap(img.Width, img.Height);
Graphics g = Graphics.FromImage(bmp);
g.DrawImage(img.ToBitmap(), 0, 0, img.Width, img.Height);
SolidBrush brush = new SolidBrush(color);
foreach (MKeyPoint kp in features.ToArray())
{
g.FillEllipse(brush, kp.Point.X - 5, kp.Point.Y - 5, 11, 11);
}
return(bmp);
}
public void Bootstrap(Mat img)
{
//Detect first features in the image (clear any current tracks)
if (img.IsEmpty || !img.IsEmpty && img.NumberOfChannels != 3)
{
throw new Exception("Image is not appropriate (Empty or wrong number of channels).");
}
_bootstrapKp.Clear();
_detector.DetectRaw(img, _bootstrapKp);
_trackedFeatures = new VectorOfKeyPoint(_bootstrapKp.ToArray());
#region Trace
Trace.Indent();
Trace.WriteLine($"Bootstrap keypoints: { _trackedFeatures.Size}.");
Trace.Unindent();
Trace.WriteLine("--------------------------");
#endregion
CvInvoke.CvtColor(img, _prevGray, ColorConversion.Bgr2Gray);
}
/// <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("keypoints");
if (mask == null)
throw new ArgumentNullException("mask");
mask.ThrowIfDisposed();
using (var keypointsVec = new VectorOfKeyPoint(keypoints))
{
NativeMethods.features2d_KeyPointsFilter_runByPixelsMask(
keypointsVec.CvPtr, mask.CvPtr);
GC.KeepAlive(mask);
return keypointsVec.ToArray();
}
}
public Mat FindHomography(VectorOfKeyPoint keypointsModel, VectorOfKeyPoint keypointsTest, List <MDMatch[]> matches, Mat Mask)
{
MKeyPoint[] kptsModel = keypointsModel.ToArray();
MKeyPoint[] kptsTest = keypointsTest.ToArray();
PointF[] srcPoints = new PointF[matches.Count];
PointF[] destPoints = new PointF[matches.Count];
for (int i = 0; i < matches.Count; i++)
{
srcPoints[i] = kptsModel[matches[i][0].TrainIdx].Point;
destPoints[i] = kptsTest[matches[i][0].QueryIdx].Point;
}
Mat homography = CvInvoke.FindHomography(srcPoints, destPoints, Emgu.CV.CvEnum.HomographyMethod.Ransac, 10, Mask);
return(homography);
}
/// <summary>
///
/// </summary>
/// <param name="featuresFinder"></param>
/// <param name="image"></param>
/// <param name="features"></param>
/// <param name="mask"></param>
public static void ComputeImageFeatures(
Feature2D featuresFinder,
InputArray image,
out ImageFeatures features,
InputArray?mask = null)
{
if (featuresFinder == null)
{
throw new ArgumentNullException(nameof(featuresFinder));
}
if (image == null)
{
throw new ArgumentNullException(nameof(image));
}
featuresFinder.ThrowIfDisposed();
image.ThrowIfDisposed();
var descriptorsMat = new Mat();
var keypointsVec = new VectorOfKeyPoint();
var wImageFeatures = new WImageFeatures
{
Keypoints = keypointsVec.CvPtr,
Descriptors = descriptorsMat.CvPtr
};
unsafe
{
NativeMethods.HandleException(
NativeMethods.stitching_computeImageFeatures2(
featuresFinder.CvPtr, image.CvPtr, &wImageFeatures, mask?.CvPtr ?? IntPtr.Zero));
}
features = new ImageFeatures(
wImageFeatures.ImgIdx,
wImageFeatures.ImgSize,
keypointsVec.ToArray(),
descriptorsMat);
GC.KeepAlive(featuresFinder);
GC.KeepAlive(image);
GC.KeepAlive(mask);
GC.KeepAlive(descriptorsMat);
}
public List <Keypoint> usingSift(Bitmap image)
{
SIFTDetector sift = new SIFTDetector();
Image <Gray, Byte> modelImage = new Image <Gray, byte>(new Bitmap(image));
VectorOfKeyPoint modelKeyPoints = sift.DetectKeyPointsRaw(modelImage, null);
MKeyPoint[] keypoints = modelKeyPoints.ToArray();
Keypoint key;
List <Keypoint> keypointsList = new List <Keypoint>();
foreach (MKeyPoint keypoint in keypoints)
{
key = new Keypoint(keypoint.Point.X, keypoint.Point.Y, keypoint.Size);
keypointsList.Add(key);
}
return(keypointsList);
}
/// <summary>
/// Download keypoints from GPU to CPU memory.
/// </summary>
/// <param name="dKeypoints"></param>
/// <returns></returns>
public KeyPoint[] DownloadKeyPoints(GpuMat dKeypoints)
{
if (disposed)
{
throw new ObjectDisposedException(GetType().Name);
}
if (dKeypoints == null)
{
throw new ArgumentNullException("dKeypoints");
}
KeyPoint[] result;
using (var keypoints = new VectorOfKeyPoint())
{
NativeMethods.gpu_ORB_GPU_downloadKeyPoints(ptr, dKeypoints.CvPtr, keypoints.CvPtr);
result = keypoints.ToArray();
}
GC.KeepAlive(dKeypoints);
return(result);
}
/// <summary>
/// Converts keypoints from GPU representation to vector of KeyPoint.
/// </summary>
/// <param name="hKeypoints"></param>
/// <returns></returns>
public KeyPoint[] ConvertKeypoints(Mat hKeypoints)
{
if (disposed)
{
throw new ObjectDisposedException(GetType().Name);
}
if (hKeypoints == null)
{
throw new ArgumentNullException("hKeypoints");
}
KeyPoint[] result;
using (var keypoints = new VectorOfKeyPoint())
{
NativeMethods.gpu_FAST_GPU_convertKeypoints(ptr, hKeypoints.CvPtr, keypoints.CvPtr);
result = keypoints.ToArray();
}
GC.KeepAlive(hKeypoints);
return(result);
}
private MKeyPoint[] RemoveFakeKeyPoint(VectorOfKeyPoint MainVecor, VectorOfKeyPoint InputVecor, double Compression, double Radius)
{
List <MKeyPoint> InputListKeyPoint = new List <MKeyPoint>(InputVecor.ToArray());
List <MKeyPoint> OutputVector = new List <MKeyPoint>();
for (int i = 0; i < MainVecor.Size; i++)
{
for (int j = InputListKeyPoint.Count - 1; j >= 0; j--)
{
PointF InputLocate = InputListKeyPoint[j].Point;
PointF MainLocate = MainVecor[i].Point;
if (Math.Pow(MainLocate.X * Compression - InputLocate.X, 2) +
Math.Pow(MainLocate.Y * Compression - InputLocate.Y, 2) <= Math.Pow(Radius, 2))
{
OutputVector.Add(InputListKeyPoint[j]);
InputListKeyPoint.RemoveAt(j);
}
}
}
return(OutputVector.ToArray());
}
/// <summary>
/// Detect image features from the given image
/// </summary>
/// <param name="image">The image to detect features from</param>
/// <param name="mask">The optional mask, can be null if not needed</param>
/// <returns>The Image features detected from the given image</returns>
public ImageFeature[] DetectFeatures(Image <Gray, Byte> image, Image <Gray, byte> mask)
{
using (VectorOfKeyPoint pts = new VectorOfKeyPoint())
using (VectorOfFloat descs = new VectorOfFloat())
{
CvSURFDetectorDetectFeature(ref this, image, mask, pts, descs);
MKeyPoint[] kpts = pts.ToArray();
int n = kpts.Length;
long add = descs.StartAddress.ToInt64();
ImageFeature[] features = new ImageFeature[n];
int sizeOfdescriptor = extended == 0 ? 64 : 128;
for (int i = 0; i < n; i++, add += sizeOfdescriptor * sizeof(float))
{
features[i].KeyPoint = kpts[i];
float[] desc = new float[sizeOfdescriptor];
Marshal.Copy(new IntPtr(add), desc, 0, sizeOfdescriptor);
features[i].Descriptor = desc;
}
return(features);
}
}
/// <summary>
/// Compute the descriptors for a set of keypoints in an image.
/// </summary>
/// <param name="image">The image.</param>
/// <param name="inKeypoints">The input keypoints. Keypoints for which a descriptor cannot be computed are removed.</param>
/// <param name="outKeypoints"></param>
/// <param name="descriptors">Copmputed descriptors. Row i is the descriptor for keypoint i.</param>param>
public virtual void Compute(InputArray image, KeyPoint[] inKeypoints, out KeyPoint[] outKeypoints,
OutputArray descriptors)
{
if (image == null)
throw new ArgumentNullException("image");
if (disposed)
throw new ObjectDisposedException(GetType().Name);
using (var keypointsVec = new VectorOfKeyPoint(inKeypoints))
{
NativeMethods.features2d_Feature2D_compute1(ptr, image.CvPtr, keypointsVec.CvPtr, descriptors.CvPtr);
outKeypoints = keypointsVec.ToArray();
}
}
/// <summary>
///
/// </summary>
/// <param name="image"></param>
/// <param name="keypoints"></param>
/// <param name="descriptors"></param>
public void Compute(Mat image, out KeyPoint[] keypoints, Mat descriptors)
{
if (image == null)
throw new ArgumentNullException("image");
using (VectorOfKeyPoint keypointsVec = new VectorOfKeyPoint())
{
NativeMethods.features2d_Feature2D_compute(ptr, image.CvPtr, keypointsVec.CvPtr, descriptors.CvPtr);
keypoints = 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>
/// <param name="pointIdxsOfClusters">pointIdxsOfClusters Indices of keypoints that belong to the cluster.
/// This means that pointIdxsOfClusters[i] are keypoint indices that belong to the i -th cluster(word of vocabulary) returned if it is non-zero.</param>
/// <param name="descriptors">Descriptors of the image keypoints that are returned if they are non-zero.</param>
public void Compute(InputArray image, out KeyPoint[] keypoints, OutputArray imgDescriptor,
out int[][] pointIdxsOfClusters, Mat descriptors = null)
{
if (IsDisposed)
throw new ObjectDisposedException(GetType().Name);
if (image == null)
throw new ArgumentNullException(nameof(image));
if (imgDescriptor == null)
throw new ArgumentNullException(nameof(imgDescriptor));
using (var keypointsVec = new VectorOfKeyPoint())
using (var pointIdxsOfClustersVec = new VectorOfVectorInt())
{
NativeMethods.features2d_BOWImgDescriptorExtractor_compute11(ptr, image.CvPtr, keypointsVec.CvPtr,
imgDescriptor.CvPtr, pointIdxsOfClustersVec.CvPtr, Cv2.ToPtr(descriptors));
keypoints = keypointsVec.ToArray();
pointIdxsOfClusters = pointIdxsOfClustersVec.ToArray();
}
GC.KeepAlive(image);
GC.KeepAlive(imgDescriptor);
GC.KeepAlive(descriptors);
}
/// <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("image");
using (var keypoints = new VectorOfKeyPoint())
{
NativeMethods.features2d_FeatureDetector_detect(ptr, image.CvPtr, keypoints.CvPtr, Cv2.ToPtr(mask));
return keypoints.ToArray();
}
}
/// <summary>
/// Extract features and computes their descriptors using SIFT algorithm
/// </summary>
/// <param name="img">Input 8-bit grayscale image</param>
/// <param name="mask">Optional input mask that marks the regions where we should detect features.</param>
/// <returns>The output vector of keypoints</returns>
#else
/// <summary>
/// Extract features and computes their descriptors using SIFT algorithm
/// </summary>
/// <param name="img">Input 8-bit grayscale image</param>
/// <param name="mask">Optional input mask that marks the regions where we should detect features.</param>
/// <returns>The output vector of keypoints</returns>
#endif
public KeyPoint[] Run(InputArray img, InputArray mask)
{
ThrowIfDisposed();
if (img == null)
throw new ArgumentNullException("img");
img.ThrowIfDisposed();
using (VectorOfKeyPoint keypointsVec = new VectorOfKeyPoint())
{
NativeMethods.nonfree_SIFT_run1(ptr, img.CvPtr, Cv2.ToPtr(mask), keypointsVec.CvPtr);
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, out KeyPoint[] keypoints, Mat imgDescriptor)
{
if (IsDisposed)
throw new ObjectDisposedException(GetType().Name);
if (image == null)
throw new ArgumentNullException(nameof(image));
if (imgDescriptor == null)
throw new ArgumentNullException(nameof(imgDescriptor));
using (var keypointsVec = new VectorOfKeyPoint())
{
NativeMethods.features2d_BOWImgDescriptorExtractor_compute2(
ptr, image.CvPtr, keypointsVec.CvPtr, imgDescriptor.CvPtr);
keypoints = keypointsVec.ToArray();
}
GC.KeepAlive(image);
GC.KeepAlive(imgDescriptor);
}
/// <summary>
/// Remove duplicated keypoints.
/// </summary>
/// <param name="keypoints"></param>
/// <returns></returns>
public static KeyPoint[] RemoveDuplicated(IEnumerable<KeyPoint> keypoints)
{
if (keypoints == null)
throw new ArgumentNullException(nameof(keypoints));
using (var keypointsVec = new VectorOfKeyPoint(keypoints))
{
NativeMethods.features2d_KeyPointsFilter_removeDuplicated(keypointsVec.CvPtr);
return keypointsVec.ToArray();
}
}
/// <summary>
/// Retain the specified number of the best keypoints (according to the response)
/// </summary>
/// <param name="keypoints"></param>
/// <param name="npoints"></param>
/// <returns></returns>
public static KeyPoint[] RetainBest(IEnumerable<KeyPoint> keypoints, int npoints)
{
if (keypoints == null)
throw new ArgumentNullException("keypoints");
using (var keypointsVec = new VectorOfKeyPoint(keypoints))
{
NativeMethods.features2d_KeyPointsFilter_retainBest(
keypointsVec.CvPtr, npoints);
return keypointsVec.ToArray();
}
}
/// <summary>
/// keypoint を検出し，その SURF ディスクリプタを計算します．[useProvidedKeypoints = true]
/// </summary>
/// <param name="img"></param>
/// <param name="mask"></param>
/// <param name="keypoints"></param>
/// <param name="descriptors"></param>
/// <param name="useProvidedKeypoints"></param>
#else
/// <summary>
/// detects keypoints and computes the SURF descriptors for them. [useProvidedKeypoints = true]
/// </summary>
/// <param name="img"></param>
/// <param name="mask"></param>
/// <param name="keypoints"></param>
/// <param name="descriptors"></param>
/// <param name="useProvidedKeypoints"></param>
#endif
public void Run(InputArray img, InputArray mask, out KeyPoint[] keypoints, OutputArray descriptors,
bool useProvidedKeypoints = false)
{
ThrowIfDisposed();
if (img == null)
throw new ArgumentNullException("img");
if (descriptors == null)
throw new ArgumentNullException("descriptors");
img.ThrowIfDisposed();
descriptors.ThrowIfNotReady();
using (VectorOfKeyPoint keypointsVec = new VectorOfKeyPoint())
{
NativeMethods.nonfree_SURF_run2_OutputArray(ptr, img.CvPtr, Cv2.ToPtr(mask), keypointsVec.CvPtr,
descriptors.CvPtr, useProvidedKeypoints ? 1 : 0);
keypoints = keypointsVec.ToArray();
}
}
/// <summary>
/// Converts keypoints from GPU representation to vector of KeyPoint.
/// </summary>
/// <param name="hKeypoints"></param>
/// <returns></returns>
public KeyPoint[] ConvertKeypoints(Mat hKeypoints)
{
if (disposed)
throw new ObjectDisposedException(GetType().Name);
if (hKeypoints == null)
throw new ArgumentNullException("hKeypoints");
KeyPoint[] result;
using (var keypoints = new VectorOfKeyPoint())
{
NativeMethods.gpu_FAST_GPU_convertKeypoints(ptr, hKeypoints.CvPtr, keypoints.CvPtr);
result = keypoints.ToArray();
}
GC.KeepAlive(hKeypoints);
return result;
}
/// <summary>
/// Download keypoints from GPU to CPU memory.
/// </summary>
/// <param name="dKeypoints"></param>
/// <returns></returns>
public KeyPoint[] DownloadKeyPoints(GpuMat dKeypoints)
{
if (disposed)
throw new ObjectDisposedException(GetType().Name);
if (dKeypoints == null)
throw new ArgumentNullException("dKeypoints");
KeyPoint[] result;
using (var keypoints = new VectorOfKeyPoint())
{
NativeMethods.gpu_ORB_GPU_downloadKeyPoints(ptr, dKeypoints.CvPtr, keypoints.CvPtr);
result = keypoints.ToArray();
}
GC.KeepAlive(dKeypoints);
return result;
}
/// <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);
keypoints1 = keypoints1Vec.ToArray();
keypoints2 = keypoints2Vec.ToArray();
}
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public KeyPoint[] ReadKeyPoints()
{
using (var valueVector = new VectorOfKeyPoint())
{
NativeMethods.core_FileNode_read_vectorOfKeyPoint(ptr, valueVector.CvPtr);
return valueVector.ToArray();
}
}
/// <summary>
/// Compute the BRISK features on an image
/// </summary>
/// <param name="image"></param>
/// <param name="mask"></param>
/// <returns></returns>
public KeyPoint[] Run(InputArray image, InputArray mask = null)
{
ThrowIfDisposed();
if (image == null)
throw new ArgumentNullException("image");
image.ThrowIfDisposed();
using (VectorOfKeyPoint keyPointsVec = new VectorOfKeyPoint())
{
NativeMethods.features2d_BRISK_run1(ptr, image.CvPtr, Cv2.ToPtr(mask), keyPointsVec.CvPtr);
return keyPointsVec.ToArray();
}
}
/// <summary>
/// Finds the keypoints using FAST detector.
/// </summary>
/// <param name="image">Image where keypoints (corners) are detected.
/// Only 8-bit grayscale images are supported.</param>
/// <param name="mask">Optional input mask that marks the regions where we should detect features.</param>
/// <param name="keypoints">The output vector of keypoints.</param>
public void Run(GpuMat image, GpuMat mask, out KeyPoint[] keypoints)
{
if (disposed)
throw new ObjectDisposedException(GetType().Name);
if (image == null)
throw new ArgumentNullException("image");
if (mask == null)
throw new ArgumentNullException("mask");
using (var keypointsVec = new VectorOfKeyPoint())
{
NativeMethods.gpu_FAST_GPU_operator2(ptr, image.CvPtr, mask.CvPtr, keypointsVec.CvPtr);
keypoints = keypointsVec.ToArray();
}
GC.KeepAlive(image);
GC.KeepAlive(mask);
}
/// <summary>
/// Compute the BRISK features and descriptors on an image
/// </summary>
/// <param name="image"></param>
/// <param name="mask"></param>
/// <param name="keyPoints"></param>
/// <param name="descriptors"></param>
/// <param name="useProvidedKeypoints"></param>
public void Run(InputArray image, InputArray mask, out KeyPoint[] keyPoints,
OutputArray descriptors, bool useProvidedKeypoints = false)
{
ThrowIfDisposed();
if (image == null)
throw new ArgumentNullException("image");
if (descriptors == null)
throw new ArgumentNullException("descriptors");
image.ThrowIfDisposed();
descriptors.ThrowIfNotReady();
using (VectorOfKeyPoint keyPointsVec = new VectorOfKeyPoint())
{
NativeMethods.features2d_BRISK_run2(ptr, image.CvPtr, Cv2.ToPtr(mask), keyPointsVec.CvPtr,
descriptors.CvPtr, useProvidedKeypoints ? 1 : 0);
keyPoints = keyPointsVec.ToArray();
}
descriptors.Fix();
}
/// <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();
}
/// <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(Mat image, ref KeyPoint[] keypoints, Mat descriptors)
{
if (image == null)
throw new ArgumentNullException("image");
if (descriptors == null)
throw new ArgumentNullException("descriptors");
using (var keypointsVec = new VectorOfKeyPoint(keypoints))
{
NativeMethods.features2d_DescriptorExtractor_compute1(
ptr, image.CvPtr, keypointsVec.CvPtr, descriptors.CvPtr);
keypoints = keypointsVec.ToArray();
}
}
/// <summary>
///
/// </summary>
/// <param name="gaussPyr"></param>
/// <param name="dogPyr"></param>
/// <returns></returns>
public KeyPoint[] FindScaleSpaceExtrema(IEnumerable<Mat> gaussPyr, IEnumerable<Mat> dogPyr)
{
ThrowIfDisposed();
if (gaussPyr == null)
throw new ArgumentNullException("gaussPyr");
if (dogPyr == null)
throw new ArgumentNullException("dogPyr");
IntPtr[] gaussPyrPtrs = EnumerableEx.SelectPtrs(gaussPyr);
IntPtr[] dogPyrPtrs = EnumerableEx.SelectPtrs(dogPyr);
using (VectorOfKeyPoint keyPointsVec = new VectorOfKeyPoint())
{
NativeMethods.nonfree_SIFT_findScaleSpaceExtrema(ptr, gaussPyrPtrs, gaussPyrPtrs.Length,
dogPyrPtrs, dogPyrPtrs.Length, keyPointsVec.CvPtr);
return keyPointsVec.ToArray();
}
}
/// <summary>
/// StarDetectorアルゴリズムによりキーポイントを取得する
/// </summary>
/// <param name="image">8ビット グレースケールの入力画像</param>
/// <returns></returns>
#else
/// <summary>
/// Retrieves keypoints using the StarDetector algorithm.
/// </summary>
/// <param name="image">The input 8-bit grayscale image</param>
/// <returns></returns>
#endif
public KeyPoint[] Run(Mat image)
{
if (image == null)
throw new ArgumentNullException("image");
image.ThrowIfDisposed();
IntPtr keypoints;
NativeMethods.features2d_StarDetector_detect(ptr, image.CvPtr, out keypoints);
using (VectorOfKeyPoint keypointsVec = new VectorOfKeyPoint(keypoints))
{
return keypointsVec.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(InputArray image, Mat mask = null)
{
if (image == null)
throw new ArgumentNullException("image");
if (disposed)
throw new ObjectDisposedException(GetType().Name);
image.ThrowIfDisposed();
try
{
using (var keypoints = new VectorOfKeyPoint())
{
NativeMethods.features2d_Feature2D_detect_InputArray(ptr, image.CvPtr, keypoints.CvPtr,
Cv2.ToPtr(mask));
return keypoints.ToArray();
}
}
finally
{
GC.KeepAlive(image);
GC.KeepAlive(mask);
}
}