public static void FindMatch(
Mat modelImage,
Mat observedImage,
out VectorOfKeyPoint modelKeyPoints,
out VectorOfKeyPoint observedKeyPoints,
VectorOfVectorOfDMatch matches,
out Mat mask,
out Mat homography)
{
int k = 9;
double uniquenessThreshold = 0.80;
Stopwatch watch;
homography = null;
modelKeyPoints = new VectorOfKeyPoint();
observedKeyPoints = new VectorOfKeyPoint();
using (UMat uModelImage = modelImage.GetUMat(AccessType.Read))
using (UMat uObservedImage = observedImage.GetUMat(AccessType.Read))
{
KAZE featureDetector = new KAZE();
//extract features from the object image
Mat modelDescriptors = new Mat();
featureDetector.DetectAndCompute(uModelImage, null, modelKeyPoints, modelDescriptors, false);
watch = Stopwatch.StartNew();
// extract features from the observed image
Mat observedDescriptors = new Mat();
featureDetector.DetectAndCompute(uObservedImage, null, observedKeyPoints, observedDescriptors, false);
using (Emgu.CV.Flann.LinearIndexParams ip = new Emgu.CV.Flann.LinearIndexParams())
using (Emgu.CV.Flann.SearchParams sp = new SearchParams())
using (DescriptorMatcher matcher = new FlannBasedMatcher(ip, sp))
{
matcher.Add(modelDescriptors);
matcher.KnnMatch(observedDescriptors, matches, k, null);
mask = new Mat(matches.Size, 1, DepthType.Cv8U, 1);
mask.SetTo(new MCvScalar(255));
Features2DToolbox.VoteForUniqueness(matches, uniquenessThreshold, 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);
}
}
}
watch.Stop();
}
}
public static int FindMatch(Mat modelImage, Mat observedImage, out long matchTime, out VectorOfKeyPoint modelKeyPoints, out VectorOfKeyPoint observedKeyPoints, VectorOfVectorOfDMatch matches, out Mat mask, out Mat homography)
{
Stopwatch watch;
homography = null;
BriefDescriptorExtractor descriptor = new BriefDescriptorExtractor();
modelKeyPoints = new VectorOfKeyPoint();
observedKeyPoints = new VectorOfKeyPoint();
using (UMat uModelImage = modelImage.GetUMat(AccessType.Read))
using (UMat uObservedImage = observedImage.GetUMat(AccessType.Read))
{
//extract features from the object image
Mat modelDescriptors = new Mat();
featureDetector.DetectAndCompute(uModelImage, null, modelKeyPoints, modelDescriptors, false);
watch = Stopwatch.StartNew();
// extract features from the observed image
featureDetector.DetectAndCompute(uObservedImage, null, observedKeyPoints, observedDescriptors, false);
// Bruteforce, slower but more accurate
// You can use KDTree for faster matching with slight loss in accuracy
using (Emgu.CV.Flann.LinearIndexParams ip = new Emgu.CV.Flann.LinearIndexParams())
using (Emgu.CV.Flann.SearchParams sp = new SearchParams())
using (DescriptorMatcher matcher = new FlannBasedMatcher(ip, sp))
{
matcher.Add(modelDescriptors);
matcher.KnnMatch(observedDescriptors, matches, k, null);
mask = new Mat(matches.Size, 1, DepthType.Cv8U, 1);
mask.SetTo(new MCvScalar(255));
Features2DToolbox.VoteForUniqueness(matches, uniquenessThreshold, mask);
nonZeroCount = CvInvoke.CountNonZero(mask);
if (nonZeroCount >= 9)
{
nonZeroCount = Features2DToolbox.VoteForSizeAndOrientation(modelKeyPoints, observedKeyPoints,
matches, mask, 1.6, 20);
if (nonZeroCount >= 12)
{
homography = Features2DToolbox.GetHomographyMatrixFromMatchedFeatures(modelKeyPoints,
observedKeyPoints, matches, mask, 2);
}
}
}
watch.Stop();
}
matchTime = watch.ElapsedMilliseconds;
return(nonZeroCount);
}
public void TestBOWKmeansTrainer()
{
Image <Gray, byte> box = EmguAssert.LoadImage <Gray, byte>("box.png");
Feature2D detector = new KAZE();
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 ImageData(string path, string correspondingValue, Emgu.CV.Features2D.ORBDetector orbDetector, KAZE featureDetector)
{
this.path = path;
this.image = new Image <Bgr, byte>(path);
orbDetector.DetectAndCompute(image, null, keyPointsOrb, descriptorOrb, false);
UMat uObservedImage = image.Mat.GetUMat(AccessType.Read);
//featureDetector.DetectAndCompute(image, null, keyPointsSurf, descriptorSurf, false);
featureDetector.DetectAndCompute(uObservedImage, null, keyPointsSurf, descriptorSurf, false);
this.correspondingValue = correspondingValue;
}
/// <summary>
///
/// </summary>
/// <param name="source"></param>
/// <returns></returns>
public static VectorOfKeyPoint FindFeature(Mat source)
{
var vectorOfKeyPoint = new VectorOfKeyPoint();
using (UMat uImage = source.GetUMat(AccessType.Read))
using (var imageDescriptors = new Mat())
{
var kaze = new KAZE();
kaze.DetectAndCompute(uImage, null, vectorOfKeyPoint, imageDescriptors, false);
}
return(vectorOfKeyPoint);
}
private void find(Mat modelImage, out VectorOfKeyPoint modelKeyPoints, VectorOfVectorOfDMatch matches, out Mat mask, out Mat homography)
{
int k = 2;
double uniquenessThreshold = 0.70;
homography = null;
VectorOfKeyPoint currentKeyPoints = new VectorOfKeyPoint();
Mat currentDescriptors = new Mat();
detector.DetectAndCompute(current, null, currentKeyPoints, currentDescriptors, false);
modelKeyPoints = new VectorOfKeyPoint();
Mat modelDescriptors = new Mat();
detector.DetectAndCompute(modelImage, null, modelKeyPoints, modelDescriptors, false);
LinearIndexParams ip = new LinearIndexParams();
SearchParams sp = new SearchParams();
DescriptorMatcher matcher = new FlannBasedMatcher(ip, sp);
matcher.Add(modelDescriptors);
matcher.KnnMatch(currentDescriptors, matches, k, null);
mask = new Mat(matches.Size, 1, DepthType.Cv8U, 1);
mask.SetTo(new MCvScalar(255));
Features2DToolbox.VoteForUniqueness(matches, uniquenessThreshold, mask);
int nonZeroCount = CvInvoke.CountNonZero(mask);
if (nonZeroCount >= 4)
{
nonZeroCount = Features2DToolbox.VoteForSizeAndOrientation(modelKeyPoints, currentKeyPoints, matches, mask, 1.5, 20);
if (nonZeroCount >= 4)
{
homography = Features2DToolbox.GetHomographyMatrixFromMatchedFeatures(modelKeyPoints, currentKeyPoints, matches, mask, 2);
}
}
}
public static void Init(Mat ModelImage)
{
double hessianThresh = 300;
uModelImage = ModelImage.GetUMat(AccessType.Read);
modelDescriptors = new Mat();
modelImage = ModelImage.Clone();
KAZE featureDetector = new KAZE();
modelKeyPoints = new VectorOfKeyPoint();
modelDescriptors = new Mat();
featureDetector.DetectAndCompute(uModelImage, null, modelKeyPoints, modelDescriptors, false);
}
private static void Feature()
{
Mat img = new Mat("data/lenna.png", ImreadModes.GrayScale);
KAZE kaze = KAZE.Create();
KeyPoint[] keyPoints;
Mat descriptors = new Mat();
kaze.DetectAndCompute(img, null, out keyPoints, descriptors);
Mat dst = new Mat();
Cv2.DrawKeypoints(img, keyPoints, dst);
Window.ShowImages(dst);
}
/// <summary>
/// Detects the feature set and caches it
/// </summary>
/// <param name="featureDetector"></param>
/// <param name="image"></param>
/// <returns></returns>
public static FeatureSet Detect(KAZE featureDetector, Image <Gray, byte> image)
{
using (UMat uModelImage = image.ToUMat())
{
Mat descriptors = new Mat();
var keyPoints = new VectorOfKeyPoint();
featureDetector.DetectAndCompute(uModelImage, null, keyPoints, descriptors, false);
return(new FeatureSet()
{
image = image,
descriptors = descriptors,
keyPoints = keyPoints,
});
}
}
public static void FindMatch(Mat modelImage, Mat observedImage, out long matchTime, out VectorOfKeyPoint modelKeyPoints, out VectorOfKeyPoint observedKeyPoints,
VectorOfVectorOfDMatch matches, out Mat mask, out Mat homography, out long score)
{
int k = 2;
double uniquenessThreshold = 0.80;
Stopwatch watch;
homography = null;
modelKeyPoints = new VectorOfKeyPoint();
observedKeyPoints = new VectorOfKeyPoint();
using (UMat uModelImage = modelImage.GetUMat(AccessType.Read))
using (UMat uObservedImage = observedImage.GetUMat(AccessType.Read))
{
KAZE featureDetector = new KAZE();
Mat modelDescriptors = new Mat();
featureDetector.DetectAndCompute(uModelImage, null, modelKeyPoints, modelDescriptors, false);
watch = Stopwatch.StartNew();
Mat observedDescriptors = new Mat();
featureDetector.DetectAndCompute(uObservedImage, null, observedKeyPoints, observedDescriptors, false);
// KdTree for faster results / less accuracy
using (var ip = new Emgu.CV.Flann.KdTreeIndexParams())
using (var sp = new SearchParams())
using (DescriptorMatcher matcher = new FlannBasedMatcher(ip, sp))
{
matcher.Add(modelDescriptors);
matcher.KnnMatch(observedDescriptors, matches, k, null);
mask = new Mat(matches.Size, 1, DepthType.Cv8U, 1);
mask.SetTo(new MCvScalar(255));
Features2DToolbox.VoteForUniqueness(matches, uniquenessThreshold, mask);
// Calculate score based on match size
score = 0;
for (int i = 0; i < matches.Size; i++)
{
if (mask.GetData(i)[0] == 0)
{
continue;
}
foreach (var e in matches[i].ToArray())
{
++score;
}
}
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);
}
}
}
watch.Stop();
}
matchTime = watch.ElapsedMilliseconds;
}
//public static long Classify(VectorOfKeyPoint modelKeyPoints, Mat modelDescriptors, Mat observedImage, double uniquenessThreshold, int k, int detectionType)
public static long Classify(Mat modelDescriptors, Mat observedImage, double uniquenessThreshold, int k, int detectionType)
{
var score = 0L;
using (var matches = new VectorOfVectorOfDMatch())
{
Mat mask = null;
//Mat homography = null;
var observedKeyPoints = new VectorOfKeyPoint();
var obsImage = new Mat();
CvInvoke.Threshold(observedImage, obsImage, 127.0, 255.0, ThresholdType.BinaryInv);
using (UMat uObservedImage = obsImage.GetUMat(AccessType.Read))
{
switch (detectionType)
{
default:
using (var featureDetector = new SIFT(0, 3, 0.04, 10.0, 1.6))
{
var observedDescriptors = new Mat();
featureDetector.DetectAndCompute(uObservedImage, null, observedKeyPoints, observedDescriptors, false);
using (var ip = new KdTreeIndexParams())
using (var sp = new SearchParams())
using (DescriptorMatcher matcher = new FlannBasedMatcher(ip, sp))
{
matcher.Add(modelDescriptors);
matcher.KnnMatch(observedDescriptors, matches, k, null);
mask = new Mat(matches.Size, 1, DepthType.Cv8U, 1);
mask.SetTo(new MCvScalar(255));
Features2DToolbox.VoteForUniqueness(matches, uniquenessThreshold, mask);
score = 0;
for (int i = 0; i < matches.Size; i++)
{
if (mask.GetData(i)[0] == 0)
{
continue;
}
foreach (var e in matches[i].ToArray())
{
++score;
}
}
//var 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);
//}
}
}
break;
case 1:
using (var featureDetector = new KAZE())
{
var observedDescriptors = new Mat();
featureDetector.DetectAndCompute(uObservedImage, null, observedKeyPoints, observedDescriptors, false);
using (var ip = new KdTreeIndexParams())
using (var sp = new SearchParams())
using (DescriptorMatcher matcher = new FlannBasedMatcher(ip, sp))
{
matcher.Add(modelDescriptors);
matcher.KnnMatch(observedDescriptors, matches, k, null);
mask = new Mat(matches.Size, 1, DepthType.Cv8U, 1);
mask.SetTo(new MCvScalar(255));
Features2DToolbox.VoteForUniqueness(matches, uniquenessThreshold, mask);
score = 0;
for (int i = 0; i < matches.Size; i++)
{
if (mask.GetData(i)[0] == 0)
{
continue;
}
foreach (var e in matches[i].ToArray())
{
++score;
}
}
//var 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);
//}
}
}
break;
}
}
}
return(score);
}
private static VectorOfPoint ProcessImageFLANN(Image <Gray, byte> template, Image <Gray, byte> sceneImage)
{
try
{
// initialization
VectorOfPoint finalPoints = null;
Mat homography = null;
VectorOfKeyPoint templateKeyPoints = new VectorOfKeyPoint();
VectorOfKeyPoint sceneKeyPoints = new VectorOfKeyPoint();
Mat tempalteDescriptor = new Mat();
Mat sceneDescriptor = new Mat();
Mat mask;
int k = 2;
double uniquenessthreshold = 0.80;
VectorOfVectorOfDMatch matches = new VectorOfVectorOfDMatch();
// feature detectino and description
KAZE featureDetector = new KAZE();
featureDetector.DetectAndCompute(template, null, templateKeyPoints, tempalteDescriptor, false);
featureDetector.DetectAndCompute(sceneImage, null, sceneKeyPoints, sceneDescriptor, false);
// Matching
//KdTreeIndexParams ip = new KdTreeIndexParams();
//var ip = new AutotunedIndexParams();
var ip = new LinearIndexParams();
SearchParams sp = new SearchParams();
FlannBasedMatcher matcher = new FlannBasedMatcher(ip, sp);
matcher.Add(tempalteDescriptor);
matcher.KnnMatch(sceneDescriptor, matches, k);
mask = new Mat(matches.Size, 1, Emgu.CV.CvEnum.DepthType.Cv8U, 1);
mask.SetTo(new MCvScalar(255));
Features2DToolbox.VoteForUniqueness(matches, uniquenessthreshold, mask);
int count = Features2DToolbox.VoteForSizeAndOrientation(templateKeyPoints, sceneKeyPoints, matches, mask, 1.5, 20);
if (count >= 4)
{
homography = Features2DToolbox.GetHomographyMatrixFromMatchedFeatures(templateKeyPoints,
sceneKeyPoints, matches, mask, 5);
}
if (homography != null)
{
System.Drawing.Rectangle rect = new System.Drawing.Rectangle(System.Drawing.Point.Empty, template.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)
};
pts = CvInvoke.PerspectiveTransform(pts, homography);
System.Drawing.Point[] points = Array.ConvertAll <PointF, System.Drawing.Point>(pts, System.Drawing.Point.Round);
finalPoints = new VectorOfPoint(points);
}
return(finalPoints);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
/// <summary>
/// The method used to discover similarities amongst the images, and populating arrays.
/// </summary>
/// <param name="m_modelImage"> The model image (library basic). </param>
/// <param name="m_observedImage"> The observed image (test). </param>
/// <param name="d_matchTime"> The output total time for computing the homography matrix. </param>
/// <param name="v_modelKeyPoints"></param>
/// <param name="v_observedKeyPoints"></param>
/// <param name="v_matches"></param>
/// <param name="m_mask"></param>
/// <param name="m_homography"></param>
/// <param name="l_score"> Field contains the score of matching. </param>
public static void FindMatch(Mat m_modelImage, Mat m_observedImage, out double d_matchTime, out VectorOfKeyPoint v_modelKeyPoints,
out VectorOfKeyPoint v_observedKeyPoints, VectorOfVectorOfDMatch v_matches, out Mat m_mask,
out Mat m_homography, out long l_score)
{
ErrInfLogger.LockInstance.InfoLog("Start of the FindMatch");
TimerAbstraction _tim = new TimerRefinedAbstraction();
_tim._iTimer = new TimerFractional();
m_homography = null;
v_modelKeyPoints = new VectorOfKeyPoint();
v_observedKeyPoints = new VectorOfKeyPoint();
KAZE featureDetector = new KAZE();
Mat modelDescriptors = new Mat();
featureDetector.DetectAndCompute(m_modelImage, null, v_modelKeyPoints, modelDescriptors, false);
_tim.MeasureStart();
Mat observedDescriptors = new Mat();
featureDetector.DetectAndCompute(m_observedImage, null, v_observedKeyPoints, observedDescriptors, false);
// KdTree for faster results / less accuracy
using (KdTreeIndexParams ip = new KdTreeIndexParams())
using (SearchParams sp = new SearchParams())
using (DescriptorMatcher matcher = new FlannBasedMatcher(ip, sp))
{
matcher.Add(modelDescriptors);
matcher.KnnMatch(observedDescriptors, v_matches, SettingsContainer.Instance.i_K, null);
m_mask = new Mat(v_matches.Size, 1, DepthType.Cv8U, 1);
m_mask.SetTo(new MCvScalar(255));
Features2DToolbox.VoteForUniqueness(v_matches, SettingsContainer.Instance.d_UniquenessThreshold, m_mask);
// Calculate score based on matches size
// ---------------------------------------------->
l_score = 0;
for (int i = 0; i < v_matches.Size; i++)
{
if (m_mask.GetData(i)[0] == 0)
{
continue;
}
foreach (var e in v_matches[i].ToArray())
{
++l_score;
}
}
// <----------------------------------------------
int nonZeroCount = CvInvoke.CountNonZero(m_mask);
if (nonZeroCount >= 4)
{
nonZeroCount = Features2DToolbox.VoteForSizeAndOrientation(v_modelKeyPoints, v_observedKeyPoints, v_matches,
m_mask, 1.5, 20);
if (nonZeroCount >= 4)
{
m_homography = Features2DToolbox.GetHomographyMatrixFromMatchedFeatures(v_modelKeyPoints, v_observedKeyPoints,
v_matches, m_mask, 2);
}
}
}
_tim.MeasureStop();
d_matchTime = Math.Round(_tim.MeasureResult().TotalMilliseconds, 2);
_tim.MeasureRestart();
ErrInfLogger.LockInstance.InfoLog("End of the FindMatch");
}
public static void FindMatch(Mat modelImage, Mat modelImage2, Mat observedImage,
out long matchTime, out VectorOfKeyPoint modelKeyPoints, out VectorOfKeyPoint observedKeyPoints, VectorOfVectorOfDMatch matches, out Mat mask, out Mat homography,
out VectorOfKeyPoint modelKeyPoints2, VectorOfVectorOfDMatch matches2, out Mat mask2, out Mat homography2)
{
int k = 2;
double uniquenessThreshold = 0.80;
Stopwatch watch;
homography = null;
homography2 = null;
modelKeyPoints = new VectorOfKeyPoint();
modelKeyPoints2 = new VectorOfKeyPoint();
observedKeyPoints = new VectorOfKeyPoint();
using (UMat uModelImage = modelImage.GetUMat(AccessType.Read)) // Создаем объект модели изображения
using (UMat uModelImage2 = modelImage2.GetUMat(AccessType.Read))
using (UMat uObservedImage = observedImage.GetUMat(AccessType.Read))
{
KAZE featureDetector = new KAZE();
//извлекаем точки интереса из изображения объекта
Mat modelDescriptors = new Mat();
featureDetector.DetectAndCompute(uModelImage, null, modelKeyPoints, modelDescriptors, false);
Mat modelDescriptors2 = new Mat();
featureDetector.DetectAndCompute(uModelImage2, null, modelKeyPoints2, modelDescriptors2, false);
watch = Stopwatch.StartNew();
// извлекаем точки интереса из исследуемого изображения
Mat observedDescriptors = new Mat();
featureDetector.DetectAndCompute(uObservedImage, null, observedKeyPoints, observedDescriptors, false);
// Bruteforce, slower but more accurate
// You can use KDTree for faster matching with slight loss in accuracy
using (Emgu.CV.Flann.LinearIndexParams ip = new Emgu.CV.Flann.LinearIndexParams())
using (Emgu.CV.Flann.SearchParams sp = new SearchParams())
using (DescriptorMatcher matcher = new FlannBasedMatcher(ip, sp))
{
matcher.Add(modelDescriptors);
matcher.KnnMatch(observedDescriptors, matches, k, null);
mask = new Mat(matches.Size, 1, DepthType.Cv8U, 1);
mask.SetTo(new MCvScalar(255));
Features2DToolbox.VoteForUniqueness(matches, uniquenessThreshold, 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);
}
}
}
using (Emgu.CV.Flann.LinearIndexParams ip = new Emgu.CV.Flann.LinearIndexParams())
using (Emgu.CV.Flann.SearchParams sp = new SearchParams())
using (DescriptorMatcher matcher2 = new FlannBasedMatcher(ip, sp))
{
matcher2.Add(modelDescriptors2);
matcher2.KnnMatch(observedDescriptors, matches2, k, null);
mask2 = new Mat(matches2.Size, 1, DepthType.Cv8U, 1);
mask2.SetTo(new MCvScalar(255));
Features2DToolbox.VoteForUniqueness(matches2, uniquenessThreshold, mask2);
int nonZeroCount = CvInvoke.CountNonZero(mask2);
if (nonZeroCount >= 4)
{
nonZeroCount = Features2DToolbox.VoteForSizeAndOrientation(modelKeyPoints2, observedKeyPoints,
matches2, mask2, 1.5, 20);
if (nonZeroCount >= 4)
{
homography2 = Features2DToolbox.GetHomographyMatrixFromMatchedFeatures(modelKeyPoints2,
observedKeyPoints, matches2, mask2, 2);
}
}
}
watch.Stop();
}
matchTime = watch.ElapsedMilliseconds;
}
public static VectorOfPoint Process(Mat logo, Mat observedImage)
{
VectorOfPoint vp = null;
Mat homography = null;
VectorOfKeyPoint logoKeyPoints = new VectorOfKeyPoint();
VectorOfKeyPoint observedKeyPoints = new VectorOfKeyPoint();
Mat mask;
int k = 2;
double uniquenessThreshold = 0.80;
using (VectorOfVectorOfDMatch matches = new VectorOfVectorOfDMatch())
{
using (UMat uModelImage = logo.GetUMat(AccessType.Read))
using (UMat uObservedImage = observedImage.GetUMat(AccessType.Read))
{
KAZE featureDetector = new KAZE();
//extract features from the object image
Mat modelDescriptors = new Mat();
featureDetector.DetectAndCompute(uModelImage, null, logoKeyPoints, modelDescriptors, false);
// extract features from the observed image
Mat observedDescriptors = new Mat();
featureDetector.DetectAndCompute(uObservedImage, null, observedKeyPoints, observedDescriptors, false);
// Bruteforce, slower but more accurate
// You can use KDTree for faster matching with slight loss in accuracy
using (Emgu.CV.Flann.LinearIndexParams ip = new Emgu.CV.Flann.LinearIndexParams())
using (Emgu.CV.Flann.SearchParams sp = new SearchParams())
using (DescriptorMatcher matcher = new FlannBasedMatcher(ip, sp))
{
matcher.Add(modelDescriptors);
matcher.KnnMatch(observedDescriptors, matches, k, null);
mask = new Mat(matches.Size, 1, Emgu.CV.CvEnum.DepthType.Cv8U, 1);
mask.SetTo(new MCvScalar(255));
Features2DToolbox.VoteForUniqueness(matches, uniquenessThreshold, mask);
int nonZeroCount = Features2DToolbox.VoteForSizeAndOrientation(logoKeyPoints, observedKeyPoints,
matches, mask, 1.5, 20);
if (nonZeroCount >= 4)
{
homography = Features2DToolbox.GetHomographyMatrixFromMatchedFeatures(logoKeyPoints,
observedKeyPoints, matches, mask, 2);
}
}
}
if (homography != null)
{
//draw a rectangle along the projected model
Rectangle rect = new Rectangle(Point.Empty, logo.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)
};
pts = CvInvoke.PerspectiveTransform(pts, homography);
Point[] points = Array.ConvertAll <PointF, Point>(pts, Point.Round);
vp = new VectorOfPoint(points);
}
return(vp);
}
}