/// <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);
            }
        }
 /// <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 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;
            }
        }
        public ImageReader(string imageFile)
        {
            Bitmap img = new Bitmap(imageFile);
            Width = img.Width;
            Height = img.Height;
            Count = 1;//Something more here!? //TODO: what is this really
            this.depth = 3;
            Pixels = new List<byte>();

            RGB rgb = new RGB();
            HSL hsl = new HSL();

            for (int j = 0; j < img.Height; j++)
            {
                for (int i = 0; i < img.Width; i++)
                {
                    Color pixel = img.GetPixel(i, j);
                    //will expect the data to be packed perpixel by row in pixel order RGB
                    Pixels.Add(pixel.R);
                    Pixels.Add(pixel.G);
                    Pixels.Add(pixel.B);

                    rgb.Red = pixel.R;
                    rgb.Green = pixel.G;
                    rgb.Blue = pixel.B;

                    // convert to HSL color space
                    HSL.FromRGB(rgb, hsl);

                    this.saturation[(int)(hsl.Saturation * 255)]++;
                    this.luminance[(int)(hsl.Luminance * 255)]++;
                    pixels++;

                    if (hsl.Luminance != 0.0)
                    {
                        swb[(int)(hsl.Saturation * 255)]++;
                        lwb[(int)(hsl.Luminance * 255)]++;
                        pixelsWithoutBlack++;
                    }

                    byte rValue, gValue, bValue;

                    // get pixel values
                    rValue = pixel.R;
                    gValue = pixel.G;
                    bValue = pixel.B;

                    r[rValue]++;
                    g[gValue]++;
                    b[bValue]++;
                    pixelsRGB++;

                    if ((rValue != 0) || (gValue != 0) || (bValue != 0))
                    {
                        rwb[rValue]++;
                        gwb[gValue]++;
                        bwb[bValue]++;
                        pixelsWithoutBlackRGB++;
                    }
                }
            }
        }