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 UpdateBackgroundOrForeground(
byte[,] rItItm1HW,
int width,
int height,
int stride,
byte[] currentFrame,
//byte[,] background,
out bool motionPresents,
out byte[,] motionWH)
{
motionPresents = false;
//TODO: get access to bytes of tiar
//TODO: get access to bytes of background
//TODO: update background.
motionWH = new byte[width, height];
for (int wi = 1; wi < (width - 1); wi++)
{
for (int hi = 1; hi < (height - 1); hi++)
{
if (rItItm1HW[hi, wi] == 1)
{
motionWH[wi, hi] = currentFrame[GrayScaleImageHelper.ToDataPosition(wi, hi, stride)];
motionPresents = true;
}
else
{
//TODO:
}
}
}
}
private byte[] GetForefround(
byte[] grayScaleHW,
int width,
int height,
int stride)
{
var foregroundHW = new byte[grayScaleHW.Length];
for (int widthI = 0; widthI < width; widthI++)
{
for (int heightI = 0; heightI < height; heightI++)
{
var position = GrayScaleImageHelper.ToDataPosition(widthI, heightI, stride);
var threshold = GetThreshold(position);
var pixel = grayScaleHW[position];
foregroundHW[position] = byte.MaxValue;
if (_backgroundModel._minIntensity[position] - threshold <= pixel &&
pixel <= _backgroundModel._maxIntensity[position] + threshold)
{
foregroundHW[position] = _backgroundPixel; // white
}
else
{
foregroundHW[position] = _foregroundPixel;
}
}
}
return(foregroundHW);
}
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 bool CheckProveShadowOriginal(byte[] frame, int widthI, int heightI, int stride)
{
double er = 0;
double eb = _backgroundModel._energyBackground[GrayScaleImageHelper.ToDataPosition(widthI, heightI, stride)];
double et = 0;
for (int regionWidthI = widthI - _regionFrameSizeDivided2;
regionWidthI < (widthI + _regionFrameSizeDivided2 + 1);
regionWidthI++)
{
for (
int regionHeightI = (heightI - _regionFrameSizeDivided2);
regionHeightI < (heightI + _regionFrameSizeDivided2 + 1);
regionHeightI++)
{
var posCheckRegion = GrayScaleImageHelper.ToDataPosition(regionWidthI, regionHeightI, stride);
er += _backgroundModel._averageBackground[posCheckRegion] * frame[posCheckRegion];
et += frame[posCheckRegion] * frame[posCheckRegion];
}
}
et = Math.Sqrt(et);
var ncc = er / (eb * et);
return(ncc > _Lncc && et < eb);
}
private bool CheckProveShadow2(byte[] frame, int widthI, int heightI, int stride)
{
var standardDeviationOfRegion = new List <double>();
for (int regionWidthI = widthI - _regionProveShadowDivided2;
regionWidthI < (widthI + _regionProveShadowDivided2 + 1);
regionWidthI++)
{
for (
int regionHeightI = (heightI - _regionProveShadowDivided2);
regionHeightI < (heightI + _regionProveShadowDivided2 + 1);
regionHeightI++)
{
var posCheckRegion = GrayScaleImageHelper.ToDataPosition(regionWidthI, regionHeightI, stride);
if (_backgroundModel._averageBackground[posCheckRegion] != 0)
{
standardDeviationOfRegion.Add((double)frame[posCheckRegion] / _backgroundModel._averageBackground[posCheckRegion]);
}
}
}
var deviation = ArrayHelper.GetStandardDeviation(standardDeviationOfRegion.ToArray());
return(deviation < _Lstd);
}
private void CalculateEnergyBackground()
{
ArrayHelper.SetToAll(_energyBackground, 0);
for (int widthI = _regionFrameSizeDivided2; widthI < (_width - _regionFrameSizeDivided2 - 1); widthI++)
{
for (int heightI = _regionFrameSizeDivided2; heightI < (_height - _regionFrameSizeDivided2 - 1); heightI++)
{
long result = 0;
for (
int regionWidthI = (widthI - _regionFrameSizeDivided2);
regionWidthI < (widthI + _regionFrameSizeDivided2 + 1);
regionWidthI++)
{
for (
int regionHeightI = (heightI - _regionFrameSizeDivided2);
regionHeightI < (heightI + _regionFrameSizeDivided2 + 1);
regionHeightI++)
{
result += _averageBackground[GrayScaleImageHelper.ToDataPosition(regionWidthI, regionHeightI, _stride)];
}
}
_energyBackground[GrayScaleImageHelper.ToDataPosition(widthI, heightI, _stride)] = Math.Sqrt(result);
}
}
}
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 ExcludeShadows(byte[] frame, byte[] foreground, int width, int height, int stride)
{
for (int widthI = _borderDivided2; widthI < (width - _borderDivided2 - 1); widthI++)
{
for (int heightI = _borderDivided2; heightI < (height - _borderDivided2 - 1); heightI++)
{
var pos = GrayScaleImageHelper.ToDataPosition(widthI, heightI, stride);
if (foreground[pos] == _foregroundPixel &&
CheckProveShadow3(frame[pos], _backgroundModel._averageBackground[pos]) &&
CheckProveShadow2(frame, widthI, heightI, stride) &&
CheckProveShadowOriginal(frame, widthI, heightI, stride))
{
foreground[pos] = _backgroundPixel;
}
}
}
}
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);
}
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);
}
private void DumpRegionOfInterestData()
{
return;
//line=363;col=374 --403;415
var roeStart = new Rectangle(363, 374, 40, 40);
var trainingData = @"D:\temp\dumps";
var dumpFile = Path.Combine(trainingData, "Dump-Region Of Interest.txt");
var outf = new StreamWriter(dumpFile);
//todo: dump median
outf.WriteLine("Median dump...");
for (int heightI = roeStart.Top; heightI < roeStart.Bottom; heightI++)
{
for (int widthI = roeStart.Left; widthI < roeStart.Right; widthI++)
{
outf.Write("\t{0:00.0}", tempMedianHW_[heightI, widthI]);
}
outf.WriteLine();
}
//todo: dump disperce
outf.WriteLine("Disperce dump...");
for (int heightI = roeStart.Top; heightI < roeStart.Bottom; heightI++)
{
for (int widthI = roeStart.Left; widthI < roeStart.Right; widthI++)
{
outf.Write("\t{0:00.0}", tempDisperceHW_[heightI, widthI]);
}
outf.WriteLine();
}
//todo: dump background model
outf.WriteLine("Background model dump...");
for (int heightI = roeStart.Top; heightI < roeStart.Bottom; heightI++)
{
for (int widthI = roeStart.Left; widthI < roeStart.Right; widthI++)
{
var position = GrayScaleImageHelper.ToDataPosition(widthI, heightI, _stride);
outf.Write("\t{0:00.0}", _maxPerFrameDifference[position]);
}
outf.WriteLine();
}
//todo: dump minimum frame
outf.WriteLine("Minimum intensity dump...");
for (int heightI = roeStart.Top; heightI < roeStart.Bottom; heightI++)
{
for (int widthI = roeStart.Left; widthI < roeStart.Right; widthI++)
{
var position = GrayScaleImageHelper.ToDataPosition(widthI, heightI, _stride);
outf.Write("\t{0:00.0}", _minIntensity[position]);
}
outf.WriteLine();
}
//todo: dump maximum frame
outf.WriteLine("Maximum intensity dump...");
for (int heightI = roeStart.Top; heightI < roeStart.Bottom; heightI++)
{
for (int widthI = roeStart.Left; widthI < roeStart.Right; widthI++)
{
var position = GrayScaleImageHelper.ToDataPosition(widthI, heightI, _stride);
outf.Write("\t{0:00.0}", _maxIntensity[position]);
}
outf.WriteLine();
}
outf.Dispose();
}
private void CalculateInitialBackgroundModelState()
{
tempMedianHW_ = new double[_height, _width];
tempDisperceHW_ = new double[_height, _width];
for (int widthI = 0; widthI < _width; widthI++)
{
for (int heightI = 0; heightI < _height; heightI++)
{
var position = GrayScaleImageHelper.ToDataPosition(widthI, heightI, _stride);
double medium = 0;
double disperce = 0;
if (_siarheiKuchuk)
{
for (int frameNo = 0; frameNo < _amountOfTrainingFrames; frameNo++)
{
medium += _trainingDataNHW[frameNo][position];
}
medium = (1.0 * medium) / _amountOfTrainingFrames;
}
else
{
var list = new List <byte>();
for (int frameNo = 0; frameNo < _amountOfTrainingFrames; frameNo++)
{
list.Add(_trainingDataNHW[frameNo][position]);
}
medium = ArrayHelper.GetMedian(list.ToArray());
}
_averageBackground[position] = (byte)medium;
for (int frameNo = 0; frameNo < _amountOfTrainingFrames; frameNo++)
{
disperce += Math.Abs(_trainingDataNHW[frameNo][position] - medium);
}
disperce = (1.0 * disperce) / _amountOfTrainingFrames;
var minIntensity = -1;
var maxIntensity = -1;
var maxPerFrameDifference = byte.MinValue;
int previousTrainingValue = -1;
for (int frameNo = 0; frameNo < _amountOfTrainingFrames; frameNo++)
{
var val = _trainingDataNHW[frameNo][position];
if (Math.Abs(val - medium) <= _dK * disperce)
{
if (minIntensity == -1 ||
val < minIntensity)
{
minIntensity = val;
}
if (maxIntensity == -1 ||
val > maxIntensity)
{
maxIntensity = val;
}
if (previousTrainingValue != -1)
{
var difference = (byte)Math.Abs(val - previousTrainingValue);
if (difference > maxPerFrameDifference)
{
maxPerFrameDifference = difference;
}
}
previousTrainingValue = val;
}
}
if (minIntensity == -1)
{
throw new InvalidDataException("min intensity!");
}
if (maxIntensity == -1)
{
throw new InvalidDataException("max intensity!");
}
_minIntensity[position] = (byte)minIntensity;
_maxIntensity[position] = (byte)maxIntensity;
_maxPerFrameDifference[position] = maxPerFrameDifference;
tempMedianHW_[heightI, widthI] = medium;
tempDisperceHW_[heightI, widthI] = disperce;
}
}
DumpRegionOfInterestData();
CalculateEnergyBackground();
#warning : DEBUG code
DumpTrainingData();
#warning END
_trainingDataNHW = null;
}
