Added four new functions and three new pictures

Display-Image.cs

@@ -1,9 +1,14 @@
 using System;
+using System.Numerics;
 using Emgu.CV;
 using Emgu.CV.Structure;
+using Emgu.CV.Util;
 
 namespace ImageMinipulation {
     
+    /// <summary>
+    /// All programs are made using videos from (Programming with Chris) video seiress
+    /// </summary>
     public class vanGoghFilters
     {
         /// <summary>
@@ -101,7 +106,7 @@ namespace ImageMinipulation {
         }
 
         /// <summary>
-        /// 
+        /// Adds a sharpen filter to a picture based on an array
         /// </summary>
         public void Five()
         {
@@ -130,5 +135,123 @@ namespace ImageMinipulation {
 
             CvInvoke.WaitKey();
         }
+
+        /// <summary>
+        /// Uses the sobel edge detection to output just the edges in the image
+        /// </summary>
+        public void Six()
+        {
+            Mat pic = CvInvoke.Imread("./img/iPhone.jpg");
+            
+            Mat guassianBlur = new Mat();
+            Mat sobelX = new Mat();
+            Mat sobelY = new Mat();
+            Mat sobelXY = new Mat();
+
+            pic.CopyTo(sobelX);
+            pic.CopyTo(sobelY);
+            pic.CopyTo(sobelXY);
+
+            CvInvoke.GaussianBlur(pic, guassianBlur, new System.Drawing.Size(3, 3), 5.0);
+
+            CvInvoke.Sobel(guassianBlur, sobelX, Emgu.CV.CvEnum.DepthType.Default, 1, 0, 5);
+            CvInvoke.Sobel(guassianBlur, sobelY, Emgu.CV.CvEnum.DepthType.Default, 0, 1, 5);
+            CvInvoke.Sobel(guassianBlur, sobelXY, Emgu.CV.CvEnum.DepthType.Default, 1, 1, 5);
+
+            CvInvoke.Imshow("sobelX", sobelX);
+            CvInvoke.Imshow("sobelY", sobelY);
+            CvInvoke.Imshow("sobelXY", sobelXY);
+
+            CvInvoke.WaitKey();
+        }
+
+        /// <summary>
+        /// Uses the canny edge detection to output the edges in an image (this method can be a little sharper depending on the image)
+        /// </summary>
+        public void Seven()
+        {
+            Mat pic = CvInvoke.Imread("./img/iPhone.jpg");
+
+            Mat guassianBlur = new Mat();
+            Mat cannyPic = new Mat();
+
+            var averge = pic.ToImage<Gray, byte>().GetAverage();
+
+            var lowerthreshold = Math.Max(0, (1.0 - 0.33) * averge.Intensity);
+            var upperthreshold = Math.Max(255, (1.0 + 0.33) * averge.Intensity);
+
+            CvInvoke.GaussianBlur(pic, guassianBlur, new System.Drawing.Size(3, 3), 5.0);
+            CvInvoke.Canny(guassianBlur, cannyPic, lowerthreshold, upperthreshold, 3);
+
+            CvInvoke.Imshow("Canny", cannyPic);
+            
+            CvInvoke.WaitKey();
+        }
+
+        /// <summary>
+        /// Makes a threshold image to tell us where the contours are then defines those contours with green lines and fills the contourd parts in with blue
+        /// </summary>
+        public void Eight()
+        {
+            Mat pic = CvInvoke.Imread("./img/iPhone.jpg");
+            Mat thresholdPic = new Mat();
+            Mat hierarchy = new Mat();
+
+            VectorOfVectorOfPoint contours = new VectorOfVectorOfPoint();
+            
+            Image<Gray, byte> grayPic = pic.ToImage<Gray, byte>();
+
+            CvInvoke.Threshold(grayPic, thresholdPic, 210, 255, Emgu.CV.CvEnum.ThresholdType.Binary);
+            CvInvoke.FindContours(thresholdPic, contours, hierarchy, Emgu.CV.CvEnum.RetrType.Tree, Emgu.CV.CvEnum.ChainApproxMethod.ChainApproxNone);
+            CvInvoke.DrawContours(pic, contours, -1, new MCvScalar(0, 255, 0), 2);
+
+            CvInvoke.FillPoly(pic, contours, new MCvScalar(255, 0, 0));
+
+            CvInvoke.Imshow("Threshold", thresholdPic);
+            CvInvoke.Imshow("pic with contours", pic);
+
+            CvInvoke.WaitKey();
+        }
+
+
+        public void Nine()
+        {
+            Mat answeredPic = CvInvoke.Imread("./img/GraderPage-Answered.jpg");
+            Mat aWasAnswered = CvInvoke.Imread("./img/A_abcd.jpg");
+            Mat templateOuput = new Mat();
+
+            CvInvoke.Resize(answeredPic, answeredPic, new System.Drawing.Size(0, 0), 0.7d, 0.7d);
+            CvInvoke.Resize(aWasAnswered, aWasAnswered, new System.Drawing.Size(0, 0), 0.7d, 0.7d);
+
+            CvInvoke.MatchTemplate(answeredPic, aWasAnswered, templateOuput, Emgu.CV.CvEnum.TemplateMatchingType.CcoeffNormed);
+
+            double minVal = 0.0d;
+            double maxVal = 0.0d;
+            System.Drawing.Point minLoc = new System.Drawing.Point();
+            System.Drawing.Point maxLoc = new System.Drawing.Point();
+
+            CvInvoke.MinMaxLoc(templateOuput, ref minVal, ref maxVal, ref minLoc, ref maxLoc);
+            CvInvoke.Threshold(templateOuput, templateOuput, 0.85, 1, Emgu.CV.CvEnum.ThresholdType.ToZero);
+
+            var matches = templateOuput.ToImage<Gray, byte>();
+
+            for (int i = 0; i < matches.Rows; i++)
+            {
+                for (int j = 0; j < matches.Cols; j++)
+                {
+                    if (matches[i, j].Intensity > .8)
+                    {
+                        System.Drawing.Point loc = new System.Drawing.Point(j, i);
+                        System.Drawing.Rectangle box = new System.Drawing.Rectangle(loc, aWasAnswered.Size);
+
+                        CvInvoke.Rectangle(answeredPic, box, new MCvScalar(0, 255, 0), 2);
+                    }
+                }
+            }
+
+            CvInvoke.Imshow("template detected", answeredPic);
+
+            CvInvoke.WaitKey();
+        }
     }
 }