private void FinalFrame_NewFrame(object sender, NewFrameEventArgs eventArgs)
{
//pictureBox1.Image = (Bitmap)eventArgs.Frame.Clone();
video = (Bitmap)eventArgs.Frame.Clone();
Bitmap video2 = (Bitmap)eventArgs.Frame.Clone();
// this is mode 1
if (mode == 1)
{
//
ColorFiltering colorfilter = new ColorFiltering();
colorfilter.Red = new IntRange(Red, (int)numericUpDownRed.Value);
colorfilter.Green = new IntRange(Green, (int)numericUpDownGreen.Value);
colorfilter.Blue = new IntRange(Blue, (int)numericUpDownBlue.Value);
colorfilter.ApplyInPlace(video2);
//BlobCounter
BlobCounter blobcounter = new BlobCounter();
blobcounter.MinHeight = 20;
blobcounter.MinWidth = 20;
blobcounter.ObjectsOrder = ObjectsOrder.Size;
blobcounter.ProcessImage(video2);
Rectangle[] rect = blobcounter.GetObjectsRectangles();
if (rect.Length > 0)
{
Rectangle target = rect[0];
Graphics graphic = Graphics.FromImage(video2); // To apply Grapghics on video2, that is, pictureBox2.
g = Graphics.FromImage(video2);
using (Pen pen = new Pen(Color.White, 3))
{
graphic.DrawRectangle(pen, target);
g.DrawString("Target Located !", new Font("Arial", 20), new SolidBrush(Color.White), new PointF(2, 2)); // to demonstrate 'recognition' of target.
g.Dispose();
}
graphic.Dispose();
}
pictureBox2.Image = video2;
}
pictureBox1.Image = video;
}
public static Bitmap buscaRectangulos(Bitmap bitmap)
{
Blob[] blobs;
Rectangle area = new Rectangle(0, 0, bitmap.Width, bitmap.Height);
// lock image
BitmapData bitmapData = bitmap.LockBits(area, ImageLockMode.ReadWrite, bitmap.PixelFormat);
// Filtramos la imagen para determinar hasts cuando de ROJO, VERDE Y AZUL se permitiráanalizar
ColorFiltering colorFilter = new ColorFiltering();
colorFilter.Red = new IntRange(0, 104);
colorFilter.Green = new IntRange(0, 104);
colorFilter.Blue = new IntRange(0, 104);
colorFilter.FillOutsideRange = false; colorFilter.ApplyInPlace(bitmapData);
// Localizamos objetos en la imagen
BlobCounter blobCounter = new BlobCounter();
blobCounter.FilterBlobs = true;
blobCounter.MinHeight = 15;
blobCounter.MinWidth = 15;
blobCounter.ProcessImage(bitmapData);
blobs = blobCounter.GetObjectsInformation();
bitmap.UnlockBits(bitmapData);
// step 3 -check objects' type and highlight
SimpleShapeChecker shapeChecker = new SimpleShapeChecker();
Graphics g = Graphics.FromImage(bitmap);
Pen yellowPen = new Pen(Color.Yellow, 2);
// Para cada figuura encontrada
for (int i = 0, n = blobs.Length; i < n; i++)
{
List <IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]);
List <IntPoint> corners;
// Cuadrado
if (shapeChecker.IsQuadrilateral(edgePoints, out corners))
{//Obtenemos cuantas esquinas tiene el shape
PolygonSubType subType = shapeChecker.CheckPolygonSubType(corners);
//Pintamos las áreas detectadas
areaInteres(g, corners);
}
}
//yellowPen.Dispose();
g.Dispose();
// put new image to clipboard
Clipboard.SetDataObject(bitmap);
// and to picture box
return(bitmap);
}
private void AnaliseMap(Bitmap mapImage)
{
mapData.Clear();
ColorFiltering filter = new ColorFiltering();
Trace.WriteLine("Analysing color map " + mapLocation + "...");
foreach (String action in colorMap.Actions)
{
Color actionColor = colorMap.GetColorFor(action);
filter.Red = new IntRange(actionColor.R, actionColor.R);
filter.Green = new IntRange(actionColor.G, actionColor.G);
filter.Blue = new IntRange(actionColor.B, actionColor.B);
using (Bitmap colorFilteredMapImage = filter.Apply(mapImage))
{
// Once we have isolated the action color on the map image
// we need to find the biggest rectangle left in the map (as there could be noise)
BlobCounter bc = new BlobCounter();
bc.ProcessImage(colorFilteredMapImage);
Rectangle[] rects = bc.GetObjectsRectangles();
if (rects.Count <Rectangle>() == 0)
{
Trace.WriteLine("Warning: No rectangles were found for " + actionColor.ToString());
}
Rectangle biggestRect = Rectangle.Empty;
foreach (Rectangle rect in rects)
{
// Compare areas
if (rect.Width * rect.Height > biggestRect.Width * biggestRect.Height)
{
biggestRect = rect;
}
}
// Did we find a rectangle?
if (!biggestRect.Equals(Rectangle.Empty) && (biggestRect.Width * biggestRect.Height > MIN_AREA_THRESHOLD))
{
Trace.WriteLine("Found rectangle for " + action + ": " + biggestRect.ToString());
mapData[action] = biggestRect;
}
}
}
}
/// <summary>
/// Process the filter on the specified image.
/// </summary>
///
/// <param name="image">Source image data.</param>
///
protected override unsafe void ProcessFilter(UnmanagedImage image)
{
// use blob counter to build objects map and filter them
blobCounter.ProcessImage(image);
int[] objectsMap = blobCounter.ObjectLabels;
// get image width and height
int width = image.Width;
int height = image.Height;
// do the job
byte *ptr = (byte *)image.ImageData.ToPointer();
if (image.PixelFormat == PixelFormat.Format8bppIndexed)
{
int offset = image.Stride - width;
for (int y = 0, p = 0; y < height; y++)
{
for (int x = 0; x < width; x++, ptr++, p++)
{
if (objectsMap[p] == 0)
{
*ptr = 0;
}
}
ptr += offset;
}
}
else
{
int pixelSize = Bitmap.GetPixelFormatSize(image.PixelFormat) / 8;
int offset = image.Stride - width * pixelSize;
for (int y = 0, p = 0; y < height; y++)
{
for (int x = 0; x < width; x++, ptr += pixelSize, p++)
{
if (objectsMap[p] == 0)
{
ptr[RGB.R] = ptr[RGB.G] = ptr[RGB.B] = 0;
}
}
ptr += offset;
}
}
}
//=============================================================================================
private Bitmap Tracker(NewFrameEventArgs frame, Color color, string colorDetectado)
{
Bitmap copia = frame.Frame.Clone() as Bitmap;
Bitmap temp = new Bitmap(copia.Width, copia.Height);
Graphics g = Graphics.FromImage(temp);
int left = copia.Width / 4;
int top = copia.Height / 4;
int width = copia.Width / 2;
int height = copia.Height / 2;
Rectangle srcRect = new Rectangle(left, top, width, height);
Rectangle dstRect = new Rectangle(0, 0, temp.Width, temp.Height);
g.DrawImage(copia, dstRect, srcRect, GraphicsUnit.Pixel);
EuclideanColorFiltering filtro = new EuclideanColorFiltering();
filtro.CenterColor = new AForge.Imaging.RGB(color.R, color.G, color.B);
filtro.Radius = 100;
filtro.ApplyInPlace(temp);
BlobCounter blobcounter = new BlobCounter();
blobcounter.MinWidth = 5;
blobcounter.MinHeight = 5;
blobcounter.FilterBlobs = true;
blobcounter.ObjectsOrder = ObjectsOrder.Size;
blobcounter.ProcessImage(temp);
Rectangle[] rects = blobcounter.GetObjectsRectangles();
if (rects.Length > 0)
{
Rectangle objectRect = rects[0];
if (objectRect.Width >= 300 && objectRect.Height >= 300)
{
//Graphics g = Graphics.FromImage(temp);
using (Pen pen = new Pen(Color.FromArgb(0, 255, 250), 5))
{
g.DrawRectangle(pen, objectRect);
this.ProcesarColor(colorDetectado);
}
g.Dispose();
}
}
return(temp);
}
private void GetPicBlobs()
{
// create filter
ColorFiltering filter = new ColorFiltering();
// set color ranges to keep
filter.Red = new IntRange(190, 255);
filter.Green = new IntRange(200, 255);
filter.Blue = new IntRange(180, 255);
// apply the filter
filter.ApplyInPlace(GameZonePic);
// locate objects using blob counter
BlobCounter = new BlobCounter();
BlobCounter.ProcessImage(GameZonePic);
Blobs = BlobCounter.GetObjectsInformation();
}
static void Main(string[] args)
{
try
{
string path = "D:\\HACK2015\\PICS";
Bitmap sourceImage = AForge.Imaging.Image.FromFile(Path.Combine(path, "CAM1s.jpg"));
Difference differenceFilter = new Difference(); //AForge.Imaging.Filters.Difference
differenceFilter.OverlayImage = sourceImage;
Bitmap sourceImg = AForge.Imaging.Image.FromFile(Path.Combine(path, "CAM1.jpg"));
Bitmap tempImg = sourceImg.Clone() as Bitmap;
tempImg = differenceFilter.Apply(tempImg);
FiltersSequence seq = new FiltersSequence();
seq.Add(Grayscale.CommonAlgorithms.BT709);
seq.Add(new OtsuThreshold());
tempImg = seq.Apply(tempImg);
tempImg.Save(Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "CAM1.jpg"));
int objectCount = 0;
BlobCounter blobCounter = new BlobCounter();
blobCounter.FilterBlobs = true;
blobCounter.MinHeight = 60;
blobCounter.MinWidth = 40;
blobCounter.ProcessImage(tempImg);
Blob[] blobs = blobCounter.GetObjectsInformation();
for (int i = 0; i < blobs.Length; i++)
{
List <IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]);
List <IntPoint> corners = null;
SimpleShapeChecker shapeChecker = new SimpleShapeChecker();
if (shapeChecker.IsQuadrilateral(edgePoints, out corners))
{
++objectCount;
}
}
Console.WriteLine("No. of BLOBS: " + blobCounter.GetObjectsInformation().Length);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
Console.Read();
}
public static void EternitySplinterDetect()
{
try
{
Bitmap bmp = Image.FromFile(PATH + @"\test.png") as Bitmap;
Bitmap newBmp = LootSystem.EternitySplinterFilter(bmp);
// locate objects using blob counter
BlobCounter blobCounter = new BlobCounter()
{
FilterBlobs = true,
MinWidth = 2,
MinHeight = 2,
MaxWidth = 28,
MaxHeight = 28
};
// Process input image
blobCounter.ProcessImage(newBmp);
// Get information about detected objects
Blob[] blobs = blobCounter.GetObjectsInformation();
// create Graphics object to draw on the image and a pen
Graphics g = Graphics.FromImage(newBmp);
Pen bluePen = new Pen(Color.Blue, 2);
// check each object and draw circle around objects, which
// are recognized as circles
for (int i = 0, n = blobs.Length; i < n; i++)
{
List <IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]);
List <IntPoint> corners = PointsCloud.FindQuadrilateralCorners(edgePoints);
g.DrawPolygon(bluePen, Helper.AForgeToPointsArray(corners));
}
bluePen.Dispose();
g.Dispose();
newBmp.Save(PATH + @"\outtest.png");
}
catch (Exception ex)
{
Debug.WriteLine(ex.StackTrace);
}
}
private Bitmap Analyse()
{
// create filter
EuclideanColorFiltering filter = new EuclideanColorFiltering();
// set center colol and radius
filter.CenterColor = new AForge.Imaging.RGB(Color.FromArgb(215, 30, 30));
filter.Radius = 100;
// apply the filter
filter.ApplyInPlace(image_analyse);
BitmapData objectsData = image_analyse.LockBits(new Rectangle(0, 0, image_analyse.Width, image_analyse.Height), ImageLockMode.ReadOnly, image_analyse.PixelFormat);
// grayscaling
UnmanagedImage grayImage = new Grayscale(0.2125, 0.7154, 0.0721).Apply(new UnmanagedImage(objectsData)); //grayscaleFilter.Apply(new UnmanagedImage(objectsData));
// unlock image
image_analyse.UnlockBits(objectsData);
BlobCounter blobCounter = new BlobCounter();
blobCounter.MinWidth = 5;
blobCounter.MinHeight = 5;
blobCounter.FilterBlobs = true;
blobCounter.ProcessImage(grayImage);
Rectangle[] rects = blobCounter.GetObjectsRectangles();
foreach (Rectangle recs in rects)
{
if (rects.Length > 0)
{
foreach (Rectangle objectRect in rects)
{
Graphics g = Graphics.FromImage(image_analyse);
using (Pen pen = new Pen(Color.FromArgb(160, 255, 160), 5))
{
g.DrawRectangle(pen, objectRect);
}
g.Dispose();
}
}
}
return(image_analyse);
}
private void vspCamaraColor_NewFrame(object sender, NewFrameEventArgs e)
{
Bitmap video = (Bitmap)e.Frame.Clone();
// Creo un vídeo clon.
Bitmap temp = video.Clone() as Bitmap;
// Creo filtro de color en el vídeo de dialogo.
EuclideanColorFiltering filter = new EuclideanColorFiltering();
// Doy valores con el cuadro de dialogo.
filter.CenterColor = new AForge.Imaging.RGB(color.R, color.G, color.B);
filter.Radius = 90;
// Aplico el filtro.
filter.ApplyInPlace(temp);
// BlobCounter es una clase que se usa para distinguir objetos, colores, etc;
BlobCounter objeto = new BlobCounter();
objeto.MinWidth = 5; // Anchura.
objeto.MinHeight = 5; // Altura.
objeto.FilterBlobs = true; // Sombras.
objeto.ObjectsOrder = ObjectsOrder.Size; // Tamaño.
objeto.ProcessImage(temp);
Rectangle[] rects = objeto.GetObjectsRectangles();
foreach (Rectangle recs in rects)
{
if (rects.Length > 0)
{
Rectangle objectRect = rects[0];
Graphics grafico = Graphics.FromImage(video);
using (Pen lapiz = new Pen(Color.FromArgb(160, 255, 160), 5))
{
grafico.DrawRectangle(lapiz, objectRect);
}
grafico.Dispose();
}
}
if (rbOriginal.Checked)
{
pbCamaraColor.Image = video;
}
else
{
pbCamaraColor.Image = temp;
}
}
private BlobCounter DetectStructures(Bitmap bmp)
{
var sw = Stopwatch.StartNew();
/* detect structures */
BlobCounter blobCounter = new BlobCounter();
blobCounter.ProcessImage(bmp);
_token.ThrowIfCancellationRequested();
sw.Stop();
Debug.Print("Time for structure detection: " + sw.Elapsed);
sw = null;
return(blobCounter);
}
private void processo2()
{
var img = (Bitmap)pictureBox1.Image.Clone();
var showImg = (Bitmap)pictureBox1.Image.Clone();
//img = Grayscale.CommonAlgorithms.Y.Apply(img);
img = new OtsuThreshold().Apply(img);
img = new Erosion().Apply(img);
img = new Invert().Apply(img);
BlobCounter bc = new BlobCounter();
bc.BackgroundThreshold = Color.Black;
bc.ProcessImage(img);
Rectangle rect = new Rectangle(0, 0, showImg.Width, showImg.Height);
BitmapData bmpData = showImg.LockBits(rect, ImageLockMode.ReadWrite, showImg.PixelFormat);
bc.GetObjectsRectangles().ToList().ForEach(i =>
{
Crop filter = new Crop(new Rectangle(i.X, i.Y, 230, 75));
var img2 = (Bitmap)filter.Apply(img);
img2 = new Invert().Apply(img2);
var ocr = new tessnet2.Tesseract();
ocr.SetVariable("tesseract_char_whitelist", "ABCDEFGHIJKLMNOPQRSTUVXWYZ-1234567890");
ocr.Init(@"tessdata", "eng", false);
var result = ocr.DoOCR(img2, Rectangle.Empty);
StringBuilder sb = new StringBuilder();
foreach (tessnet2.Word word in result)
{
sb.Append(word.Text + " ");
}
//cliente para servidor
string aux;
aux = sb.ToString();
if (aux.Length >= 6)
{
placas.Add(aux);
}
pictureBox1.Image = img2;
});
showImg.UnlockBits(bmpData);
pictureBox1.Image = img;
}
public DiffContainer GetDiffsAforge(Bitmap newFrame)
{
if (prevousFrame == null)
{
prevousFrame = UnmanagedImage.FromManagedImage(new Bitmap(@"d:\1.png"));
}
List <Bitmap> bitmaps = new List <Bitmap>();
ThresholdedDifference filter = new ThresholdedDifference(20);
filter.OverlayImage = newFrame;
var res = filter.Apply(prevousFrame);
bc.ProcessImage(res);
Rectangle[] rects = bc.GetObjectsRectangles();
foreach (Rectangle rect in rects)
{
if (rect.Width > 4 || rect.Height > 4)
{
Crop crop = new Crop(rect);
bitmaps.Add(crop.Apply(prevousFrame).ToManagedImage());
}
// Drawing.Rectangle(prevousFrame, rect, Color.Red);
}
//Parallel.ForEach(rects, rect =>
//{
// if (rect.Width > 2 && rect.Height > 2)
// {
// Crop crop = new Crop(rect);
// bitmaps.Add(crop.Apply(prevousFrame));
// }
// // Drawing.Rectangle(prevousFrame, rect, Color.Red);
//}
//);
return(new DiffContainer());// { temp = prevousFrame.ToManagedImage() };
}
public void nesnebul(Bitmap image)
{
BlobCounter blobCounter = new BlobCounter();
blobCounter.MinWidth = 2;
blobCounter.MinHeight = 2;
blobCounter.FilterBlobs = true;
blobCounter.ObjectsOrder = ObjectsOrder.Size;
Grayscale griFiltre = new Grayscale(0.2125, 0.7154, 0.0721);
Bitmap griImage = griFiltre.Apply(image);
blobCounter.ProcessImage(griImage);
Rectangle[] rects = blobCounter.GetObjectsRectangles();
pictureBox2.Image = griImage;
foreach (Rectangle recs in rects)
{
if (rects.Length > 0)
{
Rectangle objectRect = rects[0];
Graphics g = pictureBox1.CreateGraphics();
using (Pen pen = new Pen(Color.FromArgb(252, 3, 26), 2))
{
g.DrawRectangle(pen, objectRect);
}
//Cizdirilen Dikdörtgenin Koordinatlari aliniyor.
int objectX = objectRect.X + (objectRect.Width / 2);
int objectY = objectRect.Y + (objectRect.Height / 2);
g.Dispose();
Control.CheckForIllegalCrossThreadCalls = false;
if (objectX < 100)
{
serialPort1.Write("a");
}
else if (objectX > 200)
{
serialPort1.Write("b");
}
else
{
}
}
}
}
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 Bitmap DetectCircle(Bitmap image)
{
SimpleShapeChecker shapeChecker = new SimpleShapeChecker();
// locate objects using blob counter
BlobCounter blobCounter = new BlobCounter();
blobCounter.ProcessImage(image);
Blob[] blobs = blobCounter.GetObjectsInformation();
// create Graphics object to draw on the image and a pen
Graphics g = Graphics.FromImage(image);
Pen redPen = new Pen(Color.Red, 2);
// check each object and draw circle around objects, which
// are recognized as circles
for (int i = 0, n = blobs.Length; i < n; i++)
{
List <IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]);
try
{
shapeChecker.CheckShapeType(edgePoints);
}
catch (Exception)
{
continue;
}
List <IntPoint> corners;
AForge.Point center;
float radius;
if (shapeChecker.IsCircle(edgePoints, out center, out radius))
{
g.DrawEllipse(redPen,
(int)(center.X - radius),
(int)(center.Y - radius),
(int)(radius * 2),
(int)(radius * 2));
}
else if (shapeChecker.IsQuadrilateral(edgePoints, out corners))
{
g.DrawPolygon(redPen, ToPointsArray(corners));
}
}
redPen.Dispose();
g.Dispose();
return(image);
}
// 如果活动返回值，则从 CodeActivity<TResult>
// 派生并从 Execute 方法返回该值。
protected override void Execute(CodeActivityContext context)
{
// create an instance of blob counter algorithm
BlobCounterBase bc = new BlobCounter();
// set filtering options
bc.FilterBlobs = true;
bc.MinWidth = context.GetValue(最小宽度);
bc.MinHeight = context.GetValue(最小高度);
// set ordering options
bc.ObjectsOrder = ObjectsOrder.Size;
// process binary image
bc.ProcessImage(context.GetValue(处理目标));
var blobs = bc.GetObjectsInformation();
context.SetValue(输出目标, blobs);
}
//*****************************************
public void nesnebul(Bitmap image)
{
BlobCounter blobCounter = new BlobCounter();
blobCounter.MinWidth = 2;
blobCounter.MinHeight = 2;
blobCounter.FilterBlobs = true;
blobCounter.ObjectsOrder = ObjectsOrder.Size;
Grayscale griFiltre = new Grayscale(0.2125, 0.7154, 0.0721);
Bitmap griImage = griFiltre.Apply(image);
blobCounter.ProcessImage(griImage);
Rectangle[] rects = blobCounter.GetObjectsRectangles();
pictureBox2.Image = griImage;
foreach (Rectangle recs in rects)
{
if (rects.Length > 0)
{
Rectangle objectRect = rects[0];
//Graphics g = Graphics.FromImage(image);
Graphics g = pictureBox1.CreateGraphics();
using (Pen pen = new Pen(Color.FromArgb(252, 3, 26), 2))
{
g.DrawRectangle(pen, objectRect);
//Cizdirilen Dikdörtgenin Koordinatlari aliniyor.
int objectX = objectRect.X + (objectRect.Width / 2);
int objectY = objectRect.Y + (objectRect.Height / 2);
g.DrawString(objectX.ToString() + "X" + objectY.ToString(), new Font("Arial", 12), Brushes.Red, new System.Drawing.Point(250, 1));
if (serialok == true)
{
int second = 0;
int offset = 300;
second = offset - Math.Abs(objectX);
map = (float)0.85 * second;
buffer[0] = (byte)Math.Abs((int)map);
serialPort1.Write(buffer, 0, 1);
}
}
g.Dispose();
}
}
}
//Metodo che verifica se l'immagine è una pagina del libro oppure no
public Boolean VerificaLato(Bitmap immagine)
{
Blob[] blobs1;
List <Rectangle> presenzaRettangoli = new List <Rectangle>();
List <Rectangle> verificaRettangoli = new List <Rectangle>();
// Crea un istanza di un BlobCounter
BlobCounterBase bc1 = new BlobCounter();
// Un set di filtri
bc1.FilterBlobs = true;
bc1.MinWidth = 5;
bc1.MinHeight = 5;
Bitmap verifica = new Bitmap(immagine);
// Processo l'immagine
bc1.ProcessImage(verifica);
blobs1 = bc1.GetObjects(verifica, false);
// processo i blob
foreach (Blob blob in blobs1)
{
verificaRettangoli.Add(blob.Rectangle);
}
//Verifico se nell'immagine c'è un rettangolo "indicatore"
foreach (Rectangle rect in verificaRettangoli)
{
if (rect.Height < 500 / 5 && rect.Width < 500 / 2)
{
presenzaRettangoli.Add(rect);
}
}
//Se è presente n rettangolo indicatore vuol dire che l'immagine è una pagina del libro e restituisce
//vero altrimenti falso
if (presenzaRettangoli.Count == 0)
{
thisSide = false;
}
else
{
thisSide = true;
}
return(thisSide);
}
private void FinalFrame_NewFrame(object sender, NewFrameEventArgs eventArgs)
{
video = (Bitmap)eventArgs.Frame.Clone();
Bitmap video2 = (Bitmap)eventArgs.Frame.Clone();
switch (mode)
{
case 2:
g = Graphics.FromImage(video2);
g.DrawString(degisken.ToString(), new Font("Arial", 20), Brushes.Cyan, new PointF(2, 2));
g.Dispose();
break;
case 1:
ColorFiltering colorFilter = new ColorFiltering();
colorFilter.Red = new IntRange(red, (int)numericUpDownRed.Value);
colorFilter.Green = new IntRange(green, (int)numericUpDownGreen.Value);
colorFilter.Blue = new IntRange(blue, (int)numericUpDownBlue.Value);
colorFilter.ApplyInPlace(video2);
BlobCounter blobCounter = new BlobCounter();
blobCounter.MinHeight = 20;
blobCounter.MinWidth = 20;
blobCounter.ObjectsOrder = ObjectsOrder.Size;
blobCounter.ProcessImage(video2);
Rectangle[] rect = blobCounter.GetObjectsRectangles();
if (rect.Length > 0)
{
Rectangle objectt = rect[0];
Graphics graph = Graphics.FromImage(video2);
using (Pen pen = new Pen(Color.White, 3))
{
graph.DrawRectangle(pen, objectt);
}
graph.Dispose();
}
pictureBox2.Image = video2;
break;
}
pictureBox1.Image = video;
//pictureBox1.Image = (Bitmap)eventArgs.Frame.Clone();
}
public Rectangle mostInterestingArea(System.Drawing.Image img)
{
Bitmap bitmap = new Bitmap(img);
BlobCounter bc = new BlobCounter();
bc.ProcessImage(bitmap);
Rectangle[] objs = bc.GetObjectsRectangles();
Point center = getAverageRectangleCenter(objs);
Rectangle rect = getBoundContainingSDCenters(1, objs, center);
bitmap.Dispose();
return(rect);
}
private void kullanilacakcihaz_NewFrame(object sender, NewFrameEventArgs eventArgs)
{
video = (Bitmap)eventArgs.Frame.Clone();
Bitmap video2 = (Bitmap)eventArgs.Frame.Clone();
switch (mode)
{
case 1:
{
//
ColorFiltering colorfiller = new ColorFiltering();
colorfiller.Red = new IntRange(Red, (int)numericUpDown1.Value);
colorfiller.Green = new IntRange(Green, (int)numericUpDown2.Value);
colorfiller.Blue = new IntRange(Blue, (int)numericUpDown3.Value);
colorfiller.ApplyInPlace(video2);
//
BlobCounter blobcounter = new BlobCounter();
blobcounter.MinHeight = 20;
blobcounter.MinWidth = 20;
blobcounter.ObjectsOrder = ObjectsOrder.Size;
blobcounter.ProcessImage(video2);
Rectangle[] rect = blobcounter.GetObjectsRectangles();
if (rect.Length > 0)
{
Rectangle objec = rect[0];
Graphics graphic = Graphics.FromImage(video2);
using (Pen pen = new Pen(Color.White, 3))
{
graphic.DrawRectangle(pen, objec);
g = Graphics.FromImage(video);
g.DrawRectangle(pen, objec);
objectX = objec.X + (objec.Width / 2);
objectY = objec.Y + (objec.Height / 2);
g.DrawString(objectX.ToString() + "X" + objectY.ToString(), new Font("Arial", 12), Brushes.Red, new System.Drawing.Point(1, 1));
g.Dispose();
}
graphic.Dispose();
}
}
break;
}
pictureBox1.Image = video;
}
public Bitmap extractBlobs(Bitmap originalImage, Bitmap alteredImage)
{
extractor.ProcessImage(alteredImage);
foreach (Blob blob in extractor.GetObjectsInformation())
{
List <IntPoint> edgePoints = extractor.GetBlobsEdgePoints(blob);
List <IntPoint> corners = PointsCloud.FindQuadrilateralCorners(edgePoints);
if (draw2D)
{
using (var graphics = Graphics.FromImage(originalImage))
{
if (corners.Count == 4)
{
graphics.DrawLine(pen, corners[0].X, corners[0].Y, corners[1].X, corners[1].Y);
graphics.DrawLine(pen, corners[1].X, corners[1].Y, corners[2].X, corners[2].Y);
graphics.DrawLine(pen, corners[2].X, corners[2].Y, corners[3].X, corners[3].Y);
graphics.DrawLine(pen, corners[3].X, corners[3].Y, corners[0].X, corners[0].Y);
if (draw3D)
{
//Reken de afstand tussen de eerste twee hoekpunten uit
double Distance = Math.Sqrt((corners[3].X - corners[0].X) * (corners[3].X - corners[0].X) + (corners[3].Y - corners[0].Y) * (corners[3].Y - corners[0].Y));
//Convert naar integer
int IDistance = Convert.ToInt32(Distance);
//Teken alle verticale lijnen van de kubus
graphics.DrawLine(pen, corners[0].X, corners[0].Y, corners[0].X, corners[0].Y - IDistance);
graphics.DrawLine(pen, corners[1].X, corners[1].Y, corners[1].X, corners[1].Y - IDistance);
graphics.DrawLine(pen, corners[2].X, corners[2].Y, corners[2].X, corners[2].Y - IDistance);
graphics.DrawLine(pen, corners[3].X, corners[3].Y, corners[3].X, corners[3].Y - IDistance);
//Teken het bovenste vierkant van de kubub
graphics.DrawLine(pen, corners[0].X, corners[0].Y - IDistance, corners[1].X, corners[1].Y - IDistance);
graphics.DrawLine(pen, corners[1].X, corners[1].Y - IDistance, corners[2].X, corners[2].Y - IDistance);
graphics.DrawLine(pen, corners[2].X, corners[2].Y - IDistance, corners[3].X, corners[3].Y - IDistance);
graphics.DrawLine(pen, corners[3].X, corners[3].Y - IDistance, corners[0].X, corners[0].Y - IDistance);
}
}
}
}
}
return(originalImage);
}
/// <summary>
/// Processes the specified SRC image.
/// </summary>
/// <param name="srcImage">The SRC image.</param>
/// <remarks></remarks>
public void Process(Bitmap srcImage)
{
if (srcImage == null || srcImage.Width < 10 || srcImage.Height < 10)
{
return;
}
resize.NewWidth = srcImage.Width / Scale;
resize.NewHeight = srcImage.Height / Scale;
FilteredBoard = resize.Apply(srcImage);
if (Enhance)
{
ImageFilters.FlattenLighting(FilteredBoard);
}
ImageFilters.HSLFilter(FilteredBoard, targetHue, targetSat, targetBri, hueTol, satTol, briTol);
median.ApplyInPlace(FilteredBoard);
GaussianBlur blr = new GaussianBlur(2, 2);
blr.ApplyInPlace(FilteredBoard);
TileBlobs.Clear();
try
{
BlobCounter.ProcessImage(FilteredBoard);
Blob[] blobs = BlobCounter.GetObjectsInformation();
TileBlobs.Clear();
foreach (Blob b in blobs)
{
if (b.Area < 10)
{
continue;
}
TileBlobs.Add(b);
}
}
catch { }
}
/// <summary>
/// APPLY FILTER TO IMAGE
/// </summary>
/// <param name="bgSelect">TRUE, SET BACKGROUND FILTER. FALSE, SET COLONY FILTER</param>
/// <returns></returns>
private List <ColonyModel> ProcessIMG(bool bgSelect)
{
if (bgSelect)
{
// SET FILTER WITH BG COLOR
FilterImgBgSelect();
}
else
{
// SET FILTER WITH COLONY COLOR
FilterImgColonySelect();
}
// INIT BLOB COUNTER
SetBlobCounter();
blobCounter.ProcessImage(bitmapData);
BlobCounterToList(blobCounter.GetObjectsInformation());
bitmap.UnlockBits(bitmapData);
// SET DISTORTION
shapeChecker.MinAcceptableDistortion = 0.2f;
shapeChecker.RelativeDistortionLimit = 0.2f;
var cellLijst = new List <ColonyModel>();
// DRAW CIRCLE AROUND BLOB
for (int i = 0, n = blobList.Count; i < n; i++)
{
List <IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blobList[i]);
AForge.Point center;
float radius;
// IF SHAPE IS CIRCLE
if (shapeChecker.IsCircle(edgePoints, out center, out radius))
{
// ADD COLONY TO LIST
cellLijst.Add(new ColonyModel(center, radius));
}
}
this.blobList.Clear();
return(cellLijst);
}
//ilk önce bu butona tıklanmalı
private void button1_Click(object sender, EventArgs e)
{
sayac = 1;
kaynakResim = (Bitmap)System.Drawing.Image.FromFile("sample2.jpg");
//Otsu Threshold uygulandı
OtsuThreshold otsuFiltre = new OtsuThreshold();
//resim eğer renkliyse önce griye çeviriyor sonra filtre uyguluyor
//resim zaten griyse direk filtreyi uyguluyor
siyahBeyazResim = otsuFiltre.Apply(kaynakResim.PixelFormat != PixelFormat.Format8bppIndexed ? Grayscale.CommonAlgorithms.BT709.Apply(kaynakResim) : kaynakResim);
BlobCounterBase bc = new BlobCounter();
bc.FilterBlobs = true;
bc.MinHeight = 5;
bc.MinWidth = 5;
bc.ProcessImage(siyahBeyazResim);
blobs = bc.GetObjectsInformation();
label2.Text = "Toplam Şekil Sayısı = " + bc.ObjectsCount.ToString();
toplamSekilSayisi = bc.ObjectsCount;
/*aşağıdaki for döngüsü yerine buradaki koşul ifadesi kullanısaydı eğer,
* resimdeki en büyük şekil bulunacaktı.
* if (blobs.Length > 0)
* {
* bc.ExtractBlobsImage(siyahBeyazResim, blobs[0], true);
* }
* Bitmap xxx = blobs[0].Image.ToManagedImage();
*/
//bütün şekiller bulunuyor
for (int i = 0, n = blobs.Length; i < n; i++)
{
if (blobs.Length > 0)
{
bc.ExtractBlobsImage(siyahBeyazResim, blobs[i], true);
pictureBox1.Image = siyahBeyazResim;
pictureBox1.Refresh();
}
}
}
public bool BallTracking(System.Drawing.Image newFrame)
{
if (newFrame == null)
{
return(false);
}
Bitmap cleanImage = (Bitmap)newFrame.Clone();
Bitmap trackingImage = (Bitmap)newFrame.Clone();
_hslFilter.ApplyInPlace(trackingImage);
//_jitterFilter.ApplyInPlace(trackingImage);
//_contrastFilter.ApplyInPlace(trackingImage);
_blobFilter.ApplyInPlace(trackingImage);
_blobCounter.ProcessImage(trackingImage);
_rectangles = _blobCounter.GetObjectsRectangles();
if (DrawBoxes)
{
using (Pen pen = new Pen(Color.Red, 2))
using (Graphics t = Graphics.FromImage(trackingImage))
using (Graphics c = Graphics.FromImage(cleanImage))
{
foreach (Rectangle rect in _rectangles)
{
t.DrawRectangle(pen, rect);
c.DrawRectangle(pen, rect);
}
}
}
_colorImage = cleanImage;
_trackingImage = trackingImage;
if (NewCameraImage != null)
{
NewCameraImage(this, new EventArgs());
}
return(true);
}
//Generate Markers 1 End
//Depth camera feed generator END Sensor 1
//Blob Counter Start
public Blob[] blobcounter(BitmapSource bsource)
{
Bitmap b = BitmapFromSource(bsource);
BlobCounter BCounter = new BlobCounter();
ColorFiltering FilterObjects = new ColorFiltering();
BCounter.FilterBlobs = true;
BCounter.MinWidth = 50;
BCounter.MinHeight = 150;
BCounter.ProcessImage(b);
Blob[] detectedblobs = BCounter.GetObjectsInformation();
return(detectedblobs);
}
public void GetDisplayCornerfrombmp(Bitmap processbmp, out List <IntPoint> displaycornerPoints)
{
BlobCounter bbc = new BlobCounter();
bbc.FilterBlobs = true;
bbc.MinHeight = 5;
bbc.MinWidth = 5;
bbc.ProcessImage(processbmp);
Blob[] blobs = bbc.GetObjectsInformation();
SimpleShapeChecker shapeChecker = new SimpleShapeChecker();
foreach (var blob in blobs)
{
List <IntPoint> edgePoints = bbc.GetBlobsEdgePoints(blob);
List <IntPoint> cornerPoints;
// use the shape checker to extract the corner points
if (shapeChecker.IsQuadrilateral(edgePoints, out cornerPoints))
{
// only do things if the corners from a rectangle
if (shapeChecker.CheckPolygonSubType(cornerPoints) == PolygonSubType.Rectangle)
{
flagPoints = cornerPoints;
continue;
}
else
{
flagPoints = null;
continue;
}
}
}
if (flagPoints == null)
{
throw new Exception();
}
// MessageBox.Show("Cannot Find the Display");
displaycornerPoints = flagPoints;
}
private void button6_Click(object sender, EventArgs e)
{
Bitmap image = (Bitmap)pictureBox5.Image;
// create instance of blob counter
BlobCounter blobCounter = new BlobCounter();
blobCounter.FilterBlobs = true;
blobCounter.MinHeight = 5;
blobCounter.MinWidth = 5;
blobCounter.MaxWidth = 350;
blobCounter.MaxHeight = 350;
//process the dilated image
blobCounter.ProcessImage(image);
// get info about detected objects
Blob[] blobs = blobCounter.GetObjectsInformation();
// create a graphics object to draw on the image and a pen
Graphics g = Graphics.FromImage(image);
Pen Redpen = new Pen(Color.Red, 4);
SimpleShapeChecker shapechecker = new SimpleShapeChecker();
//check in image and draw around the object found as rectangle
for (int i = 0, n = blobs.Length; i < n; i++)
{
List <IntPoint> edgepoints = blobCounter.GetBlobsEdgePoints(blobs[i]);
List <IntPoint> cornerpoints;
Bitmap bmpCrop;
List <Point> Points = new List <Point>();
if (shapechecker.IsQuadrilateral(edgepoints, out cornerpoints))
{
if (shapechecker.CheckPolygonSubType(cornerpoints) == PolygonSubType.Rectangle)
{
g.DrawPolygon(Redpen, cornerpoints.Select(p => new System.Drawing.Point(p.X, p.Y)).ToArray());
}
}
}
Redpen.Dispose();
g.Dispose();
pictureBox6.Image = image;
}
/// <summary>
/// Process the filter on the specified image.
/// </summary>
///
/// <param name="image">Source image data.</param>
///
protected override unsafe void ProcessFilter( UnmanagedImage image )
{
int width = image.Width;
int height = image.Height;
// 1 - invert the source image
Invert invertFilter = new Invert( );
UnmanagedImage invertedImage = invertFilter.Apply( image );
// 2 - use blob counter to find holes (they are white objects now on the inverted image)
BlobCounter blobCounter = new BlobCounter( );
blobCounter.ProcessImage( invertedImage );
Blob[] blobs = blobCounter.GetObjectsInformation( );
// 3 - check all blobs and determine which should be filtered
byte[] newObjectColors = new byte[blobs.Length + 1];
newObjectColors[0] = 255; // don't touch the objects, which have 0 ID
for ( int i = 0, n = blobs.Length; i < n; i++ )
{
Blob blob = blobs[i];
if ( ( blob.Rectangle.Left == 0 ) || ( blob.Rectangle.Top == 0 ) ||
( blob.Rectangle.Right == width ) || ( blob.Rectangle.Bottom == height ) )
{
newObjectColors[blob.ID] = 0;
}
else
{
if ( ( ( coupledSizeFiltering ) && ( blob.Rectangle.Width <= maxHoleWidth ) && ( blob.Rectangle.Height <= maxHoleHeight ) ) |
( ( !coupledSizeFiltering ) && ( ( blob.Rectangle.Width <= maxHoleWidth ) || ( blob.Rectangle.Height <= maxHoleHeight ) ) ) )
{
newObjectColors[blob.ID] = 255;
}
else
{
newObjectColors[blob.ID] = 0;
}
}
}
// 4 - process the source image image and fill holes
byte* ptr = (byte*) image.ImageData.ToPointer( );
int offset = image.Stride - width;
int[] objectLabels = blobCounter.ObjectLabels;
for ( int y = 0, i = 0; y < height; y++ )
{
for ( int x = 0; x < width; x++, i++, ptr++ )
{
*ptr = newObjectColors[objectLabels[i]];
}
ptr += offset;
}
}