public static Matrix<byte> ExtractBriefFeatureDescriptors(Emgu.CV.Image<Gray, byte> im, MKeyPoint kp) { var f = new VectorOfKeyPoint(); f.Push(new MKeyPoint[] { kp }); //i'm are going to invoke this with a single point because otherwise I cannot tell which points failed to get descriptors return new BriefDescriptorExtractor().ComputeDescriptorsRaw(im, (Emgu.CV.Image<Gray, byte>)null, f); }
/// <summary> /// Push an array of value into the standard vector /// </summary> /// <param name="value">The value to be pushed to the vector</param> public void Push(MKeyPoint[] value) { if (value.Length > 0) { GCHandle handle = GCHandle.Alloc(value, GCHandleType.Pinned); CvInvoke.VectorOfKeyPointPushMulti(_ptr, handle.AddrOfPinnedObject(), value.Length); handle.Free(); } }
public PointF[] Calculate(IImage prev, IImage curr, MKeyPoint[] prevFeatures) { PointF[] features; byte[] status; float[] trackError; var points = prevFeatures.Select(e => e.Point).ToArray(); CvInvoke.CalcOpticalFlowPyrLK(prev, curr, points, winSize, level, criteria, out features, out status, out trackError); return features; }
/// <summary> /// Compute the descriptor given the image and the point location /// </summary> /// <param name="image">The image where the descriptor will be computed from</param> /// <param name="mask">The optional mask, can be null if not needed</param> /// <param name="keyPoints">The keypoint where the descriptor will be computed from</param> /// <returns>The image features founded on the keypoint location</returns> public ImageFeature[] ComputeDescriptors(Image<Gray, Byte> image, Image<Gray, byte> mask, MKeyPoint[] keyPoints) { using (VectorOfFloat descs = new VectorOfFloat()) using (VectorOfKeyPoint kpts = new VectorOfKeyPoint()) { kpts.Push(keyPoints); CvSURFDetectorComputeDescriptors(ref this, image, mask, kpts, descs); int n = keyPoints.Length; long address = descs.StartAddress.ToInt64(); ImageFeature[] features = new ImageFeature[n]; int sizeOfdescriptor = extended == 0 ? 64 : 128; for (int i = 0; i < n; i++, address += sizeOfdescriptor * sizeof(float)) { features[i].KeyPoint = keyPoints[i]; float[] desc = new float[sizeOfdescriptor]; Marshal.Copy(new IntPtr(address), desc, 0, sizeOfdescriptor); features[i].Descriptor = desc; } return features; } }
/// <summary> /// Compute the descriptor given the image and the point location /// </summary> /// <param name="image">The image where the descriptor will be computed from</param> /// <param name="mask">The optional mask, can be null if not needed</param> /// <param name="keyPoints">The keypoint where the descriptor will be computed from</param> /// <returns>The image features founded on the keypoint location</returns> public ImageFeature[] ComputeDescriptors(Image<Gray, Byte> image, Image<Gray, byte> mask, MKeyPoint[] keyPoints) { if (keyPoints.Length == 0) return new ImageFeature[0]; using (VectorOfFloat descVec = new VectorOfFloat()) using (VectorOfKeyPoint kpts = new VectorOfKeyPoint()) { kpts.Push(keyPoints); CvSIFTDetectorComputeDescriptors(_ptr, image, mask, kpts, descVec); int n = keyPoints.Length; float[] descs = descVec.ToArray(); //long address = descVec.StartAddress.ToInt64(); ImageFeature[] features = new ImageFeature[n]; int sizeOfdescriptor = DescriptorSize; for (int i = 0; i < n; i++) { features[i].KeyPoint = keyPoints[i]; float[] d = new float[sizeOfdescriptor]; Array.Copy(descs, i * sizeOfdescriptor, d, 0, sizeOfdescriptor); features[i].Descriptor = d; } return features; } }
/// <summary> /// Compute the ImageFeature on the image from the given keypoint locations. /// </summary> /// <param name="image">The image to compute descriptors from</param> /// <param name="keyPoints">The keypoints where the descriptor computation is perfromed</param> /// <returns>The ImageFeature from the given keypoints</returns> public ImageFeature[] ComputeDescriptors(Image<Gray, byte> image, MKeyPoint[] keyPoints) { return ComputeDescriptors(image, null, keyPoints); }
/// <summary> /// Convert the standard vector to an array of float /// </summary> /// <returns>An array of float</returns> public MKeyPoint[] ToArray() { MKeyPoint[] res = new MKeyPoint[Size]; GCHandle handle = GCHandle.Alloc(res, GCHandleType.Pinned); VectorOfKeyPointCopyData(_ptr, handle.AddrOfPinnedObject()); handle.Free(); return res; }
/* /// <summary> /// Compute the descriptor given the bgr image and the point location, using oppponent color (CGIV 2008 "Color Descriptors for Object Category Recognition"). /// </summary> /// <param name="image">The image where the descriptor will be computed from</param> /// <param name="keyPoints">The keypoint where the descriptor will be computed from</param> /// <returns>The descriptors founded on the keypoint location</returns> public Matrix<float> ComputeDescriptorsRaw(Image<Bgr, Byte> image, VectorOfKeyPoint keyPoints) { int count = keyPoints.Size; if (count == 0) return null; Matrix<float> descriptors = new Matrix<float>(count, DescriptorSize * 3, 1); CvSIFTDetectorComputeDescriptorsBGR(_ptr, image, keyPoints, descriptors); return descriptors; }*/ /// <summary> /// Compute the descriptor given the image and the point location /// </summary> /// <param name="image">The image where the descriptor will be computed from</param> /// <param name="mask">The optional mask, can be null if not needed</param> /// <param name="keyPoints">The keypoint where the descriptor will be computed from</param> /// <returns>The descriptors founded on the keypoint location</returns> public ImageFeature[] ComputeDescriptors(Image<Gray, Byte> image, Image<Gray, byte> mask, MKeyPoint[] keyPoints) { if (keyPoints.Length == 0) return new ImageFeature[0]; using (VectorOfKeyPoint kpts = new VectorOfKeyPoint()) { kpts.Push(keyPoints); using (Matrix<float> descriptor = ComputeDescriptorsRaw(image, mask, kpts)) { return Features2DTracker.ConvertToImageFeature(kpts, descriptor); } } }
internal static extern void VectorOfKeyPointGetItem(IntPtr keypoints, int index, ref MKeyPoint keypoint);
private static void ExternalSURFKeypoints(ref Image<Gray, Byte> frame, out MKeyPoint[] all_keypoints) { Console.WriteLine("External SURF Keypoint Detector"); all_keypoints = SURF.DetectKeyPoints(frame, null); }
private static void ExternalBRISKKeypoints(ref Image<Gray, Byte> frame, out MKeyPoint[] all_keypoints) { //Console.WriteLine("External BRISK Keypoint Detector"); all_keypoints = featureDetector.DetectKeyPoints(frame, null); }
/// <summary> /// Draw the model image and observed image, the matched features and homography projection. /// </summary> /// <param name="modelImage">The model image</param> /// <param name="observedImage">The observed image</param> /// <param name="matchTime">The output total time for computing the homography matrix.</param> /// <returns>The model image and observed image, the matched features and homography projection.</returns> public static Image<Bgr, Byte> Draw(Image<Gray, Byte> modelImage, Image<Gray, byte> observedImage, out long matchTime, out double featurenumber, out MKeyPoint[] keyPoints, out List<int> index) { //index = new int[100]; index = new List<int>(); HomographyMatrix homography; VectorOfKeyPoint modelKeyPoints; VectorOfKeyPoint observedKeyPoints; Matrix<int> indices; Matrix<byte> mask; FindMatch(modelImage, observedImage, out matchTime, out modelKeyPoints, out observedKeyPoints, out indices, out mask, out homography, out featurenumber); //foreach (byte data in mask.Data) //{ // if( data = 0) //} int n = 0; for (int i = 0; i < mask.Data.GetLength(0); i++) { if (mask.Data[i, 0] == 1) { index.Add(i); n++; Console.WriteLine(i); } } //Draw the matched keypoints Image<Bgr, Byte> result = Features2DToolbox.DrawMatches(modelImage, modelKeyPoints, observedImage, observedKeyPoints, indices, new Bgr(255, 0, 0), new Bgr(255, 0, 255), mask, Features2DToolbox.KeypointDrawType.NOT_DRAW_SINGLE_POINTS); #region draw the projected region on the image Rectangle rect = modelImage.ROI; PointF[] pts = new PointF[] { new PointF(rect.Left, rect.Bottom), new PointF(rect.Right, rect.Bottom), new PointF(rect.Right, rect.Top), new PointF(rect.Left, rect.Top)}; if (homography != null) { //draw a rectangle along the projected model homography.ProjectPoints(pts); result.DrawPolyline(Array.ConvertAll<PointF, Point>(pts, Point.Round), true, new Bgr(Color.Red), 5); } #endregion keyPoints = observedKeyPoints.ToArray(); featurenumber = n; return result; }
/// <summary> /// Create an standard vector of KeyPoint with the initial values /// </summary> /// <param name="values">The initial values</param> public VectorOfKeyPoint(MKeyPoint[] values) :this() { Push(values); }
internal static extern void VectorOfKeyPointGetItem(IntPtr vec, int index, ref MKeyPoint element);
/// <summary> /// Convert the standard vector to an array of KeyPoint /// </summary> /// <returns>An array of KeyPoint</returns> public MKeyPoint[] ToArray() { MKeyPoint[] res = new MKeyPoint[Size]; if (res.Length > 0) { GCHandle handle = GCHandle.Alloc(res, GCHandleType.Pinned); CvInvoke.VectorOfKeyPointCopyData(_ptr, handle.AddrOfPinnedObject()); handle.Free(); } return res; }
/// <summary> /// Get the item in the specific index /// </summary> /// <param name="index">The index</param> /// <returns>The item in the specific index</returns> public MKeyPoint this[int index] { get { MKeyPoint result = new MKeyPoint(); CvInvoke.VectorOfKeyPointGetItem(_ptr, index, ref result); return result; } }
private static void ExternalBRISKDescriptors(ref Image<Gray, Byte> frame, MKeyPoint[] keypoints, out Matrix<byte> features) { //Console.WriteLine("External BRISK Keypoint Descriptor Extractor"); Emgu.CV.Util.VectorOfKeyPoint keypoint_vector = new Emgu.CV.Util.VectorOfKeyPoint(); keypoint_vector.Push(keypoints); features = featureDetector.ComputeDescriptorsRaw(frame, null, keypoint_vector); }
/// <summary> /// Compute the descriptor given the image and the point location /// </summary> /// <param name="image">The image where the descriptor will be computed from</param> /// <param name="mask">The optional mask, can be null if not needed</param> /// <param name="keyPoints">The keypoint where the descriptor will be computed from</param> /// <returns>The image features founded on the keypoint location</returns> public ImageFeature[] ComputeDescriptors(Image<Gray, Byte> image, Image<Gray, byte> mask, MKeyPoint[] keyPoints) { int sizeOfdescriptor = _surfParams.Extended ? 128 : 64; using (VectorOfKeyPoint pts = new VectorOfKeyPoint()) { pts.Push(keyPoints); using (Matrix<float> descriptors = ComputeDescriptorsRaw(image, mask, pts)) return Features2DTracker.ConvertToImageFeature(pts, descriptors); } }
/// <summary> /// Compute the descriptor given the image and the point location /// </summary> /// <param name="image">The image where the descriptor will be computed from</param> /// <param name="mask">The optional mask, can be null if not needed</param> /// <param name="keyPoints">The keypoint where the descriptor will be computed from</param> /// <returns>The image features founded on the keypoint location</returns> public ImageFeature[] ComputeDescriptors(Image<Gray, Byte> image, Image<Gray, byte> mask, MKeyPoint[] keyPoints) { if (keyPoints.Length == 0) return new ImageFeature[0]; using (VectorOfFloat descs = new VectorOfFloat()) { GCHandle handle = GCHandle.Alloc(keyPoints, GCHandleType.Pinned); CvSIFTDetectorComputeDescriptors(_ptr, image, mask, handle.AddrOfPinnedObject(), keyPoints.Length, descs); handle.Free(); int n = keyPoints.Length; long address = descs.StartAddress.ToInt64(); ImageFeature[] features = new ImageFeature[n]; int sizeOfdescriptor = DescriptorSize; for (int i = 0; i < n; i++, address += sizeOfdescriptor * sizeof(float)) { features[i].KeyPoint = keyPoints[i]; float[] desc = new float[sizeOfdescriptor]; Marshal.Copy(new IntPtr(address), desc, 0, sizeOfdescriptor); features[i].Descriptor = desc; } return features; } }