Accélerer le traitement d'image

Bonjour à tous !

Je suis actuellement sur une application de traitement d'image en temp réel. Malheureusement, j'ai un problème de performance à cause de la grande quantité de données a traiter.

Si je prend par exemple une simple image en 1024*768 celà représente déjà une taille de buffer de 768 432 pixels (x4 pour les composantes RGBA) !! Donc evidement, il faut un certain temps de traitement pour le tout. Et cela, même pour une simple superposition de 2 images avec une valeur d'alpha.

Je voudrais savoir si il existe une technique où des buffers spécifiques pour accélerer ce genre de traitement, car le traitement temp réel n'est plus temp réel du coup.
Les serveurs graphiques d'interface sur les OS arrivent bien a gerer de très hautes résolution sans soucis. Donc li doit bien exister quelque chose.

Merci beaucoup pour votre aide.
Snark. ;)

utiliser le GPU serait d'un confort certain... ;)

Citation:

---

Envoyé par poukill

utiliser le GPU serait d'un confort certain... ;)

---

Oui, mais non... C'est prévu pour tourner sur des machines industrielles en bout de course, donc, la plupart n'ont pas ton super GPU, PCI-X 1600x sextuple slot :king:.
Il faut donc se contenter de ce que fourni le système ;-).

si un jour tu as une machine sous linux, tu pourras tester ce que donne le framebuffer logiciel sur du 1280x1024 : ca rame.

Des possibilités :
- essayes d'utiliser des instructions de traitement parallèle MMX ou SSE(2) ou 3DNow!
- essaye de renverser les boucles x/y en y/x, des fois le cache est heureux.
- derouler les boucles : au lieu de faire pixel par pixel tu les fait 8 par 8 dans un seul tour de boucle. c'est surtout valable sur les petits traitements
mais il n'y a pas vraiment de recette magique.

Citation:

---

Envoyé par Snark

Bonjour à tous !

Je suis actuellement sur une application de traitement d'image en temp réel. Malheureusement, j'ai un problème de performance à cause de la grande quantité de données a traiter.

Si je prend par exemple une simple image en 1024*768 celà représente déjà une taille de buffer de 768 432 pixels (x4 pour les composantes RGBA) !! Donc evidement, il faut un certain temps de traitement pour le tout. Et cela, même pour une simple superposition de 2 images avec une valeur d'alpha.

Je voudrais savoir si il existe une technique où des buffers spécifiques pour accélerer ce genre de traitement, car le traitement temp réel n'est plus temp réel du coup.
Les serveurs graphiques d'interface sur les OS arrivent bien a gerer de très hautes résolution sans soucis. Donc li doit bien exister quelque chose.

Merci beaucoup pour votre aide.
Snark. ;)

---

Bonjour,
que veut tu dire par temps réel??

Je pense qu'il vaut dire avec un délai suffisament petit pour que le traitement d'une image se termine avant que n'arrive l'image suivante.
T'a pas pensé à réduire la résolution bètement? Parceque sans gpu et avec une résolution pareille on ne fait pas de miracles...

Citation:

---

Envoyé par zais_ethael

Je pense qu'il vaut dire avec un délai suffisament petit pour que le traitement d'une image se termine avant que n'arrive l'image suivante.
T'a pas pensé à réduire la résolution bètement? Parceque sans gpu et avec une résolution pareille on ne fait pas de miracles.

---

Je voulais juste précisé que si c'était pas rapport a une ihm, l'utilisation de thread, serait une solution.
Sinon, faire du traitement multi échelle pourrai servir aussi. cela dépend de ce qu'il fait comment traitement

Tout dépend du traitement que tu veux appliquer.... et sur quoi...
On arrivait bien a faire du semi temps-reel (à l'affichage) sur des images de 8000x8000 avec un Mac PowerPC en 1985....

Si tu nous donnais plus d'information sur le contexte....

A noter que la méthode "brute" (prendre les pixels les uns après les autres) n'est jamais terrible de toute manière.
Quoique... maintenant, avec 13Gops de bande passante mémoire, tu ne peux traiter "que" 4000 images par seconde ;)

La taille des images n'est pas si importante que cela, à moins que les PC cibles soient vraiment lents (je veux dire: des pentiums première ou seconde génération génération). Et même dans ce cas, on arrivait à effecteur des traitements très complexes très rapidement sur des images en base 16 (2048 x 3072 x rgb) il y a 8 ans sur des PII donc je ne pense pas que le 1024x768xargb pose un gros problème.

La plupart du temps, tu dois veiller à
1) limiter le nombre d'opérations coûteuses effectuées dans ta boucle de parcours. Si tu le peux, évite les divisions pour chaque pixel, et essaie de remplacer les divisions et multiplications par des décalages de bits. Pour l'alpha blending, ça ne sera pas possible - mais au lieu d'utiliser la formule

2) vérifier que tu parcours bien l'image dans un sens qui convient à l'OS (afin de limiter les flush et rechargement de la mémoire cache de ton processeur).

3) fait confiance à ton compilateur pour optimiser le code en release - choisi l'architecture matérielle cible (VC++ te permet de spécifier quel processeur exécutera le code compilé). Programme de manière à lui simplifier le travail. Fait attention à l'aliasing (le compilateur ne sait pas si deux pointeurs pointent la même zone mémoire) et essaie d'être const correct. Ne lui donne quand même pas trop d'indications, car il risque d'être tenté de les prendre en compte et de court-circuiter certaines des optimisations qu'il ferait en interne.

4) finalement, prends un profiler, vérifie ce qui dans ton code prends le plus de temps et essaie de l'améliorer.

La boucle typique de parcours d'une image W x H x 32 bits est la suivante:

Code:

---

1 2 3 4 5 6 7 8

struct pixel { byte r, g, b,a }; pixel* begin = get_image_ptr(); pixel* end = begin + W * H; while (begin < end) { // ton traitement... ++begin; }

---

W peut être aligné sur un multiple de 4 pixels sur certaines plateformes (par exemple pour les fichiers BMP de Windows).
Pour deux images:

Code:

---

1 2 3 4 5 6 7 8 9 10

struct pixel { byte r, g, b,a }; pixel* src = get_image_1_ptr(); pixel* dst = get_image_2_ptr(); pixel* end = begin + W * H; while (dst < end) { *dst = apply_transformation(dst, src); ++dst; ++src; }

---

apply_transformation() peut être une macro ou une fonction inline; le code de apply_transformation() peut être mis directement dans la boucle.

Si malgré tout tu continues à avoir des problèmes de performances, tu peux peut-être étudier des pistes plus hardcore (assembleur, mmx, etc...).

Y a plein d'autres astuces aussi: découper les images en blocs de 256x256 par exemple (128Ko avec des pixels en 8bits par couleur) qui assure que le travail se réalisera dans le cache du processeur (il est rare qu'on ai besoin de traiter toute l'image, ou, si c'est toute l'image, de traiter chaque pixel indépendemment des autres). Voire, en fonction de ce qu'on veut faire, travailler par canal (couleur) indépendant...
Utiliser les calculs en fixed-point....

Non vraiment, les astuces d'optimisation il y en a des kilos, et tout dépend du résultat voulu.