private void edgesToolStripMenuItem_Click(object sender, EventArgs e)
{
CannyEdgeDetector gb = new CannyEdgeDetector();
newImg = gb.Apply(newImg);
pictureBox4.Image = newImg;
}
private void timerSampleMaker_Tick(object sender, EventArgs e)
{
if (_sourceImage != null)
{
try
{
// Loading some file
Bitmap _sample = (Bitmap)AForge.Imaging.Image.Clone(_sourceImage);
// We must convert it to grayscale because
// the filter accepts 8 bpp grayscale images
Grayscale GF = new Grayscale(0.2125, 0.7154, 0.0721);
Bitmap GSampleImage = GF.Apply(_sample);
// Detecting image edges and saving the result
CannyEdgeDetector CED = new CannyEdgeDetector(0, 70);
CED.ApplyInPlace(GSampleImage);
Bitmap _temp = new Bitmap(320, 240);
_temp = GSampleImage;
pictureBoxSource.Image = _temp;
ProcessByImage(_temp);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
}
private void edgeToolStripMenuItem_Click(object sender, EventArgs e)
{
CannyEdgeDetector edgeObj = new CannyEdgeDetector();
edgeImage = new Bitmap(edgeObj.Apply(grayImage));
pictureBox3.Image = edgeImage;
}
private void CannyEdgeDetectionToolStripMenuItem1_Click(object sender, EventArgs e)
{
CannyEdgeDetector ed = new CannyEdgeDetector();
Bitmap s1 = ed.Apply(grayImage);
pictureBox3.Image = s1;
}
private void OnDetect(object sender, RoutedEventArgs e)
{
DebugView.Children.Clear();
BitmapSource src = ImageContent.Source as BitmapSource;
if (src != null)
{
float min = float.Parse(Min.Text);
float max = float.Parse(Max.Text);
int minEdgeLength = int.Parse(EdgeLength.Text);
DetectButton.IsEnabled = false;
CannyEdgeDetector canny = new CannyEdgeDetector(src, max, min, minEdgeLength);
canny.EdgeDetected += OnEdgeDetected;
Task.Run(new Action(() =>
{
canny.DetectEdges();
canny.EdgeDetected -= OnEdgeDetected;
Dispatcher.BeginInvoke(new Action(() =>
{
DetectButton.IsEnabled = true;
}));
}));
//ShowImage(canny.ToImage<int>(canny.FilteredImage), "Filtered");
//ShowImage(canny.ToImage<float>(canny.DerivativeX), "DerivativeX");
//ShowImage(canny.ToImage<float>(canny.NonMax), "NonMax");
//ShowImage(canny.ToImage<float>(canny.Gradient), "Gradient");
//ShowImage(canny.ToImage<int>(canny.HorizontalEdges), "HorizontalEdges");
//ShowImage(canny.ToImage<int>(canny.VerticalEdges), "VerticalEdges");
//ShowImage(canny.ToImage<int>(canny.EdgeMap), "EdgeMap");
}
}
void CannyToolStripMenuItemClick(object sender, EventArgs e)
{
//jika gambar kosong/null maka akan mengembalikan nilai kosong/null
if (gambar == null)
{
return;
}
//clone variable gambar ke variable gambar2 dan menginisiasi class Rectangle
//dan menerapkan format pixel 24bppRgb
gambar2 = gambar.Clone(new Rectangle(0, 0, gambar.Width, gambar.Height),
System.Drawing.Imaging.PixelFormat.Format24bppRgb);
//convert ke grayscale terlebih dahulu lalu aplikasikan filter Canny.
//inisiasi filter grayscale disertai argumen
Grayscale grayscaleF = new Grayscale(0.2125, 0.7154, 0.0721);
//aplikasikan filter grayscale ke gambar2
gambar2 = grayscaleF.Apply(gambar2);
//inisiasi filter Canny
CannyEdgeDetector cannyEdgeDetector = new CannyEdgeDetector();
//aplikasikan filter pada gambar2
cannyEdgeDetector.ApplyInPlace(gambar2);
//tampilkan pada picturebox2
pictureBox2.Image = gambar2;
}
private void EdgeDetectImg(ref Bitmap frame)
{
frame = Grayscale.CommonAlgorithms.RMY.Apply(frame); // Make gray
switch (EdgeDetectValue)
{
case 1:
SobelEdgeDetector SobelFilter = new SobelEdgeDetector();
SobelFilter.ApplyInPlace(frame);
break;
case 2:
DifferenceEdgeDetector DifferenceFilter = new DifferenceEdgeDetector();
DifferenceFilter.ApplyInPlace(frame);
break;
case 3:
HomogenityEdgeDetector HomogenityFilter = new HomogenityEdgeDetector();
HomogenityFilter.ApplyInPlace(frame);
break;
case 4:
CannyEdgeDetector Cannyfilter = new CannyEdgeDetector();
// apply the MirrFilter
Cannyfilter.ApplyInPlace(frame);
break;
default:
HomogenityEdgeDetector filter = new HomogenityEdgeDetector();
filter.ApplyInPlace(frame);
break;
}
GrayscaleToRGB RGBfilter = new GrayscaleToRGB(); // back to color format
frame = RGBfilter.Apply(frame);
}
private void cannyEdgeToolStripMenuItem_Click(object sender, EventArgs e)
{
Bitmap grayImage = Grayscale.CommonAlgorithms.BT709.Apply(fd);
CannyEdgeDetector canny = new CannyEdgeDetector(0, 0, 1.4);
Bitmap edgeImage = canny.Apply(grayImage);
pictureBox6.Image = edgeImage;
// Console.WriteLine(edgeImage.Width);
int i, j, x, y, u, v;
double con1 = 0;
Color blackC = Color.FromArgb(Color.Black.ToArgb());
u = edgeImage.Width / 6;
v = edgeImage.Height / 6;
//Console.WriteLine(u);
//Console.WriteLine(v);
for (i = 0; i < 6; i++)
{
for (j = 0; j < 6; j++)
{
int count = 0;
for (x = i * u; x < ((i * u) + u); x++)
{
for (y = j * v; y < ((j * v) + v); y++)
{
Color c = (edgeImage.GetPixel(x, y));
//Console.WriteLine(c);
if (c != blackC)
{
count++;
con1++;
}
}
}
featureVector.Add(count);
//Console.WriteLine(count);
}
}
//Calculate Normalization and add the value to the featureNormVector
List <double> featureNormVector = new List <double>();
//Total Pixel Count
//Console.WriteLine(con1);
int z;
//Normalization
for (z = 0; z < featureVector.Count; z++)
{
double normalizedValue = featureVector[z] / con1;
Console.WriteLine(normalizedValue);
featureNormVector.Add(normalizedValue);
}
}
public override Bitmap ApplyFilter(Bitmap img)
{
CannyEdgeDetector ced = new CannyEdgeDetector(255, 0);
this.imgEdgeDetected = ced.Apply(img);
return(this.imgEdgeDetected);
}
/// <summary>
/// Classify user's image
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void buttonClassify_Click(object sender, EventArgs e)
{
//Create bitmap for recognition users's image
Bitmap image = (Bitmap)(pictureBox1.Image);
//Create Canny detector for contours
CannyEdgeDetector filterCanny = new CannyEdgeDetector();
//Detect contour on image
filterCanny.ApplyInPlace(image);
//Transform image in feature vector
double[] featureVector = (bagOfContourFragments as ITransform <Bitmap, double[]>).Transform(image);
//SVM decide from which class this image
string animal = GetAnimalClass(this.multiSVM.Decide(featureVector));
//display this information for user
label2.Text = "This is: " + animal + "?";
//Show buttons to analyse correct detect
labelCorrect.Visible = true;
buttonCorrectYes.Visible = true;
buttonCorrectNo.Visible = true;
}
/// <summary>
/// Applies Canny filter on specified image. (uses AForge implementation)
/// </summary>
/// <param name="im">image</param>
/// <param name="lowThreshold">Low threshold value used for hysteresis</param>
/// <param name="highThreshold">High threshold value used for hysteresis</param>
/// <param name="sigma">Gaussian sigma</param>
/// <param name="gaussianSize">Gaussian filter size</param>
/// <returns>Processed image with Canny filter</returns>
public static Gray <byte>[,] Canny(this Gray <byte>[,] im, byte lowThreshold = 20, byte highThreshold = 100, double sigma = 1.4, int gaussianSize = 5)
{
CannyEdgeDetector canny = new CannyEdgeDetector(lowThreshold, highThreshold, sigma);
canny.GaussianSize = gaussianSize;
return(im.ApplyFilter(canny));
}
private void reapplyToolStripMenuItem6_Click(object sender, EventArgs e)
{
//GrayscaleBT709 grayObject = new GrayscaleBT709();
//pictureBox2.Image = grayObject.Apply((Bitmap)pictureBox2.Image);
CannyEdgeDetector filter = new CannyEdgeDetector();
pictureBox2.Image = filter.Apply((Bitmap)pictureBox2.Image);
}
//metoda zrwacająca wynik filtru Cannyego
public static Bitmap Canny(Bitmap bitmap)
{
Bitmap temporary = ImageSupporter.ColorToGrayscale(bitmap);;
CannyEdgeDetector cannyEdgeDetector = new CannyEdgeDetector();
temporary = cannyEdgeDetector.Apply((Bitmap)temporary.Clone());
return(ImageSupporter.GrayScaleToColor(temporary));
}
public void ApplyCannyFilter(byte low, byte high, double sigma)
{
var f = new SobelEdgeDetector();
var filter = new CannyEdgeDetector(low, high, sigma);
_bitmap = filter.Apply(_bitmap);
OnPropertyChanged("ShowBitmap");
}
Bitmap CannyEdge(Bitmap bmp)
{
Bitmap tmp = AForge.Imaging.Image.Clone(bmp, bmp.PixelFormat);
//higherThreshold default = 100 lower default = 20
CannyEdgeDetector obj_canny = new CannyEdgeDetector(150, 10);
Bitmap cannyEdges = obj_canny.Apply(tmp.PixelFormat != PixelFormat.Format8bppIndexed ? Grayscale.CommonAlgorithms.BT709.Apply(tmp) : tmp);
return(cannyEdges);
}
public void cannyImageConvert()
{
//Apply canny edge detection on workingImage
Grayscale grayscaleFilter = new Grayscale(.21, .07, .72);
CannyEdgeDetector cannyFilter = new CannyEdgeDetector();
workingImage = grayscaleFilter.Apply(workingImage);
workingImage = cannyFilter.Apply(workingImage);
cannyImagePanel.Image = workingImage;
}
private void AutoCrop(AttachmentDialogImageItem img)
{
CannyEdgeDetector edgeDetector = new CannyEdgeDetector(img.Bitmap, 20, 80, 30);
edgeDetector.DetectEdges();
Rect bounds = edgeDetector.EdgeBounds;
AddResizer(img, bounds);
SetDirty();
}
private static Image <TColor, TDepth> Canny <TColor, TDepth>(this Image <TColor, TDepth> im, byte lowThreshold, byte highThreshold, double sigma, int gaussianSize = 5)
where TColor : IColor
where TDepth : struct
{
CannyEdgeDetector canny = new CannyEdgeDetector(lowThreshold, highThreshold, sigma);
canny.GaussianSize = gaussianSize;
return(im.ApplyFilter(canny));
}
public static Bitmap AccordCanny(Bitmap src)
{
Bitmap ret = (Bitmap)Convert(src);
//Bitmap ret2 = (Bitmap)ret.Clone();
byte avg = GetAVG(ret);
//ret.UnlockBits(null);
CannyEdgeDetector Canny = new CannyEdgeDetector((byte)(avg / 3 - 20), (byte)(2 * (avg / 3) + 20), 1);
return(Canny.Apply(ret));
}
/// <summary>
/// Show edges on image
/// </summary>
/// <param name="image"></param>
/// <returns></returns>
public static Image CannyEdges(this Bitmap image)
{
if (image.PixelFormat != PixelFormat.Format8bppIndexed)
{
throw new NotSupportedException("Blob extractor can be applied to binary 8bpp images only");
}
CannyEdgeDetector cannyEdge = new CannyEdgeDetector();
return(cannyEdge.Apply(image));
}
/// <summary>
/// Отобразить контуры для входного изображения
/// </summary>
/// <param name="filename">Входной файл</param>
/// <param name="resultFilename">Результирующий файл, содержащий контуры</param>
public static void DrawEdges(string filename, string resultFilename)
{
var canny = new CannyEdgeDetector((byte)80, (byte)180);
var inputBmp = new Bitmap(filename);
Bitmap grayScaled = ToGrayscale(inputBmp);
using (Bitmap edgedImage = canny.Apply(grayScaled))
{
edgedImage.Save(resultFilename);
}
}
private Bitmap GetEdgedImage(WriteableBitmap writeableBitmap)
{
var edgeFilter = new CannyEdgeDetector(255, 0);
var smoothFilter = new Median();
var grayFilter = new Grayscale(0.2125, 0.7154, 0.0721);
var bitmap = (Bitmap)writeableBitmap;
bitmap = grayFilter.Apply(bitmap);
smoothFilter.ApplyInPlace(bitmap);
edgeFilter.ApplyInPlace(bitmap);
return(bitmap);
}
private void edgeDetect()
{
Bitmap news = new Bitmap(imageGot);
GrayscaleBT709 gs = new GrayscaleBT709();
imageGot = gs.Apply(imageGot);
CannyEdgeDetector cn = new CannyEdgeDetector();
cn.LowThreshold = 0;
cn.HighThreshold = 0;
cn.GaussianSigma = 1.4;
imageGot = cn.Apply(imageGot);
pictureBox1.Image = imageGot;
}
private void button4_Click(object sender, EventArgs e)
{
Grayscale grayfilter = new Grayscale(0.2125, 0.7154, 0.0721);
Bitmap edgeImg = grayfilter.Apply(img1);
OtsuThreshold filter = new OtsuThreshold();
filter.ApplyInPlace(edgeImg);
CannyEdgeDetector filter2 = new CannyEdgeDetector();
img2 = filter2.Apply(edgeImg);
pictureBox2.Image = img2;
}
public static List <Rectangle> FindRectangles(Bitmap source)
{
Bitmap canny = Grayscale.CommonAlgorithms.RMY.Apply(source);
CannyEdgeDetector edgeDetector = new CannyEdgeDetector(5, 20);
edgeDetector.ApplyInPlace(canny);
BlobCounter blobCounter = new BlobCounter
{
FilterBlobs = true,
MinWidth = 5,
MinHeight = 5
};
blobCounter.ProcessImage(canny);
Blob[] blobs = blobCounter.GetObjectsInformation();
List <Rectangle> rectangles = new List <Rectangle>();
SimpleShapeChecker shapeChecker = new SimpleShapeChecker();
for (int i = 0; i < blobs.Length; i++)
{
List <IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]);
if (shapeChecker.IsConvexPolygon(edgePoints, out List <IntPoint> corners))
{
if (blobs[i].Rectangle.Width > canny.Width / 5.3 && blobs[i].Rectangle.Width <canny.Width / 4.41 && canny.Height / 10.3> blobs[i].Rectangle.Height && blobs[i].Rectangle.Height > canny.Height / 20.5)
{
rectangles.Add(blobs[i].Rectangle);
}
}
}
// order by descending area
rectangles.Sort((a, b) =>
{
if (a.Width * a.Height > b.Width * b.Height)
{
return(1);
}
else if (a.Width * a.Height < b.Width * b.Height)
{
return(-1);
}
return(0);
});
return(rectangles);
}
// Image Preprocessing
private Bitmap ImagePreprocessing(Bitmap image, int threshold)
{
// Grayscale
image = Grayscale.CommonAlgorithms.RMY.Apply(image);
// Edge Detection (using CannyEdgeDetector)
image = new CannyEdgeDetector().Apply(image);
// Noise Removal
int startX, startY, endX, endY;
startX = image.Width;
startY = image.Height;
endX = 0;
endY = 0;
for (int i = 0; i < image.Width; i++)
{
for (int j = 0; j < image.Height; j++)
{
if (image.GetPixel(i, j).R > threshold)
{
if (i < startX)
{
startX = i;
}
if (j < startY)
{
startY = j;
}
if (i > endX)
{
endX = i;
}
if (j > endY)
{
endY = j;
}
}
}
}
image = image.Clone(new Rectangle(startX, startY, endX - startX, endY - startY), PixelFormat.Format8bppIndexed);
// Resize
image = new ResizeBilinear(32, 32).Apply(image);
return(image);
}
void FinalFrame_NewFrame(object sender, NewFrameEventArgs eventArgs)
{
video = (Bitmap)eventArgs.Frame.Clone();
Bitmap video2 = (Bitmap)eventArgs.Frame.Clone();
if (mode == 1)
{
Grayscale gray = new Grayscale(0.2125, 0.7154, 0.0721);
Bitmap video3 = gray.Apply(video2);
CannyEdgeDetector canny = new CannyEdgeDetector(0, 70);
canny.ApplyInPlace(video3);
pictureBox2.Image = video3;
}
pictureBox1.Image = video;
}
/// <summary>
/// Called when videoPlayer receives a new frame.
/// </summary>
/// <param name="sender"></param>
/// <param name="image"></param>
private void videoPlayer_NewFrame(object sender, ref Bitmap image)
{
// convert image to grayscale
var gray = new GrayscaleBT709();
var frame = gray.Apply(image);
// threshold image to only keep light pixels
var threshold = new Threshold(125);
threshold.ApplyInPlace(frame);
// blank out everything but the road
var horizonY = (int)(image.Height * 0.65);
var fill = new CanvasFill(new Rectangle(0, 0, image.Width, horizonY), Color.Red);
fill.ApplyInPlace(frame);
// detect edges
var edgeDetector = new CannyEdgeDetector();
edgeDetector.ApplyInPlace(frame);
// do a hough line transformation, which will search for straight lines in the frame
var transform = new HoughLineTransformation();
transform.ProcessImage(frame);
var rawLines = transform.GetMostIntensiveLines(50);
// only keep non-horizontal lines that cross the horizon at the vanishing point
var lines = from l in rawLines
let range = new Range(-75, -65)
where range.IsInside(l.Radius) &&
(l.Theta <= 85 || l.Theta >= 95)
select l;
// show the edge detection view in the bottom left box
edgeBox.Image = frame;
// show the lane detection view in the bottom right box
var laneImg = new Bitmap(image.Width, image.Height);
Utility.DrawHoughLines(lines, laneImg, Color.White, 1);
laneBox.Image = laneImg;
// draw the lanes on the main camera image too
Utility.DrawHoughLines(lines, image, Color.LightGreen, 2);
}
private WriteableBitmap FindPlate(IEnumerable <Rect> rects, WriteableBitmap image)
{
WriteableBitmap bestCandidate = null;
foreach (var rect in rects)
{
var croppedImage = image.Crop(rect);
var edgeFilter = new CannyEdgeDetector();
var smoothFilter = new Median();
var grayFilter = new Grayscale(0.2125, 0.7154, 0.0721);
var blobCounter = new BlobCounter();
var cutTop = croppedImage.PixelHeight * 0.3;
croppedImage = croppedImage.Crop(new Rect(0, cutTop, croppedImage.PixelWidth, croppedImage.PixelHeight));
var bitmap = (Bitmap)croppedImage;
var grayImage = grayFilter.Apply(bitmap);
bitmap = smoothFilter.Apply(grayImage);
edgeFilter.ApplyInPlace(bitmap);
blobCounter.ProcessImage(bitmap);
var blobs = blobCounter.GetObjectsInformation();
var possibleChars = new List <Rectangle>();
foreach (var blob in blobs)
{
var objRectangle = blob.Rectangle;
var ratio = (double)objRectangle.Height / (double)objRectangle.Width;
if (ratio >= 1.16d && ratio <= 6.3d)
{
possibleChars.Add(objRectangle);
}
}
if (possibleChars.Count == 0)
{
continue;
}
bestCandidate = croppedImage;
}
return(bestCandidate);
}
public mEdgeCanny(int LowVal, int HighVal, int SampleSize)
{
Size = SampleSize;
LowValue = LowVal;
HighValue = HighVal;
BitmapType = mFilter.BitmapTypes.GrayscaleBT709;
Effect = new CannyEdgeDetector();
Effect.LowThreshold = (byte)LowValue;
Effect.HighThreshold = (byte)HighValue;
Effect.GaussianSize = Size;
filter = Effect;
}
