Создание битовой карты из массива байтов данных пикселей

Ответ 1

• Это безопасно, если вы используете данные marshal.copy, а не устанавливаете scan0 (напрямую или через эту перегрузку BitMap()). Вы не хотите, чтобы управляемые объекты были закреплены, это будет ограничивать сборщик мусора.
• Если вы копируете, совершенно безопасно.
• Входной массив управляется и может быть перемещен GC, scan0 - неуправляемый указатель, который будет устаревать, если массив перемещается. Сам объект Bitmap управляется, но устанавливает указатель scan0 в Windows с помощью дескриптора.
• ImageLockMode.UserInputBuffer есть? По-видимому, он может быть передан LockBits, возможно, он сообщает Bitmap(), чтобы скопировать данные массива ввода.

Пример кода для создания растрового изображения в шкале серого из массива:

    var b = new Bitmap(Width, Height, PixelFormat.Format8bppIndexed);

    ColorPalette ncp = b.Palette;
    for (int i = 0; i < 256; i++)
        ncp.Entries[i] = Color.FromArgb(255, i, i, i);
    b.Palette = ncp;

    var BoundsRect = new Rectangle(0, 0, Width, Height);
    BitmapData bmpData = b.LockBits(BoundsRect,
                                    ImageLockMode.WriteOnly,
                                    b.PixelFormat);

    IntPtr ptr = bmpData.Scan0;

    int bytes = bmpData.Stride*b.Height;
    var rgbValues = new byte[bytes];

    // fill in rgbValues, e.g. with a for loop over an input array

    Marshal.Copy(rgbValues, 0, ptr, bytes);
    b.UnlockBits(bmpData);
    return b;

Ответ 2

Относительно вашего вопроса 4: ImageLockMode.UserInputBuffer может дать вам управление процессом выделения тех огромных объемов памяти, на которые можно ссылаться в объект BitmapData.

Если вы решили создать себе объект BitmapData, вы можете избежать Marshall.Copy. Затем вам придется использовать этот флаг в сочетании с другим ImageLockMode.

Остерегайтесь, что это сложный бизнес, особенно касающийся Stride и PixelFormat.

Вот пример, который будет получать за один снимок содержимое 24bbp-буфера на BitMap, а затем в один другой выстрел считывает его обратно в другой буфер на 48bbp.

Size size = Image.Size;
Bitmap bitmap = Image;
// myPrewrittenBuff is allocated just like myReadingBuffer below (skipped for space sake)
// But with two differences: the buff would be byte [] (not ushort[]) and the Stride == 3 * size.Width (not 6 * ...) because we build a 24bpp not 48bpp
BitmapData writerBuff= bm.LockBits(new Rectangle(0, 0, size.Width, size.Height), ImageLockMode.UserInputBuffer | ImageLockMode.WriteOnly, PixelFormat.Format24bppRgb, myPrewrittenBuff);
// note here writerBuff and myPrewrittenBuff are the same reference
bitmap.UnlockBits(writerBuff);
// done. bitmap updated , no marshal needed to copy myPrewrittenBuff 

// Now lets read back the bitmap into another format...
BitmapData myReadingBuffer = new BitmapData();
ushort[] buff = new ushort[(3 * size.Width) * size.Height]; // ;Marshal.AllocHGlobal() if you want
GCHandle handle= GCHandle.Alloc(buff, GCHandleType.Pinned);
myReadingBuffer.Scan0 = Marshal.UnsafeAddrOfPinnedArrayElement(buff, 0);
myReadingBuffer.Height = size.Height;
myReadingBuffer.Width = size.Width;
myReadingBuffer.PixelFormat = PixelFormat.Format48bppRgb;
myReadingBuffer.Stride = 6 * size.Width;
// now read into that buff
BitmapData result = bitmap.LockBits(new Rectangle(0, 0, size.Width, size.Height), ImageLockMode.UserInputBuffer | ImageLockMode.ReadOnly, PixelFormat.Format48bppRgb, myReadingBuffer);
if (object.ReferenceEquals(result, myReadingBuffer)) {
    // Note: we pass here
    // and buff is filled
}
bitmap.UnlockBits(result);
handle.Free();
// use buff at will...

Если вы используете ILSpy, вы увидите, что ссылка этого метода на GDI + и эти методы помогают более полно.

Вы можете увеличить производительность, используя собственную схему памяти, но остерегайтесь того, что Stride может потребоваться некоторое выравнивание, чтобы получить лучшее производительность.

Затем вы сможете отправиться в дикую природу, например, распределив огромную виртуальную память, сопоставленную scan0, и blit их достаточно эффективно. Обратите внимание, что закрепление огромного массива (и особенно нескольких) не будет обузой для GC и позволит вам полностью или полностью манипулировать байтом/коротким (или небезопасным, если вы ищете скорость)

Ответ 3

Я не уверен, есть ли причина, по которой вы это делаете. Может быть, есть. Похоже, что вы сбиты с пути настолько, что можете попытаться сделать что-то более продвинутое, чем подразумевается название вашего вопроса...

Однако традиционный способ создания Bitmap из массива Byte:

using (MemoryStream stream = new MemoryStream(byteArray))
{
     Bitmap bmp = new Bitmap(stream);
     // use bmp here....
}

Ответ 4

Вот пример кода, который я написал для преобразования байтового массива пикселей в 8-битное серое изображение (bmp) этот метод принимает пиксельный массив, ширину изображения и высоту в качестве аргументов //

public Bitmap Convert2Bitmap(byte[] DATA, int width, int height)
{
    Bitmap Bm = new Bitmap(width,height,PixelFormat.Format24bppRgb);
    var b = new Bitmap(width, height, PixelFormat.Format8bppIndexed);
    ColorPalette ncp = b.Palette;
    for (int i = 0; i < 256; i++)
        ncp.Entries[i] = Color.FromArgb(255, i, i, i);
    b.Palette = ncp;
    for (int y = 0; y < height; y++)
    {
        for (int x = 0; x < width; x++)
        {
            int Value = DATA[x + (y * width)];
            Color C = ncp.Entries[Value];
            Bm.SetPixel(x,y,C);
        }
    }
   return Bm;
}