void SobelToolStripMenuItemClick(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 Sobel.
//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 Sobel
SobelEdgeDetector sobelEdgeDetector = new SobelEdgeDetector();
//aplikasikan filter pada gambar2
sobelEdgeDetector.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);
}
public Bitmap GreyscaleEdgeDetectionImage(Bitmap bitmap)
{
// Greyscale
var greyscaleImage = Grayscale.CommonAlgorithms.BT709.Apply(bitmap);
// Contrast - try to sharpen edges
//ContrastStretch filter = new ContrastStretch();
//filter.ApplyInPlace(filteredBitmap);
// edge filter
// This filters accepts 8 bpp grayscale images for processing
//Alternatives:
//DifferenceEdgeDetector edgeFilter = new DifferenceEdgeDetector();
//HomogenityEdgeDetector filter = new HomogenityEdgeDetector();
//CannyEdgeDetector filter = new CannyEdgeDetector( );
var edgeFilter = new SobelEdgeDetector();
edgeFilter.ApplyInPlace(greyscaleImage);
var threshholdFilter = new Threshold(240); //180
threshholdFilter.ApplyInPlace(greyscaleImage);
return(greyscaleImage);
}
/// <summary>
/// Apply filter
/// </summary>
/// <returns>Bitmap - filtered image</returns>
public Bitmap Apply()
{
try
{
bitmap = Grayscale.CommonAlgorithms.BT709.Apply(bitmap);
var normalizer = new ContrastStretch();
normalizer.ApplyInPlace(bitmap);
var er = new Erosion();
er.ApplyInPlace(bitmap);
var ed = new SobelEdgeDetector();
ed.ApplyInPlace(bitmap);
var th = new Threshold();
th.ApplyInPlace(bitmap);
return(bitmap);
}
catch
{
return(bitmap);
}
}
public Bitmap SobelEdges(System.Drawing.Image imgOrigin)
{
Bitmap bmp = (Bitmap)imgOrigin;
SobelEdgeDetector _filterSobel = new SobelEdgeDetector();
_filterSobel.ApplyInPlace(bmp);
return(bmp);
}
/// <summary>
/// 截图并抽边
/// </summary>
public Bitmap CaptureScreen()
{
m_graphics.CopyFromScreen(Cursor.Position.X - m_bmpForBait.Width / 2,
Cursor.Position.Y - m_bmpForBait.Height / 2,
0, 0,
m_bmpForBait.Size);
var grayscaleBMP = Grayscale.CommonAlgorithms.RMY.Apply(m_bmpForBait);
sobel.ApplyInPlace(grayscaleBMP);
// SaveImage(grayscaleBMP);
return(grayscaleBMP);
}
public static Bitmap ProcessImage(string imagePath)
{
var img = AForge.Imaging.Image.FromFile(imagePath);
ContrastStretch filterContrastStretch = new ContrastStretch();
filterContrastStretch.ApplyInPlace(img);
try
{
img = Grayscale.CommonAlgorithms.BT709.Apply(img);
}
catch
{
System.Windows.Forms.MessageBox.Show("The image should not be grayscale");
}
Opening filterOpening = new Opening();
filterOpening.ApplyInPlace(img);
SobelEdgeDetector sobel = new SobelEdgeDetector();
sobel.ApplyInPlace(img);
Closing filterClosing = new Closing();
filterClosing.ApplyInPlace(img);
Threshold threshold = new Threshold(100);
threshold.ApplyInPlace(img);
FillHoles fillHoles = new FillHoles();
fillHoles.MaxHoleWidth = img.Width;
fillHoles.MaxHoleHeight = img.Height;
fillHoles.CoupledSizeFiltering = false;
fillHoles.ApplyInPlace(img);
filterOpening.ApplyInPlace(img);
Erosion filterErosion = new Erosion();
filterErosion.ApplyInPlace(img);
return(img);
}
public bool ApplySobelEdgeFilter()
{
if (currentImage != null)
{
try
{
SobelEdgeDetector filter = new SobelEdgeDetector();
filter.ApplyInPlace(currentImage);
return(true);
}
catch (Exception e)
{
MessageBox.Show(e.ToString());
}
}
return(false);
}
public bool applySobelEdgeFilter()
{
if (currentImage != null)
{
try
{
// create filter
SobelEdgeDetector filter = new SobelEdgeDetector();
// apply the filter
filter.ApplyInPlace(currentImage);
return(true);
}
catch (Exception)
{
}
}
return(false);
}
private void TakeSnapshot_funct(Bitmap img)
{
Bitmap image = Grayscale.CommonAlgorithms.RMY.Apply(img);
// find edges
SobelEdgeDetector EdgeFilter = new SobelEdgeDetector();
EdgeFilter.ApplyInPlace(image);
// back to color format
GrayscaleToRGB RGBfilter = new GrayscaleToRGB();
image = RGBfilter.Apply(image);
// get rid of grays
EuclideanColorFiltering filter = new EuclideanColorFiltering();
filter.CenterColor.Red = 20;
filter.CenterColor.Green = 20;
filter.CenterColor.Blue = 20;
filter.FillOutside = false;
filter.Radius = 200;
filter.ApplyInPlace(image);
Color peek;
for (int y = 0; y < image.Height; y++)
{
for (int x = 0; x < image.Width; x++)
{
peek = image.GetPixel(x, y);
if (peek.R != 0)
{
image.SetPixel(x, y, Color.Blue);
}
}
}
image.MakeTransparent(Color.Black);
SnapshotImage = image;
SnapshotOriginalImage = image;
}
// =========================================================
private void Edge_detectFunc(ref Bitmap frame, int par_int)
{
frame = Grayscale.CommonAlgorithms.RMY.Apply(frame); // Make gray
switch (par_int)
{
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:
// can we not have references to canny in the code. gives me ptsd flashbacks
CannyEdgeDetector Nightmare = new CannyEdgeDetector();
// apply the filter
Nightmare.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 PatternRecognition(Bitmap bitmap) {
// Prvi korak - grayscalling originalne slike
Bitmap frame = grayscaleFilter.Apply(bitmap);
BitmapData frameData = frame.LockBits(new Rectangle(0, 0, frame.Width, frame.Height), ImageLockMode.ReadWrite, frame.PixelFormat);
// Drugi korak - detekcija ivica pomocu Sobel filtra
sobelFilter.ApplyInPlace(frameData);
// Treći korak - konvertuj sliku u crno-bijelu pri čemu je threshold = 100 odnoso od 0 do 155 je crna boja, a od 156 do 255 je bijela boja
thresholdFilter.ApplyInPlace(frameData);
// Četvrti korak - dilitacija / pojacavanje bijele boje jer
dilitationFilter.ApplyInPlace(frameData);
// Peti korak - kreiranje binarne slike
frame = frame.Clone(new Rectangle(0, 0, frame.Width, frame.Height), PixelFormat.Format8bppIndexed);
// Šesti korak - pronalazak potencijalnih oblika na slici
blobCounter.ProcessImage(frameData);
Blob[] blobs = blobCounter.GetObjectsInformation();
// za crtanje po originalnoj slici
Graphics g = Graphics.FromImage(bitmap);
// Sedmi korak - provjeri svaki oblik
foreach (Blob blob in blobs) {
List<IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blob);
List<IntPoint> hullPoints = hullFinder.FindHull(edgePoints);
List<IntPoint> corners = null;
// da li je četverougao?
if (shapeChecker.IsQuadrilateral(hullPoints, out corners))
// da li je kvadrat?
if (shapeChecker.CheckPolygonSubType(corners) == PolygonSubType.Square) {
if (!detected) {
// Osmi korak - odrđivanje centra gravitacije i gornjeg lijevog tjemena
FindNewCorners(corners);
// Deveti korak - ekstrakcija prepoznatog kvadrata sa originalne slike u novu sliku dimenzija 100x100
SimpleQuadrilateralTransformation quadrilateralTransformation = new SimpleQuadrilateralTransformation(corners, 100, 100);
Bitmap recognizedSquare = quadrilateralTransformation.Apply(bitmap);
recognizedSquare = recognizedSquare.Clone(new Rectangle(0, 0, recognizedSquare.Width, recognizedSquare.Height), PixelFormat.Format8bppIndexed);
// Deseti korak - od nove slike ponovo napravi crno-bijelu
otsuThresholdFilter.ApplyInPlace(recognizedSquare);
// Jedanaesti korak - invertuj boje
invertFilter.ApplyInPlace(recognizedSquare);
//Dvanaesti korak - prepoznaj oblik (formiraj matricu)
float confidence; // vjerovatnoća da je prepoznat pravi oblik (odnos borja crnih i bijelih piksela u ćeliji
byte[,] pattern = binaryGlyphRecognizer.Recognize(recognizedSquare, new Rectangle(0, 0, recognizedSquare.Width, recognizedSquare.Height), out confidence);
recognizedSquare.Dispose();
if (confidence >= 0.6) {
oldPatterns.Add(pattern);
Boolean canDraw = CheckPrevious();
if (canDraw) {
// Trinaesti korak - iscrtaj matricu
DrawPattern(pattern);
detected = true;
// pravim delay od 3s nakon što prepozna pattern
new Task(() => {
Thread.Sleep(3*1000);
detected = false;
}).Start();
// Komunikacija sa warehouse uređajem.
//new Thread(new RS232Communication(shape).Run).Start();
}
}
}
// iscrtaj ivice oko prepoznatog kvadrata
g.DrawPolygon(pen, ToPointsArray(hullPoints));
}
}
g.Dispose();
frame.UnlockBits(frameData);
frame.Dispose();
}
// Process image
private void ProcessImage(Bitmap bitmap)
{
//QuantizeImage(bitmap);
Grayscale grayscaleFilter = new Grayscale(0.33, 0.33, 0.34);
// apply the filter
Bitmap grayImage = grayscaleFilter.Apply(bitmap);
// create filter
SobelEdgeDetector sobelFilter = new SobelEdgeDetector();
// apply the filter
sobelFilter.ApplyInPlace(grayImage);
Threshold filter = new Threshold(243);
// apply the filter
filter.ApplyInPlace(grayImage);
int[,,] intersectPoint = new int[2, 19, 19];
GetIntersect(grayImage, bitmap, intersectPoint);
Graphics g = Graphics.FromImage(bitmap);
//Sorting
/*int[,] top19 = new int[19, 2];
* int[,] left19 = new int[19, 2];
* int[,] bot19 = new int[19, 2];
* int[,] right19 = new int[19, 2];
* int lowest = 9999999;
* int lowX = 0;
* int lowY = 0;
* for (int i = 0; i < 19; i++) {
* for (int j = 0; j < 19; j++) {
* if (intersectPoint[0, i, j] + intersectPoint[1, i, j] < lowest) {
* lowest = intersectPoint[0, i, j] + intersectPoint[1, i, j];
* lowX = Math.Abs(intersectPoint[0, i, j]);
* lowY = Math.Abs(intersectPoint[1, i, j]);
* }
* }
* }
*/
for (int i = 0; i < 19; i++)
{
for (int j = 0; j < 19; j++)
{
for (int k = 0; k < 19 - 1; k++)
{
if (Math.Abs(intersectPoint[1, i, k]) > Math.Abs(intersectPoint[1, i, k + 1]))
{
int tempX = Math.Abs(intersectPoint[0, i, k]);
int tempY = Math.Abs(intersectPoint[1, i, k]);
intersectPoint[0, i, k] = Math.Abs(intersectPoint[0, i, k + 1]);
intersectPoint[1, i, k] = Math.Abs(intersectPoint[1, i, k + 1]);
intersectPoint[0, i, k + 1] = tempX;
intersectPoint[1, i, k + 1] = tempY;
//MessageBox.Show(i + " " + k +" " +tempX + " " + tempY + " " + intersectPoint[0, i, k] + " " + intersectPoint[1, i, k] ,"ok", MessageBoxButtons.OK);
}
}
}
}
for (int i = 0; i < 19; i++)
{
for (int j = 0; j < 19; j++)
{
for (int k = 0; k < 19 - 1; k++)
{
if (Math.Abs(intersectPoint[0, k, i]) > Math.Abs(intersectPoint[0, k + 1, i]))
{
int tempX = Math.Abs(intersectPoint[0, k, i]);
int tempY = Math.Abs(intersectPoint[1, k, i]);
intersectPoint[0, k, i] = intersectPoint[0, k + 1, i];
intersectPoint[1, k, i] = intersectPoint[1, k + 1, i];
intersectPoint[0, k + 1, i] = tempX;
intersectPoint[1, k + 1, i] = tempY;
}
}
}
}
Pen redPen = new Pen(Color.Red, 4);
for (int i = 0; i < 19; i++)
{
for (int j = 0; j < 5; j++)
{
g.DrawEllipse(redPen, Math.Abs(intersectPoint[0, i, j]) - 2, Math.Abs(intersectPoint[1, i, j]) - 2, (int)5, (int)5);
//g.DrawEllipse(redPen, 0, 0, (int)5, (int)5);
}
}
Pen greenPen = new Pen(Color.Green, 4);
greenPen.Dispose();
redPen.Dispose();
g.Dispose();
/*HoughLineTransformation lineTransform = new HoughLineTransformation();
* lineTransform.ProcessImage(grayImage);
* Bitmap houghLineImage = lineTransform.ToBitmap();
* // get lines using relative intensity
* HoughLine[] lines = lineTransform.GetLinesByRelativeIntensity(0.5);
*
* BitmapData bitmapData = bitmap.LockBits(
* new Rectangle(0, 0, bitmap.Width, bitmap.Height),
* ImageLockMode.ReadWrite, bitmap.PixelFormat);
* BitmapData grayImageData = grayImage.LockBits(
* new Rectangle(0, 0, grayImage.Width, grayImage.Height),
* ImageLockMode.ReadWrite, grayImage.PixelFormat);
* UnmanagedImage unmanagedImage = new UnmanagedImage(bitmapData);
*
* int w2 = 0, h2 = 0;
* Color color = Color.Black;
*
* foreach (HoughLine line in lines)
* {
*
* String temp = line.Theta.ToString();
* //MessageBox.Show(temp, "ok", MessageBoxButtons.OK);
* // get line's radius and theta values
* int r = line.Radius;
* double t = line.Theta;
*
* // check if line is in lower part of the image
* if (r < 0)
* {
* t += 180;
* r = -r;
* }
*
* // convert degrees to radians
* t = (t / 180) * Math.PI;
*
* // get image centers (all coordinate are measured relative
* // to center)
* w2 = grayImage.Width / 2;
* h2 = grayImage.Height / 2;
*
* double x0 = 0, x1 = 0, y0 = 0, y1 = 0;
*
* if (line.Theta != 0)
* {
* // horizontal
* // none-vertical line
*
* if (line.Theta > 0 && line.Theta < 10 || line.Theta > 170)
* {
* x0 = -w2; // most left point
* x1 = w2; // most right point
*
* y0 = (-Math.Cos(t) * x0 + r) / Math.Sin(t);
* y1 = (-Math.Cos(t) * x1 + r) / Math.Sin(t);
*
* color = Color.Red;
*
* Drawing.Line(bitmapData,
* new IntPoint((int)x0 + w2, h2 - (int)y0),
* new IntPoint((int)x1 + w2, h2 - (int)y1),
* color);
* Drawing.Line(grayImageData,
* new IntPoint((int)x0 + w2, h2 - (int)y0),
* new IntPoint((int)x1 + w2, h2 - (int)y1),
* color);
* }
*
* if (line.Theta > 80 && line.Theta < 100)
* {
* x0 = -w2; // most left point
* x1 = w2; // most right point
*
* y0 = (-Math.Cos(t) * x0 + r) / Math.Sin(t);
* y1 = (-Math.Cos(t) * x1 + r) / Math.Sin(t);
*
* Drawing.Line(bitmapData,
* new IntPoint((int)x0 + w2, h2 - (int)y0),
* new IntPoint((int)x1 + w2, h2 - (int)y1),
* Color.Blue);
* Drawing.Line(grayImageData,
* new IntPoint((int)x0 + w2, h2 - (int)y0),
* new IntPoint((int)x1 + w2, h2 - (int)y1),
* Color.Blue);
* }
* }
* else
* {
* // vertical line
* x0 = line.Radius;
* x1 = line.Radius;
* y0 = h2;
* y1 = -h2;
*
* color = Color.Red;
*
* Drawing.Line(bitmapData,
* new IntPoint((int)x0 + w2, h2 - (int)y0),
* new IntPoint((int)x1 + w2, h2 - (int)y1),
* color);
* Drawing.Line(grayImageData,
* new IntPoint((int)x0 + w2, h2 - (int)y0),
* new IntPoint((int)x1 + w2, h2 - (int)y1),
* color);
* }
* }
* bitmap.UnlockBits(bitmapData);
* grayImage.UnlockBits(grayImageData);
* MessageBox.Show(lines.Length+"", "ok", MessageBoxButtons.OK);
*/
Clipboard.SetDataObject(bitmap);
// and to picture box
pictureBox.Image = bitmap;
UpdatePictureBoxPosition();
}
// Process image
private void ProcessImage(Bitmap bitmap)
{
// create filter
HistogramEqualization hisFilter = new HistogramEqualization();
// process image
//hisFilter.ApplyInPlace(Image);
// create filter
ContrastCorrection contrastFilter = new ContrastCorrection(4);
// apply the filter
contrastFilter.ApplyInPlace(bitmap);
//QuantizeImage(bitmap);
Grayscale grayscaleFilter = new Grayscale(0.33, 0.33, 0.34);
// apply the filter
Bitmap grayImage = grayscaleFilter.Apply(bitmap);
// create filter
SobelEdgeDetector sobelFilter = new SobelEdgeDetector();
// apply the filter
sobelFilter.ApplyInPlace(grayImage);
Threshold filter = new Threshold(110);
// apply the filter
filter.ApplyInPlace(grayImage);
if (GetIntersect(grayImage, bitmap, intersectPoint))
{
//MessageBox.Show("draw");
Graphics g = Graphics.FromImage(bitmap);
//Sorting
for (int i = 0; i < 19; i++)
{
for (int j = 0; j < 19; j++)
{
for (int k = 0; k < 19 - 1; k++)
{
if (Math.Abs(intersectPoint[1, i, k]) > Math.Abs(intersectPoint[1, i, k + 1]))
{
int tempX = Math.Abs(intersectPoint[0, i, k]);
int tempY = Math.Abs(intersectPoint[1, i, k]);
intersectPoint[0, i, k] = Math.Abs(intersectPoint[0, i, k + 1]);
intersectPoint[1, i, k] = Math.Abs(intersectPoint[1, i, k + 1]);
intersectPoint[0, i, k + 1] = tempX;
intersectPoint[1, i, k + 1] = tempY;
//MessageBox.Show(i + " " + k +" " +tempX + " " + tempY + " " + intersectPoint[0, i, k] + " " + intersectPoint[1, i, k] ,"ok", MessageBoxButtons.OK);
}
}
}
}
for (int i = 0; i < 19; i++)
{
for (int j = 0; j < 19; j++)
{
for (int k = 0; k < 19 - 1; k++)
{
if (Math.Abs(intersectPoint[0, k, i]) > Math.Abs(intersectPoint[0, k + 1, i]))
{
int tempX = Math.Abs(intersectPoint[0, k, i]);
int tempY = Math.Abs(intersectPoint[1, k, i]);
intersectPoint[0, k, i] = intersectPoint[0, k + 1, i];
intersectPoint[1, k, i] = intersectPoint[1, k + 1, i];
intersectPoint[0, k + 1, i] = tempX;
intersectPoint[1, k + 1, i] = tempY;
}
}
}
}
Pen redPen = new Pen(Color.Red, 4);
for (int i = 0; i < 19; i++)
{
for (int j = 0; j < 19; j++)
{
g.DrawEllipse(redPen, Math.Abs(intersectPoint[0, i, j]), Math.Abs(intersectPoint[1, i, j]), (int)5, (int)5);
//g.DrawEllipse(redPen, 0, 0, (int)5, (int)5);
//Debug.WriteLine((Math.Abs(intersectPoint[0, i, j]) - 2) + " " + (Math.Abs(intersectPoint[1, i, j]) - 2));
}
}
Pen greenPen = new Pen(Color.Green, 4);
greenPen.Dispose();
redPen.Dispose();
g.Dispose();
// Initializes the variables to pass to the MessageBox.Show method.
EspacioCamera.Image = bitmap;
string message = "Do you accecpt this detection?";
string caption = "The system found totally 38 lines.";
MessageBoxButtons buttons = MessageBoxButtons.YesNo;
DialogResult result;
// Displays the MessageBox.
result = MessageBox.Show(message, caption, buttons);
if (result == System.Windows.Forms.DialogResult.Yes)
{
// Closes the parent form.
locked = true;
}
}
EspacioCamera.Image = bitmap;
}
private void detectQuads(Bitmap bitmap)
{
// Greyscale
filteredBitmap = Grayscale.CommonAlgorithms.BT709.Apply(bitmap);
// Contrast - try to sharpen edges
//ContrastStretch filter = new ContrastStretch();
//filter.ApplyInPlace(filteredBitmap);
// edge filter
// This filters accepts 8 bpp grayscale images for processing
//Alternatives:
//DifferenceEdgeDetector edgeFilter = new DifferenceEdgeDetector();
//HomogenityEdgeDetector filter = new HomogenityEdgeDetector();
//CannyEdgeDetector filter = new CannyEdgeDetector( );
var edgeFilter = new SobelEdgeDetector();
edgeFilter.ApplyInPlace(filteredBitmap);
// Threshhold filter
var threshholdFilter = new Threshold(240); //180
threshholdFilter.ApplyInPlace(filteredBitmap);
var bitmapData = filteredBitmap.LockBits(
new Rectangle(0, 0, filteredBitmap.Width, filteredBitmap.Height),
ImageLockMode.ReadWrite, filteredBitmap.PixelFormat);
var blobCounter = new BlobCounter();
blobCounter.FilterBlobs = true;
//possible finetuning
blobCounter.MinHeight = Convert.ToInt32(int.Parse(blobHigh.Text) * fScaleFactor); //fScaleFactor
blobCounter.MinWidth = Convert.ToInt32(int.Parse(blobWidth.Text) * fScaleFactor); //fScaleFactor
#if DEBUG
Console.WriteLine("Calculate min blobsize " + blobCounter.MinWidth + "/" + blobCounter.MinHeight);
#endif
blobCounter.ProcessImage(bitmapData);
var blobs = blobCounter.GetObjectsInformation();
filteredBitmap.UnlockBits(bitmapData);
var shapeChecker = new SimpleShapeChecker();
var bm = new Bitmap(filteredBitmap.Width, filteredBitmap.Height, PixelFormat.Format24bppRgb);
var g = Graphics.FromImage(bm);
g.DrawImage(filteredBitmap, 0, 0);
var pen = new Pen(Color.Red, 5);
var cardPositions = new List <IntPoint>();
// Loop through detected shapes
for (int i = 0, n = blobs.Length; i < n; i++)
{
var edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]);
List <IntPoint> corners;
var sameCard = false;
// is triangle or quadrilateral
if (shapeChecker.IsConvexPolygon(edgePoints, out corners))
{
// get sub-type
var subType = shapeChecker.CheckPolygonSubType(corners);
// Only return 4 corner rectanges
if ((subType == PolygonSubType.Parallelogram || subType == PolygonSubType.Rectangle) &&
corners.Count == 4)
{
// Check if its sideways, if so rearrange the corners so it's veritcal
rearrangeCorners(corners);
// Prevent it from detecting the same card twice
foreach (var point in cardPositions)
{
if (corners[0].DistanceTo(point) < Convert.ToInt32(40 * fScaleFactor)) //fScaleFactor
{
sameCard = true;
}
}
if (sameCard)
{
continue;
}
/*
* This code seems to have an issue if scaled up with the factor:
*/
// Hack to prevent it from detecting smaller sections of the card instead of the whole card
if (GetArea(corners) < Convert.ToInt32(double.Parse(treasholdBox.Text) * fScaleFactor)
) //fScaleFactor
{
continue;
}
cardPositions.Add(corners[0]);
g.DrawPolygon(pen, ToPointsArray(corners));
// Extract the card bitmap
// Debug
//var transformFilter = new QuadrilateralTransformation(corners, 600, 800);
var transformFilter = new QuadrilateralTransformation(corners,
Convert.ToInt32(211 * fScaleFactor), Convert.ToInt32(298 * fScaleFactor));
cardBitmap = transformFilter.Apply(cameraBitmap);
var card = new MagicCard();
card.corners = corners;
card.cardBitmap = cardBitmap;
card.cardArtBitmap = cardArtBitmap;
magicCards.Add(card);
pen.Dispose();
g.Dispose();
filteredBitmap = bm;
return;
}
}
}
pen.Dispose();
g.Dispose();
filteredBitmap = bm;
}
private Bitmap detectQuads(Bitmap bitmap)
{
var cardArtBitmap = bitmap;
try
{
/*
* This code works and crops well on 80% of the images but we need 100%
* */
var width = bitmap.Width + bitmap.Width / 2;
var height = bitmap.Height + bitmap.Height / 2;
// Create a compatible bitmap
var dest = new Bitmap(width, height, bitmap.PixelFormat);
var gd = Graphics.FromImage(dest);
dest.Dispose();
gd.DrawImage(bitmap, 0, 0, bitmap.Width, bitmap.Height);
// Greyscale
filteredBitmap = Grayscale.CommonAlgorithms.BT709.Apply(bitmap);
// Contrast
//ContrastStretch filter = new ContrastStretch();
//filter.ApplyInPlace(filteredBitmap);
var cutMargin = 80;
// split the image to avoid the textbox beeing detected
var cropFilterPre =
new Crop(new Rectangle(0, cutMargin, filteredBitmap.Width, filteredBitmap.Height / 100 * 60));
filteredBitmap = cropFilterPre.Apply(filteredBitmap);
// edge filter
var edgeFilter = new SobelEdgeDetector(); //
edgeFilter.ApplyInPlace(filteredBitmap);
// Threshhold filter
var threshholdFilter = new Threshold(190);
threshholdFilter.ApplyInPlace(filteredBitmap);
var bitmapData = filteredBitmap.LockBits(
new Rectangle(0, 0, filteredBitmap.Width, filteredBitmap.Height),
ImageLockMode.ReadWrite, filteredBitmap.PixelFormat);
var blobCounter = new BlobCounter();
blobCounter.FilterBlobs = true;
blobCounter.MinHeight = 200;
blobCounter.MinWidth = 200;
blobCounter.ProcessImage(bitmapData);
var blobs = blobCounter.GetObjectsInformation();
filteredBitmap.UnlockBits(bitmapData);
var shapeChecker = new SimpleShapeChecker();
/*var bm = new Bitmap(filteredBitmap.Width, filteredBitmap.Height, PixelFormat.Format24bppRgb);
*
* var g = Graphics.FromImage(bm);
* g.DrawImage(filteredBitmap, 0, 0);
*
* var pen = new Pen(Color.Red, 5);
* //var cardPositions = new List<IntPoint>();*/
// Loop through detected shapes
for (int i = 0, n = blobs.Length; i < n; i++)
{
var edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]);
List <IntPoint> corners;
var sameCard = false;
// is triangle or quadrilateral
if (shapeChecker.IsConvexPolygon(edgePoints, out corners))
{
// get sub-type
var subType = shapeChecker.CheckPolygonSubType(corners);
// Only return 4 corner rectanges
if ((subType == PolygonSubType.Parallelogram || subType == PolygonSubType.Rectangle) &&
corners.Count == 4)
{
// Hack to prevent it from detecting smaller sections of the card instead of the art
if (GetArea(corners) < 120000)
{
continue;
}
//debug crap
/*Bitmap newImage = filteredBitmap;
* Random rnd = new Random();
* newImage.Save(@"X:\" + rnd.Next() + ".jpg", ImageFormat.Jpeg);*/
var x = corners[0].X;
var y = corners[0].Y + cutMargin;
var x2 = corners[2].X - corners[0].X;
var y2 = corners[2].Y - (corners[0].Y + 0);
if (x2 < 0 || y2 < 0)
{
x = corners[1].X;
y = corners[1].Y + cutMargin;
x2 = corners[3].X - corners[1].X;
y2 = corners[3].Y - (corners[1].Y + 0);
}
var cropframe = new Rectangle(x, y, x2, y2);
var gbfilter = new GaussianBlur(1, 5);
gbfilter.ApplyInPlace(bitmap);
var cropFilter = new Crop(cropframe);
cardArtBitmap = cropFilter.Apply(bitmap);
bitmap.Dispose();
// pen.Dispose();
// g.Dispose();
gd.Dispose();
filteredBitmap.Dispose();
return(cardArtBitmap);
}
}
}
Console.WriteLine("Fallback Triggered!");
var gfilter = new GaussianBlur(1, 5);
gfilter.ApplyInPlace(bitmap);
//Fallback default crop, assumes XLHQ CCGHQ images
var cropFilterFallback = new Crop(new Rectangle(88, 121, 564, 440));
cardArtBitmap = cropFilterFallback.Apply(bitmap);
bitmap.Dispose();
//pen.Dispose();
//g.Dispose();
gd.Dispose();
filteredBitmap.Dispose();
}
catch (Exception e)
{
throw;
}
return(cardArtBitmap);
}
private void FillPictureBoxes(ref Bitmap image)
{
Bitmap tmpImg = image;
Bitmap tmpImg2 = image;
try
{
bool hasFilter = false;
//setup resize and filtersequesce
//resize img to fit picturebox
ResizeBicubic resizeFilter = new ResizeBicubic(0, 0);
resizeFilter = new ResizeBicubic(pbCapture.Width, pbCapture.Height);
tmpImg = resizeFilter.Apply(tmpImg);
resizeFilter = new ResizeBicubic(pbShapes.Width, pbShapes.Height);
tmpImg2 = resizeFilter.Apply(tmpImg2);
FiltersSequence processingFilter = new FiltersSequence();
//List all filters
IFilter ConservativeSmoothingFilter = new AForge.Imaging.Filters.ConservativeSmoothing();
IFilter InvertFilter = new AForge.Imaging.Filters.Invert();
IFilter HSLFilteringFilter = new AForge.Imaging.Filters.HSLFiltering();
IFilter SepiaFilter = new AForge.Imaging.Filters.Sepia();
IFilter grayscaleFilter = new AForge.Imaging.Filters.GrayscaleBT709();
IFilter SkeletonizationFilter = new AForge.Imaging.Filters.SimpleSkeletonization();
IFilter pixFilter = new AForge.Imaging.Filters.Pixellate();
////apply filter and process img---------------------------------------------
if (ConservativeSmoothing)
{
processingFilter.Add(ConservativeSmoothingFilter);
hasFilter = true;
}
if (Invert)
{
processingFilter.Add(InvertFilter);
hasFilter = true;
}
if (HSLswitch)
{
processingFilter.Add(HSLFilteringFilter);
hasFilter = true;
}
if (sepiaSwitch)
{
processingFilter.Add(SepiaFilter);
hasFilter = true;
}
if (Skeletonization)
{
processingFilter.Add(grayscaleFilter);
processingFilter.Add(SkeletonizationFilter);
hasFilter = true;
}
//apply the filter(s) to image
if (hasFilter)
{
//tmpImg = processingFilter.Apply(tmpImg);
tmpImg2 = processingFilter.Apply(tmpImg2);
}
processingFilter.Clear();
if (bwSwitch)
{
switchBandW(ref tmpImg);
}
if (CannyEdgeDetector)
{
// create filter
CannyEdgeDetector filter = new CannyEdgeDetector();
// apply the filter
tmpImg = Grayscale.CommonAlgorithms.BT709.Apply(tmpImg);
filter.ApplyInPlace(tmpImg);
// image = DrawFocusArea(gsImage);
}
else
{
// image = DrawFocusArea(image);
}
if (DifferenceEdgeDetector)
{
DifferenceEdgeDetector dFilter = new DifferenceEdgeDetector();
// apply the filter
tmpImg = Grayscale.CommonAlgorithms.BT709.Apply(tmpImg);
dFilter.ApplyInPlace(tmpImg);
}
if (HomogenityEdgeDetector)
{
HomogenityEdgeDetector hFilter = new HomogenityEdgeDetector();
// apply the filter
tmpImg = Grayscale.CommonAlgorithms.BT709.Apply(tmpImg);
hFilter.ApplyInPlace(tmpImg);
}
if (SobelEdgeDetector)
{
SobelEdgeDetector hFilter = new SobelEdgeDetector();
// apply the filter
tmpImg = Grayscale.CommonAlgorithms.BT709.Apply(tmpImg);
hFilter.ApplyInPlace(tmpImg);
BlobCounter bc = new BlobCounter(tmpImg);
Rectangle[] brecs = bc.GetObjectsRectangles();
//Graphics pg = Graphics.FromImage(tmpImg);
//Pen p = new Pen(Color.White, 2);
//foreach (Rectangle r in brecs)
//{
// pg.DrawRectangle(p, r);
//}
}
if (findShapes)
{
tmpImg = FindShapes(tmpImg, ref tmpImg2);
//ProcessImage(image);
}
else
{
pbCapture.Image = tmpImg; //set picturebox image----------------
pbShapes.Image = tmpImg2; //set picturebox image----------------
}
// Graphics g = Graphics.FromImage(tmpImg);
// Pen p = new Pen(Color.Red, 2);
// Rectangle lr = new Rectangle(100, 120, 80, 40);
//// Rectangle rr = new Rectangle(360, 220, 80, 40);
// g.DrawRectangle(p, lr);
// //g.DrawRectangle(p, rr);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
// pbCapture.Image = tmpImg;//set picturebox image----------------
// pbShapes.Image = tmpImg2;//set picturebox image----------------
}
// Process image
private void ProcessImage(Bitmap bitmap)
{
QuantizeImage(bitmap);
Grayscale grayscaleFilter = new Grayscale(0.33, 0.33, 0.34);
// apply the filter
Bitmap grayImage = grayscaleFilter.Apply(bitmap);
//Get Histogram
/*int[] histogram = new int[256];
* for (int i = 0; i < 256; i++) {
* histogram[i] = 0;
* }
* for (int i = 0; i < grayImage.Width; i++ )
* {
* for (int j = 0; j < grayImage.Height; j++) {
* histogram[(Convert.ToInt32(grayImage.GetPixel(i, j).R.ToString()) + Convert.ToInt32(grayImage.GetPixel(i, j).G.ToString()) +
* Convert.ToInt32(grayImage.GetPixel(i, j).B.ToString()))/3] +=1;
* }
* }*/
// create filter
SobelEdgeDetector sobelFilter = new SobelEdgeDetector();
// apply the filter
sobelFilter.ApplyInPlace(grayImage);
Threshold filter = new Threshold(243);
// apply the filter
filter.ApplyInPlace(grayImage);
HoughLineTransformation lineTransform = new HoughLineTransformation();
lineTransform.ProcessImage(grayImage);
Bitmap houghLineImage = lineTransform.ToBitmap();
// get lines using relative intensity
HoughLine[] lines = lineTransform.GetLinesByRelativeIntensity(0.5);
BitmapData bitmapData = bitmap.LockBits(
new Rectangle(0, 0, bitmap.Width, bitmap.Height),
ImageLockMode.ReadWrite, bitmap.PixelFormat);
BitmapData grayImageData = grayImage.LockBits(
new Rectangle(0, 0, grayImage.Width, grayImage.Height),
ImageLockMode.ReadWrite, grayImage.PixelFormat);
UnmanagedImage unmanagedImage = new UnmanagedImage(bitmapData);
int w2 = 0, h2 = 0;
Color color = Color.Black;
foreach (HoughLine line in lines)
{
String temp = line.Theta.ToString();
//MessageBox.Show(temp, "ok", MessageBoxButtons.OK);
// get line's radius and theta values
int r = line.Radius;
double t = line.Theta;
// check if line is in lower part of the image
if (r < 0)
{
t += 180;
r = -r;
}
// convert degrees to radians
t = (t / 180) * Math.PI;
// get image centers (all coordinate are measured relative
// to center)
w2 = grayImage.Width / 2;
h2 = grayImage.Height / 2;
double x0 = 0, x1 = 0, y0 = 0, y1 = 0;
if (line.Theta != 0)
{
// horizontal
// none-vertical line
if (line.Theta > 0 && line.Theta < 10 || line.Theta > 170)
{
x0 = -w2; // most left point
x1 = w2; // most right point
y0 = (-Math.Cos(t) * x0 + r) / Math.Sin(t);
y1 = (-Math.Cos(t) * x1 + r) / Math.Sin(t);
color = Color.Red;
Drawing.Line(bitmapData,
new IntPoint((int)x0 + w2, h2 - (int)y0),
new IntPoint((int)x1 + w2, h2 - (int)y1),
color);
Drawing.Line(grayImageData,
new IntPoint((int)x0 + w2, h2 - (int)y0),
new IntPoint((int)x1 + w2, h2 - (int)y1),
color);
}
if (line.Theta > 80 && line.Theta < 100)
{
x0 = -w2; // most left point
x1 = w2; // most right point
y0 = (-Math.Cos(t) * x0 + r) / Math.Sin(t);
y1 = (-Math.Cos(t) * x1 + r) / Math.Sin(t);
Drawing.Line(bitmapData,
new IntPoint((int)x0 + w2, h2 - (int)y0),
new IntPoint((int)x1 + w2, h2 - (int)y1),
Color.Blue);
Drawing.Line(grayImageData,
new IntPoint((int)x0 + w2, h2 - (int)y0),
new IntPoint((int)x1 + w2, h2 - (int)y1),
Color.Blue);
}
}
else
{
// vertical line
x0 = line.Radius;
x1 = line.Radius;
y0 = h2;
y1 = -h2;
color = Color.Red;
Drawing.Line(bitmapData,
new IntPoint((int)x0 + w2, h2 - (int)y0),
new IntPoint((int)x1 + w2, h2 - (int)y1),
color);
Drawing.Line(grayImageData,
new IntPoint((int)x0 + w2, h2 - (int)y0),
new IntPoint((int)x1 + w2, h2 - (int)y1),
color);
}
//
// draw line on the image
}
bitmap.UnlockBits(bitmapData);
grayImage.UnlockBits(grayImageData);
MessageBox.Show(lines.Length + "", "ok", MessageBoxButtons.OK);
Clipboard.SetDataObject(bitmap);
// and to picture box
pictureBox.Image = bitmap;
UpdatePictureBoxPosition();
}
private void detectQuads(Bitmap bitmap)
{
// Greyscale
filteredBitmap = Grayscale.CommonAlgorithms.BT709.Apply(bitmap);
// edge filter
SobelEdgeDetector edgeFilter = new SobelEdgeDetector();
edgeFilter.ApplyInPlace(filteredBitmap);
// Threshhold filter
Threshold threshholdFilter = new Threshold(190);
threshholdFilter.ApplyInPlace(filteredBitmap);
BitmapData bitmapData = filteredBitmap.LockBits(
new Rectangle(0, 0, filteredBitmap.Width, filteredBitmap.Height),
ImageLockMode.ReadWrite, filteredBitmap.PixelFormat);
BlobCounter blobCounter = new BlobCounter();
blobCounter.FilterBlobs = true;
blobCounter.MinHeight = 125;
blobCounter.MinWidth = 125;
blobCounter.ProcessImage(bitmapData);
Blob[] blobs = blobCounter.GetObjectsInformation();
filteredBitmap.UnlockBits(bitmapData);
SimpleShapeChecker shapeChecker = new SimpleShapeChecker();
Bitmap bm = new Bitmap(filteredBitmap.Width, filteredBitmap.Height, PixelFormat.Format24bppRgb);
Graphics g = Graphics.FromImage(bm);
g.DrawImage(filteredBitmap, 0, 0);
Pen pen = new Pen(Color.Red, 5);
List <IntPoint> cardPositions = new List <IntPoint>();
// Loop through detected shapes
for (int i = 0, n = blobs.Length; i < n; i++)
{
List <IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]);
List <IntPoint> corners;
bool sameCard = false;
// is triangle or quadrilateral
if (shapeChecker.IsConvexPolygon(edgePoints, out corners))
{
// get sub-type
PolygonSubType subType = shapeChecker.CheckPolygonSubType(corners);
// Only return 4 corner rectanges
if ((subType == PolygonSubType.Parallelogram || subType == PolygonSubType.Rectangle) && corners.Count == 4)
{
// Check if its sideways, if so rearrange the corners so it's veritcal
rearrangeCorners(corners);
// Prevent it from detecting the same card twice
foreach (IntPoint point in cardPositions)
{
if (corners[0].DistanceTo(point) < 40)
{
sameCard = true;
}
}
if (sameCard)
{
continue;
}
// Hack to prevent it from detecting smaller sections of the card instead of the whole card
if (GetArea(corners) < 20000)
{
continue;
}
cardPositions.Add(corners[0]);
g.DrawPolygon(pen, ToPointsArray(corners));
// Extract the card bitmap
QuadrilateralTransformation transformFilter = new QuadrilateralTransformation(corners, 211, 298);
cardBitmap = transformFilter.Apply(cameraBitmap);
List <IntPoint> artCorners = new List <IntPoint>();
artCorners.Add(new IntPoint(14, 35));
artCorners.Add(new IntPoint(193, 35));
artCorners.Add(new IntPoint(193, 168));
artCorners.Add(new IntPoint(14, 168));
// Extract the art bitmap
QuadrilateralTransformation cartArtFilter = new QuadrilateralTransformation(artCorners, 183, 133);
cardArtBitmap = cartArtFilter.Apply(cardBitmap);
MagicCard card = new MagicCard();
card.corners = corners;
card.cardBitmap = cardBitmap;
card.cardArtBitmap = cardArtBitmap;
magicCards.Add(card);
}
}
}
pen.Dispose();
g.Dispose();
filteredBitmap = bm;
}