Prüfung eines Bitmaps auf Transparenz (gehts noch schneller)?

[Harry Stahl]

Oder gibt es was in der Grafik-32 Bibliothek?

Oder DirectDraw? Irgendeine Lösung, welche die schnellere GPU nutzt, wäre natürlich auch willkommen.

[jaenicke]

Die Zeit sind hier 40 Millisekunden. Davon entfallen ca. 2 Millisekunden auf das Scanline und den Teil außerhalb der Schleife, 24 Millisekunden rein auf die Schleife, 8 Millisekunden auf den Vergleich und 6 Millisekunden auf den Zugriff auf den aktuellen Wert in der Schleife.

Sonderlich viel Optmierungspotential sehe ich dort deshalb leider nicht. Ich habe auch den Assemblercode angeschaut, der ist schon durch den Compiler gut optimiert. Auch ein einfaches Verschieben des Pointers auf das vierte Byte und dann jeweils um 4 Byte hat nichts gebracht, das war meine Idee.

Ob die GPU hier helfen kann, bin ich nicht so sicher, die ist eigentlich eher bei Fließkommaoperationen sehr schnell.

Die Lösung mit TParallel ist bei mir aber schon deutlich schneller als die Standardvariante. Allerdings erst ab dem zweiten Durchlauf, dann braucht es aber konstant etwas weniger als die halbe Zeit.

[noisy_master]

Moin,

eine Winzigkeit fällt mir noch ein, um das Ganze "minimal " schneller zu bekommen: dreh die Schleife um und lass alle Berechnungen daraus weg:

dec(z);
for x := z downto 0 do begin


Der Vergleich auf 0 ist "einfacher" und damit schneller als der Vergleich auf einen festen (berechneten) Wert.

Dürfte zwar nicht DER Bringer sein, aber wenn's auch nur ein Wenig hilft..

Gruß
Dirk

[Neutral General]

Zitat von noisy_master:

eine Winzigkeit fällt mir noch ein, um das Ganze "minimal " schneller zu bekommen: dreh die Schleife um und lass alle Berechnungen daraus weg:

Delphi optimiert das normalerweise (wenn möglich) von selbst beim compilieren.

[himitsu]

Zitat:

Aber gibt es da nicht so einen Super ASM-Befehl, der das in einem Rutsch ohne Iteration erledigen kann?

Nein, auch da sind schleifen nötig.

Delphi speichert den "Endwert", also 2 Variablen, was bei fester 0 nicht nötig ist, zusätzlich zum DEC x; JZ p; , statt einem DEC x; CMP x, z; JE p; , als Abbruchbedingung (oder so in etwa)

Delphi-Quellcode:

IstUngleich0 := False;
for x := z - 1 downto 0 do begin
  if PixelArrayPointerDerAktuellenZeileInPByte[x * 4 + 3] <> 0 then begin  // das + 3 besser vorher drauf rechnen
    IstUngleich0 := True;  
    Break;
  end;

Einzelbytezugriffe sind eh schlechter, also ...

Delphi-Quellcode:

IstUngleich0 := False;
for x := z - 1 downto 0 do begin
  if PixelArrayPointerDerAktuellenZeileInPLongWordOderTColor[x] and $ff000000 <> 0 then begin
    IstUngleich0 := True;  
    Break;
  end;

geht nur bei gerade Pixelanzahl

Delphi-Quellcode:

IstUngleich0 := False;
for x := z div 2 - 1 downto 0 do begin
  if PixelArrayPointerDerAktuellenZeileInPLargeWord[x] and $ff000000ff000000 <> 0 then begin  
    IstUngleich0 := True;  
    Break;
  end;

Bei einem 32-Bit-Bitmap kann man auch alle Zeilen zusammen in dieser einen Schleife behandeln, da die Zeilen im Speicher hintereinander liegen, ohne ein Offset/Align.

Oder ohne Offsetberechnungen mit einer For/While-Schleife, von PointerErstesPixel bis PointerLetztesPixel.

[frankyboy1974]

hallo,

ich kenne jetzt ja die fachlichen Anforderungen nicht genau, aber man könnte natürlich auch sagen, wer würde bei einem Bitmap von circa 10 Mio. Pixeln schon ein einziges Pixel auf transparent setzen. Oder anders formuliert, muss du wirklich jedes Pixel auf Transparenz überprüfen, oder würde es nicht reichen 1 Pixel zu überprüfen und dann ein gewisse Anzahl zu überspringen, bis du das nächste Pixel überprüfst.

Ansonsten würde ich auch die Variante empfehlen, dass du je nach Anzahl der verfügbaren Computerkerne, eine ensprechende Anzahl parallele Handungsabläufe erzeugst.


mfg

[Neutral General]

Hallo,

Ich habe mal ne (Teil-)Assemblerversion gebaut:

Delphi-Quellcode:

function HasTransparentRGBAValues(const bmp: TBitmap): Boolean;
label schleife, ende, hasTrans;
var z: Integer; RGBA: PRGBQuad;
begin
  Result := false;
  RGBA := bmp.Scanline[bmp.Height-1];
  z := bmp.Width * bmp.Height;
  asm
    mov esi, rgba
    mov ecx, z
schleife:
    lodsd
    shr eax, 24
    inc al
    jnz hasTrans
    loop schleife
    jmp ende
hasTrans:
    mov result, true
ende:
  end;
end;

Ich habs nicht mit anderen Lösungen verglichen. Müsste man mal ausprobieren.
Ist in der Form nicht für 64-Bit geeignet, das wäre ein Stück mehr Arbeit.

[Der schöne Günther]

Wenn wir jetzt schon den Assembler rausholen, sollten wir dann nicht wenigstens alle die gleiche(n) Beispieldatei(en) haben um die Ergebnisse überhaupt vergleichen zu können? Harry, lad doch mal ein, zwei typische Bilder hoch bei denen du das prüfen möchtest.

[Uwe Raabe]

Zitat von Neutral General:

Ich habe mal ne (Teil-)Assemblerversion gebaut:

Das gibt einen ganz ulkigen Effekt auf meinem System, wenn man das Beispielprojekt mit DEBUG oder RELEASE compiliert:

Standard DEBUG: 23-24 ms
Assembler DEBUG: 20-21 ms
Standard RELEASE: 7-8 ms
Assembler RELEASE: 23-24 ms

Spricht irgendwie gegen Assembler...

[Neutral General]

Wow, da würde mich aber mal interessieren wie der generierte Assemblercode im Release aussieht
Hab hier grad nur Delphi 7 und mein Assemblercode hat deutlich weniger Anweisungen und kein cmp - Hätte da zumindest keinen so großen Vorsprung erwartet (wenn ich schon verliere )