Comment simuler un dib dans vb pour le traitement d'images

Soyez le premier à donner votre avis sur cette source.

Vue 7 720 fois - Téléchargée 660 fois

Description

Avec ce projet, vous pourrez remplacer le terrible PSet/Point en gérant directement les pixels d'une image avec un tableau de pointeurs. Cette solution est plus rapide que les API SetPixel/GetPixel; même en utilisant un DC (Device Context). Cette solution traitera votre image jusqu'à 20x plus rapide que Pset/Point et 10x plus rapide que SetPixel/GetPixel du GDI32.

Ce code est pratique pour ceux qui veulent faire du traitement d'images ou ceux qui veulent faire des jeux vidéos dans VB sans utiliser de wrapers (omme DirectX par exemple).

Note pour ceux qui programmes en C/C++:

Cette solution imite le DIB. L'élément PICT() se parcours de la même façon d'ailleurs. Par exemple, si je veux me déplacer d'un pixel, je dois gérer un "offset" de 3 bytes X mon déplacement dans le buffer, de sorte à pouvoir pointer toujours sur un pixel unique. L'ordre RGB est inversé tout comme dans un DIB. Pour parcourir tous les 'rouges' du buffer, vous devez pointer le 3e octet et parcourir le buffer avec un 'Step 3'... Parcourir le vert se fait en pointant le 2e octet et ainsi de suite.

Source / Exemple :


'--- Voir le Zip ---

Conclusion :


Je suis ouvert à vos commentaires...

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

cs_EBArtSoft
Messages postés
4531
Date d'inscription
dimanche 29 septembre 2002
Statut
Modérateur
Dernière intervention
22 avril 2019
5 -
Y a pas de simulation de DIB le IPicture n'est rien d'autre qu'une interface de DIB !

Mais comme exposé dans ton programme si le pc n'est pas en 24 bits
ça plante car le parcour ne se fait plus par 3 octets du coup
il faut implementer chaque resolution

Cela dit bonne demo ;)

@+
LogRaam (aka Gabriel Mailhot)
Messages postés
60
Date d'inscription
lundi 26 mai 2003
Statut
Membre
Dernière intervention
25 avril 2005
-
Salut EBArtSoft,

Effectivement, pour le 24-bits il faut parcourir à coup de 3 octets. Cependant, le PIC() n'est qu'un tableau d'octets et je peux aisément le parcourir octet par octet.

J'ai juste implanté le 24-bits et je n'ai pas fait de ERROR TRAP parceque c'est pas nécessaire pour démontrer l'utilisation d'un pointeur de structure. Hors, comme tu as vu, j'ai quand même mis un "checkup" pour valider que l'image est bien en 24-bits afin que le code ne plante pas en 8-bits.

Avec l'algorithme du projet, je parcours ma structure PIC() de la façon suivante:

For c = 2 To UBound(pict, 1) Step 3
For r = 0 To UBound(pict, 2)
'[TODO: Processing]
Next r
Next c

c=2 pointe sur le R du premier pixel. Le premier pixel se lit comme suit: R=(c=2), G=(c=1), B=(c=0). Ensuite, je parcour la structure pixel par pixel avec Step 3.

Si j'avais à parcourir une structure 8-bit, je changerais le parcour pour celui-ci serait implanté comme suit:

For c = 0 To UBound(pict, 1)
For r = 0 To UBound(pict, 2)
'[TODO: Processing]
Next r
Next c

De sorte à ce que le parcour soit d'un octet à la fois.

Présentement, une image 24-bits se traduit en mémoire par un tableau d'octets sur ce modèle:

========
2bgrbgrbgrbgr
1bgrbgrbgrbgr
0bgrbgrbgrbgr
0123456789
========

Lorsque j'importe le BITMAP dans le PIC() (par l'entremise de la structure TYPE SA), les octets se lisent à partir du coin gauche en bas jusqu'au coin droit en haut (d'où l'organisation inverse du tableau ci-dessus).


Par simulation d'un DIB, j'entend que mon tableau PIC() se parcours de la même façon que ce dernier, soit une liste d'octets successifs placés en BGR (ex: BGRBGRBGRBGRBGR...), accessible en changeant le "offset" par coup de 3 octets dans le cas d'une image 24-bits; le tout manuellement.


Il est aussi possible de faire d'autres algorithmes, par exemple pour brouiller une image (Blur), nous pourrions faire:

For c = 3 To UBound(pic, 1) - 3
For r = 1 To UBound(pic, 2) - 1
pic(c, r) = (CInt(pict2(c, r)) + _
CInt(pict2(c - 3, r)) +_
CInt(pict2(c + 3, r)) +_
CInt(pict2(c, r - 1)) +_
CInt(pict2(c, r + 1))) \ 5
Next r
Next c

Dans cette exemple, c-3, c+3, r-1 et r+1 sont les voisins de c,r. Le brouillage est possible en faisant la moyenne des voisins du pixel.

Maintenant, il est possible d'accélérer davantage le processus. PIC() étant lié à l'image, en modifier le contenu est plus lent que de modifier des valeurs à même un tableau qui n'est pas lié (pointeur). De ce fait, il est préférable d'attribuer la valeur PIC(c,r) à une variable, de modifier la variable temporaire pour ensuite réassigner la nouvelle valeur à PIC(c,r). C'est cette manoeuvre qui est fait dans le code en important PIC(c,r) dans la variable myByte:

'----------------------------------------
myByte = pict(c - v, r) 'Mettre la valeur du R, G ou B dans myByte pour faire le traitement

myByte = myByte - ColorIndex
If myByte < 0 Then myByte = 0

pict(c - v, r) = myByte 'Affecter la nouvelle valeur
'----------------------------------------

Voilà, vous connaissez maintenant une de mes arcanes de la programmation.


Merci à toi EBArtSoft pour ton commentaire.


MadLucas 'to the bones'

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.