Algorithmes temps-réel en GDI

Salut à tous,

J'ai besoin de renseignements, je souhaite gérer en temps réel la modification (relativement simple) d'une partie d'une image 2D, à partir de la position d'un curseur, que je peux récupérer toutes les 2ms.

Je souhaite utiliser la GDI.

Je travaille à partir d'une image en format bmp, je transforme donc cette image en DIB une première fois.

Ensuite, à chaque position du curseur, je "récupère" les centaines de pixels qui m'intéressent à partir du DIB, je lance un algo sur ces pixels, puis récupère les pixels modifiés en HBITMAP.
Je m'arrange ensuite pour effacer les pixels de la position précédente, et afficher les nouveaux pixels modifiés.

Je voudrais savoir si la GDI est bien approprié à ce genre de traitement temps-réel...
Si ce n'est pas le cas, je dois hélas quand même l'utiliser dans un premier temps. Croyez-vous que j'utilise la bonne méthode pour l'affichage (utilisation de CreateDIBitmap à chaque itération temporelle, puis BitBlt pour l'affichage) ?

A+, c'est plutot urgent ;-)

J'ai moyennement compris ce que tu fais, mais sache que Windows n'est pas temps réel, et tu ne peux pas espérer une précision de l'ordre de 2ms. 10 fois + serait d'avantage réaliste...
Mais surtout, je ne comprends pas pourquoi tu as besoin d'une telle précision. La précision max à utiliser, si j'ai bien compris, et celle du déplacement de la souris, => le nombre de messages qu'elle est capable d'envoyer. Il me semble que le défaut de base pour de l'USB est de 125 Hz, soit 8 ms.
Si tu boucles sans cesse en récupérant la position du curseur tu t'y prends mal. La solution à ce problème c'est un hook souris global : ton code sera automatiquement exécuté à chaque déplacement de souris : + fiable, - couteux.

Oui, je me suis mal exprimé, en fait, je donnais une souris comme exemple, mais il s'agit de samples obtenus à partir de capteurs.

Je suis obligé de gérer une boucle, me semble t'il, pour gérer le temps réel.
Je ne veux bien sûr pas réaliser chaque affichage toutes les 2ms :) ... En fait, 20 ou 30 ms serait largement suffisant.

Ce que je veux dire, c'est que sans faire tourner aucun algo, je récupère une information (x,y) de position toutes les 2ms.

Penses tu que mon utilisation de la GDI soit bonne ??? :

J'ai mon image en DIB à la base pour pouvoir travailler dessus...

1 - Je récupère les coordonnées (x,y) du capteur et j'en déduis les pixels de l'image que je vais devoir modifier
2 - Je modifie les pixels dans une zone rectangulaire autour de (x,y)
3 - Je crée un HBITMAP avec ma nouvelle zone rectangulaire
4 - J'affiche cette zone

En espérant avoir été plus clair!

A bientôt,
JB

Pourquoi créer un nouveau HBITMAP? Tu pourrais directement faire un BitBlt() du rectangle concerné vers le HDC de la fenêtre, non?

Je ne peux afficher qu'un HBITMAP, non (du moins, avec Bitblt()) ???

Ben, un DIB, c'est quoi ? C'est un HBITMAP aussi, non? Et si tu dessines dessus, c'est qu'il est déjà sélectionné dans un HDC...

Donc, un BitBlt() de ton HDC à celui de la fenêtre, et le tour est joué!

NON, un dib, c'est un LPVOID...
c'est le stockage des bits de données, (je dois passer par là pour traiter les pixels selont leurs valeurs)

Dans ce cas, ce n'est pas un DIB, mais des valeurs de bits. Le DIB lui-même n'existe pas encore.

Ce que je te conseille, c'est de créer ton DIB dès le début, et de travailler sur SES valeurs de bits (pour les DIBs, tu y a directement accès: La fonction CreateDIBSection() te retourne leur adresse)

Merci, mais je ne comprends pas :roll: ,... je suis plus matheux qu'informaticien :-)
Au début, j'ai la forme LPVOID ou BYTE de mon image... pourquoi préférer de travailler sur le DIB créé, que sur le LPVOID ???

L'idée, c'est :
Dès le début, j'ai mon LPVOID de l'image. Lors de la récupération du (x,y), je ne travaille QUE sur les pixels du LPVOID qui m'intéresse. Je mets le résultat dans un nouveau LPVOID, je le transforme en HBITMAP et je l'affiche....

Pourquoi est ce mieux en utilisant le DIB créé (je ne sais pas comment le créer d'ailleurs!!)

Merci pour ton aide en tout cas

1) C'est mieux, car tu n'as pas à le recréer à chaque fois.
2) C'est aussi simple : Tu crées la DIB, et hop tu travailles directement sur ses valeurs comme tu faisais avant (bref, tu n'auras pas à tellement modifier ton code)

En bref, à la création de ta fenêtre:
* Tu récupères le DC de la fenêtre avec GetDC()
* Tu crées un DIB avec les dimensions voulues avec CreateDIBSection()
* Tu crées un DC en mémoire avec CreateCompatibleDC()
* Tu te débarrasses du DC de la fenêtre avec ReleaseDC() (Les DC de fenêtre sont limités au niveau système, il faut les économiser et les garder le moins possible)
* Tu associes le DIB au DC avec SelectObject()

Lorsqu'on joue avec la souris (version simple):
* tu joues avec tes données dans ton DIB
* Tu récupères le DC de la fenêtre avec GetDC()
* Tu fais un BitBlt() de la zone voulue d'un DC à l'autre
* Tu te débarrasses du DC de la fenêtre avec ReleaseDC() (Les DC de fenêtre sont limités au niveau système, il faut les économiser et les garder le moins possible)(Vive le copier-coller)

Lorsqu'on joue avec la souris (version compliquée mais plus propre et plus économique):
* Tu joues avec tes données dans ton DIB
* Tu ordonnes que la fenêtre soit redessinée avec InvalidateRect()
* Dans le traitement du message WM_PAINT:
o Tu récupères le DC de la fenêtre avec BeginPaint()
o Tu fais un BitBlt() de la zone voulue d'un DC à l'autre
o Tu te débarrasses du DC de la fenêtre avec EndPaint()

yop, ok merci bcp
J'ai cru comprendre que ce que tu me dis est de travailler l'affichage directement sur le DIB...
Donc ça correspondrait à quelque chose comme :

hdc = GetDC(hwnd);
mdc = CreateCompatibleDC(hdc);
obm = SelectObject(mdc,bgbm_dib);

et dans la foulée :

BitBlt(hdc, wl, wt, w, h, mdc, wl, wt, SRCCOPY);

Je te dis ça, car je viens de le tester et ça ne donne rien, je dois rajouter l'étape intermédiaire:

hdibm = CreateDIBitmap(hdc, bgbm_header,
CBM_INIT, bgbm_bits,
bgbm_info, DIB_RGB_COLORS);
et là ça marche...


Qu'en penses-tu ???

Oui, ça correspond à quelque chose comme ça...
Mais c'est bizarre, chez moi, je pouvais copier directement du DC du DIB à celui de la fenêtre, sans étape intermédiaire... (Sous WinXP)

Peut-être est-ce lié au format... j'utilisais des DIB 16 couleurs vraiment très gros, mais normalement, ça ne doit pas avoir d'influence... Si c'était des bitmaps monochromes, par contre, je ne serai pas aussi sûr de moi, puisqu'ils sont compatibles avec tout...

Et je faisais exactement ce que je t'ai dit, c'est-à-dire les associer à un compatibleDC dès leur création, trifouiller dans leurs données directement, et faire un BitBlt pour les afficher...