private bool IsLicensePlate(Bitmap plate)
{
invert.ApplyInPlace(plate);
plateBlobsFiltering.ApplyInPlace(plate);
plateBlobCounter.ProcessImage(plate);
Blob[] blobs = plateBlobCounter.GetObjectsInformation();
int chars = blobs.Length;
return(5 <= chars && chars <= 9);
}
//-------------------------------------------------------------
private void process_imginput(Bitmap img, String Plate_Type)
{
//grayscale
IFilter way_filt;//= new GrayscaleY();
//process_image = way_filt.Apply(img);
//resize
if (Plate_Type == "1hang")
{
way_filt = new ResizeBilinear(600, 120); //bien 1 hang
}
else
{
way_filt = new ResizeBilinear(300, 200); //bien 2 hang
}
process_image = way_filt.Apply(img);
//process_image = get_plate(process_image, 10, 210, 30, 330);
input_image = way_filt.Apply(input_image);
p = process_image;
//threshold
way_filt = new Threshold(125);
process_image = way_filt.Apply(process_image);
//K-means
process_image = kmean(process_image);
//invert
way_filt = new Invert();
process_image = way_filt.Apply(process_image);
//liembt
//UCM
way_filt = new Median();
process_image = way_filt.Apply(process_image);
//way_filt = new AdaptiveSmooth();
//process_image = way_filt.Apply(process_image);
//end liembt
//filter k
BlobsFiltering filter = new BlobsFiltering();
filter.MinHeight = 25;//50
filter.MinWidth = 10;
filter.MaxHeight = 100;
filter.ApplyInPlace(process_image);
//p = process_image;
input_width = process_image.Width;
input_height = process_image.Height;
}
private void filterBlobs()
// Filter blobs
{
// Delare image
Bitmap bmp = new Bitmap(pictureBox1.Image);
// create filter
BlobsFiltering filter = new BlobsFiltering();
// configure filter
filter.CoupledSizeFiltering = true;
filter.MinWidth = 70;
filter.MinHeight = 70;
// apply the filter
filter.ApplyInPlace(bmp);
pictureBox1.Image = bmp;
}
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);
}
private void kullanilacakcihaz_NewFrame(object sender, NewFrameEventArgs eventArgs)
{
Bitmap image = (Bitmap)eventArgs.Frame.Clone();
Bitmap image1 = (Bitmap)eventArgs.Frame.Clone();
image = new Mirror(false, true).Apply(image);
görüntü_box.Image = image;
EuclideanColorFiltering filter = new EuclideanColorFiltering();
filter.CenterColor = new RGB(Color.FromArgb(red, green, blue)); // Algılanacak Renk ve merkez noktası bulunur.
filter.Radius = 80;
filter.ApplyInPlace(image1); //Filitre Çalıştırılır.
cevreal(image1); // Algilanan rengi Çevrçevelemek veya hedeflemek için gerekli Method.
BlobsFiltering filter2 = new BlobsFiltering( ); // Belirli Piksel Altındaki Görüntüler Alınmadı.
filter2.CoupledSizeFiltering = true;
filter2.MinWidth = 100;
filter2.MinHeight = 60;
filter2.ApplyInPlace(image1);
image1 = new Mirror(false, true).Apply(image1);
pictureBox2.Image = image1;
}
public static List <Bitmap> CutImages(Bitmap bitmap, Action <Bitmap> act = null)
{
Bitmap sourceBitmap = bitmap;
Bitmap targetBitmap = (Bitmap)sourceBitmap.Clone();
if (!AForge.Imaging.Image.IsGrayscale(targetBitmap))
{
targetBitmap = AForge.Imaging.Image.Clone(targetBitmap, PixelFormat.Format24bppRgb);
targetBitmap = Grayscale.CommonAlgorithms.BT709.Apply(targetBitmap);
}
if (act == null)
{
targetBitmap = new Threshold(50).Apply(targetBitmap);
Invert filter = new Invert();
filter.ApplyInPlace(targetBitmap);
BlobsFiltering bolbsfilter = new BlobsFiltering();
bolbsfilter.CoupledSizeFiltering = true;
bolbsfilter.MinWidth = 4;
bolbsfilter.MinHeight = 4;
bolbsfilter.ApplyInPlace(targetBitmap);
Closing binary = new Closing();
targetBitmap = binary.Apply(targetBitmap);
filter.ApplyInPlace(targetBitmap);
}
else
{
act(targetBitmap);
}
var bit1 = Crop_Y(targetBitmap);
var bit2 = Crop_X(bit1);
return(ToResizeAndCenterIt(bit2));
}
public void GetBlobs3(string inputFile, string outputPath)
{
UnmanagedImage skewedImg = null;
{
var bmp = new Bitmap(inputFile);
var img = UnmanagedImage.FromManagedImage(bmp);
var grayImg = Accord.Imaging.Filters.Grayscale.CommonAlgorithms.BT709.Apply(img);
var bwImg = new Accord.Imaging.Filters.OtsuThreshold().Apply(grayImg);
var skewChecker = new DocumentSkewChecker();
double angle = skewChecker.GetSkewAngle(bwImg);
var rotateFilter = new Accord.Imaging.Filters.RotateBilinear(-angle);
skewedImg = rotateFilter.Apply(img);
bwImg.Dispose();
grayImg.Dispose();
img.Dispose();
bmp.Dispose();
}
// create filter
BlobsFiltering filter = new BlobsFiltering();
// configure filter
filter.CoupledSizeFiltering = true;
filter.MinHeight = 200; // 1" @ 200 DPI
filter.MinWidth = 200; // 1" @ 200 DPI
// apply the filter
filter.ApplyInPlace(skewedImg);
// save output file
Bitmap finalImg = skewedImg.ToManagedImage();
skewedImg.Dispose();
System.IO.File.Delete(outputPath);
finalImg.Save(outputPath);
finalImg.Dispose();
}
/// <summary>
/// Detects and recognizes cards from source image
/// </summary>
/// <param name="source">Source image to be scanned</param>
/// <returns>Recognized Cards</returns>
public List <Card> Recognize(Bitmap source)
{
List <Card> collection = new List <Card>();
Bitmap temp = source.Clone(source.PixelFormat) as Bitmap; //Clone image to keep original image
FiltersSequence seq = new FiltersSequence();
seq.Add(Grayscale.CommonAlgorithms.BT709); //First add grayScaling filter
seq.Add(new OtsuThreshold()); //Then add binarization(thresholding) filter
temp = seq.Apply(source); // Apply filters on source image
//Extract blobs from image whose size width and height larger than 150
BlobCounter extractor = new BlobCounter();
extractor.FilterBlobs = true;
extractor.MinWidth = extractor.MinHeight = 150;
extractor.MaxWidth = extractor.MaxHeight = 350;
extractor.ProcessImage(temp);
//Will be used transform(extract) cards on source image
QuadrilateralTransformation quadTransformer = new QuadrilateralTransformation();
//Will be used resize(scaling) cards
ResizeBilinear resizer = new ResizeBilinear(CardWidth, CardHeight);
foreach (Blob blob in extractor.GetObjectsInformation())
{
//Get Edge points of card
List <IntPoint> edgePoints = extractor.GetBlobsEdgePoints(blob);
//Calculate/Find corners of card on source image from edge points
List <IntPoint> corners = PointsCloud.FindQuadrilateralCorners(edgePoints);
quadTransformer.SourceQuadrilateral = corners; //Set corners for transforming card
quadTransformer.AutomaticSizeCalculaton = true;
Bitmap cardImg = quadTransformer.Apply(source); //Extract(transform) card image
if (cardImg.Width > cardImg.Height) //If card is positioned horizontally
{
WriteableBitmap wbmp = (WriteableBitmap)cardImg;
wbmp = wbmp.Rotate(90);
cardImg = (Bitmap)wbmp; //Rotate
}
cardImg = resizer.Apply(cardImg); //Normalize card size
Card card = new Card(cardImg, corners.ToArray()); //Create Card Object
char color = ScanColor(card.GetTopLeftPart()); //Scan color
bool faceCard = IsFaceCard(cardImg); //Determine type of card(face or not)
if (!faceCard)
{
card.Suit = ScanSuit(cardImg, color); //Scan Suit of non-face card
card.Rank = ScanRank(cardImg); //Scan Rank of non-face card
}
else
{
Bitmap topLeft = card.GetTopLeftPart();
seq = null;
seq = new FiltersSequence();
seq.Add(Grayscale.CommonAlgorithms.BT709);
seq.Add(new BradleyLocalThresholding());
topLeft = seq.Apply(topLeft);
BlobsFiltering bFilter = new BlobsFiltering(5, 5, 150, 150);
bFilter.ApplyInPlace(topLeft); //Filter blobs that can not be a suit
//topLeft.Save("topleft.bmp", ImageFormat.Bmp);
card.Suit = ScanFaceSuit(topLeft, color); //Scan suit of face card
card.Rank = ScanFaceRank(topLeft); //Scan rank of face card
}
collection.Add(card); //Add card to collection
}
return(collection);
}
public int SetImage(Bitmap image)
{
leftEdges.Clear();
rightEdges.Clear();
topEdges.Clear();
bottomEdges.Clear();
hulls.Clear();
quadrilaterals.Clear();
selectedBlobID = 0;
Bitmap imageclone = AForge.Imaging.Image.Clone(image, image.PixelFormat);
// create filter
Median filterMedian = new Median();
// apply the filter
// create filter
Threshold filterThreshold = new Threshold(250);
// configure filter
// create filter
BlobsFiltering filterBlobsFiltering = new BlobsFiltering();
filterBlobsFiltering.CoupledSizeFiltering = false;
filterBlobsFiltering.MinWidth = 6; //7
filterBlobsFiltering.MinHeight = 6; //7
filterBlobsFiltering.MaxWidth = 8; //8
filterBlobsFiltering.MaxHeight = 8; //8
// apply the filter
filterThreshold.ApplyInPlace(imageclone);
filterBlobsFiltering.ApplyInPlace(imageclone);
filterMedian.ApplyInPlace(imageclone);
//this.image = AForge.Imaging.Image.Clone( image, PixelFormat.Format16bppGrayScale );
//imageclone = AForge.Imaging.Image.Clone(image);
imageWidth = imageclone.Width;
imageHeight = imageclone.Height;
blobCounter.ProcessImage(imageclone);
blobs = blobCounter.GetObjectsInformation();
center = new List <AForge.Point>();
GrahamConvexHull grahamScan = new GrahamConvexHull();
foreach (Blob blob in blobs)
{
List <IntPoint> leftEdge = new List <IntPoint>();
List <IntPoint> rightEdge = new List <IntPoint>();
List <IntPoint> topEdge = new List <IntPoint>();
List <IntPoint> bottomEdge = new List <IntPoint>();
// collect edge points
blobCounter.GetBlobsLeftAndRightEdges(blob, out leftEdge, out rightEdge);
blobCounter.GetBlobsTopAndBottomEdges(blob, out topEdge, out bottomEdge);
AForge.Point centering = blob.CenterOfGravity;
leftEdges.Add(blob.ID, leftEdge);
rightEdges.Add(blob.ID, rightEdge);
topEdges.Add(blob.ID, topEdge);
bottomEdges.Add(blob.ID, bottomEdge);
// find convex hull
List <IntPoint> edgePoints = new List <IntPoint>();
edgePoints.AddRange(leftEdge);
edgePoints.AddRange(rightEdge);
List <IntPoint> hull = grahamScan.FindHull(edgePoints);
hulls.Add(blob.ID, hull);
List <IntPoint> quadrilateral = null;
// List array center of gravity
center.Add(centering);
// find quadrilateral //
if (hull.Count < 4)
{
quadrilateral = new List <IntPoint>(hull);
}
else
{
quadrilateral = PointsCloud.FindQuadrilateralCorners(hull);
}
quadrilaterals.Add(blob.ID, quadrilateral);
// shift all points for vizualization
IntPoint shift = new IntPoint(1, 1);
PointsCloud.Shift(leftEdge, shift);
PointsCloud.Shift(rightEdge, shift);
PointsCloud.Shift(topEdge, shift);
PointsCloud.Shift(bottomEdge, shift);
PointsCloud.Shift(hull, shift);
PointsCloud.Shift(quadrilateral, shift);
}
double xhair = imageWidth / 2;
double yhair = imageHeight / 2;
if (image.PixelFormat != PixelFormat.Format24bppRgb)
{
//filterBlobX(516.0, 670.0);
//filterBlobY(360.0, 520.0);
filterBlobX(516.0, 1117.0);
filterBlobY(357.0, 460.0);
refPointList = new List <AForge.Point>();
//findRef(388.0, 0.5);
findRef(20.0, 1.5);//
findPick(refPoint.X, refPoint.Y);
}
//UpdatePosition();
//Invalidate();
//if (!Directory.Exists(path))
//{
// System.IO.Directory.CreateDirectory(path);
//}
////file = path + DateTime.Now.ToString(datePatt);
file = path + "visimg.bmp";
imageclone.Save(file);
if (blobs.Length > 0)
{
return(blobs.Length);
}
else
{
return(0);
}
}
public void test_creditcardcover()
{
try
{
const string FILE1 = @"C:\IMAGES\PB\PB742030.jpg";
const string FILE2 = @"C:\IMAGES\PB\PB742030_done2.jpg";
const string FILE3 = @"C:\IMAGES\PB\PB742030_done3.jpg";
const string FILE4 = @"C:\IMAGES\PB\PB742030_done4.jpg";
//using (var image = (Bitmap)Bitmap.FromFile(FILE1))
//{
// //Invert filter = new Invert();
// //filter.ApplyInPlace(image);
// using (var img = image.ConvertToBitonal())
// {
// img.Save(FILE2, ImageFormat.Jpeg);
// }
//}
using (var image = (Bitmap)Bitmap.FromFile(FILE1))
{
EuclideanColorFiltering filter = new EuclideanColorFiltering();
filter.CenterColor = new AForge.Imaging.RGB(Color.BlueViolet); //Pure White
filter.Radius = 0; //Increase this to allow off-whites
filter.FillColor = new AForge.Imaging.RGB(Color.Red); //Replacement Colour
filter.ApplyInPlace(image);
}
return;
//To gray scale
using (var image = (Bitmap)Bitmap.FromFile(FILE1))
{
FiltersSequence seq = new FiltersSequence();
seq.Add(Grayscale.CommonAlgorithms.BT709); //First add GrayScaling filter
seq.Add(new OtsuThreshold()); //Then add binarization(thresholding) filter
var img = seq.Apply(image); // Apply filters on source image
img.Save(FILE2, ImageFormat.Jpeg);
return;
}
using (var image = (Bitmap)Bitmap.FromFile(FILE1))
{
Grayscale filter = new Grayscale(0.2125, 0.7154, 0.0721);
// apply the filter
using (Bitmap grayImage = filter.Apply(image))
{
VerticalIntensityStatistics vis = new VerticalIntensityStatistics(grayImage);
// get gray histogram (for grayscale image)
var histogram = vis.Gray;
// output some histogram's information
System.Diagnostics.Debug.WriteLine("Mean = " + histogram.Mean);
System.Diagnostics.Debug.WriteLine("Min = " + histogram.Min);
System.Diagnostics.Debug.WriteLine("Max = " + histogram.Max);
}
}
using (var image = (Bitmap)Bitmap.FromFile(FILE2))
{
VerticalIntensityStatistics vis = new VerticalIntensityStatistics(image);
// get gray histogram (for grayscale image)
var histogram = vis.Gray;
// output some histogram's information
System.Diagnostics.Debug.WriteLine("Mean = " + histogram.Mean);
System.Diagnostics.Debug.WriteLine("Min = " + histogram.Min);
System.Diagnostics.Debug.WriteLine("Max = " + histogram.Max);
}
//using (var image = (Bitmap)Bitmap.FromFile(FILE2))
//{
// //EuclideanColorFiltering filter = new EuclideanColorFiltering();
// //// set center colol and radius
// //filter.CenterColor = new RGB(82, 26, 39);
// //filter.Radius = 100;
// //// apply the filter
// //filter.ApplyInPlace(image);
// Median filter2 = new Median();
// // apply the filter
// filter2.ApplyInPlace(image);
// image.Save(FILE3, ImageFormat.Jpeg);
//}
using (var image = (Bitmap)Bitmap.FromFile(FILE2))
{
//Median filter2 = new Median();
//// apply the filter
//filter2.ApplyInPlace(image);
//ConservativeSmoothing filter = new ConservativeSmoothing();
//filter.ApplyInPlace(image);
//BilateralSmoothing filter = new BilateralSmoothing();
//filter.KernelSize = 25;
//filter.SpatialFactor = 10;
//filter.ColorFactor = 60;
//filter.ColorPower = 0.5;
//// apply the filter
//filter.ApplyInPlace(image);
///////////////////////////////////////////
// create filter
BlobsFiltering filter3 = new BlobsFiltering();
// configure filter
//filter.CoupledSizeFiltering = true;
filter3.MinWidth = 20;
filter3.MinHeight = 20;
filter3.MaxWidth = 150;
filter3.MaxHeight = 150;
filter3.ApplyInPlace(image); //apply the filter
////////////////////////////
//ExtractBiggestBlob filter = new ExtractBiggestBlob();
//// apply the filter
//Bitmap biggestBlobsImage = filter.Apply(image);
image.Save(FILE3, ImageFormat.Jpeg);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
}
/// <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 frame)
{
if (previousFrame != null)
{
// find the thresholded euclidian difference between two subsequent frames
ThresholdedEuclideanDifference threshold = new ThresholdedEuclideanDifference(40);
threshold.OverlayImage = previousFrame;
var difference = threshold.Apply(frame);
// only keep big blobs
var filter = new BlobsFiltering();
filter.CoupledSizeFiltering = true;
filter.MinHeight = 50;
filter.MinWidth = 50;
filter.ApplyInPlace(difference);
// dilate remaining blobs
var dilate = new BinaryDilation3x3();
dilate.ApplyInPlace(difference);
dilate.ApplyInPlace(difference);
dilate.ApplyInPlace(difference);
dilate.ApplyInPlace(difference);
// put this image in the thresholded picturebox
thresholdedBox.Image = difference.Clone() as Bitmap;
// use this as a mask for the current frame
var mask = new ApplyMask(difference);
var maskedFrame = mask.Apply(frame);
// put this image in the masked picturebox
maskedBox.Image = maskedFrame.Clone() as Bitmap;
// now find all moving blobs
if (frameIndex % 10 == 0)
{
var counter = new BlobCounter();
counter.ProcessImage(difference);
// only keep blobs that:
// - do not overlap with known cars
// - do not overlap with other blobs
// - have crossed the middle of the frame
// - are at least 100 pixels tall
var blobs = counter.GetObjectsRectangles();
var newBlobs = from r in counter.GetObjectsRectangles()
where !trackers.Any(t => t.Tracker.TrackingObject.Rectangle.IntersectsWith(r)) &&
!blobs.Any(b => b.IntersectsWith(r) && b != r) &&
r.Top >= 240 && r.Bottom <= 480 &&
r.Height >= 100
select r;
// set up new camshift trackers for each detected blob
foreach (var rect in newBlobs)
{
trackers.Add(new TrackerType(rect, frameIndex, ++carIndex));
}
}
// now kill all car trackers that have expanded by too much
trackers.RemoveAll(t => t.Tracker.TrackingObject.Rectangle.Height > 360);
// and kill all trackers that have lived for 30 frames
trackers.RemoveAll(t => frameIndex - t.StartIndex > 30);
// let all remaining trackers process the current frame
var img = UnmanagedImage.FromManagedImage(maskedFrame);
trackers
.ForEach(t => t.Tracker.ProcessFrame(img));
// remember this frame for next iteration
previousFrame.Dispose();
previousFrame = frame.Clone() as Bitmap;
// draw labels on all tracked cars
var outputFrame = frame.Clone() as Bitmap;
trackers
.FindAll(t => !t.Tracker.TrackingObject.IsEmpty)
.ForEach(t => DrawCarLabel(outputFrame, t.Tracker.TrackingObject.Rectangle, t.CarNumber));
// return the processed frame to the video
frame = outputFrame;
}
// or else just remember this frame for next iteration
else
{
previousFrame = frame.Clone() as Bitmap;
}
frameIndex++;
}
/*---correction preview---*/
private UnmanagedImage previewCorrection(int imgID)
{
orginalImage = UnmanagedImage.FromManagedImage((Bitmap)System.Drawing.Image.FromFile(examImages[imgID]));
grayImage = UnmanagedImage.Create(orginalImage.Width, orginalImage.Height, PixelFormat.Format8bppIndexed);
//bright into gray
Grayscale.CommonAlgorithms.BT709.Apply(brightnessFilter.Apply(orginalImage), grayImage);
//invert
invertFilter.ApplyInPlace(grayImage);
// create rotation filter
RotateBilinear rotationFilter = new RotateBilinear(-skewChecker.GetSkewAngle(grayImage));
rotationFilter.FillColor = Color.Black;
//rotationFilter.KeepSize = true;
// rotate filter
grayImage = rotationFilter.Apply(grayImage);
//smooth
smoothFilter.ApplyInPlace(grayImage);
//threshold
thresholdFilter.ApplyInPlace(grayImage);
//size filter
blobFilter.CoupledSizeFiltering = true;
blobFilter.MinWidth = minBlobWidth;
blobFilter.MinHeight = minBlobHeight;
blobFilter.ApplyInPlace(grayImage);
//shape filter
blobCounter.ProcessImage(grayImage);
Blob[] blobs = blobCounter.GetObjectsInformation();
circleBlobs = new List <Blob>();
int anchorLeft = 0;
int anchorRight = 0;
Bitmap detactFilter = new Bitmap(grayImage.ToManagedImage());
Graphics graphics = Graphics.FromImage(detactFilter);
List <IntPoint> edgePoints;
AForge.Point center;
float radius;
for (int i = 0; i < blobs.Length; i++)
{
edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]);
// is circle
if (shapeChecker.IsCircle(edgePoints, out center, out radius))
{
circleBlobs.Add(blobs[i]);
graphics.DrawEllipse(bluePen, (float)(center.X - radius), (float)(center.Y - radius), (float)(radius * 2), (float)(radius * 2));
//is answerd?
if (blobs[i].Fullness > fullnessAvg)
{
graphics.DrawEllipse(greenPen, (float)(center.X - radius), (float)(center.Y - radius), (float)(radius * 2), (float)(radius * 2));
//understand comulmn limits
for (int d = 4; d >= 1; d--)
{
if (blobs[i].Rectangle.X < grayImage.Width / 4 * d)
{
anchorRight = grayImage.Width / 4 * d;
anchorLeft = (grayImage.Width / 4 * d) - grayImage.Width / 4;
}
}
for (int j = i + 1; j < blobs.Length; j++)
{
if (blobs[j].Fullness > fullnessAvg && Math.Abs(blobs[i].Rectangle.Y - blobs[j].Rectangle.Y) < yMinDis && blobs[j].Rectangle.X <anchorRight && blobs[j].Rectangle.X> anchorLeft)
{
graphics.DrawEllipse(yellowPen, (float)(center.X - radius), (float)(center.Y - radius), (float)(radius * 2), (float)(radius * 2));
}
}
} //end of is answerd
} //end of is cricle
} //end of for
return(grayImage);
}
private void button2_Click(object sender, EventArgs e)
{
Bitmap bmp = new Bitmap(pictureBox1.Image);
Bitmap bmpsobe;
Bitmap bmpmedian;
Bitmap otsu;
if (pictureBox1.Image == null)
{
MessageBox.Show("Lütfen önce bir resim Seçin");
}
else
{
progressBar1.Visible = true;
int i, j;
Color ort;//Color sınıfından bir renk nesne tanımlıyoruz.
//int r,g,b;
progressBar1.Maximum = bmp.Width * bmp.Height; //İşlem çubuğunun maksimim olduğu yer for döngüsünün sonundaki piksel değerine erişmemiz durumundadır.
for (i = 0; i <= bmp.Width - 1; i++) //dikey olarak görüntümüzü tarıyoruz.
{
for (j = 0; j <= bmp.Height - 1; j++) //yatay olarak görüntümüzü tarıyoruz.
{
ort = bmp.GetPixel(i, j);
ort = Color.FromArgb((byte)((ort.R + ort.G + ort.B) / 3), (byte)((ort.R + ort.G + ort.B) / 3), (byte)((ort.R + ort.G + ort.B) / 3));
bmp.SetPixel(i, j, ort);
if ((i % 10) == 0)//her on satırda bir göstergeyi güncelle
{
progressBar1.Value = i * bmp.Height + j;
Application.DoEvents();
}
}
}
}
//////////////////////// Median //////////////
bmpmedian = ExtBitmap.MedianFilter(bmp, 3);
/////////////////////// SOBEL ///////////////
bmpsobe = ExtBitmap.Sobel3x3Filter(bmpmedian, true);
Bitmap bmpsobe1 = (Bitmap)bmpsobe.Clone();
/////////// otsu
int x, y;
int genislik = bmpsobe1.Width;
int yukseklik = bmpsobe1.Height;
byte[] pixeller = new byte[(int)genislik * yukseklik];
Bitmap resim = (Bitmap)bmpsobe1.Clone();
for (y = 0; y < yukseklik; y++)
{
for (x = 0; x < genislik; x++)
{
// Pixelleri kütüphanenin işleyebileceği tek boyutlu bir diziye atıyoruz.
// Gri seviyede tüm ana renkler eşit olduğu için sadece kırmızıyı okumak gri seviye için yeterli.
pixeller[y * genislik + x] = resim.GetPixel(x, y).R;
}
}
byte esikDeger = 0;
OtsuEsikleme(ref pixeller[0], ref esikDeger, genislik, yukseklik);
int renkk;
for (y = 0; y < yukseklik; y++)
{
for (x = 0; x < genislik; x++)
{
renkk = pixeller[y * genislik + x]; // gri
resim.SetPixel(x, y, Color.FromArgb(renkk, renkk, renkk)); // Gri seviyeyi argb moduna dönüştürüp resme aktarıyoruz.
}
}
otsu = (Bitmap)resim.Clone();
Bitmap bmperosion;
Bitmap bmpdilation;
Bitmap bmpclosing;
bmperosion = ExtBitmap.DilateAndErodeFilter(otsu, 3, akıllıgecissistemleri.ExtBitmap.MorphologyType.Erosion, true, true, true);
Bitmap bmperosionn = (Bitmap)bmperosion.Clone();
bmpdilation = ExtBitmap.DilateAndErodeFilter(bmperosionn, 7, akıllıgecissistemleri.ExtBitmap.MorphologyType.Dilation, true, true, true);
Bitmap bmpdilationn = (Bitmap)bmpdilation.Clone();
Bitmap one = (Bitmap)bmpdilationn.Clone();
BlobsFiltering filter0 = new BlobsFiltering();
// filtre ayarlaması
filter0.CoupledSizeFiltering = true;
filter0.MinWidth = 70;
filter0.MinHeight = 40;
// filtre uygula
filter0.ApplyInPlace(one);
Bitmap one2 = (Bitmap)one.Clone();
bmpclosing = ExtBitmap.CloseMorphologyFilter(one2, 15, true, true, true);
Bitmap bmperosio = (Bitmap)bmpclosing.Clone();
Bitmap bmperosionson = ExtBitmap.DilateAndErodeFilter(bmperosio, 9, akıllıgecissistemleri.ExtBitmap.MorphologyType.Erosion, true, true, true);
Bitmap blobson = (Bitmap)bmperosionson.Clone();
BlobsFiltering filterson = new BlobsFiltering();
// filtre ayarla
filterson.CoupledSizeFiltering = true;
filterson.MinWidth = 50;
filterson.MinHeight = 200;
// filtre uygula
filterson.ApplyInPlace(blobson);
Bitmap rect = (Bitmap)blobson.Clone();
Bitmap one1 = (Bitmap)rect.Clone();
ConnectedComponentsLabeling filter = new ConnectedComponentsLabeling();
// filtre uygula
Bitmap newImage = filter.Apply(one1);
Bitmap newImage1 = (Bitmap)newImage.Clone();
// obje sayısını kontrol et
int objectCount = filter.ObjectCount;
BlobCounter blobCounter = new BlobCounter();
blobCounter.ProcessImage(rect);
Blob[] blobs = blobCounter.GetObjectsInformation();
// Görüntüye çizmek için Graphic nesnesi ve bir kalem oluştur
Graphics g = Graphics.FromImage(rect);
Pen bluePen = new Pen(Color.Blue, 2);
// her nesne kpntrol edilir ve etrafında daire çizilir.
for (int i = 0, n = blobs.Length; i < n; i++)
{
/*
* x1=0
* x2=1
* y1=2
* y2=3
*/
List <IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]);
List <IntPoint> corners = PointsCloud.FindQuadrilateralCorners(edgePoints);
int[] sinirlar = sinir(corners);
sinirlar[0] = sinirlar[0] - 2;
sinirlar[1] = sinirlar[1] + 2;
sinirlar[2] = sinirlar[2] - 2;
sinirlar[3] = sinirlar[3] + 2;
int en = sinirlar[1] - sinirlar[0];
int boy = sinirlar[3] - sinirlar[2];
float ort = (float)en / (float)boy;
List <IntPoint> ucnoktalar = new List <IntPoint>();
ucnoktalar.Add(new IntPoint(sinirlar[0], sinirlar[2]));
ucnoktalar.Add(new IntPoint(sinirlar[1], sinirlar[2]));
ucnoktalar.Add(new IntPoint(sinirlar[1], sinirlar[3]));
ucnoktalar.Add(new IntPoint(sinirlar[0], sinirlar[3]));
g.DrawPolygon(bluePen, ToPointsArray(ucnoktalar));
g.DrawString("Plaka kordinatlari : (x,y): (" + sinirlar[0].ToString() + "," + sinirlar[2].ToString() + ")\n en, boy,ort: " + (sinirlar[1] - sinirlar[0]).ToString() + ", "
+ (sinirlar[3] - sinirlar[2]).ToString() + "," + ort.ToString() + " blob sayisi:" + blobs.Length.ToString(), new Font("Arial", 8), Brushes.White, new System.Drawing.Point(sinirlar[0], sinirlar[3] + 4));
}
bluePen.Dispose();
g.Dispose();
Bitmap rect1 = (Bitmap)pictureBox1.Image.Clone();
Graphics g1 = Graphics.FromImage(rect1);
Pen bluePen2 = new Pen(Color.Red, 2);
// her nesne kpntrol edilir ve etrafında daire çizilir.
List <Blob> bloplar = new List <Blob>();
for (int i = 0, n = blobs.Length; i < n; i++)
{
/* x1,y1--------x2,y1
* x1=0 | |
* x2=1 | |
* y1=2 x1,y2--------x2,y2
* y2=3
*/
List <IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]);
List <IntPoint> corners = PointsCloud.FindQuadrilateralCorners(edgePoints);
int[] sinirlar = sinir(corners);
sinirlar[0] = sinirlar[0] - 5;
sinirlar[1] = sinirlar[1];
sinirlar[2] = sinirlar[2] - 5;
sinirlar[3] = sinirlar[3] + 5;
int en = sinirlar[1] - sinirlar[0];
int boy = sinirlar[3] - sinirlar[2];
float ort = (float)en / (float)boy;
if (ort >= 3 && ort <= 5.7)
{
g1.DrawLines(bluePen2, new System.Drawing.Point[] { new System.Drawing.Point(sinirlar[0], sinirlar[2]),
new System.Drawing.Point(sinirlar[1], sinirlar[2]), new System.Drawing.Point(sinirlar[1], sinirlar[3]),
new System.Drawing.Point(sinirlar[0], sinirlar[3]), new System.Drawing.Point(sinirlar[0], sinirlar[2]) });
g1.DrawString("Plaka kordinatlari : (x,y): (" + sinirlar[0].ToString() + "," + sinirlar[2].ToString() + ")\n en, boy,ort: " + (sinirlar[1] - sinirlar[0]).ToString() + ", "
+ (sinirlar[3] - sinirlar[2]).ToString() + "," + ort.ToString() + " blob sayisi:" + blobs.Length.ToString(), new Font("Arial", 8), Brushes.White, new System.Drawing.Point(sinirlar[0], sinirlar[3] + 4));
}
}
bluePen2.Dispose();
g1.Dispose();
Bitmap bn = null;
Bitmap kes1 = (Bitmap)rect1.Clone();
Graphics g2 = Graphics.FromImage(kes1);
Pen bluePen3 = new Pen(Color.Red, 2);
// her nesne kpntrol edilir ve etrafında daire çizilir.
for (int i = 0, n = blobs.Length; i < n; i++)
{
/* x1,y1--------x2,y1
* x1=0 | |
* x2=1 | |
* y1=2 x1,y2--------x2,y2
* y2=3
*/
List <IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]);
List <IntPoint> corners = PointsCloud.FindQuadrilateralCorners(edgePoints);
int[] sinirlar = sinir(corners);
sinirlar[0] = sinirlar[0] - 5;
sinirlar[1] = sinirlar[1];
sinirlar[2] = sinirlar[2] - 5;
sinirlar[3] = sinirlar[3] + 5;
int en = sinirlar[1] - sinirlar[0];
int boy = sinirlar[3] - sinirlar[2];
float ort = en / boy;
if (ort >= 3 && ort <= 5.7)
{
g2.DrawLines(bluePen3, new System.Drawing.Point[] { new System.Drawing.Point(sinirlar[0], sinirlar[2]),
new System.Drawing.Point(sinirlar[1], sinirlar[2]), new System.Drawing.Point(sinirlar[1], sinirlar[3]),
new System.Drawing.Point(sinirlar[0], sinirlar[3]), new System.Drawing.Point(sinirlar[0], sinirlar[2]) });
for (int ii = 0; ii < kes1.Width; ii++)
{
for (int ji = 0; ji < kes1.Height; ji++)
{
if ((ii >= sinirlar[0] && ii <= sinirlar[1]) && (ji >= sinirlar[2]) && ji <= sinirlar[3])
{
continue;
}
else
{
kes1.SetPixel(ii, ji, Color.Black);
}
}
}
bn = new Bitmap(en, boy);
Graphics g3 = Graphics.FromImage(bn);
g3.DrawImage(kes1, -sinirlar[0], -sinirlar[2]);
pictureBox2.Image = bn;
}
}
bluePen3.Dispose();
g2.Dispose();
//form(bmp, "Grayscala");
//form(bmpmedian, "Median");
//form(bmpsobe, "sobel");
//form(otsu, "otsu");
//form(bmperosion, "erosion");
//form(bmpdilationn, "dilation");
//form(one, "one");
//form(bmpclosing, "closing");
//form(bmperosionson, "son");
//form(blobson, "blobson");
//form(newImage, "one1");
//form(rect, "rect");
//form(rect1, "rect1");
//form(kes1, "kes1");
//form(bn, "bn");
}
private void Cap_ImageGrabbed(object sender, EventArgs e)
{
try
{
Mat imagen = new Mat();
cap.Retrieve(imagen);
//pb_lprptzanalitica.Image = imagen.Bitmap;
Bitmap frame = new Bitmap(imagen.Bitmap);
//pb_ipcam.Image = frame.Clone() as Bitmap;
if (previousFrame != null)
{
// find the thresholded euclidian difference between two subsequent frames
//ThresholdedEuclideanDifference threshold = new ThresholdedEuclideanDifference(40);
ThresholdedEuclideanDifference threshold = new ThresholdedEuclideanDifference(thr);
threshold.OverlayImage = previousFrame;
var difference = threshold.Apply(frame.Clone() as Bitmap);
// only keep big blobs
var filter = new BlobsFiltering();
filter.CoupledSizeFiltering = true;
filter.MinHeight = int.Parse(txt_tamanio2.Text);
filter.MinWidth = int.Parse(txt_tamanio2.Text);
filter.ApplyInPlace(difference);
//var sobl = new SobelEdgeDetector();
//sobl.ApplyInPlace(difference);
//erode image
var erode = new Erosion3x3();
for (int i = 0; i < int.Parse(txt_ers.Text); i++)
{
erode.ApplyInPlace(difference);
//erode.ApplyInPlace(difference);
//erode.ApplyInPlace(difference);
}
// dilate remaining blobs
var dilate = new BinaryDilation3x3();
for (int i = 0; i < int.Parse(txt_dils.Text); i++)
{
dilate.ApplyInPlace(difference);
//dilate.ApplyInPlace(difference);
//dilate.ApplyInPlace(difference);
//dilate.ApplyInPlace(difference);
}
// put this image in the thresholded picturebox
thresholdedBox.Image = difference.Clone() as Bitmap;
// use this as a mask for the current frame
var mask = new ApplyMask(difference);
var maskedFrame = mask.Apply(frame);
// put this image in the masked picturebox
maskedBox.Image = maskedFrame.Clone() as Bitmap;
// now find all moving blobs
if (frameIndex % 10 == 0)
{
var counter = new BlobCounter();
counter.ProcessImage(difference);
// only keep blobs that:
// - do not overlap with known cars
// - do not overlap with other blobs
// - have crossed the middle of the frame
// - are at least 100 pixels tall
var blobs = counter.GetObjectsRectangles();
var newBlobs = from r in counter.GetObjectsRectangles()
where !trackers.Any(t => t.Tracker.TrackingObject.Rectangle.IntersectsWith(r)) &&
!blobs.Any(b => b.IntersectsWith(r) && b != r) &&
r.Top >= 240 && r.Bottom <= 480 &&
r.Height >= int.Parse(txt_tamanio.Text)
select r;
// set up new camshift trackers for each detected blob
foreach (var rect in newBlobs)
{
trackers.Add(new TrackerType(rect, frameIndex, ++carIndex));
}
}
// now kill all car trackers that have expanded by too much
trackers.RemoveAll(t => t.Tracker.TrackingObject.Rectangle.Height > 360);
// and kill all trackers that have lived for 30 frames
//trackers.RemoveAll(t => frameIndex - t.StartIndex > 30);
trackers.RemoveAll(t => frameIndex - t.StartIndex > frames);
// let all remaining trackers process the current frame
var img = UnmanagedImage.FromManagedImage(maskedFrame);
trackers
.ForEach(t => t.Tracker.ProcessFrame(img));
// remember this frame for next iteration
previousFrame.Dispose();
previousFrame = frame.Clone() as Bitmap;
//escribir etiqueta para cada vehiculo
var outputFrame = frame.Clone() as Bitmap;
trackers
.FindAll(t => !t.Tracker.TrackingObject.IsEmpty)
.ForEach(t => DrawCarLabel(outputFrame, t.Tracker.TrackingObject.Rectangle, t.CarNumber));
// regresar frame procesado
frame = outputFrame;
//pb_ipcam.Image = outputFrame;
pb_lprptzanalitica.Image = outputFrame;
}
else
{ // recordar para siguiente iteracion
previousFrame = frame.Clone() as Bitmap;
}
frameIndex++;
}
catch (Exception)
{
MessageBox.Show("Error al decodificar video de PTZ, LPR o ANALITICA");
}
}
private void button3_Click(object sender, EventArgs e)
{
Bitmap orig = crni;
Bitmap clone = new Bitmap(orig.Width, orig.Height, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
using (Graphics gr = Graphics.FromImage(clone))
{
gr.DrawImage(orig, new Rectangle(0, 0, clone.Width, clone.Height));
}
FiltersSequence commonSeq = new FiltersSequence();
commonSeq.Add(Grayscale.CommonAlgorithms.BT709);
commonSeq.Add(new BradleyLocalThresholding());
commonSeq.Add(new DifferenceEdgeDetector());
Bitmap temp = commonSeq.Apply(clone);
BlobsFiltering filter = new BlobsFiltering();
filter.CoupledSizeFiltering = true;
filter.MinWidth = 10;
filter.MinHeight = 10;
// apply the filter
filter.ApplyInPlace(temp);
BlobCounter blobCounter = new BlobCounter();
blobCounter.ProcessImage(temp);
Blob[] blobs = blobCounter.GetObjectsInformation();
// step 3 - check objects' type and highlight
SimpleShapeChecker shapeChecker = new SimpleShapeChecker();
Bitmap temp4 = (Bitmap)pictureBox1.Image;
Graphics g = Graphics.FromImage(temp4);
Pen pen = new Pen(Color.Red, 2);
for (int i = 0, n = blobs.Length; i < n; i++)
{
List <IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]);
AForge.Point center;
float radius;
if (shapeChecker.IsCircle(edgePoints, out center, out radius))
{
g.DrawEllipse(pen,
(int)(center.X - radius),
(int)(center.Y - radius),
(int)(radius * 2),
(int)(radius * 2));
}
}
g.Dispose();
pen.Dispose();
// Set the size of the PictureBox control.
this.pictureBox3.Size = new System.Drawing.Size(396, 590);
//Set the SizeMode to center the image.
this.pictureBox3.SizeMode = PictureBoxSizeMode.CenterImage;
// Set the border style to a three-dimensional border.
this.pictureBox3.BorderStyle = BorderStyle.Fixed3D;
pictureBox3.Image = temp4;
pictureBox3.SizeMode = PictureBoxSizeMode.StretchImage;
}
private void process_Click(object sender, EventArgs e)
{
//grayscale
Grayscale filter1 = new Grayscale(0.2125, 0.7154, 0.0721);
processed = filter1.Apply(processed);
//threshold
var filter2 = new AForge.Imaging.Filters.Threshold(175);
processed = filter2.Apply(processed);
// erosion
Erosion filter3 = new Erosion();
filter3.Apply(processed);
// create filter
BlobsFiltering filter = new BlobsFiltering();
// configure filter
filter.CoupledSizeFiltering = true;
filter.MinWidth = 25;
filter.MinHeight = 25;
// apply the filter
filter.ApplyInPlace(processed);
Invert filterInvert = new Invert();
// apply the filter
filterInvert.ApplyInPlace(processed);
BlobCounterBase bc = new BlobCounter();
bc.FilterBlobs = true;
bc.MinWidth = 30; //give required value or ignore
bc.MinHeight = 30; //give required value or ignore
bc.CoupledSizeFiltering = true; // if value are given and if you want both Width and Height to be applied as a constraint to identify blob, set it to true
bc.ProcessImage(processed);
Blob[] blobs = bc.GetObjectsInformation();
int count = bc.ObjectsCount;
// lock image to draw on it
BitmapData data = processed.LockBits(
new Rectangle(0, 0, processed.Width, processed.Height),
ImageLockMode.ReadWrite, processed.PixelFormat);
// process each blob
foreach (Blob blob in blobs)
{
List <IntPoint> leftPoints, rightPoints, edgePoints;
edgePoints = new List <IntPoint>();
// get blob's edge points
bc.GetBlobsLeftAndRightEdges(blob,
out leftPoints, out rightPoints);
edgePoints.AddRange(leftPoints);
edgePoints.AddRange(rightPoints);
IConvexHullAlgorithm hullFinder = new GrahamConvexHull();
// blob's convex hull
List <IntPoint> hull = hullFinder.FindHull(edgePoints);
Drawing.Polygon(data, hull, Color.Yellow);
if (blob.Area < 8000)
{
five_cents++;
}
else if (blob.Area < 9000 && blob.Area > 8000)
{
ten_cents++;
}
else if (blob.Area < 13000 && blob.Area > 11000)
{
twentyfive_cents++;
}
else if (blob.Area < 17000 && blob.Area > 16000)
{
one_peso++;
}
else
{
five_peso++;
}
}
processed.UnlockBits(data);
pictureBox2.Image = processed;
pictureBox2.SizeMode = PictureBoxSizeMode.StretchImage;
textBox1.Text += count;
textBox2.Text += ((five_cents * .05) + (ten_cents * .10) + (twentyfive_cents * .25) + (one_peso * 1) + (five_peso * 5));
}
void SensorFrameReady(AllFramesReadyEventArgs e)
{
// if the window is displayed, show the depth buffer image
Bitmap mask = null;
using (DepthImageFrame frame = e.OpenDepthImageFrame())
{
if (frame != null)
{
_depthBitmap = CreateBitMapFromDepthFrame(frame);
ColorFiltering filter = new ColorFiltering();
filter.Red = new IntRange(50, 150);
filter.Green = new IntRange(200, 255);
filter.Blue = new IntRange(150, 255);
// apply the filter
_depthBitmap = AForge.Imaging.Image.Clone(_depthBitmap, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
mask = filter.Apply(_depthBitmap);
Grayscale gray = new Grayscale(0.7, 0.3, 0.1);
mask = gray.Apply(mask);
Threshold threshold = new Threshold(100);
threshold.ApplyInPlace(mask);
Invert invert = new Invert();
invert.ApplyInPlace(mask);
}
}
using (ColorImageFrame frame = e.OpenColorImageFrame())
{
if (frame != null)
{
_bitmap = _drawBitmap = ImageToBitmap(frame);
if (mask != null)
{
ApplyMask subtract = new ApplyMask(mask);
_bitmap = subtract.Apply(_bitmap);
}
HSLFiltering hsl = new HSLFiltering(new IntRange(330, 30), new Range(0.5f, 1), new Range(0.1f, 1));
hsl.ApplyInPlace(_bitmap);
Grayscale gray = new Grayscale(1, 0.8, 0.8);
_bitmap = gray.Apply(_bitmap);
Mean meanFilter = new Mean();
meanFilter.ApplyInPlace(_bitmap);
BlobsFiltering blob = new BlobsFiltering();
blob.CoupledSizeFiltering = false;
blob.MinHeight = 15;
blob.MinWidth = blob.MinHeight;
blob.MaxHeight = blob.MaxWidth = 300;
blob.ApplyInPlace(_bitmap);
// locate objects using blob counter
BlobCounter blobCounter = new BlobCounter();
blobCounter.ProcessImage(_bitmap);
Blob[] blobs = blobCounter.GetObjectsInformation();
Pen redPen = new Pen(Color.Red, 2);
Pen greenPen = new Pen(Color.Green, 2);
Pen purplePen = new Pen(Color.OrangeRed, 3);
Pen pen;
// check each object and draw circle around objects, which
// are recognized as circles
int maxBlob = -1;
double maxFullness = -1;
for (int i = 0, n = blobs.Length; i < n; i++)
{
float hw_ratio = (float)(blobs[i].Rectangle.Height) / blobs[i].Rectangle.Width;
if (hw_ratio > 0.65 && hw_ratio < 1.5 && blobs[i].Area > 200 && blobs[i].Fullness > 0.35)
{
if (blobs[i].Area > maxFullness)
{
maxBlob = i;
maxFullness = blobs[i].Area;
}
}
}
System.Console.WriteLine("MAX BLOB: " + maxBlob.ToString());
//draw to screen!
Grayscale gray2 = new Grayscale(0.2125, 0.7154, 0.072);
_drawBitmap = gray2.Apply(_drawBitmap);
_drawBitmap = AForge.Imaging.Image.Clone(_drawBitmap, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
Graphics g = Graphics.FromImage(_drawBitmap);
AForge.Point ballPos = new AForge.Point(-1, -1);
if (maxBlob >= 0)
{
ballPos = blobs[maxBlob].CenterOfGravity;
}
game.DrawGridAndScore(g, ballPos);
for (int i = 0, n = blobs.Length; i < n; i++)
{
float hw_ratio = (float)(blobs[i].Rectangle.Height) / blobs[i].Rectangle.Width;
if (hw_ratio > 0.65 && hw_ratio < 1.5 && blobs[i].Area > 200 && blobs[i].Fullness > 0.35)
{
AForge.Point center = blobs[i].CenterOfGravity;
if (maxBlob == i)
{
pen = purplePen;
}
else if (blobs[i].Fullness > 0.35)
{
continue;//pen = greenPen;
}
else
{
continue;// pen = redPen;
}
float radius = blobs[i].Rectangle.Width / 2;
g.DrawEllipse(pen,
(int)(center.X - radius),
(int)(center.Y - radius),
(int)(radius * 2),
(int)(radius * 2));
//g.DrawString(hw_ratio.ToString(), new Font("Arial", 16), new SolidBrush(Color.Yellow),
// new System.Drawing.Point((int)center.X, (int)center.Y));
}
}
redPen.Dispose();
greenPen.Dispose();
purplePen.Dispose();
g.Dispose();
if (game.hasWon)
{
if (player == game.winningPlayer)
{
label1.Text = "You Won!!! Congrats :)";
}
else
{
label1.Text = "You Lost... :(";
}
}
this.Refresh();
}
}
}
/// <summary>
/// Called when videoPlayer receives a new frame.
/// </summary>
/// <param name="sender"></param>
/// <param name="image"></param>
private void videoPlayer_NewFrame_1(object sender, ref Bitmap frame)
{
//if (cmb_fuente.SelectedIndex==1)
//{
// RotateBicubic filter = new RotateBicubic(90, true);
// frame = filter.Apply(frame);
//}
if (previousFrame != null)
{
// find the thresholded euclidian difference between two subsequent frames
//ThresholdedEuclideanDifference threshold = new ThresholdedEuclideanDifference(40);
ThresholdedEuclideanDifference threshold = new ThresholdedEuclideanDifference(thr);
threshold.OverlayImage = previousFrame;
var difference = threshold.Apply(frame);
// only keep big blobs
var filter = new BlobsFiltering();
filter.CoupledSizeFiltering = true;
filter.MinHeight = int.Parse(txt_tamanio2.Text);
filter.MinWidth = int.Parse(txt_tamanio2.Text);
filter.ApplyInPlace(difference);
//var sobl = new SobelEdgeDetector();
//sobl.ApplyInPlace(difference);
//erode image
var erode = new Erosion3x3();
for (int i = 0; i < int.Parse(txt_ers.Text); i++)
{
erode.ApplyInPlace(difference);
//erode.ApplyInPlace(difference);
//erode.ApplyInPlace(difference);
}
// dilate remaining blobs
var dilate = new BinaryDilation3x3();
for (int i = 0; i < int.Parse(txt_dils.Text); i++)
{
dilate.ApplyInPlace(difference);
//dilate.ApplyInPlace(difference);
//dilate.ApplyInPlace(difference);
//dilate.ApplyInPlace(difference);
}
// put this image in the thresholded picturebox
thresholdedBox.Image = difference.Clone() as Bitmap;
// use this as a mask for the current frame
var mask = new ApplyMask(difference);
var maskedFrame = mask.Apply(frame);
// put this image in the masked picturebox
maskedBox.Image = maskedFrame.Clone() as Bitmap;
// now find all moving blobs
if (frameIndex % 10 == 0)
{
var counter = new BlobCounter();
counter.ProcessImage(difference);
// only keep blobs that:
// - do not overlap with known cars
// - do not overlap with other blobs
// - have crossed the middle of the frame
// - are at least 100 pixels tall
var blobs = counter.GetObjectsRectangles();
var newBlobs = from r in counter.GetObjectsRectangles()
where !trackers.Any(t => t.Tracker.TrackingObject.Rectangle.IntersectsWith(r)) &&
!blobs.Any(b => b.IntersectsWith(r) && b != r) &&
r.Top >= 240 && r.Bottom <= 480 &&
r.Height >= int.Parse(txt_tamanio.Text)
select r;
// set up new camshift trackers for each detected blob
foreach (var rect in newBlobs)
{
trackers.Add(new TrackerType(rect, frameIndex, ++carIndex));
}
}
// now kill all car trackers that have expanded by too much
trackers.RemoveAll(t => t.Tracker.TrackingObject.Rectangle.Height > 360);
// and kill all trackers that have lived for 30 frames
//trackers.RemoveAll(t => frameIndex - t.StartIndex > 30);
trackers.RemoveAll(t => frameIndex - t.StartIndex > frames);
// let all remaining trackers process the current frame
var img = UnmanagedImage.FromManagedImage(maskedFrame);
trackers
.ForEach(t => t.Tracker.ProcessFrame(img));
// remember this frame for next iteration
previousFrame.Dispose();
previousFrame = frame.Clone() as Bitmap;
//escribir etiqueta para cada vehiculo
var outputFrame = frame.Clone() as Bitmap;
trackers
.FindAll(t => !t.Tracker.TrackingObject.IsEmpty)
.ForEach(t => DrawCarLabel(outputFrame, t.Tracker.TrackingObject.Rectangle, t.CarNumber));
// regresar frame procesado
frame = outputFrame;
}
else
{ // recordar para siguiente iteracion
previousFrame = frame.Clone() as Bitmap;
}
frameIndex++;
//if (previousFrame != null)
//{
// // find the thresholded euclidian difference between two subsequent frames
// ThresholdedEuclideanDifference threshold = new ThresholdedEuclideanDifference(40);
// threshold.OverlayImage = previousFrame;
// var difference = threshold.Apply(frame);
// // only keep big blobs
// var filter = new BlobsFiltering();
// filter.CoupledSizeFiltering = true;
// filter.MinHeight = 50;
// filter.MinWidth = 50;
// filter.ApplyInPlace(difference);
// // dilate remaining blobs
// var dilate = new BinaryDilation3x3();
// dilate.ApplyInPlace(difference);
// //dilate.ApplyInPlace(difference);
// //dilate.ApplyInPlace(difference);
// //dilate.ApplyInPlace(difference);
// // put this image in the thresholded picturebox
// thresholdedBox.Image = difference.Clone() as Bitmap;
// // use this as a mask for the current frame
// var mask = new ApplyMask(difference);
// var maskedFrame = mask.Apply(frame);
// // put this image in the masked picturebox
// maskedBox.Image = maskedFrame.Clone() as Bitmap;
// // now find all moving blobs
// if (frameIndex % 10 == 0)
// {
// var counter = new BlobCounter();
// counter.ProcessImage(difference);
// // only keep blobs that:
// // - do not overlap with known cars
// // - do not overlap with other blobs
// // - have crossed the middle of the frame
// // - are at least 100 pixels tall
// var blobs = counter.GetObjectsRectangles();
// var newBlobs = from r in counter.GetObjectsRectangles()
// where !trackers.Any(t => t.Tracker.TrackingObject.Rectangle.IntersectsWith(r))
// && !blobs.Any(b => b.IntersectsWith(r) && b != r)
// && r.Top >= 240 && r.Bottom <= 480
// && r.Height >= 100
// select r;
// // set up new camshift trackers for each detected blob
// foreach (var rect in newBlobs)
// {
// trackers.Add(new TrackerType(rect, frameIndex, ++carIndex));
// }
// }
// // now kill all car trackers that have expanded by too much
// trackers.RemoveAll(t => t.Tracker.TrackingObject.Rectangle.Height > 360);
// // and kill all trackers that have lived for 30 frames
// trackers.RemoveAll(t => frameIndex - t.StartIndex > 30);
// // let all remaining trackers process the current frame
// var img = UnmanagedImage.FromManagedImage(maskedFrame);
// trackers
// .ForEach(t => t.Tracker.ProcessFrame(img));
// // remember this frame for next iteration
// previousFrame.Dispose();
// previousFrame = frame.Clone() as Bitmap;
// // draw labels on all tracked cars
// var outputFrame = frame.Clone() as Bitmap;
// trackers
// .FindAll(t => !t.Tracker.TrackingObject.IsEmpty)
// .ForEach(t => DrawCarLabel(outputFrame, t.Tracker.TrackingObject.Rectangle, t.CarNumber));
// // return the processed frame to the video
// frame = outputFrame;
//}
//// or else just remember this frame for next iteration
//else
// previousFrame = frame.Clone() as Bitmap;
//frameIndex++;
}
