Hey Leute!


Also ich bin grade dabei eine Lösung zu finden wie ich TGA's in ein TBitmap laden kann. Wichtig ist dass es sich hierbei nur um TGA's vom Typ 2, also unkomprimierte RGB Bilder mit einer Auflösung von 256x256 und 32 Bit handelt. Das Auslesen des Headers bis zur eigentlichen Bildinformation klappt auch schon einigermaßen.

Hier mal der Anfang des Quellcodes:

zusammenfalten · markieren

Delphi-Quellcode:

procedure TMainForm.LoadTGA(stream: TStream);
var
  height, width: Word;
  TGAFormat, TGAbpp, TGAColors, TGAid: Byte;
  OffScreen: TBitmap;
  i, i2: integer;
  testbmp: TRGBValue;
begin
  OffScreen := TBitmap.Create;
  OffScreen.Height := 256;
  OffScreen.Width := 256;

  stream.seek(0, soFromCurrent);
  stream.ReadBuffer(TGAid, 1); //Länge des Image Identification Field auslesen
  stream.seek(1, soFromCurrent); //Color Map Type überspringen
  stream.ReadBuffer(TGAFormat, 1); //format lesen, diente nur zu testzwecken, bild muss format 2 sein
  stream.seek(9, soFromCurrent); //9 überspringen
  stream.ReadBuffer(width, 2); //breite auslesen, auch nur zum testen
  stream.ReadBuffer(height, 2); //höhe auslesen
  stream.ReadBuffer(TGAColors, 1); //32 bit
  stream.seek(1, soFromCurrent); //1 überspringen

  Showmessage('Länge des Image Identification Field: ' + IntToStr(TGAid));
  Showmessage('Höhe: ' + IntToStr(y) + ', Breite: ' + IntToStr(x) + ' pixel.');
  Showmessage('Typ: ' + IntToStr(TGAFormat));
  Showmessage('Pixelformat: ' + IntToStr(TGAColors)); //mal alle infos ausgeben, nur zur sicherheit ;)


  TGAbpp := ((TGAColors + 7) shr 3); //4 bytes per pixel

  Showmessage('TGA bytes per pixel: ' + IntToStr(TGAbpp)); //auch mal ausgeben

  OffScreen.PixelFormat := pf24Bit;

So, soweit so gut. Das Problem ist nun dass ich 4 bytes pro pixel hab. Das heißt eins für Blau, eins für Grün, eins für Rot und noch eines mit irgend einem Attribut, was das genau ist hab ich noch nicht rausgefunden

Ich hab jetzt einfach mal um zu sehen ob ich überhaupt die Farben richtig auslesen kann die seeeeeehr lahme Methode gewählt:

zusammenfalten · markieren

Delphi-Quellcode:

type TRGBValue = record
  Blue: Byte;
  Green: Byte;
  Red: Byte;
end;


  //--------------------------
  //Seeeeehr lahme methode!!!
  //--------------------------
  
  for i := 0 to 255 do
  for i2 := 0 to 255 do
  begin
  stream.ReadBuffer(testbmp.blue, 1);
  stream.ReadBuffer(testbmp.green, 1);
  stream.ReadBuffer(testbmp.red, 1);

  //Showmessage('Rotwert: ' + IntToStr(testbmp.red));
  //Showmessage('Blauwert: ' + IntToStr(testbmp.blue));
  //Showmessage('Grünwert: ' + IntToStr(testbmp.green)); //Zu testzwecken, bei 65536 Pixeln aber nicht ratsam ;)

  OffScreen.Canvas.Pixels[i, i2] := RGB(testbmp.red, testbmp.green, testbmp.blue); //In TColor umwandeln
  stream.Seek(1, soFromCurrent); //das 4 "attribute" byte überspringen
  end;


  GOutput.Canvas.Draw(0, 0, OffScreen); //Und auf die Form zeichnen

  OffScreen.Free;
end;

Soooo und hier meine Frage:

Wie soll ich das mit Scanline bewerkstelligen, also mit dem 4ten Byte? Habt ihr da ne Idee? (bestimmt )

Danke schonmal,

psycore


PS: Ja ich weiß dass das Bild noch verdreht ist

Einfach so machen:

markieren

Delphi-Quellcode:

type TRGBAValue = record
  case Integer of
  1: (Value: Cardinal);
  2: (Alpha, Blue, Green, Red: Byte);
end;

Dann kannst du auch so lesen:

mystream.Read(myRGBAValue, sizeof(TRGBAValue));

Erstmal danke für die fixe antwort aber könntest du das für mich ein wenig genauer ausführen? Ich verstehs nämlich nicht ganz

Naja... was gibts da noch zum ausführen? Mit diesem varianten Record kannst du auf die einzelnen Pixel deiner TGA-Datei zugreifen. Aus dem Header bekommst du Höhe und Breite, hoffe ich mal. du kannst das z.B. so umsetzen:

markieren

Delphi-Quellcode:

for y := 0 to tgaheight-1 do
  for x := 0 to tgawidth-1 do
    begin
      pixelpos := bitmap.scanline[0] + Pointer(y * height + width);
      tgastream.read(tgapixel, sizeof(tgapixel)); //typeof(tgapixel) = TRGBAValue
      TRGBTriple(pixelpos^).red := tgapixel.red; //etc. für grün und blau; ob TRGBTriple da jetzt richtig ist, weiß ich nicht, hab das mal genommen.
    end;

damit füllst du ein bitmap (das dir richtigen maße hat) mit dem tga-bild, allerdings ohne transparenz (die könntest du mit TBitmap32 auch übernehmen, aber würde mich wundern, wenn das TGA nicht standardmäßig lädt).

am besten einfach die Farbtiefe des Bildes/Bitmaps auf 32bit (pf32bit) setzen. Dann ist ein Pixel dort auch 4 Byte groß. Zudem ist das 4te Byte der Alphakanal