C#-转换8位或16位灰度原始像素数据

我需要能够将8位或16位灰度像素数据转换为.NET framework可以支持的文件格式

我有可用的数据是宽度、高度、方向（左下）和像素格式，即4096灰度（12位分辨率），每像素压缩2字节

例如，每个像素的范围从0到4096，每个像素是2个字节

我已经尝试将PixelFormat.Format16bppGrayScale与位图构造函数一起使用，它会引发GDI+异常。我读到的所有内容都表明，这种格式不受支持，MSDN是错误的

我想将此像素缓冲区转换为.NET位图格式（如Format32bppArgb），并尽可能减少图像质量损失

有人知道怎么做吗？

有两种可能的方法：

• 使用指向任意缓冲区。这要求您保留缓冲区，直到位图被释放，但不会防止在内存中不必要地复制位图数据
• 可用于获取指向位图数据的指针。在这种情况下，像往常一样使用所需的尺寸和格式构造位图。然后调用LockBits并将位图数据复制到缓冲区中。如果您的数据不是位图构造函数可以直接接受的格式，因此需要某种自定义转换，那么这将是非常缓慢的，但却是必需的

---

请参见下面的示例，该示例预计算查找表（LUT）并使用该表转换每个像素。此版本涵盖您的12位机箱；对于8位，代码非常相似，但很难跨像素格式进行推广
从12位GS到8位GS的转换将丢失数据。但是，您可以调整LUT表，以将焦点放在具有更好对比度的较小范围的输入值上（例如）

类程序
{
静态void Main（字符串[]参数）
{
//测试驱动程序-创建一个楔子，转换为位图，保存到文件
//
整数宽度=4095；
内部高度=1200；
整数位=12；
字节[]楔形=楔形（宽度、高度、位）；
位图bmp=转换（楔形、宽度、高度、位）；
string file=“wedge.png”；
保存（文件）；
进程启动（文件）；
}
静态位图转换（字节[]输入，整数宽度，整数高度，整数位）
{
//将字节缓冲区（每像素2字节）转换为32位ARGB位图
var bitmap=新位图（宽度、高度、PixelFormat.Format32bppArgb）；
var rect=新矩形（0，0，宽度，高度）；
var lut=创建lut（位）；
var bitmap_data=bitmap.LockBits（rect、ImageLockMode.WriteOnly、bitmap.PixelFormat）；
ConvertCore（宽度、高度、位、输入、位图_数据、lut）；
位图。解锁位（位图_数据）；
返回位图；
}
静态内核（整数宽度、整数高度、整数位、字节[]输入、位图数据输出、uint[]lut）
{
//应用LUT将像素从输入复制到输出
ushort mask=（ushort）（（1伪造16b格式，并在显示前使用ColorMatrix正确映射

我没有在Windows上做过这种方法的性能测试，但在其他平台（如Android）上，我需要高效的内存存储和12b或16b数据中不同范围的快速重新映射，我充分利用了这种技术

我告诉它，我的12/16b灰度数据实际上是RGB565，因此它可以很好地进行序列化、反序列化和其他操作。当我需要显示时，我会通过一个颜色矩阵，该矩阵将适当的窗口映射到argb888中的8b灰度

如果有人想试试这个，我会发布我的映射算法。
为什么不创建位图并复制它，这样你就可以将它保存为PNG？听起来并不困难，可能需要一个小时的工作。用什么复制它？你能详细说明吗？只要在需要复制图像的地方绘制每个像素。我无法复制像素数据rbatim。位图构造函数需要指定像素格式，而源像素格式不受支持。我需要将实际像素颜色信息从12位灰度转换为24位或32位RGB。理想情况下不会丢失质量。然后使用锁定位；它将帮助您完全完成所需操作。但是，您将丢失质量：两者都会丢失要转换为的像素格式每个通道只有8位。因此，每个像素将丢失12位中的4位。保持完整质量可能会有很多困难：如“PixelFormat48bppRGB，[…]每…通道使用16位。GDI+版本1.0和1.1可以读取每通道16位的图像，但这些图像会转换为每通道8位的格式，用于处理、显示和保存。”我已经在尝试使用LockBits。LockBits不进行转换。我需要编写一个算法，将8位灰度字节转换为24位RGB字节。LockBits返回BitmapData对象。BitmapData.Scan0是指向位图中第一行的指针。您可以自己进行转换；如果像素格式为24位RGB，则只需设置每个从输入位图将3个字节的值转换为相同的灰度值。
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;
    }
}