private void btnCrop_Click(object sender, EventArgs e)
{
IFilter imgeFilter = new Crop(new Rectangle(rectCropArea.X, rectCropArea.Y, rectCropArea.Width, rectCropArea.Height));
Bitmap imgEffect = new Bitmap(img, panelImage.Width, panelImage.Height);
img = imgeFilter.Apply(imgEffect);
panelImage.BackgroundImage = img;
}
/// <summary>
/// Applies the blob extraction feature of Aforge
/// </summary>
/// <param name="Mask">Mask from the flood-fill step</param>
/// <param name="Source">Source image (full image)</param>
/// <returns>A list of tuples(blob from mask, rectangle from source)</returns>
private static List <Tuple <Bitmap, Bitmap> > ApplyBlobExtractor(Bitmap Mask, Bitmap Source)
{
List <Tuple <Bitmap, Bitmap> > BlobSrcblock = new List <Tuple <Bitmap, Bitmap> >();
log.Debug("Using AForge Blob Counter to Process Mask");
AForge.Imaging.BlobCounter blobCounter = new AForge.Imaging.BlobCounter();
// Sort order
blobCounter.ObjectsOrder = AForge.Imaging.ObjectsOrder.XY;
blobCounter.ProcessImage(Mask);
AForge.Imaging.Blob[] blobs = blobCounter.GetObjects(Mask, false);
log.Info("Use the Blob Extraction Results to reverse extract blobs from images");
// Adding images into the image list
AForge.Imaging.UnmanagedImage currentImg;
foreach (AForge.Imaging.Blob blob in blobs)
{
Rectangle myRect = blob.Rectangle;
currentImg = blob.Image;
Bitmap exBlob = currentImg.ToManagedImage();
AForge.Imaging.Filters.Crop filter = new AForge.Imaging.Filters.Crop(myRect);
Bitmap exSrc = filter.Apply(Source);
BlobSrcblock.Add(new Tuple <Bitmap, Bitmap>(exBlob, exSrc));
}
log.Info("Extraction Complete: returning List of ( blob bitmap, src bitmap)");
return(BlobSrcblock);
}
public static Bitmap CropImage(this Bitmap source)
{
const int widthCrop = 80;
const int heightCrop = 50;
Crop filter = new Crop(new Rectangle(widthCrop, heightCrop, source.Width- 2* widthCrop -10, source.Height - 10 - 2 * heightCrop));
return filter.Apply(source);
}
public List<Bitmap> PickSlices(IReadOnlyList<Bitmap> inputImages, Size sliceSize)
{
var edgeImages = inputImages.Select(grayscaleFilter.Apply).ToList();
edgeImages.ForEach(edgeDetectionFilter.ApplyInPlace);
var edgeDensityHistograms = edgeImages.Select(x => new HorizontalIntensityStatistics(x).Gray).ToList();
var imagesAndHistograms = Enumerable.Range(0, inputImages.Count).Select(index => {
return new ImagesAndHistogram {
OriginalImage = inputImages[index],
EdgeImage = edgeImages[index],
EdgeDensityHistogram = edgeDensityHistograms[index],
Rating = ratingCalculator.ComputeRating(inputImages[index], edgeDensityHistograms[index], sliceSize.Width, sliceSize.Height)
};
}).OrderBy(x => x.Rating).ToList();
var sliceAspect = sliceSize.Width / (double)sliceSize.Height;
foreach (var imagesAndHistogram in imagesAndHistograms) {
var desiredWidth = (int)(imagesAndHistogram.OriginalImage.Height * sliceAspect);
if (desiredWidth > imagesAndHistogram.OriginalImage.Width) {
continue;
}
var range = thumbnailGeneratorUtilities.GetRangeOfWidth(imagesAndHistogram.EdgeDensityHistogram, desiredWidth);
var horizontalCrop = new Crop(new Rectangle(range.Min, 0, range.Max - range.Min, imagesAndHistogram.OriginalImage.Height)).Apply(imagesAndHistogram.OriginalImage);
var horizontalCrop24bpp = horizontalCrop.Clone(new Rectangle(Point.Empty, horizontalCrop.Size), PixelFormat.Format24bppRgb);
imagesAndHistogram.SliceImage = horizontalCrop24bpp;
var resizer = new ResizeBicubic(sliceSize.Width, sliceSize.Height);
imagesAndHistogram.SliceImageResized = resizer.Apply(horizontalCrop24bpp);
}
return imagesAndHistograms.Where(x => x.SliceImageResized != null).Select(x => x.SliceImageResized).ToList();
}
/// <summary>
/// Looks for the brightest pixel after applying a redness filter. Narrows search first using a resampled copy of the image to eliminate edge dots.
/// Expects an image that is already cropped to the interested area for faster processing.
/// </summary>
/// <param name="img"></param>
/// <param name="mouse"></param>
/// <param name="maxDistanceFromMouse"></param>
/// <returns></returns>
public unsafe Point FindMaxPixel(UnmanagedImage img, PointF mouse, float maxDistanceFromMouse)
{
int width = 15;
int height = (int)Math.Ceiling((double)img.Height / (double)img.Width * width);
if (width <= img.Width && height <= img.Height + 1) {
width = img.Width;
height = img.Height;
}
double scale = (double)img.Width / (double)width;
UnmanagedImage lowRed = null;
try {
if (width != img.Width && height != img.Height) {
using (Bitmap reduced = new Bitmap(width, height, PixelFormat.Format24bppRgb))
using (Graphics g = Graphics.FromImage(reduced))
using (ImageAttributes ia = new ImageAttributes()) {
g.CompositingMode = System.Drawing.Drawing2D.CompositingMode.SourceCopy;
g.CompositingQuality = System.Drawing.Drawing2D.CompositingQuality.HighQuality;
g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
g.PixelOffsetMode = System.Drawing.Drawing2D.PixelOffsetMode.HighQuality;
g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
ia.SetWrapMode(System.Drawing.Drawing2D.WrapMode.TileFlipXY);
g.DrawImage(img.ToManagedImage(false), new Rectangle(0, 0, width, height), 0, 0, img.Width, img.Height, GraphicsUnit.Pixel, ia);
//TODO: Not sure if ToManagedImage will stick around after the underying image is disposed. I know that the bitmap data will be gone, guess that's most of it.
using (UnmanagedImage rui = UnmanagedImage.FromManagedImage(reduced)) {
lowRed = new RedEyeFilter(2).Apply(rui); // Make an copy using the red eye filter
}
}
} else {
//Don't resample unless needed
lowRed = new RedEyeFilter(2).Apply(img);
}
Point max = GetMax(lowRed, new PointF(mouse.X / (float)scale, mouse.Y / (float)scale), maxDistanceFromMouse / scale);
//We weren't scaling things? OK, cool...
if (scale == 0) return max;
//Otherwise, let's get the unscaled pixel.
//Calculate the rectangle surrounding the selected pixel, but in source coordinates.
int tinySize = (int)Math.Ceiling(scale) + 1;
Rectangle tinyArea = new Rectangle((int)Math.Floor(scale * (double)max.X), (int)Math.Floor(scale * (double)max.Y), tinySize, tinySize);
if (tinyArea.Right >= img.Width) tinyArea.Width -= img.Width - tinyArea.Right + 1;
if (tinyArea.Bottom >= img.Height) tinyArea.Height -= img.Height - tinyArea.Bottom + 1;
//Filter it and look
using (UnmanagedImage tiny = new Crop(tinyArea).Apply(img)) {
using (UnmanagedImage tinyRed = new RedEyeFilter(2).Apply(tiny)) {
max = GetMax(tinyRed);
max.X += tinyArea.X;
max.Y += tinyArea.Y;
}
}
return max;
} finally {
if (lowRed != null) lowRed.Dispose();
}
}
/// <summary>
/// Celem metody jest przykadrowanie otrzymanego obrazka, tak aby widok zawierał jedynie kartkę papieru, oraz zwrócenie go do metody UploadFile
/// </summary>
/// <param name="img"></param>
/// <returns></returns>
public System.Drawing.Image CropImage(System.Drawing.Image img)
{
//DocumentSkewChecker skewChecker = new DocumentSkewChecker();
//double angle = skewChecker.GetSkewAngle(image);
//RotateBilinear rotationFilter = new RotateBilinear(-angle);
//rotationFilter.FillColor = Color.White;
//Bitmap rotatedImage = rotationFilter.Apply(image);
Bitmap image = new Bitmap(img);
UnmanagedImage grayImage = null;
if (image.PixelFormat == PixelFormat.Format8bppIndexed)
{
grayImage = UnmanagedImage.FromManagedImage(image);
}
else
{
grayImage = UnmanagedImage.Create(image.Width, image.Height,
PixelFormat.Format8bppIndexed);
Grayscale.CommonAlgorithms.BT709.Apply(UnmanagedImage.FromManagedImage(image), grayImage);
}
CannyEdgeDetector edgeDetector = new CannyEdgeDetector();
UnmanagedImage edgesImage = edgeDetector.Apply(grayImage);
OtsuThreshold thresholdFilter = new OtsuThreshold();
thresholdFilter.ApplyInPlace(edgesImage);
Dilatation DilatationFilter = new Dilatation();
DilatationFilter.Apply(edgesImage);
Opening OpeningFilter = new Opening();
OpeningFilter.Apply(edgesImage);
BlobCounter blobCounter = new BlobCounter();
blobCounter.MinHeight = 32;
blobCounter.MinWidth = 32;
blobCounter.FilterBlobs = true;
blobCounter.ObjectsOrder = ObjectsOrder.Size;
blobCounter.ProcessImage(edgesImage);
Blob[] blobs = blobCounter.GetObjectsInformation();
ExtractBiggestBlob BiggestBlob = new ExtractBiggestBlob();
Bitmap biggestBlobsImage = BiggestBlob.Apply(edgesImage.ToManagedImage());
AForge.IntPoint BiggestBlogCorners = BiggestBlob.BlobPosition;
Crop cropFilter = new Crop(new Rectangle(BiggestBlogCorners.X, BiggestBlogCorners.Y, biggestBlobsImage.Width, biggestBlobsImage.Height));
Bitmap croppedImage = cropFilter.Apply(image);
return croppedImage;
}
public static List<Ipoint> fillFeatures(Bitmap bmp, int com_x, int com_y, double[] input_i)
{
/*int cropx = Math.Max(com_x - 12, 0);
int cropy = Math.Max(com_y - 12, 0);
bmp = new Crop(new Rectangle(cropx, cropy, 24, 24)).Apply(bmp);*/
bmp = new Crop(new Rectangle(16, 16, 48, 48)).Apply(bmp);
bmp = new ResizeBicubic(12, 12).Apply(bmp);
//bmp.Save(Constants.base_folder + "hasat\\zzz\\" + DateTime.Now.Ticks + ".bmp");
for (int yy = 0; yy < 12; yy++)
{
for (int xx = 0; xx < 12; xx++)
{
input_i[yy * 12 + xx] = 1d - Constants.getColorValForLabeling(bmp.GetPixel(xx, yy));
}
}
return null;
}
public Bitmap ProcessFrame(Bitmap inputBitmap, int x, int y)
{
// Create an image for AForge to process
Bitmap workingImage = new Bitmap(inputBitmap.Width, inputBitmap.Height);
workingImage = AForge.Imaging.Image.Clone(inputBitmap, PixelFormat.Format24bppRgb);
// Create a mask for ROI selection
Rectangle roi = new Rectangle(x - 30, y-30, 80, 80);
Crop roicrop = new Crop(roi);
Bitmap outimage = roicrop.Apply(workingImage);
BlobCounter blobCounter = new BlobCounter();
blobCounter.ObjectsOrder = ObjectsOrder.Area;
Blob[] blobs;
// Find the blobs
blobCounter.ProcessImage(outimage);
blobs = blobCounter.GetObjectsInformation();
List<IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blobs[0]);
GrahamConvexHull grahamScan = new GrahamConvexHull();
List<IntPoint> hullPoints = grahamScan.FindHull(edgePoints);
Graphics g = Graphics.FromImage(outimage);
Pen redPen = new Pen(Color.Red, 2);
g.DrawPolygon(redPen, ToPointsArray(hullPoints));
//g.Clear(Color.Black);
//g.DrawImage(handImage, x, y);
//g.DrawRectangle(redPen, roi);
//g.DrawEllipse(redPen, x, y, 20, 20);
ResizeNearestNeighbor resizeFilter = new ResizeNearestNeighbor(160, 160);
Bitmap resizedImage = resizeFilter.Apply(outimage);
return resizedImage;
}
public static void fillFeatures_SURF(Bitmap inbmp, int com_x, int com_y, Node[] nds)
{
int radius = 16;
if ("circle".Equals(Constants.CIRCLE_TRIANGLE))
radius = 25;
int diameter = 2 * radius + 1;
List<Ipoint> featureList = null;
if ("SVM_SURF".Equals(Constants.NN_SVM_SURF))
{
//inbmp.Save(Constants.base_folder + "hasat\\zzz\\0_" + inbmp.Tag);
int cropx = Math.Max(com_x - radius, 0);
int cropy = Math.Max(com_y - radius, 0);
int x_min = 100, x_max = 0;
int y_min = 100, y_max = 0;
Bitmap bmp = new Crop(new Rectangle(cropx, cropy, diameter, diameter)).Apply(inbmp);
//bmp.Save(Constants.base_folder + "hasat\\zzz\\1_" + inbmp.Tag);
for (int yy = 0; yy < diameter; yy++)
{
for (int xx = 0; xx < diameter; xx++)
{
if (bmp.GetPixel(xx, yy).R < 128)
{
x_min = Math.Min(x_min, xx);
y_min = Math.Min(y_min, yy);
x_max = Math.Max(x_max, xx);
y_max = Math.Max(y_max, yy);
}
}
}
x_min--; y_min--; x_max++; y_max++;
x_min = Math.Max(x_min, 0);
y_min = Math.Max(y_min, 0);
int x_length = x_max - x_min;
int y_length = y_max - y_min;
if (x_length > y_length)
bmp = new Crop(new Rectangle(x_min, Math.Max((radius - x_length / 2), 0), x_length, x_length)).Apply(bmp);
else
bmp = new Crop(new Rectangle(Math.Max((radius - y_length / 2), 0), y_min, y_length, y_length)).Apply(bmp);
//bmp.Save(Constants.base_folder + "hasat\\zzz\\2_" + inbmp.Tag);
bmp = new ResizeBicubic(128, 128).Apply(bmp);
//bmp.Save(Constants.base_folder + "hasat\\zzz\\3_" + inbmp.Tag);
bmp = new ImageFilters.ColorLabelFilter(new Color[] { Color.White, Color.Black }, true).Apply(bmp);
//bmp.Save(Constants.base_folder + "hasat\\zzz\\4_" + inbmp.Tag);
ByteTools.imageCoM(bmp, ref com_x, ref com_y);
long start = DateTime.Now.Ticks / 10000;
Hashtable feat_hash = new Hashtable();
for (int i = 0; i < NNTrain.surf_array.Length && NNTrain.surf_array[i] != null; i++)
{
start = DateTime.Now.Ticks / 10000;
List<Ipoint> featureList_i = NNTrain.surf_array[i].getDescriptors(bmp);
// Console.WriteLine("TIME_2_" + i + "[" + featureList_i.Count + "]: " + (DateTime.Now.Ticks / 10000 - start));
start = DateTime.Now.Ticks / 10000;
if (featureList_i == null) continue;
for (int x = 0; x < featureList_i.Count; x++)
{
if (bmp.GetPixel((int)featureList_i[x].x, (int)featureList_i[x].y).R > 128)
continue;
if (!feat_hash.ContainsKey(Math.Round(featureList_i[x].x) + "_" + Math.Round(featureList_i[x].y)))
{
feat_hash.Add(Math.Round(featureList_i[x].x) + "_" + Math.Round(featureList_i[x].y), featureList_i[x]);
}
}
}
featureList = new List<Ipoint>(feat_hash.Values.Count);
IEnumerator enm = feat_hash.GetEnumerator();
while (enm.MoveNext())
featureList.Add((Ipoint)((DictionaryEntry)enm.Current).Value);
featureList = featureList.GetRange(0, (int)Math.Min(featureList.Count, NNTrain.NUM_MAX_INTEREST_POINTS));
/*
// bmp.Save(Constants.base_folder + "hasat\\zzz\\5_" + inbmp.Tag);
Graphics g = Graphics.FromImage(bmp);
g.DrawRectangle(Pens.Cyan, com_x-1, com_y-1, 2, 2);
SURF.paintSURFPoints(bmp, featureList);
bmp.Save(Constants.base_folder + "hasat\\zzz\\6_" + inbmp.Tag);
*/
int CURRENT_POINT_INDEX = 0;
for (int xx = 0; xx < nds.Length; xx++)
{
nds[xx] = new Node(xx + 1, 0);
}
float com_linear_pos = 128 * com_y + com_x;
for (int j = 0; j < NNTrain.NUM_MAX_INTEREST_POINTS; j++, CURRENT_POINT_INDEX++)
{
if (CURRENT_POINT_INDEX == featureList.Count)
CURRENT_POINT_INDEX = 0;
if (featureList.Count == 0)
{
// nds[j] = new Node(j + 1, 0);
}
else
{
float xx = featureList[CURRENT_POINT_INDEX].x;
float yy = featureList[CURRENT_POINT_INDEX].y;
int y_quantized = (int)Math.Round((yy - com_y) / NNTrain.quantizer);
int x_quantized = (int)Math.Round((xx - com_x) / NNTrain.quantizer);
y_quantized += 4;
x_quantized += 4;
int indx = y_quantized * NNTrain.num_surf_quants + x_quantized;
if (indx >= 0 && indx < (NNTrain.num_surf_quants * NNTrain.num_surf_quants))
nds[indx].Value += 1d / NNTrain.NUM_MAX_INTEREST_POINTS;
else
Console.Write("");
}
}
}
else if ("SVM_12SIMPLE".Equals(Constants.NN_SVM_SURF))
{
string filename = (string)inbmp.Tag;
int cropx = Math.Max(com_x - radius, 0);
int cropy = Math.Max(com_y - radius, 0);
/*
Graphics g = Graphics.FromImage(inbmp);
g.DrawRectangle(Pens.Cyan, com_x-1, com_y-1, 2, 2);
g.DrawRectangle(Pens.Red, cropx, cropy, diameter, diameter);
inbmp.Save(Constants.base_folder + "hasat\\zzz\\0_" + filename);
*/
inbmp = new Crop(new Rectangle(cropx, cropy, diameter, diameter)).Apply(inbmp);
int x_min = 100, x_max = 0;
int y_min = 100, y_max = 0;
for (int yy = 0; yy < diameter; yy++)
{
for (int xx = 0; xx < diameter; xx++)
{
if (inbmp.GetPixel(xx, yy).R < 128)
{
x_min = Math.Min(x_min, xx);
y_min = Math.Min(y_min, yy);
x_max = Math.Max(x_max, xx);
y_max = Math.Max(y_max, yy);
}
}
}
x_min--; y_min--; x_max++; y_max++;
x_min = Math.Max(x_min, 0);
y_min = Math.Max(y_min, 0);
int x_length = x_max - x_min;
int y_length = y_max - y_min;
if (x_length > y_length)
{
inbmp = new Crop(new Rectangle(x_min, Math.Max((radius - x_length / 2), 0), x_length, x_length)).Apply(inbmp);
}
else
{
inbmp = new Crop(new Rectangle(Math.Max((radius - y_length / 2), 0), y_min, y_length, y_length)).Apply(inbmp);
}
// inbmp.Save(Constants.base_folder + "hasat\\zzz\\8_" + filename);
inbmp = new ResizeBicubic(12, 12).Apply(inbmp);
//inbmp.Save(Constants.base_folder + "hasat\\zzz\\9_" + filename);
for (int yy = 0; yy < 12; yy++)
{
for (int xx = 0; xx < 12; xx++)
{
nds[yy * 12 + xx] = new Node(yy * 12 + xx + 1, 1d - Constants.getColorValForLabeling(inbmp.GetPixel(xx, yy)));
}
}
}
//Graphics g = Graphics.FromImage(bmp);
//g.DrawRectangle(Pens.Cyan, com_x, com_y, 2, 2);
}
public static Bitmap Crop(Bitmap bmp, int x, int y, int x2, int y2)
{
// create filter
Crop filter = new Crop(new Rectangle(x, y, x2, y2));
// apply the filter
Bitmap newImage = filter.Apply(bmp);
return newImage;
}
private void VideoNewFrame(object sender, NewFrameEventArgs e)
{
if (_requestedToStop || NewFrame==null)
return;
if (_lastframeEvent > DateTime.MinValue)
{
if ((DateTime.Now<_nextFrameTarget))
{
return;
}
double dMin = Mininterval;
_nextFrameTarget = _nextFrameTarget.AddMilliseconds(dMin);
if (_nextFrameTarget < DateTime.Now)
_nextFrameTarget = DateTime.Now.AddMilliseconds(dMin);
TimeSpan tsFr = DateTime.Now - _lastframeProcessed;
_framerates.Enqueue(1000d / tsFr.TotalMilliseconds);
if (_framerates.Count >= 30)
_framerates.Dequeue();
Framerate = _framerates.Average();
}
else
{
_lastframeEvent = DateTime.Now;
}
lock (_sync)
{
_lastframeProcessed = DateTime.Now;
var tsBrush = new SolidBrush(MainForm.Conf.TimestampColor.ToColor());
var sbTs = new SolidBrush(Color.FromArgb(128, 0, 0, 0));
Bitmap bmOrig = null, bmp = null;
Graphics g = null, gCam = null;
bool err = false;
try
{
// motionLevel = 0;
if (e.Frame != null)
{
if (LastFrameUnmanaged != null)
LastFrameUnmanaged.Dispose();
//resize?
if (CW.Camobject.settings.resize && (CW.Camobject.settings.desktopresizewidth != e.Frame.Width || CW.Camobject.settings.desktopresizeheight != e.Frame.Height))
{
var result = new Bitmap(CW.Camobject.settings.desktopresizewidth, CW.Camobject.settings.desktopresizeheight, PixelFormat.Format24bppRgb);
using (Graphics g2 = Graphics.FromImage(result))
{
g2.CompositingMode = CompositingMode.SourceCopy;
g2.CompositingQuality = CompositingQuality.HighSpeed;
g2.PixelOffsetMode = PixelOffsetMode.Half;
g2.SmoothingMode = SmoothingMode.None;
g2.InterpolationMode = InterpolationMode.Default;
g2.DrawImage(e.Frame, 0, 0, result.Width, result.Height);
}
e.Frame.Dispose();
bmOrig = result;
}
else
{
bmOrig = e.Frame;
}
if (CW.Camobject.rotate90)
bmOrig.RotateFlip(RotateFlipType.Rotate90FlipNone);
if (CW.Camobject.flipx)
{
bmOrig.RotateFlip(RotateFlipType.RotateNoneFlipX);
}
if (CW.Camobject.flipy)
{
bmOrig.RotateFlip(RotateFlipType.RotateNoneFlipY);
}
_width = bmOrig.Width;
_height = bmOrig.Height;
if (CW.NeedMotionZones)
CW.NeedMotionZones = !SetMotionZones(CW.Camobject.detector.motionzones);
if (Mask != null)
{
g = Graphics.FromImage(bmOrig);
g.DrawImage(Mask, 0, 0, _width, _height);
}
if (Plugin != null)
{
bool runplugin = true;
if (CW.Camobject.alerts.processmode == "motion")
{
//run plugin if motion detected in last 5 seconds
runplugin = _motionlastdetected > DateTime.Now.AddSeconds(-5);
}
if (runplugin)
{
bmOrig =
(Bitmap)
Plugin.GetType().GetMethod("ProcessFrame").Invoke(Plugin, new object[] {bmOrig});
var pluginAlert = (String) Plugin.GetType().GetField("Alert").GetValue(Plugin);
if (pluginAlert != "")
Alarm(pluginAlert, EventArgs.Empty);
}
}
LastFrameUnmanaged = UnmanagedImage.FromManagedImage(bmOrig);
if (_motionDetector != null)
{
if (Alarm != null)
{
_processFrameCount++;
if (_processFrameCount >= CW.Camobject.detector.processeveryframe || CW.Calibrating)
{
_processFrameCount = 0;
MotionLevel = _motionDetector.ProcessFrame(LastFrameUnmanaged, Filter);
if (MotionLevel >= _alarmLevel)
{
if (MotionLevel <= _alarmLevelMax || _alarmLevelMax >= 0.1)
{
MotionDetected = true;
_motionlastdetected = DateTime.Now;
Alarm(this, new EventArgs());
}
}
else
MotionDetected = false;
}
}
else
MotionDetected = false;
}
else
{
MotionDetected = false;
}
if (ZFactor > 1)
{
var f1 = new ResizeNearestNeighbor(LastFrameUnmanaged.Width, LastFrameUnmanaged.Height);
var f2 = new Crop(ViewRectangle);
LastFrameUnmanaged = f2.Apply(LastFrameUnmanaged);
LastFrameUnmanaged = f1.Apply(LastFrameUnmanaged);
}
if (CW.Camobject.settings.timestamplocation != 0 &&
CW.Camobject.settings.timestampformatter != "")
{
bmp = LastFrameUnmanaged.ToManagedImage();
gCam = Graphics.FromImage(bmp);
var ts = CW.Camobject.settings.timestampformatter.Replace("{FPS}",
string.Format("{0:F2}", Framerate));
ts = ts.Replace("{CAMERA}", CW.Camobject.name);
ts = ts.Replace("{REC}", CW.Recording ? "REC" : "");
var timestamp = "Invalid Timestamp";
try
{
timestamp = String.Format(ts,
DateTime.Now.AddHours(
Convert.ToDouble(CW.Camobject.settings.timestampoffset))).Trim();
}
catch
{
}
var rs = gCam.MeasureString(timestamp, Drawfont).ToSize();
var p = new Point(0, 0);
switch (CW.Camobject.settings.timestamplocation)
{
case 2:
p.X = _width/2 - (rs.Width/2);
break;
case 3:
p.X = _width - rs.Width;
break;
case 4:
p.Y = _height - rs.Height;
break;
case 5:
p.Y = _height - rs.Height;
p.X = _width/2 - (rs.Width/2);
break;
case 6:
p.Y = _height - rs.Height;
p.X = _width - rs.Width;
break;
}
var rect = new Rectangle(p, rs);
gCam.FillRectangle(sbTs, rect);
gCam.DrawString(timestamp, Drawfont, tsBrush, p);
LastFrameUnmanaged.Dispose();
LastFrameUnmanaged = UnmanagedImage.FromManagedImage(bmp);
}
}
}
catch (UnsupportedImageFormatException ex)
{
CW.VideoSourceErrorState = true;
CW.VideoSourceErrorMessage = ex.Message;
if (LastFrameUnmanaged != null)
{
try
{
lock (_sync)
{
LastFrameUnmanaged.Dispose();
LastFrameUnmanaged = null;
}
}
catch
{
}
}
err = true;
}
catch (Exception ex)
{
if (LastFrameUnmanaged != null)
{
try
{
lock (_sync)
{
LastFrameUnmanaged.Dispose();
LastFrameUnmanaged = null;
}
}
catch
{
}
}
Log.Error("",ex);//Log.Error("",ex);//MainForm.LogExceptionToFile(ex);
err = true;
}
if (gCam != null)
gCam.Dispose();
if (bmp != null)
bmp.Dispose();
if (g != null)
g.Dispose();
if (bmOrig != null)
bmOrig.Dispose();
tsBrush.Dispose();
sbTs.Dispose();
if (err)
return;
if (MotionDetector != null && !CW.Calibrating &&
MotionDetector.MotionProcessingAlgorithm is BlobCountingObjectsProcessing)
{
try
{
var blobcounter =
(BlobCountingObjectsProcessing) MotionDetector.MotionProcessingAlgorithm;
//tracking
var pCenter = new Point(Width/2, Height/2);
if (!CW.PTZNavigate && CW.Camobject.settings.ptzautotrack && blobcounter.ObjectsCount > 0 &&
blobcounter.ObjectsCount < 4 && !CW.Ptzneedsstop)
{
List<Rectangle> recs =
blobcounter.ObjectRectangles.OrderByDescending(p => p.Width*p.Height).ToList();
Rectangle rec = recs.First();
//get center point
var prec = new Point(rec.X + rec.Width/2, rec.Y + rec.Height/2);
double dratiomin = 0.6;
prec.X = prec.X - pCenter.X;
prec.Y = prec.Y - pCenter.Y;
if (CW.Camobject.settings.ptzautotrackmode == 1) //vert only
{
prec.X = 0;
dratiomin = 0.3;
}
if (CW.Camobject.settings.ptzautotrackmode == 2) //horiz only
{
prec.Y = 0;
dratiomin = 0.3;
}
double angle = Math.Atan2(-prec.Y, -prec.X);
if (CW.Camobject.settings.ptzautotrackreverse)
{
angle = angle - Math.PI;
if (angle < 0 - Math.PI)
angle += 2*Math.PI;
}
double dist = Math.Sqrt(Math.Pow(prec.X, 2.0d) + Math.Pow(prec.Y, 2.0d));
double maxdist = Math.Sqrt(Math.Pow(Width/2, 2.0d) + Math.Pow(Height/2, 2.0d));
double dratio = dist/maxdist;
if (dratio > dratiomin)
{
CW.PTZ.SendPTZDirection(angle, 1);
CW.LastAutoTrackSent = DateTime.Now;
CW.Ptzneedsstop = true;
}
}
}
catch (Exception ex)
{
Log.Error("", ex);//Log.Error("",ex);//MainForm.LogExceptionToFile(ex);
}
}
if (NewFrame != null && LastFrameUnmanaged != null)
{
LastFrameNull = false;
NewFrame(this, new EventArgs());
}
}
}
/// <summary>
/// Recognize hands gesture.
/// </summary>
///
/// <param name="imageData">Source image data to recognize hands gesture on.</param>
/// <param name="bodyImageOnly">Specifies if the passed image data contain only human's body or not.</param>
///
/// <returns>Returns gesture structure, which specifies position of both hands.</returns>
///
/// <remarks><para>The <b>bodyImageOnly</b>> parameter specifies if human's body occupies the
/// passes image from top to down and from left to rigth. If the value is set to <b>false</b>,
/// then humans' body may occupy only part of the image, what will require image shrinking.</para></remarks>
///
public Gesture Recognize( BitmapData imageData, bool bodyImageOnly )
{
// check source image format
if ( imageData.PixelFormat != PixelFormat.Format8bppIndexed )
{
throw new ArgumentException( "Source image can be binary (8 bpp indexed) only" );
}
// recognized gesture
Gesture gesture = new Gesture( HandPosition.NotRaised, HandPosition.NotRaised );
Bitmap bodyImage = null;
BitmapData bodyImageData = null;
if ( bodyImageOnly == false )
{
// use shrink filter to extract only body image
Shrink shrinkFilter = new Shrink( );
bodyImage = shrinkFilter.Apply( imageData );
// lock body image for further processing
bodyImageData = bodyImage.LockBits(
new Rectangle( 0, 0, bodyImage.Width, bodyImage.Height ),
ImageLockMode.ReadOnly, PixelFormat.Format8bppIndexed );
}
else
{
// use passed image as body image
bodyImageData = imageData;
}
int bodyWidth = bodyImageData.Width;
int bodyHeight = bodyImageData.Height;
// get statistics about horizontal pixels distribution
HorizontalIntensityStatistics his = new HorizontalIntensityStatistics( bodyImageData );
int[] hisValues = (int[]) his.Gray.Values.Clone( );
// build map of hands (0) and torso (1)
double torsoLimit = torsoCoefficient * bodyHeight;
for ( int i = 0; i < bodyWidth; i++ )
{
hisValues[i] = ( (double) hisValues[i] / 255 > torsoLimit ) ? 1 : 0;
}
// get hands' length
int leftHand = 0;
while ( ( hisValues[leftHand] == 0 ) && ( leftHand < bodyWidth ) )
leftHand++;
int rightHand = bodyWidth - 1;
while ( ( hisValues[rightHand] == 0 ) && ( rightHand > 0 ) )
rightHand--;
rightHand = bodyWidth - ( rightHand + 1 );
// get torso's width
int torsoWidth = bodyWidth - leftHand - rightHand;
// process left hand
if ( ( (double) leftHand / torsoWidth ) >= handsMinProportion )
{
// extract left hand's image
Crop cropFilter = new Crop( new Rectangle( 0, 0, leftHand, bodyHeight ) );
Bitmap leftHandImage = cropFilter.Apply( bodyImageData );
// get left hand's position
gesture.LeftHand = GetHandPosition( leftHandImage );
}
// process right hand
if ( ( (double) rightHand / torsoWidth ) >= handsMinProportion )
{
// extract right hand's image
Crop cropFilter = new Crop( new Rectangle( bodyWidth - rightHand, 0, rightHand, bodyHeight ) );
Bitmap rightHandImage = cropFilter.Apply( bodyImageData );
// get right hand's position
gesture.RightHand = GetHandPosition( rightHandImage );
}
if ( !bodyImageOnly )
{
// unlock body image and dispose it
bodyImage.UnlockBits( bodyImageData );
bodyImage.Dispose( );
}
return gesture;
}
private Bitmap CropDiff(Bitmap pixelDiff)
{
if (selection != null)
{
var crop = new Crop(selection.Value);
return crop.Apply(pixelDiff);
}
return pixelDiff;
}
/// <summary>
/// Constructs a new <see cref="MatchingTracker"/> object tracker.
/// </summary>
///
public MatchingTracker()
{
matcher = new ExhaustiveTemplateMatching(0);
crop = new Crop(Rectangle.Empty);
trackingObject = new TrackingObject();
}
public void TakePhotoOfPartAtCurrentLocation(TapeObj t)
{
if (t == null) return;
var dir = Global.BaseDirectory + @"\images\";
Directory.CreateDirectory(dir);
var size = t.GetComponentSize();
if (size == null) return;
var s = new PartLocation(size.Width, size.Height); //assumes 0 degree rotation
s = (1.5 * s) / MainForm.cameraView.downVideoProcessing.mmPerPixel; //convert to pixels and ad extra 25%
s.Rotate(t.PartAngle * Math.PI / 180d); //and rotate to final position
s.X = Math.Abs(s.X); //correct for sign changes
s.Y = Math.Abs(s.Y);
MainForm.cameraView.SetDownCameraFunctionSet("ComponentPhoto");
Global.DoBackgroundWork(); //let new images be processed
var topleft = MainForm.cameraView.downVideoProcessing.FrameCenter - (.5 * s);
var rect = new Rectangle(topleft.ToPoint(), s.ToSize());
var filter = new Crop(rect);
using (var image = MainForm.cameraView.downVideoProcessing.GetMeasurementFrame()) {
using (var cropped = filter.Apply(image)) {
var filename = dir + t.ID.Replace(" ", "_") + ".jpg";
if (File.Exists(filename)) File.Delete(filename);
cropped.Save(filename, ImageFormat.Jpeg);
t.TemplateFilename = filename;
}
}
}
/// <summary>
/// Detect hand on a given frame
/// </summary>
/// <param name="image">Image to detect the hand palm within</param>
/// <param name="cycles">Number of snapshot cycles to check against</param>
/// <param name="similarityRate">The threshold percent of pixels that have to match for a positive result</param>
/// <param name="trainingPic">A reference to secondary frame field. Temporary.</param>
/// <returns>IntPoint point at the centre of detected hand palm</returns>
public IntPoint DetectHand(Bitmap image, int cycles, int similarityRate, PictureBox trainingPic)
{
IntPoint dimensions = new IntPoint(image.Width, image.Height);
BlobCounterBase bc = new BlobCounter();
Crop cropFilter;
bc.FilterBlobs = true;
bc.MinWidth = (int)(avgSize.x * 0.6);
bc.MinHeight = (int)(avgSize.y * 0.6);
bc.ObjectsOrder = ObjectsOrder.Size;
bc.ProcessImage(image);
Blob[] blobs = bc.GetObjectsInformation();
int blobWidth = 0;
int blobHeight = 0;
float blobAspectRatio;
double angle;
RotateBilinear rotate;
ResizeBilinear resize = new ResizeBilinear((int)avgSize.x, (int)avgSize.y);
Bitmap bmp;
List<IntPoint> edges = new List<IntPoint>();
for (int b = 0; b < blobs.Length; b++)
{
Rectangle br = blobs[b].Rectangle;
cropFilter = new Crop(br);
image = cropFilter.Apply(image);
bmp = AForge.Imaging.Image.Clone(image);
//bc.ExtractBlobsImage(image, blobs[b], false);
//bmp = new Bitmap(image.Width, image.Height, PixelFormat.Format24bppRgb);
edges = bc.GetBlobsEdgePoints(blobs[b]);
IntPoint circleCenter = FindLargestCircleCenter(edges, blobs[b].Rectangle);
//bmp = ImageFilters.Draw(bmp, edges);
//Highlight circle center
//Graphics gfx = Graphics.FromImage(bmp);
//gfx.DrawRectangle(new Pen(Color.Red, 3), circleCenter.X - 10, circleCenter.Y - 10, 20, 20);
blobWidth = blobs[b].Rectangle.Width;
blobHeight = blobs[b].Rectangle.Height;
blobAspectRatio = (float)blobWidth / blobHeight;
if((blobAspectRatio) > avgAspectRatio + 0.08)
{
float test3 = avgSize.y / avgSize.x;
if ((blobAspectRatio - avgAspectRatio) <= 1)
{
angle = ((blobAspectRatio - avgAspectRatio) / (test3 - avgAspectRatio)) * 90 + (1 - (blobAspectRatio - avgAspectRatio)) * 30;
}
else
{
angle = ((blobAspectRatio - avgAspectRatio) / (test3 - avgAspectRatio)) * 90;
}
rotate = new RotateBilinear(angle, false);
image = rotate.Apply(image);
//bmp = rotate.Apply(bmp);
}
image = resize.Apply(image);
//bmp = resize.Apply(bmp);
//image = cropFilter.Apply(image);
//image = maxBlobFilter.Apply(image);
int scannedPixels = 0;
int matches = 0;
float test = 0;
float threshold = (float)similarityRate / 100;
int imgHeight, imgWidth;
for (int i = 0; i < cycles; i++)
{
for (int smpl = 0; smpl < 10; smpl++)
{
if (image.Size.Width < samples[i, smpl].Size.Width)
imgWidth = image.Size.Width;
else
imgWidth = samples[i, smpl].Size.Width;
if (image.Size.Height < samples[i, smpl].Size.Height)
imgHeight = image.Size.Height;
else
imgHeight = samples[i, smpl].Size.Height;
for (int y = 0; y < imgHeight; y += 3)
for (int x = 0; x < imgWidth; x += 3)
{
scannedPixels++;
lock (samples[i, smpl])
{
lock (image)
{
if (image.GetPixel(x, y).Equals(samples[i, smpl].GetPixel(x, y)))
{
matches++;
}
}
}
}
test = (float)matches / (float)scannedPixels;
if (test >= threshold)
{
//bc.ExtractBlobsImage(image, blobs[b], false);
//bmp.Save("detect" + detectedNum + "o.bmp");
//image.Save("detect" + detectedNum + "r.bmp");
detectedNum++;
return new IntPoint(dimensions.X - circleCenter.X, circleCenter.Y);
//return new IntPoint(image.Width - (int)blobs[b].CenterOfGravity.X, (int)blobs[b].CenterOfGravity.Y);
}
matches = 0;
scannedPixels = 0;
}
}
}
return new IntPoint();
}
public Bitmap GetTopRightPart()
{
if (image == null)
return null;
Crop crop = new Crop(new Rectangle(0, 17, 15, 20));//TODO card identity
var img = crop.Apply(image);
return img;
}
public Bitmap GetPart(Rectangle rect)
{
if (image == null)
return null;
Crop crop = new Crop(rect);//TODO card identity
var img = crop.Apply(image);
return img;
}
private Bitmap ProcessImage(Bitmap bitmap)
{
///CROP SYSTEM
//if (cropx1 != 0 && cropy1 != 0 && cropx2 != 0 && cropy2 != 0 && Worker.selected_square != 0)
//{
// Crop crop_filter = new Crop(new Rectangle(cropx1, cropy1, cropx2, cropy2));
// bitmap= crop_filter.Apply(bitmap);
// Console.WriteLine(">Crop Cutter:> Cropped\n({0},{1}),({2},{3})", cropx1, cropy1, cropx2, cropy2);
//}
//if (Worker.selected_square == 0)
//{
// Crop crop_filter = new Crop(new Rectangle(0, 0, bitmap.Width,bitmap.Height));
// bitmap = crop_filter.Apply(bitmap);
// //Console.WriteLine(">Crop Cutter:> RESET");
//}
//// step 2 - locating objects
if (cropx1 == 0 && cropy1 == 0 && cropx2 == 0 && cropy2 == 0)
{
cropx1 = 0;
cropy1 = 0;
cropx2 = bitmap.Width;
cropy2 = bitmap.Height;
}
Bitmap old = bitmap;
Crop crop_filter = new Crop(new Rectangle(cropx1, cropy1, cropx2, cropy2));
bitmap = crop_filter.Apply(bitmap);
// lock image
BitmapData bitmapData = bitmap.LockBits(
new Rectangle(0, 0, bitmap.Width, bitmap.Height),
ImageLockMode.ReadWrite, bitmap.PixelFormat);
// ////invert
// Invert inv = new Invert();
// // //apply the filter
//inv.ApplyInPlace(bitmapData);
//// create filter
//HSLFiltering filter = new HSLFiltering();
//// set color ranges to keep
//filter.Hue = new IntRange(90, 300);
//filter.Saturation = new Range(0.0f, .5f);
//filter.Luminance = new Range(0f, 1);
//// apply the filter
//filter.ApplyInPlace(bitmapData);
//EuclideanColorFiltering filter = new EuclideanColorFiltering();
//// set center colol and radius
//filter.CenterColor = new RGB(209, 206, 196);
//filter.Radius = 150;
//// apply the filter
//filter.ApplyInPlace(bitmapData);
//// create filter
ChannelFiltering filter = new ChannelFiltering();
//// set channels' ranges to keep
Invert inv = new Invert();
//// //apply the filter
inv.ApplyInPlace(bitmapData);
if (red_max > 255)
{
red_max = 255;
Console.WriteLine("1THRESHOLD OVERIDE");
}
if (blue_max > 255)
{
blue_max = 255;
Console.WriteLine("2THRESHOLD OVERIDE");
}
if (green_max > 255)
{
green_max = 255;
Console.WriteLine("3THRESHOLD OVERIDE");
}
if (red > 255)
{
red = 254;
Console.WriteLine("4THRESHOLD OVERIDE");
}
if (blue > 255)
{
blue = 254;
Console.WriteLine("5THRESHOLD OVERIDE");
}
if (green > 255)
{
green = 254;
Console.WriteLine("6THRESHOLD OVERIDE");
}
if (red < 0)
{
red = 1;
Console.WriteLine("7THRESHOLD UNDERIDE");
}
if (blue < 0)
{
blue = 1;
Console.WriteLine("8THRESHOLD UNDERIDE");
}
if (green < 0)
{
green = 1;
Console.WriteLine("9THRESHOLD UNDERIDE");
}
if (red_max < 0)
{
red_max = 255;
Console.WriteLine("10THRESHOLD UNDERIDE");
}
if (blue_max < 0)
{
blue_max = 255;
Console.WriteLine("11THRESHOLD UNDERIDE");
}
if (green_max < 0)
{
green_max = 255;
Console.WriteLine("13THRESHOLD UNDERIDE");
}
if (red_max < red)
{
Console.WriteLine("14THRESHOLD UNION ERROR");
red = 0;
red_max = 255;
}
if (blue_max < blue)
{
blue = 0;
Console.WriteLine("15THRESHOLD UNION ERROR");
blue_max = 255;
}
if (green_max < green)
{
green = 0;
green_max = 255;
Console.WriteLine("16THRESHOLD UNION ERROR");
}
file.WriteLine("R: " + red + " R_M: " + red_max);
file.WriteLine("G: " + green + " G_M: " + green_max);
file.WriteLine("B: " + blue + " B_M: " + blue_max);
file.WriteLine("EOE");
//file.Close();
filter.Red = new IntRange(red, red_max);
filter.Green = new IntRange(green, green_max);
filter.Blue = new IntRange(blue, blue_max);
//// apply the filter
filter.ApplyInPlace(bitmapData);
////invert
//edge
//CannyEdgeDetector edge_filter = new CannyEdgeDetector();
//// apply the filter
//edge_filter.ApplyInPlace(bitmapData);
BlobCounter blobCounter = new BlobCounter();
blobCounter.FilterBlobs = true;
blobCounter.MinHeight = blob_size * 3;
blobCounter.MinWidth = blob_size * 4;
blobCounter.ProcessImage(bitmapData);
Blob[] 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); // circles
Pen redPen = new Pen(Color.Red, 2); // quadrilateral
Pen brownPen = new Pen(Color.Brown, 2); // quadrilateral with known sub-type
Pen greenPen = new Pen(Color.Green, 2); // known triangle
Pen bluePen = new Pen(Color.Blue, 2); // triangle
double curdist = 0;
double leastdist = 100;
//List<IntPoint> bestcorn;//promoted to super
for (int i = 0, n = blobs.Length; i < n; i++)
{
List<IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]);
List<IntPoint> corners; // the list of x,y coordinates. corners(list)->corner(intpoint)->[x,y]
// is triangle or quadrilateral
if (shapeChecker.IsConvexPolygon(edgePoints, out corners))
{
cornide = corners;
// get sub-type
PolygonSubType subType = shapeChecker.CheckPolygonSubType(corners);
Pen pen;
if (subType == PolygonSubType.Rectangle || subType == PolygonSubType.Trapezoid || subType == PolygonSubType.Parallelogram || subType == PolygonSubType.Rhombus || subType == PolygonSubType.Square || subType == PolygonSubType.Unknown)
{
if (corners.Count == 4)
{
pen = redPen;
IntPoint[] array_of_corners = corners.ToArray();//array_of_corners is now an array of corners
if (((732 / avdisty(array_of_corners)) + .222) < ((989 / avdistx(array_of_corners)) + 3.37))
{
curdist = ((732 / avdisty(array_of_corners)) + .222);//from our graph
}
else
{
curdist = ((989 / avdistx(array_of_corners)) + 3.37);//from our graph
}
//if (Worker.selected_square == 1)
//{
// Console.WriteLine("called\n");
// IntPoint one = array_of_corners[0];
// IntPoint two = array_of_corners[3];
// cropx1 = one.X - 5;
// cropy1 = one.Y - 5;
// cropx2 = two.X + 5;
// cropy2 = two.Y + 5;
//}
//else if (i == Worker.selected_square - 1 && Worker.selected_square != 1)
//{
// Console.WriteLine("called\n");
// IntPoint one = array_of_corners[0];
// IntPoint two = array_of_corners[3];
// cropx1 = one.X - 5;
// cropy1 = one.Y - 5;
// cropx2 = two.X + 5;
// cropy2 = two.Y + 5;
//}
//if (Worker.selected_square == 0)
//{
// cropx1 = 0;
// cropy1 = 0;
// cropx2 = 0;
// cropy2 = 0;
//}
if (Worker.selected_square == 0)//PREDATOR VISION
{
if (curdist < leastdist)
{
// Console.WriteLine((abs(array_of_corners[0].Y - array_of_corners[1].Y)) / (abs(array_of_corners[0].X - array_of_corners[1].X)));
//if ((abs(array_of_corners[0].Y - array_of_corners[3].Y)) / (abs(array_of_corners[0].X - array_of_corners[1].X)) < 1.25 && (abs(array_of_corners[0].Y - array_of_corners[3].Y)) / (abs(array_of_corners[0].X - array_of_corners[1].X)) > .5)
if (true)
{
leastdist = curdist;
if (leastdist < 55 && leastdist > 2)
{
double angle = (array_of_corners[0].X + array_of_corners[3].X) / 2;
Console.WriteLine("0: " + array_of_corners[0].X + " 1: " + array_of_corners[1].X + " 2: " + array_of_corners[2].X + " 3: " + array_of_corners[3].X);
Server.SetData(((array_of_corners[0].X + array_of_corners[1].X) / 2), 1);
Console.WriteLine("PREDATOR: " + Server.GetData(1));
Console.WriteLine(leastdist);
Server.SetData(leastdist, 0);
bestcorn = corners;//superify?
//g.DrawPolygon(pen, ToPointsArray(bestcorn));//leave here as a comment
IntPoint ones = array_of_corners[0];
PointF string_draw = new PointF(ones.X, ones.Y);
SolidBrush tbrush = new SolidBrush(Color.Red);
try
{
if (string_draw.X != 0 && string_draw.Y != 0)
{
g.DrawString(n.ToString(), this.Font, tbrush, string_draw);
}
}
catch (Exception e)
{
Console.WriteLine("{0} in {1} ({2},{3})", e.Message, e.StackTrace, string_draw.X, string_draw.Y);
}
}
}
}
try
{
Graphics global_graphics_predator = Graphics.FromImage(bitmap);
Pen penc = new Pen(Color.YellowGreen, 2);
//g.DrawPolygon(penc, ToPointsArray(bestcorn));
global_graphics_predator.DrawPolygon(penc, ToPointsArray(bestcorn));
global_graphics_predator.DrawLine(penc, new System.Drawing.Point(320, 1), new System.Drawing.Point(320, 479));
//bitmap = global_bitmap;
}
catch (Exception e)
{
}
yellowPen.Dispose();
redPen.Dispose();
greenPen.Dispose();
bluePen.Dispose();
brownPen.Dispose();
g.Dispose();
return bitmap;
}
else
{
int sel_least_dist = Worker.selected_square;
sel_least_dist *= 3;//threefeet
sel_least_dist -= 1;
int sel_max_dist = sel_least_dist + 5;
Console.WriteLine(sel_least_dist);
Console.WriteLine(sel_max_dist);
//Console.WriteLine(sel_least_dist + " " + sel_max_dist);
if (curdist < leastdist && curdist > sel_least_dist && curdist < sel_max_dist)
{
// Console.WriteLine((abs(array_of_corners[0].Y - array_of_corners[1].Y)) / (abs(array_of_corners[0].X - array_of_corners[1].X)));
//if ((abs(array_of_corners[0].Y - array_of_corners[3].Y)) / (abs(array_of_corners[0].X - array_of_corners[1].X)) < 1.25 && (abs(array_of_corners[0].Y - array_of_corners[3].Y)) / (abs(array_of_corners[0].X - array_of_corners[1].X)) > .5)
if (true)//todo
{
leastdist = curdist;
if (leastdist < 55 && leastdist > 2)
{
// Console.WriteLine("0: " + array_of_corners[0].X + " 1: " + array_of_corners[1].X + " 2: " + array_of_corners[2].X + " 3: " + array_of_corners[3].X);
Server.SetData(((array_of_corners[0].X + array_of_corners[1].X) / 2), 1);
Console.WriteLine(Server.GetData(1));
//Console.WriteLine(leastdist);
Server.SetData(leastdist, 0);
bestcorn = corners;//superify?
//g.DrawPolygon(pen, ToPointsArray(bestcorn));//leave here as a comment
IntPoint ones = array_of_corners[0];
PointF string_draw = new PointF(ones.X, ones.Y);
SolidBrush tbrush = new SolidBrush(Color.Red);
try
{
if (string_draw.X != 0 && string_draw.Y != 0)
{
g.DrawString(n.ToString(), this.Font, tbrush, string_draw);
// glob.DrawLine(penc, new System.Drawing.Point(10, 10), new System.Drawing.Point(20, 20));
//g.DrawLine(pen, new System.Drawing.Point(10, 10), new System.Drawing.Point(20, 20));
}
}
catch (Exception e)
{
Console.WriteLine("{0} in {1} ({2},{3})", e.Message, e.StackTrace, string_draw.X, string_draw.Y);
}
}
}
}
}
//pen = (corners.Count == 4) ? redPen : bluePen;
}//TODO get rid of anything that ISNT drawn, eg corner
}
//else
//{
// pen = (corners.Count == 4) ? brownPen : greenPen;
//}
}
}
//Console.WriteLine(leastdist); how dod oyo
//double leastdist = 0;
//for (int i = 0, n = blobs.Length; i < n; i++)
//{
// try
// {
// List<IntPoint> filterlist;
// filterlist = cornide;
// IntPoint[] filter_corners = filterlist.ToArray();
// double currentdist = 0;
// for (int corner_count = 0; corner_count < filter_corners.Length; corner_count++)
// {
// IntPoint one_f = filter_corners[corner_count];
// corner_count++;
// IntPoint two_f = filter_corners[corner_count];
// corner_count++;
// IntPoint three_f = filter_corners[corner_count];
// corner_count++;
// IntPoint four_f = filter_corners[corner_count];
// double y_average_a = ((double)one_f.Y + (double)two_f.Y) / 2;
// double y_average_b = ((double)three_f.Y + (double)four_f.Y) / 2;
// double averaged_dist = y_average_b - y_average_a;
// currentdist = ((732 / averaged_dist) + .222);//from our graph
// if (currentdist <= leastdist)
// {
// leastdist = currentdist;
// Pen pencil = redPen;
// g.DrawPolygon(pencil, ToPointsArray(filterlist));
// }
// }
// }
// catch
// {
// //do nothING
// }
//}
//Console.WriteLine(leastdist);
try
{
Graphics global_graphics = Graphics.FromImage(global_bitmap);
Pen penc = new Pen(Color.YellowGreen, 2);
{
//g.DrawPolygon(penc, ToPointsArray(bestcorn));
global_graphics.DrawPolygon(penc, ToPointsArray(bestcorn));
global_graphics.DrawLine(penc, new System.Drawing.Point(320, 1), new System.Drawing.Point(320, 479));
bitmap = global_bitmap;
}
}
catch (Exception e)
{
}
try
{
g.DrawLine(redPen, 220, 1, 220, 100);
}
catch (Exception e)
{
Console.WriteLine(e.StackTrace);
Console.WriteLine(e.InnerException);
}
yellowPen.Dispose();
redPen.Dispose();
greenPen.Dispose();
bluePen.Dispose();
brownPen.Dispose();
g.Dispose();
return bitmap;
}
/// <summary>
///
/// </summary>
/// <param name="image"></param>
/// <param name="start"></param>
/// <param name="maxEyeRadius">Should be 2-3 percent of max(width/height)</param>
/// <param name="maxPointSearchDistance">In source pixels, the max distance from 'start' from which to look for the starting point. Good default: roughly 24 display pixels.</param>
public static void MarkEye(UnmanagedImage image, Point start, int maxEyeRadius, float maxPointSearchDistance = 0)
{
int maxRadius = maxEyeRadius * 2 + (int)Math.Ceiling(maxPointSearchDistance);
//Find subset
Rectangle subset = new Rectangle(start.X - maxRadius,start.Y - maxRadius,maxRadius * 2, maxRadius * 2);
if (subset.X < 0) { subset.Width += subset.X; subset.X = 0; }
if (subset.Y < 0) { subset.Height += subset.Y; subset.Y = 0; }
if (subset.Right >= image.Width) subset.Width -= (subset.Right - image.Width + 1);
if (subset.Bottom >= image.Height) subset.Height -= (subset.Bottom - image.Height + 1);
start.X -= subset.X;
start.Y -= subset.Y;
//Skip processing if we're slightly out of bounds
if (subset.X < 0 || subset.Y < 0 || subset.Width < 0 || subset.Height < 0 || subset.Right >= image.Width || subset.Bottom >= image.Height) return;
UnmanagedImage red = null;
try{
Point startAt = start;
using (UnmanagedImage c = new Crop(subset).Apply(image)) {
red = new RedEyeFilter(2).Apply(c);
if (maxPointSearchDistance > 0) startAt = new ManualSearcher().FindMaxPixel(c,start,maxPointSearchDistance);
}
var fill = new AdaptiveCircleFill(red, startAt, start, maxEyeRadius * 2);
fill.FirstPass();
fill.SecondPass();
fill.CorrectRedEye(image, subset.X, subset.Y);
//fill.MarkFilledPixels(image, subset.X, subset.Y, new byte[] { 0, 255, 0, 0 });
//fill.SetPixel(image, startAt.X + subset.X, startAt.Y + subset.Y, new byte[] { 255, 255, 0, 0 });
}finally{
if (red != null) red.Dispose();
}
}
public Bitmap GetSelectedPicture()
{
var crop = new Crop(Rect);
var newBmp = crop.Apply(pictureBox1.Image as Bitmap);
return newBmp;
}
// =========================================================
private void ZoomFunct(ref Bitmap frame, double Factor)
{
if (Factor < 0.1)
{
return;
}
int centerX = frame.Width / 2;
int centerY = frame.Height / 2;
int OrgSizeX = frame.Width;
int OrgSizeY = frame.Height;
int fromX = centerX - (int)(centerX / Factor);
int fromY = centerY - (int)(centerY / Factor);
int SizeX = (int)(OrgSizeX / Factor);
int SizeY = (int)(OrgSizeY / Factor);
Crop CrFilter = new Crop(new Rectangle(fromX, fromY, SizeX, SizeY));
frame = CrFilter.Apply(frame);
ResizeBilinear RBfilter = new ResizeBilinear(OrgSizeX, OrgSizeY);
frame = RBfilter.Apply(frame);
}
/// <summary>
/// Scans dominant color on image and returns it.
/// Crops rank part on image and analyzes suit part on image
/// </summary>
/// <param name="bmp">Bitmap to be scanned</param>
/// <returns>Returns 'B' for black , 'R' for red</returns>
private char ScanColor(Bitmap bmp)
{
char color = 'B';
//Crop rank part
Crop crop = new Crop(new Rectangle(0, bmp.Height / 2, bmp.Width, bmp.Height / 2));
bmp = crop.Apply(bmp);
Bitmap temp = commonSeq.Apply(bmp); //Apply filters
//Find suit blob on image
BlobCounter counter = new BlobCounter();
counter.ProcessImage(temp);
Blob[] blobs = counter.GetObjectsInformation();
if (blobs.Length > 0) //If blobs found
{
Blob max = blobs[0];
//Find blob whose size is biggest
foreach (Blob blob in blobs)
{
if (blob.Rectangle.Height > max.Rectangle.Height)
max = blob;
else if (blob.Rectangle.Height == max.Rectangle.Height)
max = blob.Rectangle.Width > max.Rectangle.Width ? blob : max;
}
QuadrilateralTransformation trans = new QuadrilateralTransformation();
trans.SourceQuadrilateral = PointsCloud.FindQuadrilateralCorners(counter.GetBlobsEdgePoints(max));
bmp = trans.Apply(bmp); //Extract suit
}
//Lock Bits for processing
BitmapData imageData = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height),
ImageLockMode.ReadOnly, bmp.PixelFormat);
int totalRed = 0;
int totalBlack = 0;
unsafe
{
//Count red and black pixels
try
{
UnmanagedImage img = new UnmanagedImage(imageData);
int height = img.Height;
int width = img.Width;
int pixelSize = (img.PixelFormat == PixelFormat.Format24bppRgb) ? 3 : 4;
byte* p = (byte*)img.ImageData.ToPointer();
// for each line
for (int y = 0; y < height; y++)
{
// for each pixel
for (int x = 0; x < width; x++, p += pixelSize)
{
int r = (int)p[RGB.R]; //Red pixel value
int g = (int)p[RGB.G]; //Green pixel value
int b = (int)p[RGB.B]; //Blue pixel value
if (r > g + b) //If red component is bigger then total of green and blue component
totalRed++; //then its red
if (r <= g + b && r < 50 && g < 50 && b < 50) //If all components less 50
totalBlack++; //then its black
}
}
}
finally
{
bmp.UnlockBits(imageData); //Unlock
}
}
if (totalRed > totalBlack) //If red is dominant
color = 'R'; //Set color as Red
return color;
}
/// <summary>
/// Function that crops top-right part of card image , with size 30x60
/// </summary>
/// <returns>Cropped image</returns>
public Bitmap GetTopRightPart()
{
if (image == null)
return null;
Crop crop = new Crop(new Rectangle(image.Width - 37, 10, 30, 60));
return crop.Apply(image);
}
/// <summary>
/// Get movement samples from the specified image area
/// </summary>
/// <param name="x">Position of the upper left corner of the area on the x axis</param>
/// <param name="y">Position of the upper left corner on of the area the y axis</param>
/// <param name="width">Width of the area</param>
/// <param name="height">Height of the area</param>
/// <param name="maxCycles">Number of cycles to run</param>
/// <param name="getImg">A delegate returning images to process</param>
/// <param name="progEv">A delegate specifying code to run when progress of learning changes</param>
/// <param name="complEv">A delegate specifying code to run when learning is complete</param>
public void Learn(int x, int y, int width, int height, int maxCycles, Func<Bitmap> getImg, ProgressChangedEventHandler progEv,
RunWorkerCompletedEventHandler complEv)
{
if (samples != null)
{
foreach(Bitmap b in samples)
{
b.Dispose();
}
}
ResizeBilinear resize = new ResizeBilinear(70, (int)(70 * ((float)height / width)));
BackgroundWorker bw = new BackgroundWorker();
samples = new Bitmap[maxCycles, 10];
Crop cropFilter;
Mirror mirror = new Mirror(false,true);
HomogenityEdgeDetector edgeDetector = new HomogenityEdgeDetector();
// this allows our worker to report progress during work
bw.WorkerReportsProgress = true;
// what to do in the background thread
bw.DoWork += new DoWorkEventHandler(
delegate(object o, DoWorkEventArgs args)
{
BackgroundWorker b = o as BackgroundWorker;
//Bitmap img;
int xSize = 0, ySize = 0;
int numImages = 0;
for (int learningPoints = 0; learningPoints < maxCycles; learningPoints++)
{
b.ReportProgress((100 / maxCycles) * learningPoints);
for (int tutorialBox = 0; tutorialBox < 100; tutorialBox++)
{
if (tutorialBox % 10 == 0)
{
numImages += 1;
b.ReportProgress((100 / maxCycles) * learningPoints + (tutorialBox / maxCycles));
cropFilter = new Crop(new Rectangle(x - tutorialBox, y, width, height));
//img = resize.Apply(maxBlobFilter.Apply(cropFilter.Apply(getImg())));
xSize += width;
ySize += height;
samples[learningPoints, tutorialBox / 10] = resize.Apply(mirror.Apply(cropFilter.Apply(getImg())));
samples[learningPoints, tutorialBox / 10].Save("sample" + tutorialBox / 10 + ".bmp");
}
System.Threading.Thread.Sleep(15);
}
}
avgSize.x = (float)xSize / numImages;
avgSize.y = (float)ySize / numImages;
avgAspectRatio = (float)xSize / ySize;
b.ReportProgress(100);
args.Result = samples;
});
// what to do when progress changed (update the progress bar for example)
bw.ProgressChanged += progEv;
// what to do when worker completes its task (notify the user)
bw.RunWorkerCompleted += complEv;
bw.RunWorkerAsync();
}
// New frame received by the player
private void videoSourcePlayer_NewFrame( object sender, ref Bitmap image )
{
BitmapData imageData = image.LockBits(new Rectangle(0, 0, image.Width, image.Height), ImageLockMode.ReadWrite, image.PixelFormat);
try
{
UnmanagedImage unmanagedImg = new UnmanagedImage( imageData );
int x = (int)(unmanagedImg.Width / 3.19); // 443
int y = (int)(unmanagedImg.Height / 2.2); // 490
int w = (int)(unmanagedImg.Width / 2.7); // 553
int h = (int)(unmanagedImg.Height / 4); // 270
int s = (int)(unmanagedImg.Width / 10.2); // 141
// Crop the player scroll window. Speeds up the next couple operations
Crop onePlayer = new Crop(new Rectangle(x, y, w, h));
UnmanagedImage img = onePlayer.Apply(unmanagedImg);
// Use a quadrilateral transformation to make the scroller a big square.
List<IntPoint> corners = new List<IntPoint>();
corners.Add(new IntPoint(s, 0));
corners.Add(new IntPoint(img.Width - s, 0)); ;
corners.Add(new IntPoint(img.Width, img.Height));
corners.Add(new IntPoint(0, img.Height));
QuadrilateralTransformation filter =
new QuadrilateralTransformation(corners, img.Width, img.Height);
img = filter.Apply(img);
// Crop the bottom half since it appears to have the best imagery
Crop bottom = new Crop(new Rectangle(0, img.Height / 2, img.Width, img.Height / 2));
img = bottom.Apply(img);
UnmanagedImage grayImg = UnmanagedImage.Create(img.Width, img.Height, PixelFormat.Format8bppIndexed);
Grayscale.CommonAlgorithms.BT709.Apply(img, grayImg);
OtsuThreshold threshold = new OtsuThreshold();
threshold.ApplyInPlace(grayImg);
// Divide the square into 5 peices. One for each color.
UnmanagedImage[] colorImg = new UnmanagedImage[5];
for(int i=0; i < 5; i++) {
int colorWidth = grayImg.Width / 5;
int colorHeight = grayImg.Height;
Crop colorCrop = new Crop(new Rectangle(colorWidth * i, 0, colorWidth, colorHeight));
colorImg[i] = colorCrop.Apply(grayImg);
}
greenCol.Image = colorImg[GREEN].ToManagedImage();
redCol.Image = colorImg[RED].ToManagedImage();
yellowCol.Image = colorImg[YELLOW].ToManagedImage();
blueCol.Image = colorImg[BLUE].ToManagedImage();
orangeCol.Image = colorImg[ORANGE].ToManagedImage();
VerticalIntensityStatistics[] hist = new VerticalIntensityStatistics[5];
for (int i = 0; i < 5; i++)
{
hist[i] = new VerticalIntensityStatistics(colorImg[i]);
}
findPucks(hist);
greenHist.Values = hist[GREEN].Gray.Values;
redHist.Values = hist[RED].Gray.Values;
yellowHist.Values = hist[YELLOW].Gray.Values;
blueHist.Values = hist[BLUE].Gray.Values;
orangeHist.Values = hist[ORANGE].Gray.Values;
pictureBox1.Image = img.ToManagedImage();
}
finally
{
image.UnlockBits( imageData );
}
}
/// <summary>
/// Scans dominant color on image and returns it.
/// Crops rank part on image and analyzes suit part on image
/// </summary>
/// <param name="bmp">Bitmap to be scanned</param>
/// <returns>Returns 'B' for black , 'R' for red</returns>
private char ScanColor(Bitmap bmp)
{
//System.Diagnostics.Debug.Flush();
//System.Diagnostics.Debug.Print("I'm here");
char color = 'B';
//Crop rank part
Crop crop = new Crop(new Rectangle(0, bmp.Height / 2, bmp.Width, bmp.Height / 2));
bmp = crop.Apply(bmp);
Bitmap temp = commonSeq.Apply(bmp); //Apply filters
//Find suit blob on image
BlobCounter counter = new BlobCounter();
counter.ProcessImage(temp);
Blob[] blobs = counter.GetObjectsInformation();
if (blobs.Length > 0) //If blobs found
{
Blob max = blobs[0];
//Find blob whose size is biggest
foreach (Blob blob in blobs)
{
if (blob.Rectangle.Height > max.Rectangle.Height)
max = blob;
else if (blob.Rectangle.Height == max.Rectangle.Height)
max = blob.Rectangle.Width > max.Rectangle.Width ? blob : max;
}
QuadrilateralTransformation trans = new QuadrilateralTransformation();
trans.SourceQuadrilateral = PointsCloud.FindQuadrilateralCorners(counter.GetBlobsEdgePoints(max));
bmp = trans.Apply(bmp); //Extract suit
}
//Lock Bits for processing
//int bitsPerPixel = ((int)bmp.PixelFormat & 0xff00) >> 8;
//int bytesPerPixel = (bitsPerPixel + 7) / 8;
//int stride = 4 * ((bmp.Width * bytesPerPixel + 3) / 4);
// BitmapData imageData=new BitmapData(bmp.Width, bmp.Height, bmp. )
// BitmapData imageData = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height),ImageLockMode.ReadOnly, bmp.PixelFormat);
int totalRed = 0;
int totalBlack = 0;
WriteableBitmap wbmp = (WriteableBitmap)bmp;
wbmp.ForEach((x, y, pcolor) =>
{
int r=Convert.ToInt32(pcolor.R);
int g=Convert.ToInt32(pcolor.G);
int b=Convert.ToInt32(pcolor.B);
if (r > g + b)
totalRed++;
else if (r <= g + b && (r < 50 && g < 50))
totalBlack++;
return pcolor;
});
if (totalRed > totalBlack) //If red is dominant
color = 'R'; //Set color as Red
return color;
}
private void timer1_Tick(object sender, EventArgs e)
{
IVideoSource videoSource1 = videoSourcePlayer1.VideoSource;
Bitmap currentVideoFrame = videoSourcePlayer1.GetCurrentVideoFrame();
pictureBox1.Image = currentVideoFrame;
if (currentVideoFrame != null)
{
Crop filter1 = new Crop(new Rectangle(1, 1, 319, 479));
Crop filter2 = new Crop(new Rectangle(321, 1, 639, 479));
Bitmap leftimage = filter1.Apply(currentVideoFrame);
Bitmap rightimage = filter2.Apply(currentVideoFrame);
// get grayscale image
IFilter grayscaleFilter = new GrayscaleRMY();
leftimage = grayscaleFilter.Apply(leftimage);
rightimage = grayscaleFilter.Apply(rightimage);
// apply threshold filter
Threshold th = new Threshold(trackBar1.Value);
Bitmap filteredImage1 = th.Apply(leftimage);
pictureBox2.Image = filteredImage1;
Bitmap filteredImage2 = th.Apply(rightimage);
pictureBox3.Image = filteredImage2;
label6.Text = trackBar1.Value.ToString();
ImageStatistics lftstat = new ImageStatistics(filteredImage1);
int lftpxlcntwthoutblck = lftstat.PixelsCountWithoutBlack;
ImageStatistics rghtstat = new ImageStatistics(filteredImage2);
int rghtpxlcntwthoutblck = rghtstat.PixelsCountWithoutBlack;
int val = trackBar1.Value;
if (((lftpxlcntwthoutblck - rghtpxlcntwthoutblck) > val) || ((rghtpxlcntwthoutblck - lftpxlcntwthoutblck) > val))
{
if ((lftpxlcntwthoutblck-rghtpxlcntwthoutblck) >val)
{
//label4.Text = "left";
label4.Text = "right";
}
if ((rghtpxlcntwthoutblck-lftpxlcntwthoutblck) >val)
{
//label4.Text = "right";
label4.Text = "left";
}
}
else if ((lftpxlcntwthoutblck == 0) && (rghtpxlcntwthoutblck == 0))
{
label4.Text = "Stop!! No space ahead";
}
else {
label4.Text = "Forward";
}
}
}
public Bitmap CutWhiteSpaces(Bitmap bmp)
{
Bitmap tempBlob = bmp;
int x, y;
x = 0;
y = 0;
while (true)
{
if (tempBlob.GetPixel(x, y).R < 127) break;
y++;
if (y >= tempBlob.Height)
{
y = 0;
x++;
if (x >= tempBlob.Width) break;
}
}
int xMin = x;
x = tempBlob.Width - 1;
y = 0;
while (true)
{
if (tempBlob.GetPixel(x, y).R < 127) break;
y++;
if (y >= tempBlob.Height)
{
y = 0;
x--;
if (x == 0) break;
}
}
int xMax = x;
x = 0;
y = 0;
while (true)
{
if (tempBlob.GetPixel(x, y).R < 127) break;
x++;
if (x >= tempBlob.Width)
{
x = 0;
y++;
if (y >= tempBlob.Height) break;
}
}
int yMin = y;
x = 0;
y = tempBlob.Height - 1;
while (true)
{
if (tempBlob.GetPixel(x, y).R < 127) break;
x++;
if (x >= tempBlob.Width)
{
x = 0;
y--;
if (y >= tempBlob.Height) break;
}
}
int yMax = y;
Crop crop = new Crop(new Rectangle(xMin, yMin, xMax - xMin+1, yMax - yMin+1));
tempBlob = crop.Apply(bmp);
return tempBlob;
}
/// <summary>
/// Function that crops top-right part of card image , with size 30x60
/// </summary>
/// <returns>Cropped image</returns>
public Bitmap GetTopLeftPart()
{
if (image == null)
return null;
Crop crop = new Crop(new Rectangle(0, 0, 30, 84));
Bitmap im2 = crop.Apply(image);
//im2.Save("cropped", System.Drawing.Imaging.ImageFormat.Jpeg);
return crop.Apply(image);
}
private void VideoNewFrame(object sender, NewFrameEventArgs e)
{
var nf = NewFrame;
var f = e.Frame;
if (_requestedToStop || nf==null || f==null)
return;
if (_lastframeEvent > DateTime.MinValue)
{
if ((Helper.Now<_nextFrameTarget))
{
return;
}
CalculateFramerates();
}
_lastframeEvent = Helper.Now;
Bitmap bmOrig = null;
bool bMotion = false;
lock (_sync)
{
try
{
bmOrig = ResizeBmOrig(f);
if (RotateFlipType != RotateFlipType.RotateNoneFlipNone)
{
bmOrig.RotateFlip(RotateFlipType);
}
_width = bmOrig.Width;
_height = bmOrig.Height;
if (ZPoint == Point.Empty)
{
ZPoint = new Point(bmOrig.Width / 2, bmOrig.Height / 2);
}
if (CW.NeedMotionZones)
CW.NeedMotionZones = !SetMotionZones(CW.Camobject.detector.motionzones);
if (Mask != null)
{
ApplyMask(bmOrig);
}
if (CW.Camobject.alerts.active && Plugin != null && Alarm!=null)
{
bmOrig = RunPlugin(bmOrig);
}
var bmd = bmOrig.LockBits(new Rectangle(0, 0, bmOrig.Width, bmOrig.Height), ImageLockMode.ReadWrite, bmOrig.PixelFormat);
//this converts the image into a windows displayable image so do it regardless
using (var lfu = new UnmanagedImage(bmd))
{
if (_motionDetector != null)
{
bMotion = ApplyMotionDetector(lfu);
}
else
{
MotionDetected = false;
}
if (CW.Camobject.settings.FishEyeCorrect)
{
_feCorrect.Correct(lfu, CW.Camobject.settings.FishEyeFocalLengthPX,
CW.Camobject.settings.FishEyeLimit, CW.Camobject.settings.FishEyeScale, ZPoint.X,
ZPoint.Y);
}
if (ZFactor > 1)
{
var f1 = new ResizeNearestNeighbor(lfu.Width, lfu.Height);
var f2 = new Crop(ViewRectangle);
try
{
using (var imgTemp = f2.Apply(lfu))
{
f1.Apply(imgTemp, lfu);
}
}
catch (Exception ex)
{
ErrorHandler?.Invoke(ex.Message);
}
}
}
bmOrig.UnlockBits(bmd);
PiP(bmOrig);
AddTimestamp(bmOrig);
}
catch (UnsupportedImageFormatException ex)
{
CW.VideoSourceErrorState = true;
CW.VideoSourceErrorMessage = ex.Message;
bmOrig?.Dispose();
return;
}
catch (Exception ex)
{
bmOrig?.Dispose();
ErrorHandler?.Invoke(ex.Message);
return;
}
if (MotionDetector != null && !CW.Calibrating && MotionDetector.MotionProcessingAlgorithm is BlobCountingObjectsProcessing && !CW.PTZNavigate && CW.Camobject.settings.ptzautotrack)
{
try
{
ProcessAutoTracking();
}
catch (Exception ex)
{
ErrorHandler?.Invoke(ex.Message);
}
}
}
if (!_requestedToStop)
{
nf.Invoke(this, new NewFrameEventArgs(bmOrig));
}
if (bMotion)
{
TriggerDetect(this);
}
}
public static Image ApplyImageProperties(byte[] blobContent, ImageProperties properties)
{
Bitmap image = null;
try {
using (var ms = new MemoryStream(blobContent)) {
image = (Bitmap)System.Drawing.Image.FromStream(ms, false, false);
image = AForge.Imaging.Image.Clone(image, PixelFormat.Format24bppRgb);
if (properties.Crop != null)
{
AForge.Imaging.Filters.Crop filter = new AForge.Imaging.Filters.Crop(new Rectangle(properties.Crop.XOffset, properties.Crop.YOffset, properties.Crop.CropWidth, properties.Crop.CropHeight));
image = filter.Apply(image);
}
if (properties.ImageWidth != properties.OriginalWidth || properties.ImageHeight != properties.OriginalHeight)
{
var filter = new ResizeBicubic(properties.ImageWidth, properties.ImageHeight);
image = filter.Apply(image);
}
if (properties.Colors != null)
{
if (properties.Colors.TransparentColor != null)
{
image.MakeTransparent(ColorTranslator.FromHtml("#" + properties.Colors.TransparentColor));
}
var brightness = properties.Colors.Brightness;
var bfilter = new BrightnessCorrection(brightness);
bfilter.ApplyInPlace(image);
var contrast = properties.Colors.Contrast;
var cfilter = new ContrastCorrection(contrast);
cfilter.ApplyInPlace(image);
if (properties.Colors.Hue != 0)
{
var hue = properties.Colors.Hue;
HueModifier filter = new HueModifier(hue);
filter.ApplyInPlace(image);
}
var saturation = properties.Colors.Saturation;
var sfilter = new SaturationCorrection(saturation * 0.01f);
sfilter.ApplyInPlace(image);
}
# region Effects
if (!String.IsNullOrEmpty(properties.Effects))
{
var effects = properties.Effects.Split(';');
foreach (var item in effects)
{
switch (item)
{
case "Grayscale":
var g = new Grayscale(0.2125, 0.7154, 0.0721);
image = g.Apply(image);
break;
case "Sepia":
var s = new Sepia();
image = AForge.Imaging.Image.Clone(image, PixelFormat.Format24bppRgb);
s.ApplyInPlace(image);
break;
case "Rotate Channels":
image = AForge.Imaging.Image.Clone(image, PixelFormat.Format24bppRgb);
var r = new RotateChannels();
r.ApplyInPlace(image);
break;
case "Invert":
var i = new Invert();
i.ApplyInPlace(image);
break;
case "Blur":
var b = new Blur();
b.ApplyInPlace(image);
break;
case "Gaussian Blur":
var gb = new GaussianBlur(4, 11);
gb.ApplyInPlace(image);
break;
case "Convolution":
int[,] kernel = { { -2, -1, 0 }, { -1, 1, 1 }, { 0, 1, 2 } };
var c = new Convolution(kernel);
c.ApplyInPlace(image);
break;
case "Edges":
var e = new Edges();
e.ApplyInPlace(image);
break;
}
}
}
# endregion
}
} catch (Exception) {