Artefakte beim Einblendeffekt

zett42

Hallo zusammen,

ein rein kosmetisches Problem tritt bei mir auf, wenn ich SuRun's "Starte als Administrator"-Funktion nutze und der "abgedunkelte Desktop" eingeblendet wird. Das abgedunkelte und weichgezeichnete Hintergrundbild wirkt, als wenn die Farbtiefe stark reduziert wäre, was in Artefakten resultiert, die vor allem bei Farbverläufen zu sehen sind (siehe Anhang).
Ich glaube, das war auch schon bei v1.1 so.

Bildschirmauflösung: 1920x1200, 32 Bit Farbtiefe, Grafikkarte NVidia 8800 GT mit aktuellem Treiber
Es scheint aber unabhängig von der Auflösung zu sein, auch bei 1024x768 tritt es noch auf.

Mich würde erstmal interessieren, ob das Problem nur auf meinem Rechner (XP SP3) auftritt oder ob auch andere dies nachvollziehen können.

Grüße

Kay

Da haben sich wohl eMail und Blog überschnitten ;-)
Also hier nochmal die Mehl-Antwort:

Das sind Rundungs-Fehler. Die Unschärfe des Bildes wird, wie folgt erzeugt:
[m]------------------------------
static int g_m8rx[3][3]={{5,4,5},{4,3,4},{5,4,5}};
static int g_msk [3][3]={{0x00070707,0x000F0F0F,0x00070707},
{0x000F0F0F,0x001F1F1F,0x000F0F0F},
{0x00070707,0x000F0F0F,0x00070707}};
//Simplified 3x3 Gausian blur
inline HBITMAP Blur(HBITMAP hbm,int w,int h)
{
[...]
for (int y=0;y<h;y++)
for (int x=0;x<w;x++)
for (int cx=max(0,1-x);cx<min(3,w-x);cx++)
for (int cy=max(0,1-y);cy<min(3,h-y);cy++)
pDst[x+y*w]+=(pSrc[(x+cx-1)+(y+cy-1)*w]>>g_m8rx[cx][cy])& g_msk[cx][cy];
[...]
}
-------------------------------------[/m]
Die 3x3 Matrix ist schon ungenau. Noch schlechter ist die "Shift-Matrix".
Die Routine ist nur deswegen so drin, weil sie sehr schnell ist.

Falls jemand eine bessere schnelle Funktion kennt, wäre ich für einen Tipp dankbar :-D

Kay

Danke für die eMail.
Ich habe Box-Blur ausprobiert.
Es ist wirklich sehr schnell...sieht aber doof aus!
Alles wirkt irgendwie nach oben und unten gezerrt.

Der 3x3 Gauss wirkt da optisch viel besser.
Deshalb habe ich dessen Fehler minimiert und das "Banding" beseitigt:
[m]//The (roughly Gausian) matrix is not multiplied, it is shifted to gain speed
static DWORD g_m8rx[3][3]={{0,1,0},{1,2,1},{0,1,0}};
//Simplified 3x3 Gausian blur
inline void Blur(COLORREF* pDst,COLORREF* pSrc,DWORD w,DWORD h)
{
DWORD x,y,cx,cy,c1,c2,c3;
COLORREF Src;
for (y=1;y<h-1;y++)
for (x=1;x<w-1;x++)
{
c1=c2=c3=0;
for (cy=0;cy<3;cy++)
for (cx=0;cx<3;cx++)
{
Src=pSrc[(x+cx-1)+(y+cy-1)*w];
c1+=(Src&0xFF)<<g_m8rx[cx][cy];
Src>>=8;
c2+=(Src&0xFF)<<g_m8rx[cx][cy];
Src>>=8;
c3+=(Src&0xFF)<<g_m8rx[cx][cy];
}
pDst[x+y*w]=((c1>>5)&0xFF)+(((c2>>5)&0xFF)<<8)+(((c3>>5)&0xFF)<<16);
}
}[/m]

Auf einem Core 2 quad mit 2.4GHz braucht das für 2800x1050 Pixel ~110ms, Box-Blur braucht ~70ms.
Ich denke, das ist ok.

Das Resultat ist als stilles Update im Download. ;-)

Kay

Noch ein Update:
[m]//Simplified 3x3 Gausian blur
inline void Blur(COLORREF* pDst,COLORREF* pSrc,DWORD w,DWORD h)
{
DWORD x,y,c1,c2;
for (y=1;y<h-1;y++)
for (x=1;x<w-1;x++)
{
c1 =(pSrc[x-1+(y-1)*w]&0x00FF00FF);
c2 =(pSrc[x-1+(y-1)*w]&0x0000FF00);
c1+=(pSrc[x+(y-1)*w]&0x00FF00FF)<<1;
c2+=(pSrc[x+(y-1)*w]&0x0000FF00)<<1;
c1+=(pSrc[x+1+(y-1)*w]&0x00FF00FF);
c2+=(pSrc[x+1+(y-1)*w]&0x0000FF00);
c1+=(pSrc[x-1+y*w]&0x00FF00FF)<<1;
c2+=(pSrc[x-1+y*w]&0x0000FF00)<<1;
c1+=(pSrc[x+y*w]&0x00FF00FF)<<2;
c2+=(pSrc[x+y*w]&0x0000FF00)<<2;
c1+=(pSrc[x+1+y*w]&0x00FF00FF)<<1;
c2+=(pSrc[x+1+y*w]&0x0000FF00)<<1;
c1+=(pSrc[x-1+(y+1)*w]&0x00FF00FF);
c2+=(pSrc[x-1+(y+1)*w]&0x0000FF00);
c1+=(pSrc[x+(y+1)*w]&0x00FF00FF)<<1;
c2+=(pSrc[x+(y+1)*w]&0x0000FF00)<<1;
c1+=(pSrc[x+1+(y+1)*w]&0x00FF00FF);
c2+=(pSrc[x+1+(y+1)*w]&0x0000FF00);
pDst[x+y*w]=((c1>>5)&0x00FF00FF)+((c2>>5)&0x0000FF00);
}
}[/m]
...das beschleunigt die Berechnung so, dass mein 2.4GHz Core 2 Quad für 2800x1050 nur noch 41ms braucht :-D

Danke, für den Denkanstoß!!!

zett42

Das Resultat sieht sehr gut aus!

Auf jeden Fall weniger Code als ich brauchte :)
Aber die Multiplikationen pro Pixel könntest Du noch einsparen, indem Du den Offset nur pro Zeile berechnest. Für die Quellpixel oberhalb und unterhalb des Zielpixels bräuchtest Du dann nur noch "w" hinzuzuaddieren bzw. zu subtrahieren.

Kay

Das scheint VC wegzuoptimieren.
Hatte schon mal eine Version, die
[m]
p=pSrc[(y-1)*w]
for (x=1;x<w-1;x++)
{
c1 =(*p & 0x00FF00FF);
c2 =(*p++ & 0x0000FF00);
c1+=(*p & 0x00FF00FF)<<1;
c2+=(*p++ & 0x0000FF00)<<1;
c1+=(*p & 0x00FF00FF);
c2+=(*p & 0x0000FF00);
p+=w-2;
...[/m]
gemacht hat.
War genauso schnell nur weniger übersichtlich. ;-)

BTW: Die erste und letzte Zeile und Spalte des Bitmap bleiben bei der Routine Dunkel... aber das habe ich der Geschwindigkeit gerne geopfert...