The class encapsulates RGB color components.
PixelFormat.Format24bppRgb actually means BGR format.
/// <summary> /// Paint the controls. /// </summary> /// /// <param name="e">Paint event arguments.</param> /// protected override void OnPaint(PaintEventArgs e) { Graphics g = e.Graphics; Rectangle rc = this.ClientRectangle; Rectangle rcPie; Brush brush; RGB rgb = new RGB(); HSL hsl = new HSL(); // get pie rectangle rcPie = new Rectangle(4, 4, System.Math.Min(rc.Right, rc.Bottom) - 8, System.Math.Min(rc.Right, rc.Bottom) - 8); // init HSL value hsl.Luminance = 0.5f; hsl.Saturation = 1.0f; if (type == HuePickerType.Value) { // draw HSL pie for (int i = 0; i < 360; i++) { hsl.Hue = i; // convert from HSL to RGB Accord.Imaging.HSL.ToRGB(hsl, rgb); // create brush brush = new SolidBrush(rgb.Color); // draw one hue value g.FillPie(brush, rcPie, -i, -1); brush.Dispose(); } } else { // draw HSL pie for (int i = 0; i < 360; i++) { if ( ((min < max) && (i >= min) && (i <= max)) || ((min > max) && ((i >= min) || (i <= max)))) { hsl.Hue = i; // convert from HSL to RGB Accord.Imaging.HSL.ToRGB(hsl, rgb); // create brush brush = new SolidBrush(rgb.Color); } else { brush = new SolidBrush(Color.FromArgb(128, 128, 128)); } // draw one hue value g.FillPie(brush, rcPie, -i, -1); brush.Dispose(); } } // double halfWidth = (double)rcPie.Width / 2; double angleRad = -min * System.Math.PI / 180; double angleCos = System.Math.Cos(angleRad); double angleSin = System.Math.Sin(angleRad); double x = halfWidth * angleCos; double y = halfWidth * angleSin; ptCenter.X = rcPie.Left + (int)(halfWidth); ptCenter.Y = rcPie.Top + (int)(halfWidth); ptMin.X = rcPie.Left + (int)(halfWidth + x); ptMin.Y = rcPie.Top + (int)(halfWidth + y); // draw MIN pointer g.FillEllipse(blackBrush, rcPie.Left + (int)(halfWidth + x) - 4, rcPie.Top + (int)(halfWidth + y) - 4, 8, 8); g.DrawLine(blackPen, ptCenter, ptMin); // check picker type if (type == HuePickerType.Range) { angleRad = -max * System.Math.PI / 180; angleCos = System.Math.Cos(angleRad); angleSin = System.Math.Sin(angleRad); x = halfWidth * angleCos; y = halfWidth * angleSin; ptMax.X = rcPie.Left + (int)(halfWidth + x); ptMax.Y = rcPie.Top + (int)(halfWidth + y); // draw MAX pointer g.FillEllipse(whiteBrush, rcPie.Left + (int)(halfWidth + x) - 4, rcPie.Top + (int)(halfWidth + y) - 4, 8, 8); g.DrawLine(whitePen, ptCenter, ptMax); } base.OnPaint(e); }
/// <summary> /// Creates a color histogram discarding low intensity colors /// </summary> /// private unsafe float[] createHistogram(UnmanagedImage frame, Rectangle area) { int width = frame.Width; int height = frame.Height; int stride = frame.Stride; int pixelSize = Bitmap.GetPixelFormatSize(frame.PixelFormat) / 8; int offset = stride - area.Width * pixelSize; float[] histogram = new float[histogramSize]; // stay inside the image int areaX = Math.Max(area.X, 0); int areaY = Math.Max(area.Y, 0); int areaWidth = Math.Min(area.Width, width - areaX); int areaHeight = Math.Min(area.Height, height - areaY); if (mode == CamshiftMode.HSL) { // Process as HSL HSL hsl = new HSL(); RGB rgb = new RGB(); byte* src = (byte*)frame.ImageData.ToPointer() + areaX * pixelSize + areaY * stride; for (int y = 0; y < areaHeight; y++) { for (int x = 0; x < areaWidth; x++, src += 3) { rgb.Red = (*(src + RGB.R)); rgb.Green = (*(src + RGB.G)); rgb.Blue = (*(src + RGB.B)); Accord.Imaging.HSL.FromRGB(rgb, hsl); if ((hsl.Saturation >= hslSaturation.Min) && (hsl.Saturation <= hslSaturation.Max) && (hsl.Luminance >= hslLuminance.Min) && (hsl.Luminance <= hslLuminance.Max)) histogram[hsl.Hue] += 1; } src += offset; } } else if (mode == CamshiftMode.Mixed) { // Process in mixed mode HSL hsl = new HSL(); RGB rgb = new RGB(); byte* src = (byte*)frame.ImageData.ToPointer() + areaX * pixelSize + areaY * stride; for (int y = 0; y < areaHeight; y++) { for (int x = 0; x < areaWidth; x++, src += 3) { rgb.Red = (*(src + RGB.R)); rgb.Green = (*(src + RGB.G)); rgb.Blue = (*(src + RGB.B)); Accord.Imaging.HSL.FromRGB(rgb, hsl); if ((hsl.Saturation >= hslSaturation.Min) && (hsl.Saturation <= hslSaturation.Max) && (hsl.Luminance >= hslLuminance.Min) && (hsl.Luminance <= hslLuminance.Max)) histogram[(int)(hsl.Hue * 10 + hsl.Saturation * 100 + hsl.Luminance * 10)] += 1; } src += offset; } } else { // Process as RGB byte* src = (byte*)frame.ImageData.ToPointer() + areaX * pixelSize + areaY * stride; for (int y = 0; y < areaHeight; y++) { for (int x = 0; x < areaWidth; x++, src += 3) { // (small values are discarded) int r = (int)(*(src + RGB.R)) >> 4; int g = (int)(*(src + RGB.G)) >> 4; int b = (int)(*(src + RGB.B)) >> 4; histogram[256 * r + 16 * g + b] += 1; } src += offset; } } return histogram; }
// 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; int[] yhisto = new int[256]; int[] cbhisto = new int[256]; int[] crhisto = new int[256]; int[] yhistoWB = new int[256]; int[] cbhistoWB = new int[256]; int[] crhistoWB = new int[256]; RGB rgb = new RGB(); YCbCr ycbcr = new YCbCr(); int pixelSize = (image.PixelFormat == PixelFormat.Format24bppRgb) ? 3 : 4; int offset = image.Stride - width * pixelSize; int maskOffset = maskLineSize - width; // 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) { rgb.Red = p[RGB.R]; rgb.Green = p[RGB.G]; rgb.Blue = p[RGB.B]; // convert to YCbCr color space Accord.Imaging.YCbCr.FromRGB(rgb, ref ycbcr); yhisto[(int)(ycbcr.Y * 255)]++; cbhisto[(int)((ycbcr.Cb + 0.5) * 255)]++; crhisto[(int)((ycbcr.Cr + 0.5) * 255)]++; pixels++; if ((ycbcr.Y != 0.0) || (ycbcr.Cb != 0.0) || (ycbcr.Cr != 0.0)) { yhistoWB[(int)(ycbcr.Y * 255)]++; cbhistoWB[(int)((ycbcr.Cb + 0.5) * 255)]++; crhistoWB[(int)((ycbcr.Cr + 0.5) * 255)]++; 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; } rgb.Red = p[RGB.R]; rgb.Green = p[RGB.G]; rgb.Blue = p[RGB.B]; // convert to YCbCr color space Accord.Imaging.YCbCr.FromRGB(rgb, ref ycbcr); yhisto[(int)(ycbcr.Y * 255)]++; cbhisto[(int)((ycbcr.Cb + 0.5) * 255)]++; crhisto[(int)((ycbcr.Cr + 0.5) * 255)]++; pixels++; if ((ycbcr.Y != 0.0) || (ycbcr.Cb != 0.0) || (ycbcr.Cr != 0.0)) { yhistoWB[(int)(ycbcr.Y * 255)]++; cbhistoWB[(int)((ycbcr.Cb + 0.5) * 255)]++; crhistoWB[(int)((ycbcr.Cr + 0.5) * 255)]++; pixelsWithoutBlack++; } } p += offset; mask += maskOffset; } } // create histograms yHistogram = new ContinuousHistogram(yhisto, new Range(0.0f, 1.0f)); cbHistogram = new ContinuousHistogram(cbhisto, new Range(-0.5f, 0.5f)); crHistogram = new ContinuousHistogram(crhisto, new Range(-0.5f, 0.5f)); yHistogramWithoutBlack = new ContinuousHistogram(yhistoWB, new Range(0.0f, 1.0f)); cbHistogramWithoutBlack = new ContinuousHistogram(cbhistoWB, new Range(-0.5f, 0.5f)); crHistogramWithoutBlack = new ContinuousHistogram(crhistoWB, new Range(-0.5f, 0.5f)); }
/// <summary> /// Convert the color to <b>RGB</b> color space. /// </summary> /// /// <returns>Returns <see cref="RGB"/> instance, which represents converted color value.</returns> /// public RGB ToRGB() { RGB rgb = new RGB(); ToRGB(this, rgb); return rgb; }
/// <summary> /// Image histogram back-projection. /// </summary> /// private unsafe void generateBackprojectionMap(UnmanagedImage frame, float[] ratioHistogram) { int width = frame.Width; int height = frame.Height; int stride = frame.Stride; int pixelSize = Bitmap.GetPixelFormatSize(frame.PixelFormat) / 8; int offset = stride - width * pixelSize; fixed (float* map_ptr = map) { byte* src = (byte*)frame.ImageData.ToPointer(); float* dst = map_ptr; if (mode == CamshiftMode.HSL) { // Process as HSL HSL hsl = new HSL(); RGB rgb = new RGB(); for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++, src += pixelSize, dst++) { // RGB rgb.Red = (*(src + RGB.R)); rgb.Green = (*(src + RGB.G)); rgb.Blue = (*(src + RGB.B)); // Transform into HSL Accord.Imaging.HSL.FromRGB(rgb, hsl); if ((hsl.Saturation >= hslSaturation.Min) && (hsl.Saturation <= hslSaturation.Max) && (hsl.Luminance >= hslLuminance.Min) && (hsl.Luminance <= hslLuminance.Max)) *dst = ratioHistogram[hsl.Hue]; else *dst = 0; } src += offset; } } else if (mode == CamshiftMode.Mixed) { // Process in mixed mode HSL hsl = new HSL(); RGB rgb = new RGB(); for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++, src += pixelSize, dst++) { // RGB rgb.Red = (*(src + RGB.R)); rgb.Green = (*(src + RGB.G)); rgb.Blue = (*(src + RGB.B)); // Transform into HSL Accord.Imaging.HSL.FromRGB(rgb, hsl); if ((hsl.Saturation >= hslSaturation.Min) && (hsl.Saturation <= hslSaturation.Max) && (hsl.Luminance >= hslLuminance.Min) && (hsl.Luminance <= hslLuminance.Max)) *dst = ratioHistogram[(int)(hsl.Hue * 10 + hsl.Saturation * 100 + hsl.Luminance * 10)]; else *dst = 0; } src += offset; } } else { // Process as RGB for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++, src += pixelSize, dst++) { // RGB int r = (int)(*(src + RGB.R)) >> 4; int g = (int)(*(src + RGB.G)) >> 4; int b = (int)(*(src + RGB.B)) >> 4; *dst = ratioHistogram[256 * r + 16 * g + b]; } src += offset; } } } }
/// <summary> /// Convert from RGB to YCbCr color space (Rec 601-1 specification). /// </summary> /// /// <param name="rgb">Source color in <b>RGB</b> color space.</param> /// /// <returns>Returns <see cref="YCbCr"/> instance, which represents converted color value.</returns> /// public static YCbCr FromRGB(RGB rgb) { YCbCr ycbcr = new YCbCr(); FromRGB(rgb, ycbcr); return ycbcr; }
/// <summary> /// Convert from YCbCr to RGB color space. /// </summary> /// /// <param name="ycbcr">Source color in <b>YCbCr</b> color space.</param> /// <param name="rgb">Destination color in <b>RGB</b> color space.</param> /// public static void ToRGB(YCbCr ycbcr, RGB rgb) { // Don't worry about zeros. Compiler will remove them float r = Math.Max(0.0f, Math.Min(1.0f, (float)(ycbcr.Y + 0.0000 * ycbcr.Cb + 1.4022 * ycbcr.Cr))); float g = Math.Max(0.0f, Math.Min(1.0f, (float)(ycbcr.Y - 0.3456 * ycbcr.Cb - 0.7145 * ycbcr.Cr))); float b = Math.Max(0.0f, Math.Min(1.0f, (float)(ycbcr.Y + 1.7710 * ycbcr.Cb + 0.0000 * ycbcr.Cr))); rgb.Red = (byte)(r * 255); rgb.Green = (byte)(g * 255); rgb.Blue = (byte)(b * 255); rgb.Alpha = 255; }
/// <summary> /// Convert from HSL to RGB color space. /// </summary> /// /// <param name="hsl">Source color in <b>HSL</b> color space.</param> /// <param name="rgb">Destination color in <b>RGB</b> color space.</param> /// public static void ToRGB(HSL hsl, RGB rgb) { if (hsl.Saturation == 0) { // gray values rgb.Red = rgb.Green = rgb.Blue = (byte)(hsl.Luminance * 255); } else { float v1, v2; float hue = (float)hsl.Hue / 360; v2 = (hsl.Luminance < 0.5) ? (hsl.Luminance * (1 + hsl.Saturation)) : ((hsl.Luminance + hsl.Saturation) - (hsl.Luminance * hsl.Saturation)); v1 = 2 * hsl.Luminance - v2; rgb.Red = (byte)(255 * Hue_2_RGB(v1, v2, hue + (1.0f / 3))); rgb.Green = (byte)(255 * Hue_2_RGB(v1, v2, hue)); rgb.Blue = (byte)(255 * Hue_2_RGB(v1, v2, hue - (1.0f / 3))); } rgb.Alpha = 255; }
/// <summary> /// Convert from RGB to YCbCr color space (Rec 601-1 specification). /// </summary> /// /// <param name="rgb">Source color in <b>RGB</b> color space.</param> /// <param name="ycbcr">Destination color in <b>YCbCr</b> color space.</param> /// public static void FromRGB(RGB rgb, YCbCr ycbcr) { float r = (float)rgb.Red / 255; float g = (float)rgb.Green / 255; float b = (float)rgb.Blue / 255; ycbcr.Y = (float)(0.2989 * r + 0.5866 * g + 0.1145 * b); ycbcr.Cb = (float)(-0.1687 * r - 0.3313 * g + 0.5000 * b); ycbcr.Cr = (float)(0.5000 * r - 0.4184 * g - 0.0816 * b); }
/// <summary> /// Convert from RGB to HSL color space. /// </summary> /// /// <param name="rgb">Source color in <b>RGB</b> color space.</param> /// /// <returns>Returns <see cref="HSL"/> instance, which represents converted color value.</returns> /// public static HSL FromRGB(RGB rgb) { HSL hsl = new HSL(); FromRGB(rgb, hsl); return hsl; }
/// <summary> /// Convert from RGB to HSL color space. /// </summary> /// /// <param name="rgb">Source color in <b>RGB</b> color space.</param> /// <param name="hsl">Destination color in <b>HSL</b> color space.</param> /// /// <remarks><para>See <a href="http://en.wikipedia.org/wiki/HSI_color_space#Conversion_from_RGB_to_HSL_or_HSV">HSL and HSV Wiki</a> /// for information about the algorithm to convert from RGB to HSL.</para></remarks> /// public static void FromRGB(RGB rgb, HSL hsl) { float r = (rgb.Red / 255.0f); float g = (rgb.Green / 255.0f); float b = (rgb.Blue / 255.0f); float min = Math.Min(Math.Min(r, g), b); float max = Math.Max(Math.Max(r, g), b); float delta = max - min; // get luminance value hsl.Luminance = (max + min) / 2; if (delta == 0) { // gray color hsl.Hue = 0; hsl.Saturation = 0.0f; } else { // get saturation value hsl.Saturation = (hsl.Luminance <= 0.5) ? (delta / (max + min)) : (delta / (2 - max - min)); // get hue value float hue; if (r == max) { hue = ((g - b) / 6) / delta; } else if (g == max) { hue = (1.0f / 3) + ((b - r) / 6) / delta; } else { hue = (2.0f / 3) + ((r - g) / 6) / delta; } // correct hue if needed if (hue < 0) hue += 1; if (hue > 1) hue -= 1; hsl.Hue = (int)(hue * 360); } }
// 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; int[] s = new int[256]; int[] l = new int[256]; int[] swb = new int[256]; int[] lwb = new int[256]; RGB rgb = new RGB(); HSL hsl = new HSL(); int pixelSize = (image.PixelFormat == PixelFormat.Format24bppRgb) ? 3 : 4; int offset = image.Stride - width * pixelSize; int maskOffset = maskLineSize - width; // 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) { rgb.Red = p[RGB.R]; rgb.Green = p[RGB.G]; rgb.Blue = p[RGB.B]; // convert to HSL color space Accord.Imaging.HSL.FromRGB(rgb, hsl); s[(int)(hsl.Saturation * 255)]++; l[(int)(hsl.Luminance * 255)]++; pixels++; if (hsl.Luminance != 0.0) { swb[(int)(hsl.Saturation * 255)]++; lwb[(int)(hsl.Luminance * 255)]++; 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; rgb.Red = p[RGB.R]; rgb.Green = p[RGB.G]; rgb.Blue = p[RGB.B]; // convert to HSL color space Accord.Imaging.HSL.FromRGB(rgb, hsl); s[(int)(hsl.Saturation * 255)]++; l[(int)(hsl.Luminance * 255)]++; pixels++; if (hsl.Luminance != 0.0) { swb[(int)(hsl.Saturation * 255)]++; lwb[(int)(hsl.Luminance * 255)]++; pixelsWithoutBlack++; } } p += offset; mask += maskOffset; } } // create histograms saturation = new ContinuousHistogram(s, new Range(0, 1)); luminance = new ContinuousHistogram(l, new Range(0, 1)); saturationWithoutBlack = new ContinuousHistogram(swb, new Range(0, 1)); luminanceWithoutBlack = new ContinuousHistogram(lwb, new Range(0, 1)); }
// 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; int[] yhisto = new int[256]; int[] cbhisto = new int[256]; int[] crhisto = new int[256]; int[] yhistoWB = new int[256]; int[] cbhistoWB = new int[256]; int[] crhistoWB = new int[256]; RGB rgb = new RGB(); YCbCr ycbcr = new YCbCr(); int pixelSize = (image.PixelFormat == PixelFormat.Format24bppRgb) ? 3 : 4; int offset = image.Stride - width * pixelSize; int maskOffset = maskLineSize - width; // 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) { rgb.Red = p[RGB.R]; rgb.Green = p[RGB.G]; rgb.Blue = p[RGB.B]; // convert to YCbCr color space Accord.Imaging.YCbCr.FromRGB(rgb, ycbcr); yhisto[(int)(ycbcr.Y * 255)]++; cbhisto[(int)((ycbcr.Cb + 0.5) * 255)]++; crhisto[(int)((ycbcr.Cr + 0.5) * 255)]++; pixels++; if ((ycbcr.Y != 0.0) || (ycbcr.Cb != 0.0) || (ycbcr.Cr != 0.0)) { yhistoWB[(int)(ycbcr.Y * 255)]++; cbhistoWB[(int)((ycbcr.Cb + 0.5) * 255)]++; crhistoWB[(int)((ycbcr.Cr + 0.5) * 255)]++; 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; rgb.Red = p[RGB.R]; rgb.Green = p[RGB.G]; rgb.Blue = p[RGB.B]; // convert to YCbCr color space Accord.Imaging.YCbCr.FromRGB(rgb, ycbcr); yhisto[(int)(ycbcr.Y * 255)]++; cbhisto[(int)((ycbcr.Cb + 0.5) * 255)]++; crhisto[(int)((ycbcr.Cr + 0.5) * 255)]++; pixels++; if ((ycbcr.Y != 0.0) || (ycbcr.Cb != 0.0) || (ycbcr.Cr != 0.0)) { yhistoWB[(int)(ycbcr.Y * 255)]++; cbhistoWB[(int)((ycbcr.Cb + 0.5) * 255)]++; crhistoWB[(int)((ycbcr.Cr + 0.5) * 255)]++; pixelsWithoutBlack++; } } p += offset; mask += maskOffset; } } // create histograms yHistogram = new ContinuousHistogram(yhisto, new Range(0.0f, 1.0f)); cbHistogram = new ContinuousHistogram(cbhisto, new Range(-0.5f, 0.5f)); crHistogram = new ContinuousHistogram(crhisto, new Range(-0.5f, 0.5f)); yHistogramWithoutBlack = new ContinuousHistogram(yhistoWB, new Range(0.0f, 1.0f)); cbHistogramWithoutBlack = new ContinuousHistogram(cbhistoWB, new Range(-0.5f, 0.5f)); crHistogramWithoutBlack = new ContinuousHistogram(crhistoWB, new Range(-0.5f, 0.5f)); }
// 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; int[] s = new int[256]; int[] l = new int[256]; int[] swb = new int[256]; int[] lwb = new int[256]; RGB rgb = new RGB(); HSL hsl = new HSL(); int pixelSize = (image.PixelFormat == PixelFormat.Format24bppRgb) ? 3 : 4; int offset = image.Stride - width * pixelSize; int maskOffset = maskLineSize - width; // 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) { rgb.Red = p[RGB.R]; rgb.Green = p[RGB.G]; rgb.Blue = p[RGB.B]; // convert to HSL color space Accord.Imaging.HSL.FromRGB(rgb, hsl); s[(int)(hsl.Saturation * 255)]++; l[(int)(hsl.Luminance * 255)]++; pixels++; if (hsl.Luminance != 0.0) { swb[(int)(hsl.Saturation * 255)]++; lwb[(int)(hsl.Luminance * 255)]++; 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; } rgb.Red = p[RGB.R]; rgb.Green = p[RGB.G]; rgb.Blue = p[RGB.B]; // convert to HSL color space Accord.Imaging.HSL.FromRGB(rgb, hsl); s[(int)(hsl.Saturation * 255)]++; l[(int)(hsl.Luminance * 255)]++; pixels++; if (hsl.Luminance != 0.0) { swb[(int)(hsl.Saturation * 255)]++; lwb[(int)(hsl.Luminance * 255)]++; pixelsWithoutBlack++; } } p += offset; mask += maskOffset; } } // create histograms saturation = new ContinuousHistogram(s, new Range(0, 1)); luminance = new ContinuousHistogram(l, new Range(0, 1)); saturationWithoutBlack = new ContinuousHistogram(swb, new Range(0, 1)); luminanceWithoutBlack = new ContinuousHistogram(lwb, new Range(0, 1)); }