Geht das noch schneller? - Bitmap-Verrechnung

[Harry Stahl]

@Amateurprofi:

Danke, dass Du Dich der Sache noch mal angenommen hast. Allerdings stimmt das Ergebnis immer noch nicht.

Falls Du die Sache noch weiter verfolgen willst, kannst Du hier im Thread-Beitrag Nr. 26 das Demoprojekt laden, das ich gepostet habe.

Da brauchst Du nur im Button-Click Event folgendes zu machen, um Deine Procedure einzubinden:

Delphi-Quellcode:

  for L := 1 to count do begin
    AsmDraw32BitToBitmap (b, b3);
    //Draw32BitToBitmapnew (b, b3);
  end;

Dann Siehst Du direkt im Vergleich, ob beide Bilder den gleichen Inhalt haben.

[Harry Stahl]

Ich habe nun den Rat gefolgt und habe mir die Graphics32-Unit mal angehen.

Der Grafk-Typ TBitmap32 ist zwar ein eigener Klassen-Typ, aber die Lowlowel-Routinen, die dahinter liegen, kann man auch auf TBitmap anwenden.

Die Lösung besteht also nun darin, GR32 und GR32_Blend aus der Graphics32 einzubinden und dann kann man die Funktion mit einer Zeile (1) benutzen, die dann auch nur noch 31 MS benötigt, um das Bild zu verrechnen:

Delphi-Quellcode:

procedure Draw32BitToBitmap(const BitOben: TBitmap; BitUnten: TBitmap);
begin
  BLEND_LINE[cmBlend]^(pColor32(BitOben.ScanLine[BitUnten.Height-1]),
    pColor32(BitUnten.ScanLine[BitUnten.Height-1]), BitUnten.Width* BitUnten.Height);
end;

[Amateurprofi]

Zitat von Harry Stahl:

Allerdings stimmt das Ergebnis immer noch nicht.
Falls Du die Sache noch weiter verfolgen willst, kannst Du hier im Thread-Beitrag Nr. 26 das Demoprojekt laden, das ich gepostet habe.

@Harry:
Habe ich geprüft.
Ich habe eine 8Bit-Integer-Multipikation benutzt, bei der Byte-Werte > $7F als negativ betrachtet werden.
Im Debugger sah ich dann, dass bei Deiner Prozedur eine 32Bit-Integer Multiplikation verwendet wird.
Bei den Tests fiel das nicht ins Gewicht, weil ich einfach den gesamten Screen nach BitOben und BitUnten kopiert hatte.
Somit waren die Rgb-Werte in Oben und Unten gleich und die Subtraktion von z.B. Oben.rgbRed - Unten.rgbRed ergab immer 0.
Nachdem ich die Bitmaps mit Zufallswerten gefüllt hatte konnte den Grund der Abweichungen finden.
Ich habe die Prozedur Blend32 umgeschrieben. Für mich sehr überraschend, ist sie dadurch schneller geworden; ich hatte das Gegenteil erwartet.

Dein Beispiel Projekt läßt sich bei mir (XE2) nicht kompilieren.

Delphi-Quellcode:

PROCEDURE Blend32(Source,Dest:pRGBQuad; Width,Height,OOffset,UOffset:Integer);
const
   RegSize=4;
   WOffs=6*RegSize; HOffs=12*RegSize; OOffs=11*RegSize; UOffs=10*RegSize;
asm
         pushad
         lea      esi,[eax+ecx*4]        // Source
         lea      edi,[edx+ecx*4]        // Dest
         neg      ecx
         mov      [esp+WOffs],ecx
         mov      ebp,[esp+HOffs]
@Loop:   movzx    ebx,[esi+ecx*4].TRgbQuad.rgbReserved // S.Reserved
         test     ebx,ebx
         jz       @Next
         // Blue
         movzx    eax,[esi+ecx*4].TRgbQuad.rgbBlue     // S.Blue
         movzx    edx,[edi+ecx*4].TRgbQuad.rgbBlue     // D.Blue
         sub      eax,edx                              // S.Blue-D.Blue
         imul     ebx                                  // (S.Blue-D.Blue)*S.Reserved
         add      [edi+ecx*4].TRgbQuad.rgbBlue,ah
         // Green
         movzx    eax,[esi+ecx*4].TRgbQuad.rgbGreen    // S.Green
         movzx    edx,[edi+ecx*4].TRgbQuad.rgbGreen    // D.Green
         sub      eax,edx                              // S.Green-D.Green
         imul     ebx                                  // (S.Green-D.Green)*S.Reserved
         add      [edi+ecx*4].TRgbQuad.rgbGreen,ah
         // Red
         movzx    eax,[esi+ecx*4].TRgbQuad.rgbRed      // S.Red
         movzx    edx,[edi+ecx*4].TRgbQuad.rgbRed      // D.Red
         sub      eax,edx                              // S.Red-D.Red
         imul     ebx                                  // (S.Red-D.Red)*S.Reserved
         add      [edi+ecx*4].TRgbQuad.rgbRed,ah
         // Reserved
         mov      [edi+ecx*4].TRgbQuad.rgbReserved,$FF
@Next:   add      ecx,1
         jl       @Loop
         // Nächste Zeile
         add      esi,[esp+OOffs]
         add      edi,[esp+UOffs]
         mov      ecx,[esp+WOffs]
         sub      ebp,1
         jnz      @Loop
@End:    popad
end;

[Harry Stahl]

Um das jetzt noch zu vervollständigen: Jetzt funktioniert auch Deine Lösung mit ca. 32 MS recht schnell und richtig.

Wenn man die Graphics32 also nicht verwenden möchte, wäre Deine Lösung auch noch eine Variante.

OK, mit XE2 kannst Du das Demo nicht kompilieren, da ja dort noch nicht die TParallel-Library zur Verfügung stand.

Wenn Du aber die "System.Threading" Unit rausnimmst und "Draw32BitToBitmappara" auskommentierst sollte es gehen.

[Codix32]

Ich bitte um Entschuldigung, wenn ich eine Frage habe, die nicht ganz zum Thread passt, aber:

Frage:
Gibt es eine Möglichkeit, ein Bitmap mit geringer Auflösung (72dpi), das sich beim vergrößern total verpixelt, irgendwie so zu schärfen, dass die Details sichtbar werden?

also in Krimisendungen habe ich das schon gesehen, dass dort Aufnahmen vergrößert werden, dann verpixelt sind, dann mit einem Programm dennoch geschärft werden. Mir geht es dabei nicht, um irgendwelche verpixelten Gesichter zu erkennen, sondern um andere Objekte.

Enthält also eine kleine Grafik genug Infos, um die beim Vergrößern entstehenden Quadrate mit einem Algorythmus so zu bearbeiten, dass daraus ein größeres scharfes Bild wird?
Enthalten die Blöcke oder Quadrate überhaupt genug Farbinfos dafür?

Oder geht da wohl nur was mit Vectoren...?

[Valle]

Dann eröffne doch bitte einen neuen Thread für eine andere Frage.

Dann musst du doch nicht den Thread vom armen Harry durcheinander bringen.

Kurze Antwort: Nein, das geht nicht zufriedenstellend automatisch. Reine Fiktion.

[manfred42]

Nach flüchtigem Verfolgen der Diskussion meine ich:
Es geht hier, wie schon anklang, um Alphablending.
Da gab es doch 2005 das Thema
Alphablending mit MMX / SSE Befehle

Aber zur jetzigen Diskussion
Wenn man anstatt 255 durch 256 per Shift dividiert,
dann geht das nur bei nichnegativem Nenner.

Für den Datentyp Int32 kann man den Trick mit der
magischen Zahl $8081 zur Division durch 255 verwenden.

const
Magic: UInt16 = $8081;
var
n: Integer;

Dann ist für -Sqr(255) <= n<=Sqr(255)
( n * Magic) div (1 shl 23) = n div 255
Der Compiler erzeugt für den ersten Ausdruck
einen arithmetische Rechtsshift um 23.
Müsste mal mit RDTSC timen.

Manfred

[arnof]

nur mit einem Auge das hier verfolgt, aber ist folgender Blog nicht genau das Thema:

http://www.delphifeeds.com/go/f/1217...hiFeeds.com%29


Die haben hier ein VCL Beispiel und hinweise für die Firemonkey Umsetzung