|
Registriert seit: 17. Nov 2005
Ort: Hamburg
1.077 Beiträge
Delphi XE2 Professional
|
AW: Durchschnittsfarbe eines Bitmap "schnell" ermitteln
11. Mai 2021, 23:34
In #16 wurde in den Raum geworfen, ob man nicht einfach ein Resize auf 1x1 Pixel machen kann.
Ich hab das mal geprüft und in meiner Funktion TestGetAvgColor; vor dem Bmp.Free folgendes eingefügt:
Scheint zu funktionieren, was aber auch daran liegen könnte, dass in der Testprozedur alle Pixel die gleiche Farbe haben.
Korrektur: Hab es gerade mit einem echten Bild geprüft.
Die Methode, das Bild auf 1x1 Pixel zu reduzieren, liefert eine andere Durchschnittsfarbe.
Danke für den Test! Das schonmal vorweg. 
Anstelle auf 1x1, wäre meine Überlegung ein sinnvolles Resize erst dann durchzuführen wenn Int64 für die Berechnung nicht mehr ausreicht.
Es wurden zwar viele Zahlen in den Raum geworfen, aber wie sollte man da Sinnvoll vorgehen?...
Ein Bild besteht ja aus zwei Dimensionen, ein Int64 ist nur eine.
Was ich meine, gibt es eine logik die so etwas berechnen kann, ein bild kann ja 100 million pixel Hoch aber nur 1 pixel breit sein.
Andersrum genauso.
Oder eben in beide Dimensionen sehr sehr viele Pixel besitzen.
Also es gäbe halt mehr als nur eine Möglichkeit diese berechnung hier zum platzen zu bringen.
Ein Resize auf eine Dimension die es nicht zum platzen bringt, das wäre das Sahnetörtchen  Meine Assembler-Routinen arbeiten so:
Bei der 32Bit-Version werden für eine Zeile die R, G, B Werte in 32-Bit Registern summiert.
Ein Überlauf kann also frühestens dann auftreten, wenn die Bitmap breiter ist als High(Cardinal)/255 = 16843009 Pixel.
Die Summen je Zeile werden dann in UInt64-Variablen summiert.
Bei der 64Bit-Version werden die Summen der R,G,B Werte in 64Bit-Registern gebildet
Ein Überlauf kann somit erst auftreten, wenn die Bitmap mehr als High(UInt64)/255 = 72340172838076673 Pixel hat.
Michael II hat das ja auch schon in #40 geschildert.
Die von dir ins Spiel gebrachte Bitmap mit 100 Millionen Pixel Höhe und 1 Pixel Breite ist somit für beide Versionen unproblematisch.
Wenn die Bitmap allerdings 100 Millionen Pixel breit und 1 Pixel hoch ist, könnte bei der 32Bit-Version ein Überlauf auftreten.
Auch das kann man verhindern, aber das kostet Zeit.
Ich habe das mal probiert mit einer Bitmap, 20 Mio breit, 1 hoch und alle Pixel = $FFFFFF.
Das Testergebnis siehst du in anhängender .jpg
Beachte die von der Funktion aus #3 gelieferte Durchschnittsfarbe.
Achtung:
Hierfür muss auch die FUNCTION GetAvgColor(Bmp:TBitmap):TColor;
geringfügig geändert werden.
Delphi-Quellcode:
FUNCTION GetAvgColor(Bmp:TBitmap):TColor; overload
var LO,P:NativeInt;
begin
Assert(Bmp.PixelFormat=pf24bit);
Assert(Bmp.Width>0);
Assert(Bmp.Height>0);
P:=NativeInt(Bmp.ScanLine[0]);
if Bmp.Height>1 then LO:=NativeInt(Bmp.ScanLine[1])-P else LO:=0;
Result:=AvgColor(P,LO,Bmp.Width,Bmp.Height);
end;
Und so sieht dann die Assembler-Routine aus.
Delphi-Quellcode:
FUNCTION AvgColor(P,LO,W,H:NativeInt):TColor;
// P : Zeiger auf das erste Pixel der ersten Zeile einer Bitmap
// LO : Offset (in Bytes) auf die jeweils nächste Zeit
// W : Breite der Bitmap
// H : Höhe der Bitmap
{$IFDEF CPUX86}
const
OfsBlueLo=0; OfsBlueHi=OfsBlueLo+4;
OfsGreenLo=OfsBlueHi+4; OfsGreenHi=OfsGreenLo+4;
OfsRedLo=OfsGreenHi+4; OfsRedHi=OfsRedLo+4;
OfsCount=OfsRedHi+4; OfsH=OfsCount+4; OfsLO=OfsH+4;
OfsStack=OfsLO+4;
{$ENDIF}
asm
{$IFDEF CPUX86}// EAX=P, EDX=LO, ECX=W, Stack=H
// Register retten
push ebx
push edi
push esi
// LO, H und Anzahl Pixel auf Stack legen
push edx // LO
mov ebx,H
push ebx // H
imul ebx,ecx
push ebx // Anzahl Pixel
// Summen auf Stack
push 0
push 0
push 0
push 0
push 0
push 0
// ESI hinter erste Zeile
lea ebp,[ecx+ecx*2]
lea esi,[eax+ebp]
neg ebp
// Summen ermitteln
@Loop1: mov edi,ebp
xor ebx,ebx
xor ecx,ecx
xor edx,edx
@Loop2: movzx eax,byte[esi+edi] // Blue
add ebx,eax
jns @Green
add [esp+OfsBlueLo],ebx // Summe Blue
adc [esp+OfsBlueHi],0
xor ebx,ebx
@Green: movzx eax,byte[esi+edi+1] // Green
add ecx,eax
jns @Red
add [esp+OfsGreenLo],ecx // Summe Green
adc [esp+OfsGreenHi],0
xor ecx,ecx
@Red: movzx eax,byte[esi+edi+2] // Red
add edx,eax
jns @Next
add [esp+OfsRedLo],edx // Summe Red
adc [esp+OfsRedHi],0
xor edx,edx
@Next: add edi,3
jl @Loop2 // Nächstes Pixel
add [esp+OfsBlueLo],ebx // Summe Blue
adc [esp+OfsBlueHi],0
add [esp+OfsGreenLo],ecx // Summe Green
adc [esp+OfsGreenHi],0
add [esp+OfsRedLo],edx // Summe Red
adc [esp+OfsRedHi],0
// Zeiger auf nächste Zeile
add esi,[esp+OfsLO];
dec [esp+OfsH]
jnz @Loop1
// AvgWerte erbitteln
mov eax,[esp+OfsBlueLo]
mov edx,[esp+OfsBlueHi]
div [esp+OfsCount]
movzx ecx,al
shl ecx,16
mov eax,[esp+OfsGreenLo]
mov edx,[esp+OfsGreenHi]
div [esp+OfsCount]
mov ch,al
mov eax,[esp+OfsRedLo]
mov edx,[esp+OfsRedHi]
div [esp+OfsCount]
mov cl,al
mov eax,ecx // Result=AvgColor
// Stack bereinigen
add esp,OfsStack
// Register wieder herstellen
pop esi
pop edi
pop ebx
{$ELSE} // RCX=P, RDX=LO, R8=W, R9=H
push r12
push r13
push r14
// Anzahl Pixel in R13
mov r13,R8
imul R13,R9
// R11 hinter erste Zeile, R12=-W*3
lea r12,[r8+r8*2]
lea r11,[rcx+r12]
neg r12
// Summen ermitteln
xor rcx,rcx // Summe Blue
xor r8,r8 // Summe Green
xor r10,r10 // Summe Red
@Loop1: mov r14,r12
@Loop2: movzx rax,byte[r11+r14] // Blue
add rcx,rax
movzx rax,byte[r11+r14+1] // Green
add r8,rax
movzx rax,byte[r11+r14+2] // Red
add r10,rax
add r14,3
jl @Loop2 // Nächstes Pixel
// Zeiger auf nächste Zeile
add r11,rdx;
dec r9
jnz @Loop1
// AvgWerte erbitteln
mov rax,rcx // Blue
xor rdx,rdx
div r13
movzx rcx,al
shl rcx,16
mov rax,r8 // Green
xor rdx,rdx
div r13
mov ch,al
mov rax,r10
xor rdx,rdx
div r13
mov cl,al
mov rax,rcx // Result=AvgColor
// Register wieder herstellen
pop r14
pop r13
pop r12
{$ENDIF}
end;
Gruß, Klaus
Die Titanic wurde von Profis gebaut,
die Arche Noah von einem Amateur.
... Und dieser Beitrag vom Amateurprofi....
|