reading a jpeg file in c#.

Question

Hello. I have a doubt in c#. How to read a jpeg or bmp file using c#? and how to store the pixel's RGB values in array? Then how to check whether the value is already exist or not?

Answer 1

You can use Image.FromFile (http://msdn.microsoft.com/en-us/library/system.drawing.image.fromfile.aspx) to create an Image object from an image on disk.

Answer 2

1. Read the file using the Bitmap class.
2. Lock pixels.
3. Retrieve bytes from array.

Alternatively, you can use GetPixel if you just need one or two.

Answer 3

James Schek has it, but beware that GetPixel is extremely, incredibly slow.

Here's a complete sample using lockbits:

/*Note unsafe keyword*/
public unsafe Image ThresholdUA(float thresh)
{
    Bitmap b = new Bitmap(_image);//note this has several overloads, including a path to an image

    BitmapData bData = b.LockBits(new Rectangle(0, 0, _image.Width, _image.Height), ImageLockMode.ReadWrite, b.PixelFormat);

    byte bitsPerPixel = GetBitsPerPixel(bData.PixelFormat);

    /*This time we convert the IntPtr to a ptr*/
    byte* scan0 = (byte*)bData.Scan0.ToPointer();

    for (int i = 0; i < bData.Height; ++i)
    {
        for (int j = 0; j < bData.Width; ++j)
        {
            byte* data = scan0 + i * bData.Stride + j * bitsPerPixel / 8;

            //data is a pointer to the first byte of the 3-byte color data
        }
    }

    b.UnlockBits(bData);

    return b;
}

There's another way to do it using marshaling though. Here's the same thing, but with marshaling:

/*No unsafe keyword!*/
public Image ThresholdMA(float thresh)
{
    Bitmap b = new Bitmap(_image);

    BitmapData bData = b.LockBits(new Rectangle(0, 0, _image.Width, _image.Height), ImageLockMode.ReadWrite, b.PixelFormat);

    /* GetBitsPerPixel just does a switch on the PixelFormat and returns the number */
    byte bitsPerPixel = GetBitsPerPixel(bData.PixelFormat);

    /*the size of the image in bytes */
    int size = bData.Stride * bData.Height;

    /*Allocate buffer for image*/
    byte[] data = new byte[size];

    /*This overload copies data of /size/ into /data/ from location specified (/Scan0/)*/
    System.Runtime.InteropServices.Marshal.Copy(bData.Scan0, data, 0, size);

    for (int i = 0; i < size; i += bitsPerPixel / 8 )
    {
        double magnitude = 1/3d*(data[i] +data[i + 1] +data[i + 2]);

        //data[i] is the first of 3 bytes of color

    }

    /* This override copies the data back into the location specified */
    System.Runtime.InteropServices.Marshal.Copy(data, 0, bData.Scan0, data.Length);

    b.UnlockBits(bData);

    return b;
}

Answer 4

As it was already mentioned, the fastest way to retrieve pixels is to use LockBits(). However, there's a way to do it without MarshalCopy or unsafe code.

First, you'll need to compute Stride of your image.

var stride = ComputeStride(img.Width, format);

it is width*bytesPerPixel value rounded up to be divisible by 4. See formulas here.

Then you'll need to initialize an array of required size

var pixels = new byte[img.Height*stride]

Then you'll need to retrieve an unmanaged pointer to the beginning of this array. You may use Marshal.UnsafeAddrOfPinnedArrayElement(pixels, 0), but it's more safe to pin array in memory:

var handle = GCHandle.Alloc(pixels, GCHandleType.Pinned);
var scan0 = pixels.AddrOfPinnedObject();

You'll need to create BitmapData structure

var bData = new BitmapData{Width = img.Width, height = img.Height, Stride = stride, Scan0 = scan0};

Then you'll pass it to LockBits method while setting ImageLockMode.UserInputBuffer flag.

img.LockBits(area, ImageLockMode.Readonly | ImageLockMode.UserInputBuffer, format, bData);

Voila! pixels are stored in pixels array. But you'll need to unpin your buffer:

handle.Free();

This may seem cumbersome, but this is the fastest way, since only one copying of data is required.