24-Bit Bitmap um 90 grad drehen - Resourcen-Optimierung

[Harry Stahl]

Also das 32-Bit wirkt nur größer, da es schon (richtig) gedreht wurde.
Das 24-Bit wurde mit Deiner Funktion "gedreht", aber hat ersichtlich nicht funktioniert.

Ich mache gleich mal zum Testen ein neues Miniprojekt und teste das mal...

[Renate Schaaf]

Danke für die Idee mit den worker-threads, probier ich doch gleich mal aus!

Wenn man nur 2mal GetScanline aufruft, geht es auch schneller.

Renate

[Harry Stahl]

Zitat von Renate Schaaf:

Danke für die Idee mit den worker-threads, probier ich doch gleich mal aus!

Wenn man nur 2mal GetScanline aufruft, geht es auch schneller.

Renate

Gerne. Was meinst Du mit nur 2 mal aufrufen?

Ich habe ja die Original-Routine von Doberenz schon um ca. 20% Speed gesteigert, indem ich das

PEnd := Bm.scanline[bm.height-1];

vor die Schleife gesetzt habe und in der Schleife nur den gespeicherten Wert zuweisen muss. Aber "rowout := help.scanline [y];" brauche ich doch weiterhin und kann es nicht ersetzen.

Oder?

[Amateurprofi]

@Harry:

Wenn du auf Performance aus bist, dann versuch doch mal folgendes.
Sollte deutlich schneller sein.

Achtung:
Der 64Bit-Teil in CopyColumn24 ist ungetestet, weil das Projekt mit dem ich gerade herumspiele nicht 64Bit-fähig ist.
Unter 32 Bit (mit relativ kleinen Bitmaps) ergibt meine Messung dass das doppelt so schnell läuft, wie die ursprüngliche Routine.

Delphi-Quellcode:

PROCEDURE CopyColumn24(PSource,PDest:Pointer; Count,LO:NativeInt);
asm
{$IFDEF CPUX86}// RAX=PSource, RDX=PDest, RCX=Count, Stack=LO
               push     ebx
               mov      ebp,LO
               dec      ecx
@Loop:         mov      ebx,[eax]
               mov      [edx],ebx
               add      eax,ebp
               add      edx,3
               sub      ecx,1
               jnz      @Loop
               mov      bx,[eax]
               mov      [edx],bx
               mov      bl,[eax+2]
               mov      [edx+2],bl
               pop      ebx
{$ELSE}        // RCX=PSource, RDX=PDest, R8=Count, R9=LO
               dec      r8
@Loop:         mov      eax,[rcx]
               mov      [rdx],eax
               add      rcx,r9
               add      rdx,3
               sub      r8,1
               jnz      @Loop
               mov      ax,[rcx]
               mov      [rdx],ax
               mov      al,[rcx+2]
               mov      [rdx+2],al
{$ENDIF}
end;

Delphi-Quellcode:

PROCEDURE RotateRight24(Bmp:TBitmap);
var W,H,Y,LoSource,LoDest:NativeInt; PSource,PDest:PByte; Dest:TBitmap;
begin
   W:=Bmp.Height;
   H:=Bmp.Width;
   PSource:=Bmp.ScanLine[W-1];
   LoSource:=NativeInt(Bmp.ScanLine[W-2])-NativeInt(PSource);
   Dest:=TBitmap.Create;
   Dest.PixelFormat:=pf24bit;
   Dest.SetSize(W,H);
   PDest:=Dest.ScanLine[0];
   LoDest:=NativeInt(Dest.ScanLine[1])-NativeInt(PDest);
   for Y:=H-1 downto 0 do begin
      CopyColumn24(PSource,PDest,W,LoSource);
      Inc(PSource,3);
      Inc(PDest,LoDest);
   end;
   Bmp.Assign(Dest);
   Dest.free;
end;

[Renate Schaaf]

Zitat:

Gerne. Was meinst Du mit nur 2 mal aufrufen?

So in etwa:

Delphi-Quellcode:

procedure Drehe90Rechts24NurPointers(bm: TBitmap);
var
  P, Pend, Pdest: PRGBTriple;
  x, y, b, h: Integer;
  RowOut: PByte;
  help: TBitmap;
var
  Offs, OffsDest: NativeInt;
begin
  help := TBitmap.create;
  help.pixelformat := pf24bit;

  b := bm.height;
  h := bm.width;

  help.SetSize(b, h);
  RowOut := help.scanline[0];
  Pend := bm.scanline[bm.height - 1];
  Offs := ((h * 24 + 31) and not 31) div 8;
  OffsDest := ((b * 24 + 31) and not 31) div 8;
  for y := 0 to h - 1 do
  begin
    P := Pend;
    inc(P, y);
    Pdest := PRGBTriple(RowOut);
    for x := 0 to b - 1 do
    begin
      Pdest^ := P^;
      inc(Pdest);
      inc(NativeInt(P), Offs);
    end;
    dec(RowOut, OffsDest);
  end;

  bm.Assign(help);
  help.free;
 end;

[Harry Stahl]

Nur Pointer bringt auch noch mal 500 ms. Hier auf dem Entwicklungs-PC in der virtuellen Maschine wird das große Bild mit Deiner Variante in ca. 5 bis 5,5 Sek. gedreht.

Mit meiner ursprünglichen Variante und den Workerthreads geht's in ca. 3 Sekunden (auf meinem Vertriebs-PC (I5-Prozessor) geht's in ca. 1 Sekunde).

Im Vergleich zu MS-Paint: das braucht auf den Entwicklungs-PC 20 Sekunden um das Bild zu drehen, auf dem Vertreibs-PC 8 Sekunden (und verbraucht nach 1 mal Drehen 4.5 GB Arbeitsspeicher, mein Programm mit Undo-Aktiv ca. 2 GB).

[Harry Stahl]

Zitat von Amateurprofi:

@Harry:

Wenn du auf Performance aus bist, dann versuch doch mal folgendes.
Sollte deutlich schneller sein.

Achtung:
Der 64Bit-Teil in CopyColumn24 ist ungetestet, weil das Projekt mit dem ich gerade herumspiele nicht 64Bit-fähig ist.
Unter 32 Bit (mit relativ kleinen Bitmaps) ergibt meine Messung dass das doppelt so schnell läuft, wie die ursprüngliche Routine.

Delphi-Quellcode:

PROCEDURE CopyColumn24(PSource,PDest:Pointer; Count,LO:NativeInt);
asm
{$IFDEF CPUX86}// RAX=PSource, RDX=PDest, RCX=Count, Stack=LO
               push     ebx
               mov      ebp,LO
               dec      ecx
@Loop:         mov      ebx,[eax]
               mov      [edx],ebx
               add      eax,ebp
               add      edx,3
               sub      ecx,1
               jnz      @Loop
               mov      bx,[eax]
               mov      [edx],bx
               mov      bl,[eax+2]
               mov      [edx+2],bl
               pop      ebx
{$ELSE}        // RCX=PSource, RDX=PDest, R8=Count, R9=LO
               dec      r8
@Loop:         mov      eax,[rcx]
               mov      [rdx],eax
               add      rcx,r9
               add      rdx,3
               sub      r8,1
               jnz      @Loop
               mov      ax,[rcx]
               mov      [rdx],ax
               mov      al,[rcx+2]
               mov      [rdx+2],al
{$ENDIF}
end;

Delphi-Quellcode:

PROCEDURE RotateRight24(Bmp:TBitmap);
var W,H,Y,LoSource,LoDest:NativeInt; PSource,PDest:PByte; Dest:TBitmap;
begin
   W:=Bmp.Height;
   H:=Bmp.Width;
   PSource:=Bmp.ScanLine[W-1];
   LoSource:=NativeInt(Bmp.ScanLine[W-2])-NativeInt(PSource);
   Dest:=TBitmap.Create;
   Dest.PixelFormat:=pf24bit;
   Dest.SetSize(W,H);
   PDest:=Dest.ScanLine[0];
   LoDest:=NativeInt(Dest.ScanLine[1])-NativeInt(PDest);
   for Y:=H-1 downto 0 do begin
      CopyColumn24(PSource,PDest,W,LoSource);
      Inc(PSource,3);
      Inc(PDest,LoDest);
   end;
   Bmp.Assign(Dest);
   Dest.free;
end;

Oh, habe ich gerade erst gesehen (manchmal überholen sich die Beiträge irgendwie), werde ich mir morgen Abend auf jeden Fall auch noch mal ansehen und mich melden.

[Harry Stahl]

Zu guter letzt noch die Feststellung, dass sich die WorkerThreads eigentlich nur bei ganz großen Dateien lohnen. Bei kleineren Bitmaps (alles so unter 4000 x 4000) ist der Thread-Verwaltungsaufwand wohl zu hoch, da ist das z.T. auch schon mal langsamer als nur eine Routine. Da man auf alle Worker-Threads warten muss, bevor man das Ergebnis zuweist, kann es sich evtl. auch etwas in die Länge ziehen, wenn eine CPU zu sehr belastet ist und daher einen Thread etwas blockiert..

Vielleicht sollte ich auch nicht alle zur Verfügung stehenden CPUs nutzen, sondern immer 1 oder 2 weniger, damit so evtl. die restlichen voll für meine Berechnungsaufgaben zur Verfügung stehen.

Muss ich morgen noch mal testen...

[dummzeuch]

Zitat von Harry Stahl:

Ich habe ja die Original-Routine von Doberenz schon um ca. 20% Speed gesteigert, indem ich das

PEnd := Bm.scanline[bm.height-1];

vor die Schleife gesetzt habe und in der Schleife nur den gespeicherten Wert zuweisen muss. Aber "rowout := help.scanline [y];" brauche ich doch weiterhin und kann es nicht ersetzen.

Du kannst Die Adressen der Zeilen jeweils selbst berechnen. Das sind dann nur noch zwei Aufrufe von Scanline[]. Das macht einen riesigen Unterschied.

Ich habe darüber vor einiger Zeit mal geblogt.

Edit: Ich sehe gerade, Renate Schaaf hatte das auch schon geschrieben, incl. Code. Sorry für das Duplikat.

[striderx]

Nachtrag der Vollständigkeit halber

Delphi-Quellcode:

function GDIPRotateFlipBitmap(ABitmap:  tBitmap;  Mode:  RotateFlipType):  Boolean;

var
  BM:         tBitmap;
  GR:         tGPGraphics;
  AGPBitmap:  tGPBitmap;
  AStatus:    Status;
  W:          Integer;

begin
  if Mode = RotateNoneFlipNone then begin
     Result := True;
     Exit;
  end;
  
  BM := tBitmap.Create;      
  BM.Assign(ABitmap);        
  AGPBitmap := tGPBitmap.Create(BM.Handle, 0);  
  
  AGPBitmap.RotateFlip(Mode);
  
  if (ABitmap.Width <> ABitmap.Height) and
>     (Mode in [Rotate90FlipNone, Rotate270FlipNone,
>               Rotate90FlipX, Rotate270FlipX,
>               Rotate90FlipY, Rotate270FlipY,
>               Rotate90FlipXY, Rotate270FlipXY]) then begin
     W := ABitmap.Width;
     ABitmap.Width  := ABitmap.Height;
     ABitmap.Height := W;
  end;
  
  GR := tGPGraphics.Create(ABitmap.Canvas.Handle);
  GR.DrawImage(AGPBitmap, 0, 0);
  AStatus := GR.GetLastStatus;
  
  Result := (AStatus = OK);
  
  AGPBitmap.Free;
  BM.Free;
  GR.Free;
end;