C # - Преобразование 8-разрядных или 16-разрядных необработанных данных пикселей в градациях серого

Question

Мне нужно иметь возможность преобразовывать 8-битные или 16-битные пиксельные данные в градациях серого в формат файла, который может поддерживать .NET Framework.

Доступные мне данные: ширина, высота, ориентация (внизу слева) и формат пикселя в виде 4096 оттенков серого (12-разрядное разрешение), упакованных по 2 байта на пиксель.

Так, например, каждый пиксель находится в диапазоне от 0 до 4096, а каждый пиксель составляет 2 байта.

Я уже пытался использовать PixelFormat.Format16bppGrayScale с конструктором Bitmap, и он генерирует исключение GDI +. Все, что я прочитал, говорит о том, что этот формат не поддерживается и что MSDN неверен.

Я хочу преобразовать этот пиксельный буфер в формат растрового изображения .NET (например, Format32bppArgb) с минимальной потерей качества изображения.

Кто-нибудь знает как?

Answer 1

См. Пример ниже, который предварительно вычисляет таблицу соответствия (LUT) и использует ее для преобразования каждого пикселя. Эта версия охватывает ваш 12-битный случай; для 8-битного кода он очень похож, но его сложно обобщить по пиксельным форматам.

Преобразование из 12-битного GS в эффективно 8-битный GS приведет к потере данных. Однако вы можете настроить таблицу LUT для фокусировки на меньшем диапазоне входных значений с лучшей контрастностью (например, Центр окна DICOM / Ширина окна ).

class Program
{
    static void Main( string[] args )
    {
        // Test driver - create a Wedge, convert to Bitmap, save to file
        //
        int width = 4095;
        int height = 1200;
        int bits = 12;

        byte[] wedge = Wedge( width, height, bits );

        Bitmap bmp = Convert( wedge, width, height, bits );

        string file = "wedge.png";

        bmp.Save( file );

        Process.Start( file );
    }

    static Bitmap Convert( byte[] input, int width, int height, int bits )
    {
        // Convert byte buffer (2 bytes per pixel) to 32-bit ARGB bitmap

        var bitmap = new Bitmap( width, height, PixelFormat.Format32bppArgb );

        var rect = new Rectangle( 0, 0, width, height );

        var lut = CreateLut( bits );

        var bitmap_data = bitmap.LockBits( rect, ImageLockMode.WriteOnly, bitmap.PixelFormat );

        ConvertCore( width, height, bits, input, bitmap_data, lut );

        bitmap.UnlockBits( bitmap_data );

        return bitmap;
    }

    static unsafe void ConvertCore( int width, int height, int bits, byte[] input, BitmapData output, uint[] lut )
    {
        // Copy pixels from input to output, applying LUT

        ushort mask = (ushort)( ( 1 << bits ) - 1 );

        int in_stride = output.Stride;
        int out_stride = width * 2;

        byte* out_data = (byte*)output.Scan0;

        fixed ( byte* in_data = input )
        {
            for ( int y = 0; y < height; y++ )
            {
                uint* out_row = (uint*)( out_data + ( y * in_stride ) );

                ushort* in_row = (ushort*)( in_data + ( y * out_stride ) );

                for ( int x = 0; x < width; x++ )
                {
                    ushort in_pixel = (ushort)( in_row[ x ] & mask );

                    out_row[ x ] = lut[ in_pixel ];
                }
            }
        }
    }

    static uint[] CreateLut( int bits )
    {
        // Create a linear LUT to convert from grayscale to ARGB

        int max_input = 1 << bits;

        uint[] lut = new uint[ max_input ];

        for ( int i = 0; i < max_input; i++ )
        {
            // map input value to 8-bit range
            //
            byte intensity = (byte)( ( i * 0xFF ) / max_input );

            // create ARGB output value A=255, R=G=B=intensity
            //
            lut[ i ] = (uint)( 0xFF000000L | ( intensity * 0x00010101L ) );
        }

        return lut;
    }

    static byte[] Wedge( int width, int height, int bits )
    {
        // horizontal wedge

        int max = 1 << bits;

        byte[] pixels = new byte[ width * height * 2 ];

        for ( int y = 0; y < height; y++ )
        {
            for ( int x = 0; x < width; x++ )
            {
                int pixel = x % max;

                int addr = ( ( y * width ) + x ) * 2;

                pixels[ addr + 1 ] = (byte)( ( pixel & 0xFF00 ) >> 8 );
                pixels[ addr + 0 ] = (byte)( ( pixel & 0x00FF ) );
            }
        }

        return pixels;
    }
}

Answer 2

Подберите формат 16b и используйте ColorMatrix, чтобы правильно отобразить его перед отображением.

Я не проводил тесты производительности этого подхода на Windows, но на других платформах (например, Android), где мне требовалось эффективное хранение памяти и быстрое переназначение различных диапазонов в данных 12b или 16b, которые я хорошо использовал. эта техника.

Я говорю, что мои данные в градациях серого 12 / 16b действительно RGB565, так что они счастливы в сериализации, десериализации и других манипуляциях. Когда мне нужно отобразить, я пропускаю его через ColorMatrix, который отображает соответствующее окно в 8b оттенков серого в ARGB8888.

Если кто-то захочет попробовать это, я опубликую свой алгоритм отображения.

Answer 3

Два возможных способа:

• Использовать Конструктор растрового изображения , указывающий на произвольный буфер. Это требует, чтобы вы сохраняли буфер до тех пор, пока не будет удалено растровое изображение, но предотвращают ненужное копирование растровых данных в память.
• Метод LockBits может использоваться для получения указателя на данные растрового изображения. В этом случае создайте растровое изображение как обычно с желаемыми размерами и форматом. Затем вызовите LockBits и скопируйте данные растрового изображения в буфер. Это было бы медленнее, но необходимо, если ваши данные не в формате, который конструктор растровых изображений может принимать напрямую, и поэтому требуют какого-то специального преобразования.