kuddlmuddl
Commander
- Registriert
- Mai 2010
- Beiträge
- 2.704
Hi Leute,
ich habe ein Performance-Problem und brauche mal Tipps von euch Profi-Bitschubsern
Mein Ziel ist ganz einfach: Ich will möglichst schnell ein RGB Bild in ein Graubild umrechnen. Allerdings soll die Gewichtung der drei Farbkanäle wählbar sein. (8bit je Farbkanal und 8bit im Ziel-Grauwertbild)
Mein Code für einen Pixel sieht in etwa so aus:
Die Gewichte haben Werte zwischen -9 und 9, sollen aber nicht so stark wirken. Daher der bitshift vor den ifs.
Der Code braucht ziemlich genau 5ms für 1mio Pixel was für meine Anwendung leider deutlich zu langsam ist.
Was ich bereits getestet habe ist eine Look-Up-Table für die Multiplikationen. Die hab ich als Member der Klasse deklariert und im Konstruktor des Farbumrechners initialisiert. Es gibt ja nur 256 Werte je Farbkanal und 19 verschiedene Gewichte. Ich hab also ein Array precalc_werte[256][19] benutzt und dann nur dort ausgelesen in der Form:
Ich habs hier jetzt etwas vereinfacht dargestellt denn natürlich darf man die (evtl negativen) Gewichte nicht als Array-Index verwenden. Ich hab dafür einfach den Wertebereich um 9 verschoben damit der Zugriff klappt. Bei 0 bis 8 standen dann also die Werte für <0 in der Tabelle. Hat funktioniert, nur:
Leider ist die Laufzeit dadurch nicht besser sondern sogar leicht schlechter geworden. Ich habs mir damit begründet, dass der Zugriff auf RAM/Heap (über langsamer als cpu getakteten bus?) länger dauert als mal eben 3 Multiplikationen zu rechnen.
Jetzt also die Frage:
- Seht ihr noch irgendeine Möglichkeit den Code zu optimieren?
ich habe ein Performance-Problem und brauche mal Tipps von euch Profi-Bitschubsern
Mein Ziel ist ganz einfach: Ich will möglichst schnell ein RGB Bild in ein Graubild umrechnen. Allerdings soll die Gewichtung der drei Farbkanäle wählbar sein. (8bit je Farbkanal und 8bit im Ziel-Grauwertbild)
Mein Code für einen Pixel sieht in etwa so aus:
Code:
char inline rgb_to_grey_pixel(int pixel, // rgb des Farbbilds steckt hier drin
int r_gewicht, int g_gewicht, int b_gewicht)
{
char r = 0xff & pixel;
char g = 0xff & (pixel >> 8);
char b = 0xff & (pixel >> 16);
int new_grey_value = r * r_gewicht +
g * g_gewicht +
b * b_gewicht;
if (new_grey_value < 0) return 0;
else
{
new_grey_value >>= 1;
if (new_grey_value > 255) return 255;
}
return (char)new_grey_value;
}Die Gewichte haben Werte zwischen -9 und 9, sollen aber nicht so stark wirken. Daher der bitshift vor den ifs.
Der Code braucht ziemlich genau 5ms für 1mio Pixel was für meine Anwendung leider deutlich zu langsam ist.
Was ich bereits getestet habe ist eine Look-Up-Table für die Multiplikationen. Die hab ich als Member der Klasse deklariert und im Konstruktor des Farbumrechners initialisiert. Es gibt ja nur 256 Werte je Farbkanal und 19 verschiedene Gewichte. Ich hab also ein Array precalc_werte[256][19] benutzt und dann nur dort ausgelesen in der Form:
Code:
int new_grey_value = precalc_werte[r][r_gewicht] +
precalc_werte[g][g_gewicht] +
precalc_werte[b][b_gewicht];Leider ist die Laufzeit dadurch nicht besser sondern sogar leicht schlechter geworden. Ich habs mir damit begründet, dass der Zugriff auf RAM/Heap (über langsamer als cpu getakteten bus?) länger dauert als mal eben 3 Multiplikationen zu rechnen.
Jetzt also die Frage:
- Seht ihr noch irgendeine Möglichkeit den Code zu optimieren?
Zuletzt bearbeitet:
