Pixelweise Bildbearbeitung: Unterschied zwischen den Versionen

Version vom 10. März 2009, 19:07 Uhr

Zugriff durch Canvas.Pixels

Vorteile:

• Sehr einfach anzuwenden
• Funktioniert für alle Farbtiefen/Pixelformate
• Geringes risiko falsche Bereiche zu überschreiben

Nachteile:

• Sehr langsam

begin

Man greift über die Pixels Eigenschaft des Canvas auf die Pixeldaten des Bitmaps zu. Dabei wird der Farbe des Pixels automatisch von/zu TColor konvertiert. Diese Methode ist jedoch extrem langsam, und daher höchstens zum ändern einzelner Pixel, jedoch nicht für ein ganzes Bild geeignet.

Beispiel:

procedure Invert(Bmp:TBitmap);
var 
  x,y:Integer;
begin
  for y := 0 to Bmp.Height-1 do
    for x := 0 to Bmp.Width-1 do
      Bmp.Canvas.Pixels[x,y] := Bmp.Canvas.Pixels[x,y] xor $FFFFFF;
end;

Zugriff mittels scanline

Vorteile:

• Sehr schnell

Nachteile:

• Bei komplexeren Manipulationen umständlich
• Kein zugriff über x,y -Koordinate
• Hohes Risiko falsche Bereiche zu überschreiben
• Man muss den code für jedes Pixelformat extra erstellen.
• Für 24BPP ungünstig, da es keinen 3byte großen primitiven typ gibt. (Geschwindigkeitsvorteiteil gegenüber Arraymethode sinkt)

Beschreibung: Man holt sich mittels der scanline eigenschaft des Bitmaps einen direkten zeiger auf die zeilenanfänge. Mittels Zeigermanipulation bearbeitet man anschließend die Pixeldaten. Das ist natürlich sehr schnell, besonders für 8,16 und 32bit. Man kann jedoch nur schwer mittels koordinaten auf einzelne pixel zugreifen, man arbeitet die pixel üblicherweise in zeilen nacheinander ab. Es ist außerdem Vorsicht geboten, damit man nicht unabsichtlich über den Datenbereich hinaus liest/schreibt. Diese Methode spielt ihren Geschwindigkeitsvorteil(gegenüber der Arraymethode) vor allem dann aus, wenn man einfache Änderungen an Pixeldaten durchführt, die nicht von anderen Pixeln abhängen und die Pixel direkt in einen Integertyp geladen werden können.

Beispiel:

type 
  TPixel = packed record 
    B,G,R: Byte;
  end;
  
procedure Invert(bmp:TBitmap);
var 
  P:^TPixel;
  X,Y:integer;
begin
  if bmp.PixelFormat <> pf24Bit then raise Exception.Create('Pixelformat not supported');
  for Y:=0 to bmp.Height-1 do
  begin
    P:=bmp.Scanline[y];
    for x:=0 to bmp.width-1 do
    begin
      P.R := P.R xor $FF;
      P.G := P.G xor $FF;
      P.B := P.B xor $FF;
      Inc(P);//1Pixel weiter
   end;
  end;
end;

Zugriff mittels dynamischer arrays

Vorteile:

• Schnell
• Flexibel (Zugriff über x,y-Koordinate)

Nachteile

• Mittleres Risiko falsche Bereiche zu überschreiben
• Man muss den code für jedes Pixelformat extra erstellen.

Beschreibung: Auch hier holt man sich wieder per scanline die Zeiger auf die Zeilenanfänge. Statt sie jedoch direkt zu verwenden schreibt man sie in ein dynamisches Array, dessen Größe auf die höhe des Bitmaps gesetzt wird. Dabei wird der untypisierte Pointer auf den Zeilenanfang in einen Zeiger auf ein array von Pixeln umgewandelt. Anschließend kann man mittels Pixels[y,x] auf die einzelnen Pixel zugreifen. Für andere Pixelformate muss muss TPixel anders definiert werden. Man sollte jedoch darauf achten nur Koordinaten aus dem gültigen Bereich zu übergeben.

Beispiel:

 Type 
  TPixel = packed record 
    B, G, R: Byte;
  end;
  TPixelArray = array [0..715827881] of TPixel;//Knapp unter 2GB
  PPixelArray = ^TPixelarray;
  TPixels = array of PPixelarray;
  
procedure Invert(bmp:TBitmap);
var 
  Pixels:TPixels;
  x, y:integer;
begin
  if bmp.PixelFormat <> pf24Bit then raise Exception.Create('Pixelformat not supported');
  //Pixels initialisieren
  SetLength(Pixels,bmp.Height);
  // Hier eventuell umgekehrte Reihenfolge von Zeilen in der Bitmap beachten!
  for y:=0 to bmp.Height-1 do
    Pixels[y]:=bmp.Scanline[y];
  //Bild bearbeiten
  for y:=0 to bmp.Height-1 do
    for x:=0 to bmp.Width-1 do
    begin
      Pixels[y,x].R := Pixels[y,x].R xor $FF;
      Pixels[y,x].G := Pixels[y,x].G xor $FF;
      Pixels[y,x].B := Pixels[y,x].B xor $FF;
    end;
end;

procedure Grayscale(bmp:TBitmap);
var 
  Pixels:TPixels;
  x, y:integer;
begin
  if bmp.PixelFormat <> pf24Bit then raise Exception.Create('Pixelformat not supported');
  //Pixels initialisieren
  setlength(Pixels,bmp.Height);
  // Hier eventuell umgekehrte Reihenfolge von Zeilen in der Bitmap beachten!
  for y:=0 to bmp.Height-1 do
    Pixels[y]:=bmp.Scanline[y];
  //Bild bearbeiten
  for y:=0 to bmp.Height-1 do
    for x:=0 to bmp.Width-1 do
    begin
      Pixels[y,x].R := (Pixels[y,x].R + Pixels[y,x].G + Pixels[y,x].B) div 3;
      Pixels[y,x].G := Pixels[y,x].R;
      Pixels[y,x].B := Pixels[y,x].R;
    end;
end;