C# LockBitmap - xy-coordinate to Pixel byte conversion

Question

I am trying to learn LockBitmap class for image processing and I came across this code posted below. Basically it returns the color of a x-y coordinate.

Of course this method only works after I perform source.LockBits() and Marshal.Copy() / unsafe context.

public Color GetPixel(int x, int y, Bitmap source)
{
    int Depth = System.Drawing.Bitmap.GetPixelFormatSize(source.PixelFormat);
    int Width = source.Width;
    int Height = source.Height;
    Color clr = Color.Empty;

    // Get color components count
    int cCount = Depth / 8;
    int PixelCounts = Width * Height;
    byte[] Pixels = new byte[cCount * PixelCounts];

    // Get start index of the specified pixel
    int i = ((y * Width) + x) * cCount;

    byte b = Pixels[i];
    byte g = Pixels[i + 1];
    byte r = Pixels[i + 2];
    byte a = Pixels[i + 3]; // a
    clr = Color.FromArgb(a, r, g, b);

    return clr;
}

1. What is cCount, why is it always Depth / 8?
2. int i = ((y * Width) + x) * cCount, is this a fixed formula to convert from (x,y) coordinate to Pixels[i]? Why?

Answer 1

First of all, cCount is how many bytes one pixel is (bytes per pixel), Depth is how many bits one pixel is (bits per pixel). Division by 8 is done to convert from bits to bytes. (Though, Depth / 8 is inefficient, use (int)Math.Ceiling(Depth / 8d) instead)

To answer your second question, pixels are layed out row-by-row. Since each row is width pixels, then the size of each row would width * cCount bytes. If you want to get the position of, let's say, the second row, you would use ((2-1) * width) * cCount. If you want to get the position of the fourth pixel in that row, you would use ((2-1) * width + (4-1)) * cCount. Therefore, to get the position of the pixel with the coordinates, (x, y), you would use the formula, (y * width + x) * cCount.

Answer 2

1. It isn't always, check out this. This might be a superior implementation to yours.

   It can be 8, 16, 24, 32, etc. because 8 (or 16, etc.) bytes are required for color information.

Example code from the posted source:

 // Get start index of the specified pixel
        int i = ((y * Width) + x) * cCount;

        if (i > Pixels.Length - cCount)
            throw new IndexOutOfRangeException();

        if (Depth == 32) // For 32 bpp get Red, Green, Blue and Alpha
        {
            byte b = Pixels[i];
            byte g = Pixels[i + 1];
            byte r = Pixels[i + 2];
            byte a = Pixels[i + 3]; // a
            clr = Color.FromArgb(a, r, g, b);
        }
        if (Depth == 24) // For 24 bpp get Red, Green and Blue
        {
            byte b = Pixels[i];
            byte g = Pixels[i + 1];
            byte r = Pixels[i + 2];
            clr = Color.FromArgb(r, g, b);
        }
        if (Depth == 8)
        // For 8 bpp get color value (Red, Green and Blue values are the same)
        {
            byte c = Pixels[i];
            clr = Color.FromArgb(c, c, c);

2. Because bitmaps are stored as arrays in memory.

   (y * Width) is the dimension, + x) is the pixel in the dimension and * cCount is the step per pixel. (every pixel needs cCount bytes in memory.)

Think of it as if you put all pixels in a line, and it starts with bottom left, goes to top left, and ends up 2nd row from left bottom to 2nd row top bottom and goes on until it reaches top right.