public void SetHistogram( Histogram histogram )
{
this.histogram = histogram;
histogramControl.Values = histogram.Values;
int length = histogram.Values.Length;
Text = string.Format( "Histogram - {0} values", length );
statsBox.Text = string.Format( "Min: {0} Max: {1} Mean: {2:F2} Std.Dev.: {3:F2}",
histogram.Min, histogram.Max, histogram.Mean, histogram.StdDev );
// set form size
int formWidth = System.Math.Min( 800, length ) + 40;
int formHeight = HistogramHeight + 120;
this.Size = new Size( formWidth, formHeight );
// set histogram control size
int width = length + 2;
int height = HistogramHeight + 2;
int x = ( width > mainPanel.ClientSize.Width ) ? 0 : ( mainPanel.ClientSize.Width - width ) / 2;
int y = ( height > mainPanel.ClientSize.Height ) ? 0 : ( mainPanel.ClientSize.Height - height ) / 2;
histogramControl.SuspendLayout( );
histogramControl.Size = new Size( width, height );
histogramControl.Location = new System.Drawing.Point( x, y );
histogramControl.ResumeLayout( );
}
/// <summary>
/// Gather vertical intensity statistics for specified image.
/// </summary>
///
/// <param name="image">Source image.</param>
///
private void ProcessImage( UnmanagedImage image )
{
PixelFormat pixelFormat = image.PixelFormat;
// get image dimension
int width = image.Width;
int height = image.Height;
red = green = blue = gray = null;
// do the job
unsafe
{
// check pixel format
if ( pixelFormat == PixelFormat.Format8bppIndexed )
{
// 8 bpp grayscale image
byte* p = (byte*) image.ImageData.ToPointer( );
int offset = image.Stride - width;
// histogram array
int[] g = new int[height];
// for each pixel
for ( int y = 0; y < height; y++ )
{
int lineSum = 0;
// for each pixel
for ( int x = 0; x < width; x++, p++ )
{
lineSum += *p;
}
g[y] = lineSum;
p += offset;
}
// create historgram for gray level
gray = new Histogram( g );
}
else if ( pixelFormat == PixelFormat.Format16bppGrayScale )
{
// 16 bpp grayscale image
byte* basePtr = (byte*) image.ImageData.ToPointer( );
int stride = image.Stride;
// histogram array
int[] g = new int[height];
// for each pixel
for ( int y = 0; y < height; y++ )
{
ushort* p = (ushort*) ( basePtr + stride * y );
int lineSum = 0;
// for each pixel
for ( int x = 0; x < width; x++, p++ )
{
lineSum += *p;
}
g[y] = lineSum;
}
// create historgram for gray level
gray = new Histogram( g );
}
else if (
( pixelFormat == PixelFormat.Format24bppRgb ) ||
( pixelFormat == PixelFormat.Format32bppRgb ) ||
( pixelFormat == PixelFormat.Format32bppArgb ) )
{
// 24/32 bpp color image
byte* p = (byte*) image.ImageData.ToPointer( );
int pixelSize = ( pixelFormat == PixelFormat.Format24bppRgb ) ? 3 : 4;
int offset = image.Stride - width * pixelSize;
// histogram arrays
int[] r = new int[height];
int[] g = new int[height];
int[] b = new int[height];
// for each line
for ( int y = 0; y < height; y++ )
{
int lineRSum = 0;
int lineGSum = 0;
int lineBSum = 0;
// for each pixel
for ( int x = 0; x < width; x++, p += pixelSize )
{
lineRSum += p[RGB.R];
lineGSum += p[RGB.G];
lineBSum += p[RGB.B];
}
r[y] = lineRSum;
g[y] = lineGSum;
b[y] = lineBSum;
p += offset;
}
// create histograms
red = new Histogram( r );
green = new Histogram( g );
blue = new Histogram( b );
}
else if (
( pixelFormat == PixelFormat.Format48bppRgb ) ||
( pixelFormat == PixelFormat.Format64bppArgb ) )
{
// 48/64 bpp color image
byte* basePtr = (byte*) image.ImageData.ToPointer( );
int stride = image.Stride;
int pixelSize = ( pixelFormat == PixelFormat.Format48bppRgb ) ? 3 : 4;
// histogram arrays
int[] r = new int[height];
int[] g = new int[height];
int[] b = new int[height];
// for each line
for ( int y = 0; y < height; y++ )
{
ushort* p = (ushort*) ( basePtr + stride * y );
int lineRSum = 0;
int lineGSum = 0;
int lineBSum = 0;
// for each pixel
for ( int x = 0; x < width; x++, p += pixelSize )
{
lineRSum += p[RGB.R];
lineGSum += p[RGB.G];
lineBSum += p[RGB.B];
}
r[y] = lineRSum;
g[y] = lineGSum;
b[y] = lineBSum;
}
// create histograms
red = new Histogram( r );
green = new Histogram( g );
blue = new Histogram( b );
}
}
}
// Gather statistics for the specified image
private unsafe void ProcessImage( UnmanagedImage image, byte* mask, int maskLineSize )
{
// get image dimension
int width = image.Width;
int height = image.Height;
pixels = pixelsWithoutBlack = 0;
red = green = blue = gray = null;
redWithoutBlack = greenWithoutBlack = blueWithoutBlack = grayWithoutBlack = null;
int maskOffset = maskLineSize - width;
// check pixel format
if ( image.PixelFormat == PixelFormat.Format8bppIndexed )
{
// alloc arrays
int[] g = new int[256];
int[] gwb = new int[256];
byte value;
int offset = image.Stride - width;
// do the job
byte * p = (byte*) image.ImageData.ToPointer( );
if ( mask == null )
{
// for each pixel
for ( int y = 0; y < height; y++ )
{
// for each pixel
for ( int x = 0; x < width; x++, p++ )
{
// get pixel value
value = *p;
g[value]++;
pixels++;
if ( value != 0 )
{
gwb[value]++;
pixelsWithoutBlack++;
}
}
p += offset;
}
}
else
{
// for each pixel
for ( int y = 0; y < height; y++ )
{
// for each pixel
for ( int x = 0; x < width; x++, p++, mask++ )
{
if ( *mask == 0 )
continue;
// get pixel value
value = *p;
g[value]++;
pixels++;
if ( value != 0 )
{
gwb[value]++;
pixelsWithoutBlack++;
}
}
p += offset;
mask += maskOffset;
}
}
// create historgram for gray level
gray = new Histogram( g );
grayWithoutBlack = new Histogram( gwb );
}
else
{
// alloc arrays
int[] r = new int[256];
int[] g = new int[256];
int[] b = new int[256];
int[] rwb = new int[256];
int[] gwb = new int[256];
int[] bwb = new int[256];
byte rValue, gValue, bValue;
int pixelSize = ( image.PixelFormat == PixelFormat.Format24bppRgb ) ? 3 : 4;
int offset = image.Stride - width * pixelSize;
// do the job
byte * p = (byte*) image.ImageData.ToPointer( );
if ( mask == null )
{
// for each line
for ( int y = 0; y < height; y++ )
{
// for each pixel
for ( int x = 0; x < width; x++, p += pixelSize )
{
// get pixel values
rValue = p[RGB.R];
gValue = p[RGB.G];
bValue = p[RGB.B];
r[rValue]++;
g[gValue]++;
b[bValue]++;
pixels++;
if ( ( rValue != 0 ) || ( gValue != 0 ) || ( bValue != 0 ) )
{
rwb[rValue]++;
gwb[gValue]++;
bwb[bValue]++;
pixelsWithoutBlack++;
}
}
p += offset;
}
}
else
{
// for each line
for ( int y = 0; y < height; y++ )
{
// for each pixel
for ( int x = 0; x < width; x++, p += pixelSize, mask++ )
{
if ( *mask == 0 )
continue;
// get pixel values
rValue = p[RGB.R];
gValue = p[RGB.G];
bValue = p[RGB.B];
r[rValue]++;
g[gValue]++;
b[bValue]++;
pixels++;
if ( ( rValue != 0 ) || ( gValue != 0 ) || ( bValue != 0 ) )
{
rwb[rValue]++;
gwb[gValue]++;
bwb[bValue]++;
pixelsWithoutBlack++;
}
}
p += offset;
mask += maskOffset;
}
}
// create histograms
red = new Histogram( r );
green = new Histogram( g );
blue = new Histogram( b );
redWithoutBlack = new Histogram( rwb );
greenWithoutBlack = new Histogram( gwb );
blueWithoutBlack = new Histogram( bwb );
}
}
