private static void TakeScreenshot(Form form,
string destinationFile,
string destinationFileInverted)
{
if (File.Exists(destinationFile))
{
File.Delete(destinationFile);
}
if (File.Exists(destinationFileInverted))
{
File.Delete(destinationFileInverted);
}
using (var destinationBitmap = new Bitmap(form.Width, form.Height))
{
form.DrawToBitmap(destinationBitmap, new Rectangle(0, 0, destinationBitmap.Width, destinationBitmap.Height));
destinationBitmap.Save(destinationFile);
using (var grayScaleImage = GrayScaleImageHelper.ToGrayScale(destinationBitmap))
{
var bounds = new Rectangle(0, 0, grayScaleImage.Width, grayScaleImage.Height);
BitmapData bitmapData = grayScaleImage.LockBits(bounds, ImageLockMode.ReadOnly, grayScaleImage.PixelFormat);
var grayScaleHW = new byte[grayScaleImage.Height * bitmapData.Stride];
Marshal.Copy(bitmapData.Scan0, grayScaleHW, 0, grayScaleImage.Height * bitmapData.Stride);
var stride = bitmapData.Stride;
grayScaleImage.UnlockBits(bitmapData);
GrayScaleImageHelper.Invert(grayScaleHW, stride, grayScaleImage.Width, grayScaleImage.Height);
var data = GrayScaleImageHelper.FromData2(grayScaleImage.Width, grayScaleImage.Height, stride, grayScaleHW);
File.WriteAllBytes(destinationFileInverted, data);
}
}
}
private void testButton__Click(object sender, EventArgs e)
{
using (var openFileDialog = new OpenFileDialog())
{
if (openFileDialog.ShowDialog() == DialogResult.OK)
{
using (var bitmap = new Bitmap(openFileDialog.FileName))
{
using (var gs = GrayScaleImageHelper.ToGrayScale(bitmap))
{
using (var gsClone = (Bitmap)gs.Clone())
{
double[,] result;
GrayScaleImageHelper.GetMultiplier1(gs, gsClone, out result);
var maxValue = double.MinValue;
for (int wi = 0; wi < result.GetLength(0); wi++)
{
for (int hi = 0; hi < result.GetLength(1); hi++)
{
if (maxValue < result[wi, hi])
{
maxValue = result[wi, hi];
}
}
}
MessageBox.Show("" + Math.Round(maxValue));
}
}
}
}
}
}
private void OnImageToGrayscaleClick(object sender, EventArgs e)
{
using (var openFileDialog = new OpenFileDialog())
{
if (openFileDialog.ShowDialog() == DialogResult.OK)
{
using (var bitmap = new Bitmap(openFileDialog.FileName))
{
if (BackgroundImage != null)
{
BackgroundImage.Dispose();
}
BackgroundImage = GrayScaleImageHelper.ToGrayScale(bitmap);
}
}
}
}
private void OnCalculateMeanAndVarianceClick(object sender, EventArgs e)
{
var baseDir = Path.GetDirectoryName(Path.GetDirectoryName(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)));
var testData = GrayScaleImageHelper.ToGrayScale(Path.Combine(baseDir, @"Test cases\MeanVarianceTest\Input.txt"));
byte[,] meanTest;
byte[,] varianceTest;
GrayScaleImageHelper.CalculateMeanAndVarianceM9(testData, out meanTest, out varianceTest);
var meanExpected = ArrayHelper.FromFile(Path.Combine(baseDir, @"Test cases\MeanVarianceTest\MeanOutput.txt"));
var varianceExpected = ArrayHelper.FromFile(Path.Combine(baseDir, @"Test cases\MeanVarianceTest\VarianceOutput.txt"));
if (!ArrayHelper.Compare(meanExpected, meanTest, 1))
{
MessageBox.Show("Mean test failed.");
}
if (!ArrayHelper.Compare(varianceExpected, varianceTest, 1))
{
MessageBox.Show("Variance test failed.");
}
using (var openFileDialog = new OpenFileDialog())
{
if (openFileDialog.ShowDialog() == DialogResult.OK)
{
using (var bitmap = new Bitmap(openFileDialog.FileName))
{
var grayscale = GrayScaleImageHelper.ToGrayScale(bitmap);
byte[,] mean;
byte[,] variance;
GrayScaleImageHelper.CalculateMeanAndVarianceM9(grayscale, out mean, out variance);
var viewResultForm = new ViewResultForm();
viewResultForm.Initialize("Average Brightness M9", GrayScaleImageHelper.ToGrayScale(mean));
viewResultForm.Show();
var viewResultForm2 = new ViewResultForm();
viewResultForm2.Initialize("Variance Brightness M9", GrayScaleImageHelper.ToGrayScale(variance));
viewResultForm2.Show();
}
}
}
}
public string Process(Bitmap bitmap)
{
// When video device initializes it adapts to
// background for some frames.
if (_skipStartingFrames > 0)
{
_skipStartingFrames--;
return(null);
}
using (var grayScaleImage = GrayScaleImageHelper.ToGrayScale(bitmap))
{
if (_previous == null)
{
byte[,] imageTMinus1MeanWH;
byte[,] imageTMinus1VarianceWH;
GrayScaleImageHelper.CalculateMeanAndVarianceM9(
grayScaleImage,
out imageTMinus1MeanWH,
out imageTMinus1VarianceWH);
_previous = new RadiometricSimilarityImage(
grayScaleImage,
imageTMinus1MeanWH,
imageTMinus1VarianceWH
);
_grayScaleBackground = (Bitmap)grayScaleImage.Clone();
return(null);
}
var bounds = new Rectangle(0, 0, grayScaleImage.Width, grayScaleImage.Height);
BitmapData bitmapData = grayScaleImage.LockBits(bounds, ImageLockMode.ReadOnly, grayScaleImage.PixelFormat);
var grayScaleHW = new byte[grayScaleImage.Height * bitmapData.Stride];
Marshal.Copy(bitmapData.Scan0, grayScaleHW, 0, grayScaleImage.Height * bitmapData.Stride);
grayScaleImage.UnlockBits(bitmapData);
byte[,] imageTMean;
byte[,] imageTVariance;
byte[,] motionWH;
bool motionPresents;
GrayScaleImageHelper.CalculateMeanAndVarianceM9(
grayScaleImage.Width,
grayScaleImage.Height,
bitmapData.Stride,
grayScaleHW,
out imageTMean,
out imageTVariance);
var current = new RadiometricSimilarityImage(grayScaleImage.Width,
grayScaleImage.Height,
bitmapData.Stride,
grayScaleHW,
imageTMean, imageTVariance);
byte[,] motionData, stationaryData;
Bitmap motionImage, stationaryImage;
GrayScaleImageHelper.GetRadiometricSimmilarity(
_previous,
current,
RadiometricDifferenceThrethhold,
out motionData,
out motionImage,
out stationaryData,
out stationaryImage);
{
using (motionImage)
{
_interceptor.Intercept(RadiometricSimmilarityFrameTFrameTMinus1Motion, ImageHelper.ToBytes(motionImage));
}
using (stationaryImage)
{
_interceptor.Intercept(RadiometricSimmilarityFrameTFrameTMinus1Stationary, ImageHelper.ToBytes(stationaryImage));
}
UpdateBackgroundOrForeground(
motionData,
grayScaleImage.Width,
grayScaleImage.Height,
bitmapData.Stride,
grayScaleHW,
out motionPresents,
out motionWH);
}
_previous = current;
using (var image = GrayScaleImageHelper.FromWH(motionWH))
{
_interceptor.Intercept(DifferenceImage, ImageHelper.ToBytes(image));
}
if (motionPresents)
{
return("Movement detected!");
}
}
return(null);
}
public string Process(Bitmap bitmap)
{
// When video device initializes it adapts to
// background for some frames.
if (_skipStartingFrames > 0)
{
_skipStartingFrames--;
return(null);
}
using (var grayScaleImage = GrayScaleImageHelper.ToGrayScale(bitmap))
{
if (_grayScaleFrameTMinus1 == null ||
_grayScaleBackground == null)
{
_grayScaleFrameTMinus1 = (Bitmap)grayScaleImage.Clone();
GrayScaleImageHelper.CalculateMeanAndVarianceM9(
_grayScaleFrameTMinus1,
out _imageTMinus1MeanWH,
out _imageTMinus1VarianceWH);
_grayScaleBackground = (Bitmap)grayScaleImage.Clone();
return(null);
}
var bounds = new Rectangle(0, 0, grayScaleImage.Width, grayScaleImage.Height);
BitmapData bitmapData = grayScaleImage.LockBits(bounds, ImageLockMode.ReadOnly, grayScaleImage.PixelFormat);
var grayScaleHW = new byte[grayScaleImage.Height * bitmapData.Stride];
Marshal.Copy(bitmapData.Scan0, grayScaleHW, 0, grayScaleImage.Height * bitmapData.Stride);
byte[,] imageTMean;
byte[,] imageTVariance;
byte[,] temporalImageAnalysisResultHW;
byte[,] motionWH;
bool motionPresents;
using (var temporalImageAnalysisResult = GetRadiometricSimmilarity(
grayScaleImage.Width,
grayScaleImage.Height,
bitmapData.Stride,
grayScaleHW,
out temporalImageAnalysisResultHW,
out imageTMean,
out imageTVariance))
{
_interceptor.Intercept(RadiometricSimmilarity, temporalImageAnalysisResult);
UpdateBackgroundOrForeground(
temporalImageAnalysisResultHW,
grayScaleImage.Width,
grayScaleImage.Height,
bitmapData.Stride,
grayScaleHW,
out motionPresents,
out motionWH);
}
_imageTMinus1MeanWH = imageTMean;
_imageTMinus1VarianceWH = imageTVariance;
_grayScaleFrameTMinus1 = (Bitmap)grayScaleImage.Clone();
grayScaleImage.UnlockBits(bitmapData);
_interceptor.Intercept(DifferenceImage, GrayScaleImageHelper.FromWH(motionWH));
if (motionPresents)
{
return("Movement detected!");
}
}
return(null);
}
protected override string ProcessInternal(Bitmap bitmap)
{
using (var grayScaleImage = GrayScaleImageHelper.ToGrayScale(bitmap))
{
var bounds = new Rectangle(0, 0, grayScaleImage.Width, grayScaleImage.Height);
BitmapData bitmapData = grayScaleImage.LockBits(bounds, ImageLockMode.ReadOnly, grayScaleImage.PixelFormat);
var grayScaleHW = new byte[grayScaleImage.Height * bitmapData.Stride];
Marshal.Copy(bitmapData.Scan0, grayScaleHW, 0, grayScaleImage.Height * bitmapData.Stride);
var stride = bitmapData.Stride;
grayScaleImage.UnlockBits(bitmapData);
if (!_backgroundModel.IsOperational())
{
_backgroundModel.Train(grayScaleHW, grayScaleImage.Width, grayScaleImage.Height, stride);
if (_backgroundModel.IsOperational())
{
_interceptor.Intercept(MinIntensityBackgroundDebugView, GrayScaleImageHelper.FromData2(_backgroundModel._width, _backgroundModel._height, _backgroundModel._stride, _backgroundModel._minIntensity));
_interceptor.Intercept(MaxIntensityBackgroundDebugView, GrayScaleImageHelper.FromData2(_backgroundModel._width, _backgroundModel._height, _backgroundModel._stride, _backgroundModel._maxIntensity));
_interceptor.Intercept(MaxPerFrameDifferenceDebugView, GrayScaleImageHelper.FromData2(_backgroundModel._width, _backgroundModel._height, _backgroundModel._stride, _backgroundModel._maxPerFrameDifference));
}
return(null);
}
var foreground = GetForefround(grayScaleHW, grayScaleImage.Width, grayScaleImage.Height, stride);
//excluded, because does not work.
//ExcludeShadows(grayScaleHW, foreground, grayScaleImage.Width, grayScaleImage.Height, stride);
var temp = GrayScaleImageHelper.FromData(
_backgroundModel._width,
_backgroundModel._height,
_backgroundModel._stride,
foreground);
int countDetected = 0;
// create filter
var diamondMask = CreateClosingOpeningFileter();
Closing filter = new Closing(diamondMask);
Opening filter2 = new Opening(diamondMask);
// apply the filter
filter.ApplyInPlace(temp);
filter2.ApplyInPlace(temp);
_interceptor.Intercept(
XXX,
ImageHelper.ToBytes(temp));
// blobs!
var bc = new BlobCounter {
BackgroundThreshold = Color.FromArgb(254, 254, 254)
};
bc.ProcessImage(temp);
Rectangle[] rects = bc.GetObjectsRectangles();
var rectanglesToDraw = new List <Rectangle>();
foreach (Rectangle rect in rects)
{
if (rect.Width < _maximumDetectionWidthPixels &&
rect.Width > _minimumDetectionWidthPixels &&
rect.Height < _maximumDetectionHeightPixels &&
rect.Height > _minimumDetectionHeightPixels)
{
countDetected++;
rectanglesToDraw.Add(rect);
}
}
temp.Dispose();
_interceptor.Intercept(InputFrameDebugView, GrayScaleImageHelper.FromData2(_backgroundModel._width, _backgroundModel._height, _backgroundModel._stride, grayScaleHW));
_interceptor.Intercept(DifferenceDebugView, GrayScaleImageHelper.FromData2(_backgroundModel._width, _backgroundModel._height, _backgroundModel._stride, foreground));
using (Graphics graphics = Graphics.FromImage(bitmap))
using (var brush = new SolidBrush(Color.Red))
using (var pen = new Pen(brush, 3))
{
if (rectanglesToDraw.Any())
{
graphics.DrawRectangles(pen, rectanglesToDraw.ToArray());
}
_interceptor.Intercept(DetectedBlobDebugView, ImageHelper.ToBytes(bitmap));
}
if (countDetected > 0)
{
return("Alarm: " + countDetected);
}
}
return(null);
}