Блог

Я работал над декодером растровых изображений, но мой алгоритм обработки пиксельных данных, похоже, не совсем правильный:

     public IntPtr ReadPixels(Stream fs, int offset, int width, int height, int bpp)
    {
        IntPtr bBits;

        int pixelCount = bpp * width * height;
        int Row = 0;
        decimal value = ((bpp*width)/32)/4;
        int RowSize = (int)Math.Ceiling(value);
        int ArraySize = RowSize * Math.Abs(height);
        int Col = 0;
        Byte[] BMPData = new Byte[ArraySize];

        BinaryReader r = new BinaryReader(fs);
        r.BaseStream.Seek(offset, SeekOrigin.Begin);

        while (Row < height)
        {
            Byte ReadByte;

            if (!(Col >= RowSize))
            {                       
                ReadByte = r.ReadByte();
                BMPData[(Row * RowSize)   Col] = ReadByte;
                Col  = 1;                    
            }

            if (Col >= RowSize)
            {
                Col = 0;
                Row  = 1;
            }
        }

        bBits = System.Runtime.InteropServices.Marshal.AllocHGlobal(BMPData.Length);
        System.Runtime.InteropServices.Marshal.Copy(BMPData, 0, bBits, BMPData.Length);

        return bBits;
}
  

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

     decimal value = ((bpp*width)/32)/4;
    int RowSize = (int)Math.Ceiling(value);
  

Это неверно. Ваша переменная RowSize на самом деле называется «stride». Вы вычисляете это следующим образом:

     int bytes = (width * bitsPerPixel   7) / 8;
    int stride = 4 * ((bytes   3) / 4);
  

Вы игнорируете stride.

Строки изображений можно дополнить слева дополнительными байтами, чтобы их размер делился на число, например (1 = без заполнения, 2, 4, 8 = по умолчанию для многих изображений, 16, …).

Кроме того, изображения могут представлять собой прямоугольную область внутри большего изображения, что делает «отступ» между строками на меньшем изображении еще больше (поскольку шаг — это шаг большего изображения). — В этом случае изображение также может иметь смещение для своей начальной точки в буфере.

Лучшая практика — это:

 // Overload this method 3 time for different bit per SUB-pixel values (8, 16, or 32)
// = (byte, int, float)
// SUB-pixel != pixel (= 1 3 or 4 sub-pixels (grey or RGB or BGR or BGRA or RGBA or ARGB or ABGR)
unsafe
{
    byte[] buffer = image.Buffer;
    int stride = image.buffer.Length / image.PixelHeight;
    // or int stride = image.LineSize; (or something like that)

    fixed (float* regionStart = (float*)(void*)buffer) // or byte* or int* depending on datatype
    {
        for (int y = 0; y < height; y  ) // height in pixels
        {
            // float* and float or byte* and byte or int* and int
            float* currentPos
                = regionStart   offset / SizeOf(float)   stride / SizeOf(float) * y;

            for (int x = 0; x < width; x  ) // width in pixels
            {
                for (int chan = 0; chan < channel; chan  ) // 1, 3 or 4 channels
                {
                    // DO NOT USE DECIMAL - you want accurate image values
                    // with best performance - primative types
                    // not a .NET complex type used for nice looking values for users e.g. 12.34
                    // instead use actual sub pixel type (float/int/byte) or double instead!
                    var currentValue = value;

                    currentPos  ;
                }
            }
        }
    }
}
  

Я нахожу кое-что, чего не понимаю:

 decimal value = ((bpp*width)/32)/4;
int RowSize = (int)Math.Ceiling(value);
  

Размер строки, на мой взгляд, должен быть (bpp*width) / 8 (bpp%8==0?0:1)