.net - vectoriales - Cómo acceder a cada byte en una imagen de mapa de bits

que es un mapa de bits en corel draw

Question

Supongamos que tengo una imagen de mapa de bits, ¿es posible recorrer todos los bytes individuales de la imagen? Si es así, ¿cómo?

Answer 1

Encontré esto: http://channel9.msdn.com/forums/TechOff/108813-Bitmap-to-byte-array/

Diciendo que podrías usar un Memorystream y el método .Save se vería así:

System.Drawing.Bitmap bmp = GetTheBitmap();
System.IO.MemoryStream stream = new System.IO.MemoryStream();
bmp.Save(stream, System.Drawing.Imaging.ImageFormat.Bmp);
stream.Position = 0;
byte[] data = new byte[stream.Length];
stream.Read(data, 0, stream.Length);

Answer 2

Si necesita acceder a la información de píxeles, la forma súper lenta pero súper fácil es llamar a los métodos GetPixel y SetPixel en su objeto Bitmap.

La forma súper rápida y no tan difícil es llamar al método LockBits de Bitmap y usar el objeto BitmapData que se devuelve para leer y escribir directamente los datos de bytes de Bitmap. Puedes hacer esta última parte con la clase Mariscal como en el ejemplo de Ilya, o puedes omitir los gastos generales del Mariscal de esta manera:

    BitmapData data;
    int x = 0; //or whatever
    int y = 0;
    unsafe
    {
        byte* row = (byte*)data.Scan0 + (y * data.Stride);
        int columnOffset = x * 4;
        byte B = row[columnOffset];
        byte G = row[columnOffset + 1];
        byte R = row[columnOffset + 2];
        byte A = row[columnOffset + 3];
    }

Answer 3

Utilice el miembro LockBits en la clase Bitmap para obtener BitmapData, luego use Scan0 y Marshal.ReadByte en readbytes. Aquí hay un pequeño ejemplo (sin embargo, no se trata del ajuste de brillo correcto):

    public static void AdjustBrightness(Bitmap image, int brightness)
    {
        int offset = 0;
        brightness = (brightness * 255) / 100;
        // GDI+ still lies to us - the return format is BGR, NOT RGB.
        BitmapData bmData = image.LockBits(new Rectangle(0, 0, image.Width, image.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);

        int stride = bmData.Stride;
        IntPtr Scan0 = bmData.Scan0;

        int nVal = 0;
        int nOffset = stride - image.Width * 3;
        int nWidth = image.Width * 3;

        for (int y = 0; y < image.Height; ++y)
        {
            for (int x = 0; x < nWidth; ++x)
            {
                nVal = Marshal.ReadByte(Scan0, offset) + brightness;

                if (nVal < 0)
                    nVal = 0;
                if (nVal > 255)
                    nVal = 255;

                Marshal.WriteByte(Scan0, offset, (byte)nVal);
                ++offset;
            }
            offset += nOffset;
        }
        image.UnlockBits(bmData);
    }

Answer 4

Otra solución es utilizar LockBits y Marshal.Copy para convertir su mapa de bits en una matriz. Necesitaba esta solución porque tenía dos imágenes que diferían solo en su profundidad de color y las otras soluciones ofrecidas no se manejan tan bien (o son demasiado lentas).

using (Bitmap bmp = new Bitmap(fname)) {
    // Convert image to int32 array with each int being one pixel
    int cnt = bmp.Width * bmp.Height * 4 / 4;
    BitmapData bmData = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height),
                            ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
    Int32[] rgbValues = new Int32[cnt];

    // Copy the RGB values into the array.
    System.Runtime.InteropServices.Marshal.Copy(bmData.Scan0, rgbValues, 0, cnt);
    bmp.UnlockBits(bmData);
    for (int i = 0; i < cnt; ++i) {
        if (rgbValues[i] == 0xFFFF0000)
            Console.WriteLine ("Red byte");
    }
}