public void FindPeaksTest()
{
Bitmap hand = Properties.Resources.rhand;
GaussianBlur median = new GaussianBlur(1.1);
median.ApplyInPlace(hand);
// Extract contour
BorderFollowing bf = new BorderFollowing(1);
List<IntPoint> contour = bf.FindContour(hand);
hand = hand.Clone(new Rectangle(0, 0, hand.Width, hand.Height), PixelFormat.Format24bppRgb);
// Find peaks
KCurvature kcurv = new KCurvature(30, new DoubleRange(0, 45));
// kcurv.Suppression = 30;
var peaks = kcurv.FindPeaks(contour);
List<IntPoint> supports = new List<IntPoint>();
for (int i = 0; i < peaks.Count; i++)
{
int j = contour.IndexOf(peaks[i]);
supports.Add(contour[(j + kcurv.K) % contour.Count]);
supports.Add(contour[Accord.Math.Tools.Mod(j - kcurv.K, contour.Count)]);
}
// show(hand, contour, peaks, supports);
Assert.AreEqual(2, peaks.Count);
Assert.AreEqual(46, peaks[0].X);
Assert.AreEqual(0, peaks[0].Y);
Assert.AreEqual(2, peaks[1].X);
Assert.AreEqual(11, peaks[1].Y);
}
static DiffCalculator()
{
threshold = new Threshold(THERSHOLD);
fillHoles = new FillHoles();
fillHoles.MaxHoleHeight = 125;
fillHoles.MaxHoleWidth = 125;
fillHoles.CoupledSizeFiltering = true;
gaussianBlur = new GaussianBlur(3, 11);
}
public static Bitmap DoIt(Bitmap bmp)
{
GaussianBlur blur = new GaussianBlur(10, 50);
Bitmap blurred = blur.Apply(bmp);
Bitmap ret = new Bitmap(blurred.Width, blurred.Height, blurred.PixelFormat);
for (int y = 0; y < blurred.Height; y++)
{
for (int x = 0; x < blurred.Width; x++)
{
Color blurredColor = blurred.GetPixel(x, y);
Color orinalColor = bmp.GetPixel(x, y);
Color newColor = Color.FromArgb((blurredColor.R + orinalColor.R * 2) / 3,
(blurredColor.G + orinalColor.G * 2) / 3,
(blurredColor.B + orinalColor.B * 2) / 3);
ret.SetPixel(x, y, newColor);
}
}
GammaCorrection gc = new GammaCorrection(.8);
gc.ApplyInPlace(ret);
Sharpen sharpen = new Sharpen();
sharpen.ApplyInPlace(ret);
Grayscale filter = new Grayscale(0.2125, 0.7154, 0.0721);
Bitmap gray = filter.Apply(ret);
CannyEdgeDetector canny = new CannyEdgeDetector();
gray = canny.Apply(gray);
for (int y = 0; y < gray.Height; y++)
{
for (int x=0;x < gray.Width; x++)
{
if(gray.GetPixel(x,y).R > 0)
{
Color retColor = ret.GetPixel(x, y);
Color newColor = Color.FromArgb(
(int)(retColor.R * .7),
(int)(retColor.G * .7),
(int)(retColor.B * .7));
ret.SetPixel(x, y, newColor);
}
}
}
return ret;
}
public double GetTemperature()
{
var temp = 0.0;
var image = Image.FromFile(filename);
var grayscale = new Grayscale(0.2125, 0.7154, 0.0721);
image = grayscale.Apply(image);
var invert = new Invert();
image = invert.Apply(image);
var stats = new ImageStatistics(image);
var levelsLinear = new LevelsLinear
{
InGray = stats.Gray.GetRange(2.90)
};
image = levelsLinear.Apply(image);
var contrast = new ContrastStretch();
image = contrast.Apply(image);
var erosion = new Erosion();
image = erosion.Apply(image);
var blur = new GaussianBlur(2, 3);
image = blur.Apply(image);
var threshold = new Threshold(79);
image = threshold.Apply(image);
image.Save(processedFileName, System.Drawing.Imaging.ImageFormat.Jpeg);
image.Dispose();
var text = Recognise();
double.TryParse(text.Replace(',', '.'), out temp);
return temp;
}
public static Bitmap GaussianBlur(Bitmap bmp, int value)
{
// create filter with kernel size equal to 11
// and Gaussia sigma value equal to 4.0
GaussianBlur filter = new GaussianBlur(value, 11);
// apply the filter
filter.ApplyInPlace(bmp);
return bmp;
}
/// <summary>
/// Processes the specified SRC image.
/// </summary>
/// <param name="srcImage">The SRC image.</param>
/// <remarks></remarks>
public void Process(Bitmap srcImage)
{
if (srcImage == null || srcImage.Width < 10 || srcImage.Height < 10)
return;
resize.NewWidth = srcImage.Width / Scale;
resize.NewHeight = srcImage.Height / Scale;
FilteredBoard = resize.Apply(srcImage);
if (Enhance)
ImageFilters.FlattenLighting(FilteredBoard);
ImageFilters.HSLFilter(FilteredBoard, targetHue, targetSat, targetBri, hueTol, satTol, briTol);
median.ApplyInPlace(FilteredBoard);
GaussianBlur blr = new GaussianBlur(2, 2);
blr.ApplyInPlace(FilteredBoard);
TileBlobs.Clear();
try
{
BlobCounter.ProcessImage(FilteredBoard);
Blob[] blobs = BlobCounter.GetObjectsInformation();
TileBlobs.Clear();
foreach (Blob b in blobs)
{
if (b.Area < 10) continue;
TileBlobs.Add(b);
}
}
catch { }
}
private void SmoothEdges()
{
var d = 5;
//Apply your Gaussian blur method to the image
//(for example, with AForge.NET, you might use the following code:)
var filter = new GaussianBlur(15, 15);
filter.ApplyInPlace(Painting, new Rectangle(0, height/2 - d, width, 2*d));
filter.ApplyInPlace(Painting, new Rectangle(width/2 - d, 0, 2*d, height));
// filter.ApplyInPlace(Painting);
}
/// <summary>
/// Process the filter on the specified image.
/// </summary>
///
/// <param name="image">Source image data.</param>
///
protected override unsafe void ProcessFilter(UnmanagedImage image)
{
UnmanagedImage bgImage = null;
BitmapData bgLockedData = null;
// get image size
var width = image.Width;
var height = image.Height;
var offset = image.Stride - ((image.PixelFormat == PixelFormat.Format8bppIndexed) ? width : width * 3);
// check if we have provided background
if ((this.backgroundImage == null) && (this.unmanagedBackgroundImage == null))
{
// resize image to 1/3 of its original size to make bluring faster
var resizeFilter = new ResizeBicubic((int)width / 3, (int)height / 3);
var tempImage = resizeFilter.Apply(image);
// create background image from the input image blurring it with Gaussian 5 times
var blur = new GaussianBlur(5, 21);
blur.ApplyInPlace(tempImage);
blur.ApplyInPlace(tempImage);
blur.ApplyInPlace(tempImage);
blur.ApplyInPlace(tempImage);
blur.ApplyInPlace(tempImage);
// resize the blurred image back to original size
resizeFilter.NewWidth = width;
resizeFilter.NewHeight = height;
bgImage = resizeFilter.Apply(tempImage);
tempImage.Dispose( );
}
else
{
if (this.backgroundImage != null)
{
// check background image
if ((width != this.backgroundImage.Width) || (height != this.backgroundImage.Height) || (image.PixelFormat != this.backgroundImage.PixelFormat))
{
throw new InvalidImagePropertiesException("Source image and background images must have the same size and pixel format");
}
// lock background image
bgLockedData = this.backgroundImage.LockBits(
new Rectangle(0, 0, width, height),
ImageLockMode.ReadOnly, this.backgroundImage.PixelFormat);
bgImage = new UnmanagedImage(bgLockedData);
}
else
{
bgImage = this.unmanagedBackgroundImage;
}
}
// get background image's statistics (mean value is used as correction factor)
var bgStatistics = new ImageStatistics(bgImage);
var src = (byte *)image.ImageData.ToPointer( );
var bg = (byte *)bgImage.ImageData.ToPointer( );
// do the job
if (image.PixelFormat == PixelFormat.Format8bppIndexed)
{
// grayscale image
var mean = bgStatistics.Gray.Mean;
for (var y = 0; y < height; y++)
{
for (var x = 0; x < width; x++, src++, bg++)
{
if (*bg != 0)
{
*src = (byte)Math.Min(mean * *src / *bg, 255);
}
}
src += offset;
bg += offset;
}
}
else
{
// color image
var meanR = bgStatistics.Red.Mean;
var meanG = bgStatistics.Green.Mean;
var meanB = bgStatistics.Blue.Mean;
for (var y = 0; y < height; y++)
{
for (var x = 0; x < width; x++, src += 3, bg += 3)
{
// red
if (bg[RGB.R] != 0)
{
src[RGB.R] = (byte)Math.Min(meanR * src[RGB.R] / bg[RGB.R], 255);
}
// green
if (bg[RGB.G] != 0)
{
src[RGB.G] = (byte)Math.Min(meanG * src[RGB.G] / bg[RGB.G], 255);
}
// blue
if (bg[RGB.B] != 0)
{
src[RGB.B] = (byte)Math.Min(meanB * src[RGB.B] / bg[RGB.B], 255);
}
}
src += offset;
bg += offset;
}
}
if (this.backgroundImage != null)
{
this.backgroundImage.UnlockBits(bgLockedData);
}
// dispose background image if it was not set manually
if ((this.backgroundImage == null) && (this.unmanagedBackgroundImage == null))
{
bgImage.Dispose( );
}
}
/// <summary>
/// Process the filter on the specified image.
/// </summary>
///
/// <param name="image">Source image data.</param>
///
protected override unsafe void ProcessFilter( UnmanagedImage image )
{
UnmanagedImage bgImage = null;
BitmapData bgLockedData = null;
// get image size
int width = image.Width;
int height = image.Height;
int offset = image.Stride - ( ( image.PixelFormat == PixelFormat.Format8bppIndexed ) ? width : width * 3 );
// check if we have provided background
if ( ( backgroundImage == null ) && ( unmanagedBackgroundImage == null ) )
{
// resize image to 1/3 of its original size to make bluring faster
ResizeBicubic resizeFilter = new ResizeBicubic( (int) width / 3, (int) height / 3 );
UnmanagedImage tempImage = resizeFilter.Apply( image );
// create background image from the input image blurring it with Gaussian 5 times
GaussianBlur blur = new GaussianBlur( 5, 21 );
blur.ApplyInPlace( tempImage );
blur.ApplyInPlace( tempImage );
blur.ApplyInPlace( tempImage );
blur.ApplyInPlace( tempImage );
blur.ApplyInPlace( tempImage );
// resize the blurred image back to original size
resizeFilter.NewWidth = width;
resizeFilter.NewHeight = height;
bgImage = resizeFilter.Apply( tempImage );
tempImage.Dispose( );
}
else
{
if ( backgroundImage != null )
{
// check background image
if ( ( width != backgroundImage.Width ) || ( height != backgroundImage.Height ) || ( image.PixelFormat != backgroundImage.PixelFormat ) )
{
throw new InvalidImagePropertiesException( "Source image and background images must have the same size and pixel format" );
}
// lock background image
bgLockedData = backgroundImage.LockBits(
new Rectangle( 0, 0, width, height ),
ImageLockMode.ReadOnly, backgroundImage.PixelFormat );
bgImage = new UnmanagedImage( bgLockedData );
}
else
{
bgImage = unmanagedBackgroundImage;
}
}
// get background image's statistics (mean value is used as correction factor)
ImageStatistics bgStatistics = new ImageStatistics( bgImage );
byte* src = (byte*) image.ImageData.ToPointer( );
byte* bg = (byte*) bgImage.ImageData.ToPointer( );
// do the job
if ( image.PixelFormat == PixelFormat.Format8bppIndexed )
{
// grayscale image
double mean = bgStatistics.Gray.Mean;
for ( int y = 0; y < height; y++ )
{
for ( int x = 0; x < width; x++, src++, bg++ )
{
if ( *bg != 0 )
{
*src = (byte) Math.Min( mean * *src / *bg, 255 );
}
}
src += offset;
bg += offset;
}
}
else
{
// color image
double meanR = bgStatistics.Red.Mean;
double meanG = bgStatistics.Green.Mean;
double meanB = bgStatistics.Blue.Mean;
for ( int y = 0; y < height; y++ )
{
for ( int x = 0; x < width; x++, src += 3, bg += 3 )
{
// red
if ( bg[RGB.R] != 0 )
{
src[RGB.R] = (byte) Math.Min( meanR * src[RGB.R] / bg[RGB.R], 255 );
}
// green
if ( bg[RGB.G] != 0 )
{
src[RGB.G] = (byte) Math.Min( meanG * src[RGB.G] / bg[RGB.G], 255 );
}
// blue
if ( bg[RGB.B] != 0 )
{
src[RGB.B] = (byte) Math.Min( meanB * src[RGB.B] / bg[RGB.B], 255 );
}
}
src += offset;
bg += offset;
}
}
if ( backgroundImage != null )
{
backgroundImage.UnlockBits( bgLockedData );
}
// dispose background image if it was not set manually
if ( ( backgroundImage == null ) && ( unmanagedBackgroundImage == null ) )
{
bgImage.Dispose( );
}
}
public static Bitmap gaussianBlur(this Bitmap bitmap, int blur)
{
AForge.Imaging.Filters.GaussianBlur filter = new AForge.Imaging.Filters.GaussianBlur(Convert.ToDouble(blur), 9);
return(filter.Apply(AForge.Imaging.Image.Clone(bitmap, PixelFormat.Format24bppRgb)));
}
/// <summary>
/// Blur image with Gauss
/// </summary>
/// <param name="image"></param>
/// <param name="sigma">Gaussia sigma</param>
/// <param name="kernelSize">Gaussia kermel</param>
/// <returns></returns>
public static Image Gauss(this Image image, double sigma, int kernelSize)
{
GaussianBlur blur = new GaussianBlur(sigma, kernelSize);
return blur.Apply(new Bitmap(image));
}
public void RunWorker()
{
while (true)
{
bool ajSuccess = false;
resetEvent.WaitOne();
frameMutex.WaitOne(); //RNM
// Process image
this.workerStatus = WorkerStatus.Busy;
if (processingImage.Width != grayBuffer.Width || processingImage.Height != grayBuffer.Height)
grayBuffer = new Bitmap(processingImage.Width, processingImage.Height, System.Drawing.Imaging.PixelFormat.Format8bppIndexed);
System.Drawing.Imaging.BitmapData imageBD = LockTotalBitmap(processingImage, System.Drawing.Imaging.ImageLockMode.ReadWrite);
System.Drawing.Imaging.BitmapData grayBufferBD = LockTotalBitmap(grayBuffer, System.Drawing.Imaging.ImageLockMode.ReadWrite);
try
{
// create unmanaged images
UnmanagedImage imageUMI = new UnmanagedImage(imageBD);
UnmanagedImage grayBufferUMI = new UnmanagedImage(grayBufferBD);
// Apply grayscale and otsu filters
if (this.probabilityMap == null)
{
// Grayscale Otsu Thresholding
grayFilter.Apply(imageUMI, grayBufferUMI);
otsuFilter.ApplyInPlace(grayBufferUMI);
//Median mf = new Median(5);
//mf.ApplyInPlace(grayBufferUMI);
}
else
{
// BPM Colour Thresholding
probabilityMap.TresholdImage(imageUMI, grayBufferUMI);
//Median mf = new Median(5);
//mf.ApplyInPlace(grayBufferUMI);
GaussianBlur gb = new GaussianBlur(3.0);
Threshold t = new Threshold(127);
gb.ApplyInPlace(grayBufferUMI);
t.ApplyInPlace(grayBufferUMI);
//AForge.Imaging.Filters.Erosion er = new AForge.Imaging.Filters.Erosion();
//er.ApplyInPlace(grayBufferUMI);
}
bool ccSuccess = componentFinder.FindBlobs(grayBufferUMI);
// Create adjacency matrix
if (ccSuccess)
{
ajSuccess = regionAdjacencyGraph.ConstructGraph(componentFinder.ObjectLabels, componentFinder.ObjectCount, processingImage.Width, processingImage.Height);
}
// If producing the graph has failed, for example due to too many regions, stop processing the current frame.
if (!ajSuccess)
{
if (detectedMarkerList != null)
detectedMarkerList.Clear();
if (permittedMarkerList != null)
permittedMarkerList.Clear();
this.workerStatus = WorkerStatus.Finished;
continue;
}
detectedMarkerList = markerDetector.FindMarkers(componentFinder, regionAdjacencyGraph);
permittedMarkerList = markerDetector.PermitMarkers(detectedMarkerList, permittedCodes);
}
catch (Exception e)
{
//RNM
resetEvent.Reset();
frameMutex.ReleaseMutex();
MessageBox.Show("An exception occurred during Marker Detection: " + e.Message);
throw;
}
finally
{
processingImage.UnlockBits(imageBD);
grayBuffer.UnlockBits(grayBufferBD);
if (!ajSuccess)
{
resetEvent.Reset();
frameMutex.ReleaseMutex();
}
}
if (detectedMarkerList != null && permittedMarkerList.Count > 0)
{
//send marker xml.
sendMarkerXml(permittedMarkerList);
// Draw other UI components
using (Graphics g = Graphics.FromImage(processingImage))
{
Pen boundingBoxPen = new Pen(Color.Blue, 4.0f);
boundingBoxPen.StartCap = System.Drawing.Drawing2D.LineCap.Round;
boundingBoxPen.EndCap = System.Drawing.Drawing2D.LineCap.Round;
Font markerFont = new Font("Arial", 16.0f);
for (int marker = 0; marker < permittedMarkerList.Count; marker++)
{
int markerID = permittedMarkerList[marker].ID;
string markerCode = permittedMarkerList[marker].Code;
BoundingBox bb = componentFinder.ObjectBoundingBoxes[markerID];
g.DrawLine(boundingBoxPen, new System.Drawing.Point(bb.x1, bb.y1), new System.Drawing.Point(bb.x1, bb.y2));
g.DrawLine(boundingBoxPen, new System.Drawing.Point(bb.x1, bb.y2), new System.Drawing.Point(bb.x2, bb.y2));
g.DrawLine(boundingBoxPen, new System.Drawing.Point(bb.x2, bb.y2), new System.Drawing.Point(bb.x2, bb.y1));
g.DrawLine(boundingBoxPen, new System.Drawing.Point(bb.x2, bb.y1), new System.Drawing.Point(bb.x1, bb.y1));
}
for (int marker = 0; marker < permittedMarkerList.Count; marker++)
{
int markerID = permittedMarkerList[marker].ID;
string markerCode = permittedMarkerList[marker].Code;
BoundingBox bb = componentFinder.ObjectBoundingBoxes[markerID];
g.DrawString(markerCode, markerFont, Brushes.Red, new PointF(bb.x1, bb.y2));
}
}
}
this.workerStatus = WorkerStatus.Finished;
workerTicks++;
resetEvent.Reset();
frameMutex.ReleaseMutex();
}
}
protected override unsafe void ProcessFilter(UnmanagedImage image)
{
UnmanagedImage unmanagedBackgroundImage = null;
BitmapData bitmapData = null;
int width = image.Width;
int height = image.Height;
int num3 = image.Stride - ((image.PixelFormat == PixelFormat.Format8bppIndexed) ? width : (width * 3));
if ((this.backgroundImage == null) && (this.unmanagedBackgroundImage == null))
{
ResizeBicubic bicubic = new ResizeBicubic(width / 3, height / 3);
UnmanagedImage image3 = bicubic.Apply(image);
GaussianBlur blur = new GaussianBlur(5.0, 0x15);
blur.ApplyInPlace(image3);
blur.ApplyInPlace(image3);
blur.ApplyInPlace(image3);
blur.ApplyInPlace(image3);
blur.ApplyInPlace(image3);
bicubic.NewWidth = width;
bicubic.NewHeight = height;
unmanagedBackgroundImage = bicubic.Apply(image3);
image3.Dispose();
}
else if (this.backgroundImage != null)
{
if (((width != this.backgroundImage.Width) || (height != this.backgroundImage.Height)) || (image.PixelFormat != this.backgroundImage.PixelFormat))
{
throw new InvalidImagePropertiesException("Source image and background images must have the same size and pixel format");
}
bitmapData = this.backgroundImage.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.ReadOnly, this.backgroundImage.PixelFormat);
unmanagedBackgroundImage = new UnmanagedImage(bitmapData);
}
else
{
unmanagedBackgroundImage = this.unmanagedBackgroundImage;
}
ImageStatistics statistics = new ImageStatistics(unmanagedBackgroundImage);
byte * numPtr = (byte *)image.ImageData.ToPointer();
byte * numPtr2 = (byte *)unmanagedBackgroundImage.ImageData.ToPointer();
if (image.PixelFormat == PixelFormat.Format8bppIndexed)
{
double num4 = statistics.Gray.get_Mean();
for (int i = 0; i < height; i++)
{
int num6 = 0;
while (num6 < width)
{
if (numPtr2[0] != 0)
{
numPtr[0] = (byte)Math.Min((double)((num4 * numPtr[0]) / ((double)numPtr2[0])), (double)255.0);
}
num6++;
numPtr++;
numPtr2++;
}
numPtr += num3;
numPtr2 += num3;
}
}
else
{
double num7 = statistics.Red.get_Mean();
double num8 = statistics.Green.get_Mean();
double num9 = statistics.Blue.get_Mean();
for (int j = 0; j < height; j++)
{
int num11 = 0;
while (num11 < width)
{
if (numPtr2[2] != 0)
{
numPtr[2] = (byte)Math.Min((double)((num7 * numPtr[2]) / ((double)numPtr2[2])), (double)255.0);
}
if (numPtr2[1] != 0)
{
numPtr[1] = (byte)Math.Min((double)((num8 * numPtr[1]) / ((double)numPtr2[1])), (double)255.0);
}
if (numPtr2[0] != 0)
{
numPtr[0] = (byte)Math.Min((double)((num9 * numPtr[0]) / ((double)numPtr2[0])), (double)255.0);
}
num11++;
numPtr += 3;
numPtr2 += 3;
}
numPtr += num3;
numPtr2 += num3;
}
}
if (this.backgroundImage != null)
{
this.backgroundImage.UnlockBits(bitmapData);
}
if ((this.backgroundImage == null) && (this.unmanagedBackgroundImage == null))
{
unmanagedBackgroundImage.Dispose();
}
}
protected unsafe override void ProcessFilter(UnmanagedImage image)
{
UnmanagedImage unmanagedImage = null;
BitmapData bitmapData = null;
int width = image.Width;
int height = image.Height;
int num = image.Stride - ((image.PixelFormat == PixelFormat.Format8bppIndexed) ? width : (width * 3));
if (backgroundImage == null && unmanagedBackgroundImage == null)
{
ResizeBicubic resizeBicubic = new ResizeBicubic(width / 3, height / 3);
UnmanagedImage unmanagedImage2 = resizeBicubic.Apply(image);
GaussianBlur gaussianBlur = new GaussianBlur(5.0, 21);
gaussianBlur.ApplyInPlace(unmanagedImage2);
gaussianBlur.ApplyInPlace(unmanagedImage2);
gaussianBlur.ApplyInPlace(unmanagedImage2);
gaussianBlur.ApplyInPlace(unmanagedImage2);
gaussianBlur.ApplyInPlace(unmanagedImage2);
resizeBicubic.NewWidth = width;
resizeBicubic.NewHeight = height;
unmanagedImage = resizeBicubic.Apply(unmanagedImage2);
unmanagedImage2.Dispose();
}
else if (backgroundImage != null)
{
if (width != backgroundImage.Width || height != backgroundImage.Height || image.PixelFormat != backgroundImage.PixelFormat)
{
throw new InvalidImagePropertiesException("Source image and background images must have the same size and pixel format");
}
bitmapData = backgroundImage.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.ReadOnly, backgroundImage.PixelFormat);
unmanagedImage = new UnmanagedImage(bitmapData);
}
else
{
unmanagedImage = unmanagedBackgroundImage;
}
ImageStatistics imageStatistics = new ImageStatistics(unmanagedImage);
byte * ptr = (byte *)image.ImageData.ToPointer();
byte * ptr2 = (byte *)unmanagedImage.ImageData.ToPointer();
if (image.PixelFormat == PixelFormat.Format8bppIndexed)
{
double mean = imageStatistics.Gray.Mean;
for (int i = 0; i < height; i++)
{
int num2 = 0;
while (num2 < width)
{
if (*ptr2 != 0)
{
*ptr = (byte)System.Math.Min(mean * (double)(int)(*ptr) / (double)(int)(*ptr2), 255.0);
}
num2++;
ptr++;
ptr2++;
}
ptr += num;
ptr2 += num;
}
}
else
{
double mean2 = imageStatistics.Red.Mean;
double mean3 = imageStatistics.Green.Mean;
double mean4 = imageStatistics.Blue.Mean;
for (int j = 0; j < height; j++)
{
int num3 = 0;
while (num3 < width)
{
if (ptr2[2] != 0)
{
ptr[2] = (byte)System.Math.Min(mean2 * (double)(int)ptr[2] / (double)(int)ptr2[2], 255.0);
}
if (ptr2[1] != 0)
{
ptr[1] = (byte)System.Math.Min(mean3 * (double)(int)ptr[1] / (double)(int)ptr2[1], 255.0);
}
if (*ptr2 != 0)
{
*ptr = (byte)System.Math.Min(mean4 * (double)(int)(*ptr) / (double)(int)(*ptr2), 255.0);
}
num3++;
ptr += 3;
ptr2 += 3;
}
ptr += num;
ptr2 += num;
}
}
if (backgroundImage != null)
{
backgroundImage.UnlockBits(bitmapData);
}
if (backgroundImage == null && unmanagedBackgroundImage == null)
{
unmanagedImage.Dispose();
}
}
