/// <summary> /// Initializes this instance. /// </summary> /// protected void Init(IFeatureDetector <TPoint, TFeature> detector, IClusteringAlgorithm <TFeature> algorithm) { this.NumberOfWords = algorithm.Clusters.Count; this.Clustering = algorithm; this.Detector = detector; this.ParallelOptions = new ParallelOptions(); }
private void FindKeypoint(int ID, InputFileModel inputFile, IFeatureDetector detector, bool AddToList = true) { WindowsFormHelper.AddLogToConsole($"Start finding key points for: {inputFile.fileInfo.Name.ToString()}\n"); var detectedKeyPoints = detector.DetectKeyPoints(new Mat(inputFile.fileInfo.FullName)); if (AddToList) { DetectedKeyPoints.Add(ID, new KeyPointModel() { DetectedKeyPoints = new VectorOfKeyPoint(detectedKeyPoints), InputFile = inputFile, ID = ID } ); } WindowsFormHelper.AddLogToConsole($"FINISH finding key points for: {inputFile.fileInfo.Name.ToString()}\n"); // Save drawing image Mat output = new Mat(); Directory.CreateDirectory($@"{tempDirectory}\DrawKeypoint"); Features2DToolbox.DrawKeypoints(new Mat(inputFile.fileInfo.FullName), new VectorOfKeyPoint(detectedKeyPoints), output, new Bgr(0, 0, 255), KeypointDrawType.DrawRichKeypoints); output.Save(Path.Combine($@"{tempDirectory}\DrawKeypoint", $"{Path.GetFileNameWithoutExtension(inputFile.fileInfo.Name)}.JPG")); fileManager.listViewerModel._lastDrawnKeypoint = new Image <Bgr, byte>(output.Bitmap); var file = new InputFileModel(Path.Combine($@"{tempDirectory}\DrawKeypoint", $"{Path.GetFileNameWithoutExtension(inputFile.fileInfo.Name)}.JPG")); var imageList = _winForm.ImageList[(int)EListViewGroup.DrawnKeyPoint]; var listViewer = _winForm.ListViews[(int)EListViewGroup.DrawnKeyPoint]; fileManager.AddInputFileToList(file, fileManager.listViewerModel.ListOfListInputFolder[(int)EListViewGroup.DrawnKeyPoint], imageList, listViewer); }
/// <summary> /// Adapts a detector to partition the source image into a grid and detect points in each cell. /// </summary> /// <param name="detector">Detector that will be adapted</param> /// <param name="maxTotalKeyPoints">Maximum count of keypoints detected on the image. Only the strongest keypoints</param> /// <param name="gridRows">Grid rows count</param> /// <param name="gridCols">Grid column count</param> public GridAdaptedFeatureDetector(IFeatureDetector detector, int maxTotalKeyPoints, int gridRows, int gridCols) { _baseDetector = detector; MaxTotalKeyPoints = maxTotalKeyPoints; GridRows = gridRows; GridCols = gridCols; _ptr = GridAdaptedFeatureDetectorCreate(detector.FeatureDetectorPtr, maxTotalKeyPoints, gridRows, gridCols); }
/// <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> /// Detects keypoints in the specified input image. /// </summary> /// <param name="detector">The feature detector used to find image keypoints.</param> /// <param name="image">The image on which to detect keypoints.</param> /// <param name="mask">The optional operation mask used to specify where to look for keypoints.</param> /// <returns>The collection of detected keypoints.</returns> public static KeyPointCollection Detect(this IFeatureDetector detector, Arr image, Arr mask = null) { if (detector == null) { throw new ArgumentNullException("detector"); } var keyPoints = new KeyPointCollection(); detector.Detect(image, keyPoints, mask); return(keyPoints); }
/// <summary> /// Process image looking for interest points. /// </summary> /// <typeparam name="TPoint">The type of returned feature points.</typeparam> /// <typeparam name="TFeature">The type of extracted features.</typeparam> /// <param name="featureDetector">Feature detector.</param> /// <param name="image">Source image data to process.</param> /// <returns>Returns list of found interest points.</returns> public static List <TPoint> ProcessImage <TPoint, TFeature>(this IFeatureDetector <TPoint, TFeature> featureDetector, Gray <byte>[,] image) where TPoint : IFeatureDescriptor <TFeature> { List <TPoint> points; using (var uImg = image.Lock()) { points = featureDetector.ProcessImage(uImg.AsAForgeImage()); } return(points); }
public void ContinueInComputingSFM(IFeatureDetector detector, IFeatureDescriptor descriptor, IFeatureMatcher matcher, List <InputFileModel> listOfInput) { var iterMatches = FoundedMatches.Count; countInputFile = DetectedKeyPoints.Count; StartDetectingKeyPoint(countInputFile, listOfInput, detector); StartComputingDescriptor(countInputFile, descriptor); StartMatching(countInputFile, matcher); WriteAddedImages(listOfInput); AppendMatches(FoundedMatches, iterMatches); ContinueVisualSFM(); }
public void ComputeSfM(IFeatureDetector detector, IFeatureDescriptor descriptor, IFeatureMatcher matcher, List <InputFileModel> listOfInput) { countInputFile = 0; DetectedKeyPoints.Clear(); ComputedDescriptors.Clear(); FoundedMatches.Clear(); switch (fileManager._inputType) { case EInput.ListView: StartDetectingKeyPoint(0, listOfInput, detector); StartComputingDescriptor(0, descriptor); StartMatching(0, matcher); break; case EInput.ConnectedStereoCamera: countInputFile = DetectedKeyPoints.Count; listOfInput = GetInputFromStereoCamera(countInputFile); StartDetectingKeyPoint(countInputFile, listOfInput, detector); StartComputingDescriptor(countInputFile, descriptor); while (!stopSFM) { countInputFile = DetectedKeyPoints.Count; listOfInput = GetInputFromStereoCamera(countInputFile); StartDetectingKeyPoint(countInputFile, listOfInput, detector); StartComputingDescriptor(countInputFile, descriptor); StartStereoMatching(countInputFile, matcher); } break; } WriteAllMatches(FoundedMatches); RunVisualSFM(); }
public void SetFeatureDetector(object sender, EventArgs e) { var currentItem = sender as ToolStripComboBox; var enumItem = EnumExtension.ReturnEnumValue <EFeaturesDetector>(currentItem.SelectedItem.ToString()); IFeatureDetector tempItem = null; switch (enumItem) { case EFeaturesDetector.ORB: tempItem = new OrientedFastAndRotatedBrief(); break; case EFeaturesDetector.FAST: tempItem = new FAST(); break; case EFeaturesDetector.FREAK: tempItem = new FREAK(); break; case EFeaturesDetector.BRIEF: tempItem = new BRIEF(); break; case EFeaturesDetector.CudaORB: tempItem = new CudaOrientedFastAndRotatedBrief(); break; } _sfmManager._detector = tempItem; }
/// <summary> /// Constructs a new <see cref="BagOfVisualWords"/>. /// </summary> /// /// <param name="detector">The feature detector to use.</param> /// <param name="algorithm">The clustering algorithm to use.</param> /// public BagOfVisualWords(IFeatureDetector <TPoint, TFeature> detector, IClusteringAlgorithm <TFeature> algorithm) { this.NumberOfWords = algorithm.Clusters.Count; this.Clustering = algorithm; this.Detector = detector; }
/// <summary> /// Detect the features in the image /// </summary> /// <param name="detector">The feature detector</param> /// <param name="keypoints">The result vector of keypoints</param> /// <param name="image">The image from which the features will be detected from</param> /// <param name="mask">The optional mask.</param> public static void DetectRaw(this IFeatureDetector detector, IInputArray image, VectorOfKeyPoint keypoints, IInputArray mask = null) { using (InputArray iaImage = image.GetInputArray()) using (InputArray iaMask = mask == null ? InputArray.GetEmpty() : mask.GetInputArray()) CvFeatureDetectorDetectKeyPoints(detector.FeatureDetectorPtr, iaImage, keypoints.Ptr, iaMask); }
/// <summary> /// Constructs a new <see cref="BagOfVisualWords"/>. /// </summary> /// /// <param name="detector">The feature detector to use.</param> /// <param name="algorithm">The clustering algorithm to use.</param> /// public BagOfVisualWords(IFeatureDetector <TPoint, TFeature> detector, //IClusteringAlgorithm<TFeature> IUnsupervisedLearning <IClassifier <TFeature, int>, TFeature, int> algorithm) { Init(detector, algorithm); }
/// <summary> /// Initializes a new instance of the <see cref="PointsOfInterestFeatureBuilder"/> class. /// </summary> /// <param name="detector">The feature detector.</param> /// <exception cref="ArgumentNullException"> /// <paramref name="detector"/> is <b>null</b>. /// </exception> public PointsOfInterestFeatureBuilder(IFeatureDetector detector) { this.detector = detector ?? throw new ArgumentNullException(nameof(detector)); }
/// <summary> /// Process image looking for interest points. /// </summary> /// <typeparam name="TPoint">The type of returned feature points.</typeparam> /// <typeparam name="TFeature">The type of extracted features.</typeparam> /// <param name="featureDetector">Feature detector.</param> /// <param name="image">Source image data to process.</param> /// <returns>Returns list of found interest points.</returns> public static List <TPoint> ProcessImage <TPoint, TFeature>(this IFeatureDetector <TPoint, TFeature> featureDetector, Image <Gray, byte> image) where TPoint : IFeatureDescriptor <TFeature> { return(featureDetector.ProcessImage(image.ToAForgeImage(copyAlways: false, failIfCannotCast: true))); }
/// <summary> /// Constructs a new <see cref="BagOfVisualWords"/>. /// </summary> /// /// <param name="detector">The feature detector to use.</param> /// <param name="algorithm">The clustering algorithm to use.</param> /// public BagOfVisualWords(IFeatureDetector <TPoint> detector, //IClusteringAlgorithm<double[]> IUnsupervisedLearning <IClassifier <double[], int>, double[], int> algorithm) { base.Init(detector, algorithm); }
/// <summary> /// Constructs a new <see cref="BagOfVisualWords"/>. /// </summary> /// /// <param name="detector">The feature detector to use.</param> /// <param name="numberOfWords">The number of codewords.</param> /// public BagOfVisualWords(IFeatureDetector <TPoint> detector, int numberOfWords) { base.Init(detector, base.KMeans(numberOfWords)); }
/// <summary> /// Constructs a new <see cref="BagOfVisualWords"/>. /// </summary> /// /// <param name="detector">The feature detector to use.</param> /// <param name="algorithm">The clustering algorithm to use.</param> /// public BagOfVisualWords(IFeatureDetector <TPoint, TFeature> detector, IClusteringAlgorithm <TFeature> algorithm) { Init(detector, algorithm); }
/// <summary> /// Constructs a new <see cref="BagOfVisualWords"/>. /// </summary> /// /// <param name="detector">The feature detector to use.</param> /// <param name="numberOfWords">The number of codewords.</param> /// public BagOfVisualWords(IFeatureDetector <TPoint> detector, int numberOfWords) : base(detector, new KMeans(numberOfWords)) { }
private void StartDetectingKeyPoint(int countOfInput, List <InputFileModel> listOfInput, IFeatureDetector detector) { _winForm.SetMaximumProgressBar("Detecting keypoints", listOfInput.Count - countInputFile); if (_useParallel) { Parallel.For(0, listOfInput.Count, x => { FindKeypoint(countOfInput + x, listOfInput[x], detector); }); } else { for (int i = 0; i < listOfInput.Count; i++) { FindKeypoint(countOfInput + i, listOfInput[i], detector); } } _winForm.IncrementValueProgressBar(); }
/// <summary> /// Constructs a new <see cref="BagOfVisualWords"/>. /// </summary> /// /// <param name="detector">The feature detector to use.</param> /// <param name="algorithm">The clustering algorithm to use.</param> /// public BagOfVisualWords(IFeatureDetector <TPoint> detector, IClusteringAlgorithm <double[]> algorithm) : base(detector, algorithm) { }
public static bool TestFeature2DTracker(IFeatureDetector keyPointDetector, IDescriptorExtractor descriptorGenerator) { //for (int k = 0; k < 1; k++) { Feature2D feature2D = null; if (keyPointDetector == descriptorGenerator) { feature2D = keyPointDetector as Feature2D; } Image <Gray, Byte> modelImage = EmguAssert.LoadImage <Gray, byte>("box.png"); //Image<Gray, Byte> modelImage = new Image<Gray, byte>("stop.jpg"); //modelImage = modelImage.Resize(400, 400, true); //modelImage._EqualizeHist(); #region extract features from the object image Stopwatch stopwatch = Stopwatch.StartNew(); VectorOfKeyPoint modelKeypoints = new VectorOfKeyPoint(); Mat modelDescriptors = new Mat(); if (feature2D != null) { feature2D.DetectAndCompute(modelImage, null, modelKeypoints, modelDescriptors, false); } else { keyPointDetector.DetectRaw(modelImage, modelKeypoints); descriptorGenerator.Compute(modelImage, modelKeypoints, modelDescriptors); } stopwatch.Stop(); EmguAssert.WriteLine(String.Format("Time to extract feature from model: {0} milli-sec", stopwatch.ElapsedMilliseconds)); #endregion //Image<Gray, Byte> observedImage = new Image<Gray, byte>("traffic.jpg"); Image <Gray, Byte> observedImage = EmguAssert.LoadImage <Gray, byte>("box_in_scene.png"); //Image<Gray, Byte> observedImage = modelImage.Rotate(45, new Gray(0.0)); //image = image.Resize(400, 400, true); //observedImage._EqualizeHist(); #region extract features from the observed image stopwatch.Reset(); stopwatch.Start(); VectorOfKeyPoint observedKeypoints = new VectorOfKeyPoint(); using (Mat observedDescriptors = new Mat()) { if (feature2D != null) { feature2D.DetectAndCompute(observedImage, null, observedKeypoints, observedDescriptors, false); } else { keyPointDetector.DetectRaw(observedImage, observedKeypoints); descriptorGenerator.Compute(observedImage, observedKeypoints, observedDescriptors); } stopwatch.Stop(); EmguAssert.WriteLine(String.Format("Time to extract feature from image: {0} milli-sec", stopwatch.ElapsedMilliseconds)); #endregion //Merge the object image and the observed image into one big image for display Image <Gray, Byte> res = modelImage.ConcateVertical(observedImage); 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) }; HomographyMatrix homography = null; stopwatch.Reset(); stopwatch.Start(); int k = 2; DistanceType dt = modelDescriptors.Depth == CvEnum.DepthType.Cv8U ? DistanceType.Hamming : DistanceType.L2; //using (Matrix<int> indices = new Matrix<int>(observedDescriptors.Rows, k)) //using (Matrix<float> dist = new Matrix<float>(observedDescriptors.Rows, k)) using (VectorOfVectorOfDMatch matches = new VectorOfVectorOfDMatch()) using (BruteForceMatcher matcher = new BruteForceMatcher(dt)) { matcher.Add(modelDescriptors); matcher.KnnMatch(observedDescriptors, matches, k, null); Matrix <byte> mask = new Matrix <byte>(matches.Size, 1); mask.SetValue(255); Features2DToolbox.VoteForUniqueness(matches, 0.8, mask); int nonZeroCount = CvInvoke.CountNonZero(mask); if (nonZeroCount >= 4) { nonZeroCount = Features2DToolbox.VoteForSizeAndOrientation(modelKeypoints, observedKeypoints, matches, mask, 1.5, 20); if (nonZeroCount >= 4) { homography = Features2DToolbox.GetHomographyMatrixFromMatchedFeatures(modelKeypoints, observedKeypoints, matches, mask, 2); } } } stopwatch.Stop(); EmguAssert.WriteLine(String.Format("Time for feature matching: {0} milli-sec", stopwatch.ElapsedMilliseconds)); bool success = false; if (homography != null) { PointF[] points = pts.Clone() as PointF[]; homography.ProjectPoints(points); for (int i = 0; i < points.Length; i++) { points[i].Y += modelImage.Height; } res.DrawPolyline( #if NETFX_CORE Extensions. #else Array. #endif ConvertAll <PointF, Point>(points, Point.Round), true, new Gray(255.0), 5); success = true; } //Emgu.CV.UI.ImageViewer.Show(res); return(success); } /* * stopwatch.Reset(); stopwatch.Start(); * //set the initial region to be the whole image * using (Image<Gray, Single> priorMask = new Image<Gray, float>(observedImage.Size)) * { * priorMask.SetValue(1.0); * homography = tracker.CamShiftTrack( * observedFeatures, * (RectangleF)observedImage.ROI, * priorMask); * } * Trace.WriteLine(String.Format("Time for feature tracking: {0} milli-sec", stopwatch.ElapsedMilliseconds)); * * if (homography != null) //set the initial tracking window to be the whole image * { * PointF[] points = pts.Clone() as PointF[]; * homography.ProjectPoints(points); * * for (int i = 0; i < points.Length; i++) * points[i].Y += modelImage.Height; * res.DrawPolyline(Array.ConvertAll<PointF, Point>(points, Point.Round), true, new Gray(255.0), 5); * return true; * } * else * { * return false; * }*/ } }