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();
}
}
}
}
// Radometric Simillarity returns doubles 0..1.
// They are converted to grayscale bitmap for quantification and future analysis.
private Bitmap GetRadiometricSimmilarity(
int width,
int height,
int stride,
byte[] grayScaleData,
out byte[,] dataHeigthWidth,
out byte[,] imageTMeanWH,
out byte[,] imageTVarianceWH)
{
GrayScaleImageHelper.CalculateMeanAndVarianceM9(
width,
height,
stride,
grayScaleData,
out imageTMeanWH,
out imageTVarianceWH);
// Radiometric simillarity.
GCHandle handle;
var result = GrayScaleImageHelper.BeginImage(width, height, out dataHeigthWidth, out handle);
double[,] firstItemWH;
GrayScaleImageHelper.GetMultiplier1(width, height, stride, grayScaleData, _grayScaleFrameTMinus1, out firstItemWH);
for (int widthI = 1; widthI < (width - 1); widthI++)
{
for (int heightI = 1; heightI < (height - 1); heightI++)
{
dataHeigthWidth[heightI, widthI] = (byte)
(
byte.MaxValue * (firstItemWH[widthI, heightI] -
imageTMeanWH[widthI, heightI] * _imageTMinus1MeanWH[widthI, heightI]
)
/
Math.Sqrt(imageTVarianceWH[widthI, heightI] * _imageTMinus1VarianceWH[widthI, heightI]));
}
}
GrayScaleImageHelper.EndImage(handle);
return(result);
}
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);
}