public void TestChessboardCalibration() { Size patternSize = new Size(9, 6); Image <Gray, Byte> chessboardImage = EmguAssert.LoadImage <Gray, byte>("left01.jpg"); Util.VectorOfPointF corners = new Util.VectorOfPointF(); bool patternWasFound = CvInvoke.FindChessboardCorners(chessboardImage, patternSize, corners); chessboardImage.FindCornerSubPix( new PointF[][] { corners.ToArray() }, new Size(10, 10), new Size(-1, -1), new MCvTermCriteria(0.05)); MCvPoint3D32f[] objectPts = CalcChessboardCorners(patternSize, 1.0f); IntrinsicCameraParameters intrisic = new IntrinsicCameraParameters(8); ExtrinsicCameraParameters[] extrinsic; double error = CameraCalibration.CalibrateCamera(new MCvPoint3D32f[][] { objectPts }, new PointF[][] { corners.ToArray() }, chessboardImage.Size, intrisic, CvEnum.CalibType.Default, new MCvTermCriteria(30, 1.0e-10), out extrinsic); CvInvoke.DrawChessboardCorners(chessboardImage, patternSize, corners, patternWasFound); //CameraCalibration.DrawChessboardCorners(chessboardImage, patternSize, corners); Image <Gray, Byte> undistorted = intrisic.Undistort(chessboardImage); //UI.ImageViewer.Show(undistorted, String.Format("Reprojection error: {0}", error)); }
public void TestBOWKmeansTrainer() { Image <Gray, byte> box = EmguAssert.LoadImage <Gray, byte>("box.png"); SURF detector = new SURF(500); VectorOfKeyPoint kpts = new VectorOfKeyPoint(); Mat descriptors = new Mat(); detector.DetectAndCompute(box, null, kpts, descriptors, false); BOWKMeansTrainer trainer = new BOWKMeansTrainer(100, new MCvTermCriteria(), 3, CvEnum.KMeansInitType.PPCenters); trainer.Add(descriptors); Mat vocabulary = new Mat(); trainer.Cluster(vocabulary); BFMatcher matcher = new BFMatcher(DistanceType.L2); BOWImgDescriptorExtractor extractor = new BOWImgDescriptorExtractor(detector, matcher); extractor.SetVocabulary(vocabulary); Mat descriptors2 = new Mat(); extractor.Compute(box, kpts, descriptors2); }
public void TestBOWKmeansTrainer2() { Image <Gray, byte> box = EmguAssert.LoadImage <Gray, byte>("box.png"); Brisk detector = new Brisk(30, 3, 1.0f); VectorOfKeyPoint kpts = new VectorOfKeyPoint(); Mat descriptors = new Mat(); detector.DetectAndCompute(box, null, kpts, descriptors, false); Mat descriptorsF = new Mat(); descriptors.ConvertTo(descriptorsF, CvEnum.DepthType.Cv32F); //Matrix<float> descriptorsF = descriptors.Convert<float>(); BOWKMeansTrainer trainer = new BOWKMeansTrainer(100, new MCvTermCriteria(), 3, CvEnum.KMeansInitType.PPCenters); trainer.Add(descriptorsF); Mat vocabulary = new Mat(); trainer.Cluster(vocabulary); BFMatcher matcher = new BFMatcher(DistanceType.L2); BOWImgDescriptorExtractor extractor = new BOWImgDescriptorExtractor(detector, matcher); Mat vocabularyByte = new Mat(); vocabulary.ConvertTo(vocabularyByte, CvEnum.DepthType.Cv8U); extractor.SetVocabulary(vocabularyByte); Mat descriptors2 = new Mat(); extractor.Compute(box, kpts, descriptors2); }
public void TestChessboardCalibration() { Size patternSize = new Size(9, 6); Image <Gray, Byte> chessboardImage = EmguAssert.LoadImage <Gray, byte>("left01.jpg"); Util.VectorOfPointF corners = new Util.VectorOfPointF(); bool patternWasFound = CvInvoke.FindChessboardCorners(chessboardImage, patternSize, corners); chessboardImage.FindCornerSubPix( new PointF[][] { corners.ToArray() }, new Size(10, 10), new Size(-1, -1), new MCvTermCriteria(0.05)); MCvPoint3D32f[] objectPts = CalcChessboardCorners(patternSize, 1.0f); using (VectorOfVectorOfPoint3D32F ptsVec = new VectorOfVectorOfPoint3D32F(new MCvPoint3D32f[][] { objectPts })) using (VectorOfVectorOfPointF imgPtsVec = new VectorOfVectorOfPointF(corners)) using (Mat cameraMatrix = new Mat()) using (Mat distortionCoeff = new Mat()) using (VectorOfMat rotations = new VectorOfMat()) using (VectorOfMat translations = new VectorOfMat()) { Mat calMat = CvInvoke.InitCameraMatrix2D(ptsVec, imgPtsVec, chessboardImage.Size, 0); Matrix <double> calMatF = new Matrix <double>(calMat.Rows, calMat.Cols, calMat.NumberOfChannels); calMat.CopyTo(calMatF); double error = CvInvoke.CalibrateCamera(ptsVec, imgPtsVec, chessboardImage.Size, cameraMatrix, distortionCoeff, rotations, translations, CalibType.Default, new MCvTermCriteria(30, 1.0e-10)); using (Mat rotation = new Mat()) using (Mat translation = new Mat()) using (VectorOfPoint3D32F vpObject = new VectorOfPoint3D32F(objectPts)) { CvInvoke.SolvePnPRansac( vpObject, corners, cameraMatrix, distortionCoeff, rotation, translation, true); } CvInvoke.DrawChessboardCorners(chessboardImage, patternSize, corners, patternWasFound); using (Mat undistorted = new Mat()) { CvInvoke.Undistort(chessboardImage, undistorted, cameraMatrix, distortionCoeff); String title = String.Format("Reprojection error: {0}", error); //CvInvoke.NamedWindow(title); //CvInvoke.Imshow(title, undistorted); //CvInvoke.WaitKey(); //UI.ImageViewer.Show(undistorted, String.Format("Reprojection error: {0}", error)); } } }
public void TestCalibration() { Size patternSize = new Size(9, 6); Image <Gray, Byte> left01 = EmguAssert.LoadImage <Gray, byte>("left01.jpg"); using (Util.VectorOfPointF vec = new Util.VectorOfPointF()) { CvInvoke.FindChessboardCorners(left01, patternSize, vec); PointF[] corners = vec.ToArray(); } }
public void TestCirclesGrid() { Size patternSize = new Size(4, 3); Image <Gray, Byte> circlesGridImage = EmguAssert.LoadImage <Gray, byte>("circlesGrid.bmp"); using (SimpleBlobDetector detector = new SimpleBlobDetector()) using (Util.VectorOfPointF centers = new Util.VectorOfPointF()) { bool found = CvInvoke.FindCirclesGrid(circlesGridImage, patternSize, centers, CvEnum.CalibCgType.SymmetricGrid | CvEnum.CalibCgType.Clustering, detector); CvInvoke.DrawChessboardCorners(circlesGridImage, patternSize, centers, found); //UI.ImageViewer.Show(circlesGridImage); } }
public void TestGridAdaptedFeatureDetectorRepeatedRun() { Image <Gray, byte> box = EmguAssert.LoadImage <Gray, byte>("box.png"); SURFDetector surfdetector = new SURFDetector(400); GridAdaptedFeatureDetector detector = new GridAdaptedFeatureDetector(surfdetector, 1000, 2, 2); VectorOfKeyPoint kpts1 = new VectorOfKeyPoint(); detector.DetectRaw(box, kpts1); VectorOfKeyPoint kpts2 = new VectorOfKeyPoint(); detector.DetectRaw(box, kpts2); EmguAssert.IsTrue(kpts1.Size == kpts2.Size); }
public void TestClahe() { if (CudaInvoke.HasCuda) { Image <Gray, Byte> image = EmguAssert.LoadImage <Gray, Byte>("pedestrian.png"); CudaImage <Gray, Byte> cudaImage = new CudaImage <Gray, byte>(image); CudaImage <Gray, Byte> cudaResult = new CudaImage <Gray, byte>(cudaImage.Size); using (CudaClahe clahe = new CudaClahe(40.0, new Size(8, 8))) { Image <Gray, Byte> result = new Image <Gray, byte>(cudaResult.Size); clahe.Apply(cudaImage, cudaResult, null); cudaResult.Download(result); //Emgu.CV.UI.ImageViewer.Show(image.ConcateHorizontal(result)); } } }
public void TestChessboardCalibration() { Size patternSize = new Size(9, 6); Image <Gray, Byte> chessboardImage = EmguAssert.LoadImage <Gray, byte>("left01.jpg"); Util.VectorOfPointF corners = new Util.VectorOfPointF(); bool patternWasFound = CvInvoke.FindChessboardCorners(chessboardImage, patternSize, corners); chessboardImage.FindCornerSubPix( new PointF[][] { corners.ToArray() }, new Size(10, 10), new Size(-1, -1), new MCvTermCriteria(0.05)); MCvPoint3D32f[] objectPts = CalcChessboardCorners(patternSize, 1.0f); IntrinsicCameraParameters intrisic = new IntrinsicCameraParameters(8); ExtrinsicCameraParameters[] extrinsic; using (VectorOfVectorOfPoint3D32F ptsVec = new VectorOfVectorOfPoint3D32F(new MCvPoint3D32f[][] { objectPts })) using (VectorOfVectorOfPointF imgPtsVec = new VectorOfVectorOfPointF(corners)) { Mat calMat = CvInvoke.InitCameraMatrix2D(ptsVec, imgPtsVec, chessboardImage.Size, 0); Matrix <double> calMatF = new Matrix <double>(calMat.Rows, calMat.Cols, calMat.NumberOfChannels); calMat.CopyTo(calMatF); } double error = CameraCalibration.CalibrateCamera(new MCvPoint3D32f[][] { objectPts }, new PointF[][] { corners.ToArray() }, chessboardImage.Size, intrisic, CvEnum.CalibType.Default, new MCvTermCriteria(30, 1.0e-10), out extrinsic); CvInvoke.DrawChessboardCorners(chessboardImage, patternSize, corners, patternWasFound); //CameraCalibration.DrawChessboardCorners(chessboardImage, patternSize, corners); Image <Gray, Byte> undistorted = intrisic.Undistort(chessboardImage); //UI.ImageViewer.Show(undistorted, String.Format("Reprojection error: {0}", error)); Mat[] rotationVectors, translationVectors; CvInvoke.CalibrateCamera(new MCvPoint3D32f[][] { objectPts }, new PointF[][] { corners.ToArray() }, chessboardImage.Size, intrisic.IntrinsicMatrix, intrisic.DistortionCoeffs, CalibType.Default, new MCvTermCriteria(30, 1.0e-10), out rotationVectors, out translationVectors); }
public void TestDetectorColor() { Image <Bgr, byte> box = EmguAssert.LoadImage <Bgr, byte>("box.png"); Image <Gray, byte> gray = box.Convert <Gray, Byte>(); SURFDetector surf = new SURFDetector(400); OpponentColorDescriptorExtractor opponentSurf = new OpponentColorDescriptorExtractor(surf); SIFTDetector sift = new SIFTDetector(); OpponentColorDescriptorExtractor opponentSift = new OpponentColorDescriptorExtractor(sift); //using (Util.VectorOfKeyPoint kpts = surf.DetectKeyPointsRaw(gray, null)) using (Util.VectorOfKeyPoint kpts = new VectorOfKeyPoint()) { sift.DetectRaw(gray, kpts); for (int i = 1; i < 2; i++) { using (Mat surfDescriptors = new Mat()) { opponentSurf.Compute(box, kpts, surfDescriptors); //EmguAssert.IsTrue(surfDescriptors.Width == (surf.SURFParams.Extended == 0 ? 64 : 128) * 3); } //TODO: Find out why the following test fails using (Mat siftDescriptors = new Mat()) { sift.Compute(gray, kpts, siftDescriptors); EmguAssert.IsTrue(siftDescriptors.Cols == sift.GetDescriptorSize()); } int siftDescriptorSize = sift.GetDescriptorSize(); using (Mat siftDescriptors = new Mat()) { opponentSift.Compute(box, kpts, siftDescriptors); EmguAssert.IsTrue(siftDescriptors.Cols == siftDescriptorSize * 3); } } } }
public void TestSURFDetector2() { //Trace.WriteLine("Size of MCvSURFParams: " + Marshal.SizeOf(typeof(MCvSURFParams))); Image <Gray, byte> box = EmguAssert.LoadImage <Gray, byte>("box.png"); SURF detector = new SURF(400); Stopwatch watch = Stopwatch.StartNew(); VectorOfKeyPoint vp1 = new VectorOfKeyPoint(); Mat descriptors1 = new Mat(); detector.DetectAndCompute(box, null, vp1, descriptors1, false); watch.Stop(); EmguAssert.WriteLine(String.Format("Time used: {0} milliseconds.", watch.ElapsedMilliseconds)); watch.Reset(); watch.Start(); MKeyPoint[] keypoints = detector.Detect(box, null); //ImageFeature<float>[] features2 = detector.Compute(box, keypoints); watch.Stop(); EmguAssert.WriteLine(String.Format("Time used: {0} milliseconds.", watch.ElapsedMilliseconds)); watch.Reset(); watch.Start(); //MCvSURFParams p = detector.SURFParams; //SURFFeature[] features3 = box.ExtractSURF(ref p); //watch.Stop(); //EmguAssert.WriteLine(String.Format("Time used: {0} milliseconds.", watch.ElapsedMilliseconds)); // EmguAssert.IsTrue(features1.Length == features2.Length); //EmguAssert.IsTrue(features2.Length == features3.Length); PointF[] pts = #if NETFX_CORE Extensions. #else Array. #endif ConvertAll <MKeyPoint, PointF>(keypoints, delegate(MKeyPoint mkp) { return(mkp.Point); }); //SURFFeature[] features = box.ExtractSURF(pts, null, ref detector); //int count = features.Length; /* * for (int i = 0; i < features1.Length; i++) * { * Assert.AreEqual(features1[i].KeyPoint.Point, features2[i].KeyPoint.Point); * float[] d1 = features1[i].Descriptor; * float[] d2 = features2[i].Descriptor; * * for (int j = 0; j < d1.Length; j++) * Assert.AreEqual(d1[j], d2[j]); * }*/ foreach (MKeyPoint kp in keypoints) { box.Draw(new CircleF(kp.Point, kp.Size), new Gray(255), 1); } }
public static bool TestFeature2DTracker(Feature2D keyPointDetector, Feature2D descriptorGenerator) { //for (int k = 0; k < 1; k++) { Feature2D feature2D = null; if (keyPointDetector == descriptorGenerator) { feature2D = keyPointDetector as Feature2D; } Mat modelImage = EmguAssert.LoadMat("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.ToImage <Gray, Byte>().ConcateVertical(observedImage); Rectangle rect = new Rectangle(Point.Empty, modelImage.Size); 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) }; Mat 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 (BFMatcher matcher = new BFMatcher(dt)) { //ParamDef[] parameterDefs = matcher.GetParams(); matcher.Add(modelDescriptors); matcher.KnnMatch(observedDescriptors, matches, k, null); Mat mask = new Mat(matches.Size, 1, DepthType.Cv8U, 1); mask.SetTo(new MCvScalar(255)); //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[]; points = CvInvoke.PerspectiveTransform(points, homography); //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; * }*/ } }