16 Bit Graustufen ausgeben

[Endurion]

Is nix schönes, die Ausgangssituation ist ein 24bit RGB-Feld, Ziel ist ein 16bit (555) RGB-Feld:

  int             i,
                  j;

  WORD            wWidth,
                  wHeight;

  
  unsigned char   ucPart[3];

  static BYTE     ucPattern[8][4][4] =
  { { { 0, 0, 0, 0 },
  { 0, 0, 0, 0 },
  { 0, 0, 0, 0 },
  { 0, 0, 0, 0 } },
  { { 1, 0, 0, 0 },
  { 0, 0, 0, 0 },
  { 0, 0, 1, 0 },
  { 0, 0, 0, 0 } },
  { { 0, 0, 0, 0 },
  { 0, 1, 0, 1 },
  { 0, 0, 0, 0 },
  { 0, 1, 0, 1 } },
  { { 1, 0, 1, 0 },
  { 0, 0, 0, 1 },
  { 1, 0, 1, 0 },
  { 0, 1, 0, 0 } },
  { { 1, 0, 1, 0 },
  { 0, 1, 0, 1 },
  { 1, 0, 1, 0 },
  { 0, 1, 0, 1 } },
  { { 0, 1, 0, 1 },
  { 1, 1, 1, 0 },
  { 0, 1, 0, 1 },
  { 1, 0, 1, 1 } },
  { { 0, 1, 0, 1 },
  { 1, 1, 1, 1 },
  { 0, 1, 0, 1 },
  { 1, 1, 1, 1 } },
    { { 1, 1, 1, 1 },
  { 1, 0, 1, 1 },
  { 1, 1, 1, 1 },
  { 1, 1, 1, 0 } } };


  CConvertOptions   coDlg;

  coDlg.DoModal();


  wWidth = pImageSource->GetWidth();
  wHeight = pImageSource->GetHeight();
  int iR,iG,iB;
  for ( j = 0; j < (int)wHeight; j++ )
  {
    for ( i = 0; i < (int)wWidth; i++ )
    {
      ucPart[0] = pSourceData[3 * i + j * 3 * wWidth];
      ucPart[1] = pSourceData[3 * i + j * 3 * wWidth + 1];
      ucPart[2] = pSourceData[3 * i + j * 3 * wWidth + 2];

          // Dithering
          iR = ( ucPart[0] >> 3 ) + ucPattern[ucPart[0] & 0x07][i % 4][j % 4];
          iG = ( ucPart[1] >> 3 ) + ucPattern[ucPart[1] & 0x07][i % 4][j % 4];
          iB = ( ucPart[2] >> 3 ) + ucPattern[ucPart[2] & 0x07][i % 4][j % 4];
          if ( iR > 31 )
          {
            iR = 31;
          }
          if ( iG > 31 )
          {
            iG = 31;
          }
          if ( iB > 31 )
          {
            iB = 31;
          }
          ( (WORD*)pTargetData)[i + j * wWidth] = 
            ( iR ) + 
            ( iG << 5 ) + 
            ( iB << 10 );
    }
  }

ucPattern sind die Dithermuster. Bei 1 kommt ein Pixel der höheren Farbe hin, bei 0 nicht.

Beachte ucPart[0] & 0x07. Das nimmt die abzuschneidenden Bits (3 bits) und benutzt die als Index in die Dithermuster.

Das % 4 bei i und j kachelt quasi die Dithermuster über dem Bild, so dass die Pixel-Verteilung übernommen wird. Weder effizient noch besonder schöner Code, klappt aber herfürragend.

edit: Stell dir vor, es gibt Foren, und die benutzen alle dieselben Code-Tags!

 

[Trendy Andy]

Ich dank dir erstmal. Ich werde den Code dann mal am Wochenende ausprobieren.