Association Québécoise de Robotique Amateur

Étude comparative des algorithmes de connexité appliqués à la détection de régions dans une image

Pierre-Luc Bacon — 2009-03-15T00:45:32Z

Ce projet a été réalisé en 2008 alors que développant l'algo de vision pour le robot, je réalisais également un travail d'analyse pour tenter de déterminer la meilleure approche à adopter pour ce problème. Les résultats de mes recherches ont été rassemblés dans ce document qui a été proposé en "travail de fin d'études" au CÉGEP.

Ce document présente les résultats d'une étude comparative visant à déterminer l'efficacité d'une implantation réelle d'algorithmes servant à l'extraction des régions d'intérêt d'après les composants connectés d'une image. Nous nous intéressons plus en détails aux techniques développées par Bruce et al. (2000) ainsi que (Wu et al., 2005) qui sont toutes deux caractérisées par une complexité en temps linéaire O(n). Une approche théorique permettra d'abord de préciser les caractéristiques théoriques de quelques techniques développées pour solutionner ce problème alors que des essais pratiques metteront ensuite en lumière leur temps d'exécution.

L'article en question est téléchargeable au bas de cette page.

Étiquetage des composants connectés et segmentation des couleurs avec CMVision 1.2

Pierre-Luc Bacon — 2009-03-15T00:18:20Z

Toute équipe qui doit embarquer une caméra sur son robot doit le faire à tout coup. Implanter un algorithme effiace d'étiquetage des régions de couleurs (aka "connected component labeling") est souvent une étape complexe qui, si mal réalisée peu entraîner des délais de traitement beaucoup trop important. Un choix s'impose alors : tenter une solution "maison" ou utiliser une solution libre déjà disponible.

OpenCV est souvent choisi dans ce cas. Bien que très perfectionnée, OpenCV a peut-être trop à offrir quand vient le temps d'implanter une solution simple pour un système aux ressources limitées.

CMVision (c++) s'avère être un choix tout indiqué pour répondre au besoin précis d'étiquetage des régions de couleurs. Réalisé par des étudiants du MIT dans le cadre de Robocup, cette librairie utilise plusieurs algorithmes performants pour réaliser cette opération. Les couleurs sont d'abord détectées par un algorithme de seuillage ordinaire à la différence près qu'une astuce permet de déterminer si un pixel appartient à une classe de couleur (jusqu'à 32) en une seule opération binaire plutôt qu'en procédant à 6 comparaisons logiques requises par l'approche "naïve". L'image seuillée est ensuite encodée en séries de pixels adjacents et analysée dans un algorithme de type Union- Find implanté sous forme de listes chaînées.

Utilisation

Un seul constructeur est fourni dans la version 1.2 pour un objet de type "CMVision".

L'utilisateur devra ensuite fournir d'autres paramètres d'initialisation manuellement :

Ces méthodes sont celles qui devront le plus souvent être appelées. loadOptions() prend en argument le nom d'un fichier qui contient une liste de seuils pour chacune des couleurs à détecter. Il est formaté comme suit :

La section "colors" contient le triplet RGB associé à la couleur (utile pour le debugging ou pour la partie GUI), la valeur "merge" (non utilisée ici), et un identifiant texte. La section threshold contient quand à elle les seuils min et max pour chacun des 3 canaux de couleur.

Une fois ces quelques méthodes executées, nous sommes déjà en mesure d'effectuer le traitement sur l'image :

Cette méthode est surchargée pour supporter plusieurs arrangement en mémoire possibles de l'image :

où image_pixel est un format pré-défini dans cmvision.h qui, selon le "define" utilisé au moment de la compilation, sera défini comme une de ces structures :

Dans la plupart des applications, il sera plus simple de fournir une image de type "unsigned" où chaque pixel est défini un après l'autre par 3 valeurs de canaux consécutives.

Si l'image contient un certains nombre de régions de couleurs tel que précisé dans le fichier de configuration, getRegions() permettra de les acquérir via un pointeur de type "region".

où color_id et le numéro associé à la couleur définie dans le fichier de configuration (la numération est automatique par ordre de définition).

indiquera le nombre de régions détectées.

Le type région est défini ainsi :

Connaissant le nombre de couleurs ainsi que le nombre de régions d'après numRegions(). nous pourrions alors exécuter une boucle pour afficher les informations de la structure "region" pour chaque composant détecté.

Finalement,

peut s'avérer utile pour visualiser les pixels détectés dans la phase de seuillage. Un fichier ppm sera alors créé où chaque pixel prendra la valeur de son identifiant de couleur.

Il n'existe pas de documentation officielle pour la librairie CMVision-1.2. Ainsi, les méthodes présentées ici ne représentent pas réellement toutes celles disponibles. La lecture de cmvision.h suffira bien souvent pour comprendre le fonctionnement de ces autres méthodes.

Exemple

L'exemple suivant utilise les méthodes décrites plus haut de CMVision-1.2, la classe VideoInput, ainsi que les librairies SDL et SDL-gfx (sudo apt-get install libsdl-gfx1.2-dev).

Une fenêtre SDL affichera en temps réel les images capturées par la caméra, les pixels seuillés, et les régions d'intérêts détectées.

Le code de ce programme est disponible au bas de cette page. Pour le compiler, il suffira d'exécuter "make" dans le dossier créé après décompression de l'archive.

Port série en C sous Linux

Pierre-Luc Bacon — 2007-06-14T22:26:08Z

Sommaire

Le port parallèle peut semble plus simple à utiliser à bien des égards quand vient le temps déterminer l'interface de communication avec un robot. Toutefois, celui-ci est appelé à disparaître sur le nouveau matériel et est bien souvent absent des cartes mères embarquées (single board computer). Certes, il en est de même pour le port série, mais les adapteurs usb/série sont très faciles à trouver. Notons ici que FTDI Chip produit le FT245 qui permet d'obtenir une liaison parallèle virtuelle au travers d'un port USB.

Ouverture et fermeture du port

Les fonctions qui permettent de réaliser ces opérations sont les mêmes que celles utilisées courament dans les systèmes UNIX : open() et close() serviront donc, vous l'aurez deviné.

Vous aurez ici remarqué que /dev/ttyUSB0 est passé à la fonction open() plutôt que /dev/ttyS0. Ceci n'est applicable que si la notation retenue dans udev pour un adapteur usb/série est sous cette forme. Voyez dmesg après branchement pour plus de détails. Même si la liaison RS232 s'effectue par USB, l'interface de programmation ne change pas : le driver se charge de rendre opaque les détails d'implémentation USB.

O_NOCTTY est une option permettant de spécifier que le programme ne sera pas un "controlling terminal" : un paramètre passé presque à tout coup pour la plupart des programmes.

O_RDWR signifie que le fichier est ouvert en lecture et en écriture.

O_NDELAY spécifie finalement de ne pas attendre un changement de ligne sur le signal DCD. Si cette option n'est pas passée, le programme sera bloqué jusqu'à ce que DCD passe à l'état bas.

La fonction fcntl est quant à elle appelée pour permettre de rétablir le port série en mode bloquant pour la fonction read(). Ainsi, si aucun charactère n'est encore disponible en lecture, le programme attendra en ce point du programme.

La fermeture du port se fait avec la fonction close(), tout simplement :

Permissions

Comme le port série est représenté comme un fichier en /dev, il sera nécessaire d'exécuter le programme avec les droits de super-utilisateur root.

Sinon, il est possible de changer les droits d'accès sur le fichier ou d'en changer le groupe. Voici quelques exemples sous Linux où le port série apparaîtra comme /dev/ttSx (/dev/cuaax sous FreeBSD).

Définir l'accès pour un nouveau groupe

Cette solution est à préférer.

Donner accès à tous les utilisateurs possibles

À éviter si possible, mais tolérable en phase de test.

Donner l'accès à soit-même seulement

Prenez note que si votre système est configuré avec udev, ces commandes n'auront pas un effet permanent après redémarrage. Il sera alors nécessaire d'adapter un fichier de configuration généralement situé dans le répertoire /etc/udev/rules.d/

L'interface POSIX

<termios.h> fournit les structures de contrôle ainsi que les fonctions POSIX qui permettront de définir les propriétés des laisons sérielles qui seront mises en place.

Vitesse de connection

Dans ce bout de code, une structure termios est déclarée et initialisée par la fonction tcgetattr. Cette structure comprend plusieurs membres qui seront assignés à des valeurs définies par des #define en utilisant des opérateurs bit à bit.

Dans cet exemple, cfsetospeed est utilisé car cette fonction permet de définir la vitesse (le "baud rate") dans le membre approprié de la structure termios. En effet, certains systèmes POSIX ne définissent pas cette valeur des le même membre (c_flag, c_ispeed, ou c_ospeed), d'où le besoin d'une fonction indépendante du système.

Les options CLOCAL et CREAD sont définies pour éviter que le programme soit considéré en tant que propriétaire du port. Précisons au passage que l'accès aux membres de la structure devra toujours s'effectuer avec les opérateurs bit à bit tel que montré ci-haut. Un OU binaire sert ici à combiner les nouvelles options à celles déjà existantes dans le membre sans les écraser.

Bits de données (taille du charactère)

Cette première ligne permet de mettre toute valeur pour cette option à 0. CSIZE n'est donc ici qu'un masque "nié" par "~" et affecté à c_cflag par l'opérateur binaire "&" (ET). CS8 (8 bits) peut ensuite être attribué au membre par un OU binaire qui renverra nécessairement CS8 puisque les bits du masque sont maintenant tous à 0. Rappelons-nous que le fonctionnement du OU peut se résumer à : "l'un, ou l'autre, ou les deux en même temps". Dans ce cas, "l'un" suffit à faire égaler le résultat à la valeur exacte de CS8.

Notez que CS5, CS6 et CS7 sont aussi disponibles.

Parité

Si on ne choisit pas de méthode de vérification par parité pour les données envoyées, c_flag devra être défini ainsi :

Avec CSIZE et CSTOPB, on reconnaît ici la configuration 8N1 : 8 bits de données (8), pas de parité (N) et 1 bit d'arrêt (1),

Application des attributs

Après avoir défini la structure termios avec les options voulues, elles doivent être appliquées par la fonction tcsetattr.

TCSANOW indique que les changements doivent être appliqués immédiatement sans attendre la fin des données en entrée ou en sortie.

Envoi des données

Cette opération s'effectuera avec le simple appel de la fonction write.

Le troisième argument de la fonction indique le nombre d'octets à écrire. Lorsque les données ont pu être envoyées, le nombre d'octets écrits est retourné.

Lecture

Mode non bloquant

Comme spécifié plus haut, la fonction read() qui permet de lire les données sur le port série peut être configurée en mode bloquant ou non. En effet par un appel à fcntl() avec l'option FNDELAY, read() retournera immédiatement avec la valeur 0 si aucune donnée n'est actuellement disponible.

La syntaxe de la fonction read est quant à elle identique à write :

Où buffer est un pointeur sur le tableau qui contiendra les données et "4" , dans cet exemple, le nombre d'octets à copier dans cet espace.

select

Dans bien des cas, des contraintes de temps de réponse sont exigées dans un programme. En effet, plusieurs tâches doivent souvent être exécutées simultanément. Un appel à la fonction read peut ainsi compliquer quelque peu l'organisation du programme puisque deux choix pourraient s'offrir à priori : attendre les données (mode bloquant), ou faire un pooling sur read. La fonction select peut alors s'avérer utile pour surveiller l'état de plusieurs descripteurs de fichiers en même temps. On pourrait par exemple définir un ensemble socket et port série et à l'arrivée de donnée sur l'un ou l'autre des descripteurs, select renverrait une valeur supérieure à 0. On s'évite ainsi un pooling systématique pour chaque fichier à surveiller. [1]

signal

La programmation d'une routine de communication sur le port série pour un microcontrôleur aurait été facilement réalisée par un mécanisme d'interruptions. Toutefois, les interruptions matérielles à proprement dit ne sont pas accessibles dans l'espace utilisateur du système. Seul un pseudo-mécanisme d'interruptions seraient alors envisageable par la programmation d'un driver qui enverrait un signal à un programme de l'espace d'utilisateur. [2]

Aussi, l'utilisation d'une extension temps réelle au noyau permettrait de réaliser de telles opérations avec des fonctions de son API. Ceci ne sera cependant pas couvert ici. [3]

Enfin, c'est l'option O_ASYNC [4] passée à open qui permettra la mise en place de ce mécanisme. Un signal SIGIO sera alors généré à toute arrivée ou écriture de donnée (lorsque le buffer en sortie aura été rempli) pour un fichier ouvert en mode RW. Ensuite, il suffira de mettre en place une fonction de prise en charge du signal (handler) attaché à ce signal et de bien s'assurer par select que le SIGIO reçu corresponde bien à l'événement souhaité sur le port. L'attribut F_SETOWN [5] devrait aussi être appliqué avec la fonction fcntl pour le descripteur de fichier du port série.

Référence

Le livre Serial Programming Guide for POSIX Operating System de Michael R Sweet a servi de référence pour la rédaction de cet article. Il est disponible librement sur internet ou peut être acheté via lulu.com.

[1] Un exemple de select : Using the SELECT System Call.

[2] Voir opening bananas with steamrollers.

[3] Voir RTAI Serial Port Communication Example pour plus de détails.

[4] voir open(2).

[5] Voir fcntl(2) .

Représentation en mémoire d'un triplet de canaux de couleur

Pierre-Luc Bacon — 2007-01-04T20:02:25Z

Tableau bidimensionnel d'entiers

Sommaire

Il peut parfois être utile de disposer d'une image dans un tableau de telle sorte qu'on puisse retrouver la valeur d'un pixel directement par sa position. Un tableau du genre :

buffer[x][y]

J'ai été cependant confronté au problème suivant en voulant faire ainsi : comment exprimer ce triplet, en l'occurence trois char, dans un seul élément du tableau ? La solution trouvée, peu élégante à certains égards, est de disposer les trois canaux dans l'ordre RGB un à la suite de l'autre sur un int. Puisque nous avons trois char, qui occupent généralement 24bit (3*8bit), un int, codé sur 32 bits, suffira à les contenir.

int rgb;
 unsigned char r,g,b;

Si on applique un opérateur de cast sur un char vers un int, alors on aura de gauche à droite 16 bits à 0 et les 8 autres à droite qui expriment la valeur contenue dans le char. Ensuite on déplace ces 8 bits qui nous intéressent vers la gauche de 16 bits avec un opérateur de shift pour le canal R. Pour G, on applique la même procédure mais pour un déplacement de 8 bits. Quant à B, rien ne doit bouger. On a alors quelque chose semblable à :

R=111111110000000000000000
 G=000000001111111100000000
 B=000000000000000011111111

Avec cet encadré montrant une représentation où les trois canaux seraient à 255, on voit qu'un OR des ces valeurs suffiraient à les combiner dans l'ordre voulu.

En des termes plus applicable à un programme, on pourrait faire :

rgb=(((int)r)<<16)|(((int)g)<<8)|((int)b) ;

Une autre astuce pourrait consister à déclarer un pointeur unsigned char sur une variable int 32 bits. Par la suite, on accède à la variable int par le pointeur comme tableau :

unsigned int pixel32;
 unsigned char *pixel = (unsigned char *)&pixel32;
 
 pixel[0] = r;
 pixel[1] = g;
 pixel[2] = b
 pixel[3] = 0;

Maintenant pour retrouver les canaux individuels, on appliquera le masque approprié et effectuera le décalage requis pour avoir les 8 bits tous à droite dans la représentation sur 32 bits. Ceci permettra ensuite de faire un cast sur l'entier int et d'obtenir la valeur souhaitée dans la variable. Les masques utilisés dans ce AND binaire sont trouvés du fait que l'opération d'un bit ET d'un autre à 1 renvera nécessairement la même valeur de base. De même manière, un ET avec 0 aurait l'effet d'un NON. Par exemple :

 1011110101110111
 ET 0000000011111111
 -----------------
 0000000001110111

On pourrait donc coder quelque chose semblable à :

r=(unsigned char) ((rgb & 0xFF0000)>>16);
 g=(unsigned char) ((rgb & 0xFF00)>>8);
 b=(unsigned char) (rgb & 0xFF);

Cette solution n'est peut-être pas celle qui fait preuve du bon usage du langage C, mais devrait convenir dans la plupart des cas. De plus, elle a l'avantage de n'utiliser aucune fonctions spéciales des bibliothèques. L'utilisation d'unions est aussi une possibilité plus lisibile à considérer pour effectuer une opération similaire (merci à Pierre pour cette suggestion).

Tableau unidimensionnel de type unsigned char

Lorsqu'on capture une image depuis une caméra, celle-ci est accessible par un pointeur. Cette notion de pointeur étant liée à celle de tableau, la zone mémoire occupée par l'image sera assimilable à un tableau unidimensionnel. En effet, soit un tableau tbl[100], alors *tbl pointera sur le premier élément en mémoire de celui-ci. De cette manière, si *tbl correspond à tbl[0], alors *(tbl+1) sera équivalent à tbl[1]. Connaissant ceci, on peut donc calculer le bond à effetuer pour atteindre une case mémoire donnée. Dans le cas de notre image, on peut en déduire les relations suivantes d'après l'illustration ci-dessous :

saut_r = 3*position_y*largeur + 3*position_x

saut_g = 3*position_y*largeur + 3*position_x +1

saut_b = 3*position_y*largeur + 3*position_x + 2

Le trois (3) dans ces équations provient du nombre de canaux à sauter pour atteindre un emplacement donné.

Voici un bout de code montrant cette idée :

/*rgb(1;0)*/
 *(tbl+3)=55;
 *(tbl+4)=56;
 *(tbl+5)=57;
 
 r=*(tbl+(3*y*LARGEUR)+(3*x));
 g=*(tbl+(3*y*LARGEUR)+(3*x)+1);
 b=*(tbl+(3*y*LARGEUR)+(3*x)+2);
 
 printf("pos(%d;%d): rgb(%d;%d;%d)\n",x,y,r,g,b);

Utilisation d'une structure

Voilà maintenant un moyen plus lisible et plus direct de représenter ce triplet dans un emplacement du tableau à deux dimensions. On peut donc déclarer un type triplet ainsi :

typedef struct {
 unsigned char r;
 unsigned char g;
 unsigned char b;
 } triplet;

Il suffit par la suite d'initialiser dynamiquement ou statiquement un tableau de type triplet. On accédera aux éléments du tableau ainsi :

triplet rgb[LARGEUR][HAUTEUR];
 rgb[x][y].r=200;
 rgb[x][y].g [...]
 rgb[x][y].b [...]

Utilisation d'une Union

Un collaborateur (user0081) propose une solution tout aussi élégante qui consiste à utiliser une union. Ceci permettra d'arriver au même résultat que ci-haut, sans la complexité des opérateurs binaires.

typedef union {
 int rgb;
 struct {
 unsigned char r;
 unsigned char g;
 unsigned char b;
 } chan;
 } pixel

Pour un élément donné d'un tableau à deux dimensions qui contient tous les pixels de l'image, on pourra retrouver à la fois chacun des canaux séparément ainsi que leur combinaison sur un entier :

pixel image[LARGEUR][HAUTEUR];
 rgb=image[x][y].rgb;
 r=image[x][y].chan.r;
 g=image[x][y].chan.g;
 b=image[x][y].chan.b;

L'exemple suivant illustre davantage l'astuce mise en jeu :

typedef union {
 int yuv;
 struct {
 unsigned char y;
 unsigned char u;
 unsigned char v;
 } chan;
 } pixel;
 pixel image[240][240];
 
 image[0][2].chan.y=23;
 image[0][2].chan.u=128;
 image[0][2].chan.v=57;
 
 printf("YUV: %d:%d:%d\t YUV32:%d\n",image[0][2].chan.y,image[0][2].chan.u,image[0][2].chan.v,image[0][2].yuv);

On obtiendra alors en sortie :


 YUV: 23:128:57 YUV32:3768343
 R,G,B: ff,c8,9b

Soit 23->10111 en binaire, 128->10000000 et 57->111001, 3768343 correspond alors à 1110011000000000010111. Ce résultat est alors de la même forme que celui obtenu par l'approche "binaire pure" avec les canaux YUV (ou RGB) dans l'ordre voulu.

Déterminer l'histogramme HSV d'une image RGB

Pierre-Luc Bacon — 2005-12-29T08:09:05Z

Il m'était nécessaire récemment d'étudier les histogrammes d'une série d'images enregistrées sous le format jpg. Or, je n'ai pu trouver d'outils satisfaisants à cette tache sous Linux. J'ai donc choisi de coder la solution.

Pour réduire la complexité du développement qui était contraint à quelques heures, il a été convenu que le format PPM était tout indiqué à nouveau pour ce type d'expérimentation. En effet, le programme nivgris, détaillé dans cet [article-35], allait servir de base à l'autre. Également, il avait été décidé que Gnuplot allait servir à l'affichage des données de l'histogramme : ce qui réduit considérablement les demandes en travail par rapport à une solution basée par exemple sur la librairie GD. Cela permet donc, par l'entremise de la bibliothèque gnuplot_i qui n'est qu'une "interface", d'obtenir directement un graphique en format png.

Le principe du programme se présente donc ainsi :

Ouvrir le fichier ppm
Scruter tous les pixels RGB et les convertir en HSV
Incrémenter l'élément d'un tableau - 3 en tout (H,S et V) - selon la valeur de H, S ou V qui sert d'indice
Produire un fichier dat pour gnuplot
Fermer le fichier
Créer les graphiques avec gnuplot_i

Conversion HSV vers RGB

Le format HSV, acronyme de "Hue Saturation Value", est un format qui possède des caractéristiques intéressantes pour toute application d'analyse vidéo. En effet, contrairement au RGB, le HSV est un format dit "naturel" car sa définition relève davantage de la conception humaine de la couleur plutôt que celle du RGB qui s'applique d'abord à des dispositifs électroniques. Cela rend donc le HSV apte par exemple à une opération de seuillage des couleurs qui autrement pourrait être facilement faussée quelque facteur externe.

La signification des composants du HSV peuvent s'expliquer de cette manière :

Le hue peut être définie comme le "type" de couleur ou la "teinte". Ex : bleu, rouge, orange
La saturation est la "pureté" d'une couleur. Plus sa valeur approche de 0, plus la couleur devient grisâtre.
V (value) est la clareté de la couleur.

Chacune de ces valeurs est définie dans une gamme déterminée. Par exemple, le hue variera généralement de 0 à 360 mais peut être parfois normalisé entre 0 et 100. Quant à S et V, ceux-ci varient de 0 à 1 ou, exprimé en pourcentage, de 0 à 100%. Il est plus facile de comprendre ceci en observant cette représentation du HSV :

Représentation du HSV par un cône

Le hue est donc vu comme la variation autour de la circonférence du cône, d'où s'explique sa gamme de valeurs comprises entre 0 et 360 degrés. La saturation s'explique comme le rayon d'un disque du cône. V varie finalement du sommet du cône à sa base.

Outre la méthode théorique directement issue du modèle mathématique, la conversion d'une valeur en RGB vers le HSI peut être effectuée sans trop de charge du processeur. En effet, il se trouve que l'on puisse recourir à ce raccourci :

Également deux exceptions se présentent :

Si max=min alors h ne peut être définit
Si max=0 alors s ne peut être définit

Cette conversion peut-être codée ainsi dans une fonction :

Cette fonction, appellée avec la valeur des composants RGB en paramètre ainsi que l'adresse sur les variables pour H,S et V, retournera H dans l'intervalle 0-360 ainsi que S et V dans 0-100.

Notez ici que les fonction max et min sont en fait des macros qu'il faudra prendre soin de définir dans l'entête :

Création de l'histogramme

Comme expliqué sommairement plus-haut, le principe de calcul de l'histogramme se base sur l'incrémentation d'un tableau pour H, S et V. Ceci est visible dans cette partie du programme :

Le fichier PPM est parcouru pour obtenir toutes les valeurs RGB des pixels et être convertis en HSV. Par la suite, on incrémente un élément d'un des tableaux à la position indexée par la valeur convertie. Par exemple, si l'on trouve que la valeur de hue pour un pixel vaut 134, alors hue[134] sera incrémenté. De cette manière, chaque élément du tableau représente chacune des valeurs entières possibles pour H,S et V.

Par la suite, on procède à l'opération contraire de lecture du tableau pour écrire un fichier .dat pour Gnuplot :

Finalement, après avoir "déroulé" les tableaux dans le même fichier Gnuplot et fermé ce dernier, on peut créer les fichier png à partir de gnuplot_i. Consultez le manuel de référence de Gnuplot et gnuplot_i pour en savoir davantage.

/*Creation du fichier png*/ gnuplot_ctrl * h1; gnuplot_ctrl * h2; h1 = gnuplot_init() ; gnuplot_cmd(h1, "set title \"Histogramme de s et v pour %s\"",argv[1]); gnuplot_cmd(h1, "set terminal png"); gnuplot_cmd(h1, "set output \"sv.png\""); gnuplot_cmd(h1, "set mxtics 4"); gnuplot_cmd(h1, "set mytics 4"); gnuplot_cmd(h1, "set xtics 10"); gnuplot_setstyle(h1,"boxes"); gnuplot_set_xlabel(h1,""); gnuplot_set_ylabel(h1,"px"); gnuplot_cmd(h1, "plot '%s' using 1:3 with boxes title \"saturation\", '%s' using 1:4 with boxes title \"value\"", argv[2],argv[2]) ; h2 = gnuplot_init() ; gnuplot_cmd(h2, "set title \"Histogramme du hue pour %s\"",argv[1]); gnuplot_cmd(h2, "set terminal png"); gnuplot_cmd(h2, "set output \"hue.png\""); gnuplot_cmd(h2, "set mxtics 4"); gnuplot_cmd(h2, "set mytics 4"); gnuplot_set_xlabel(h2,"hue"); gnuplot_set_ylabel(h2,"px"); gnuplot_cmd(h2, "plot '%s' using 1:2 with boxes title \"hue\"",argv[2]) ; gnuplot_close(h1) ; gnuplot_close(h2) ;

Résultat

Après avoir exécuté hsvhist sur une image ppm de cette manière :

hsvhist fichier.ppm donnees

3 fichiers sont créés. D'abord le fichier gnuplot qui contient les histogrammes pour H,S et V ainsi que les graphiques en format png du hue et de sv.

Image à analyser

Saturation et Value

Histogramme du hue

Les résultats semblent concluants et l'outil, bien pratique. Également, il serait possible de faire évoluer le programme de telle sorte qu'il puisse créer d'autres graphiques plus détaillés par exemple. Cependant, dans le cadre des exigences initiales, l'objectif est atteint. L'étude de ces histogrammes est donc maintenant à venir

Notez d'ailleurs cette caractéristique du hue pour la couleur de "peau" près de 25...

À consulter également...

Conversion en bloc JPG vers PPM

Conversion d'images couleur en niveaux de gris

gnuplot_i

Programmation de réseaux neuronaux artificiels sous Linux

Pierre-Luc Bacon — 2005-12-27T06:01:12Z

Étant contraint par des échéances trop demandantes, mon projet de développement d'une bibliothèque de fonctions pour l'implémentation d'un algorithme de rétropropagation de l'erreur (BPNN) a été interrompu par la découverte d'un outil puissant qui sera applicable dans les délais.

Bien que la compréhension générale des principes soutenant les modèles de réseaux neuronaux puisse être assez accessible, il en est cependant tout autrement quand vient le temps d'implémenter ces concepts dans un programme. Plutôt que de coder entièrement des bibliothèques dédiées à cette fin, il serait nettement plus efficace de tirer profit des travaux déjà réalisés dans le domaine. Ainsi, la bibliothèque FANN, acronyme de Fast Artificial Neural Network Library, nous permet de parvenir à notre objectif rapidement.

FANN permet le déploiement d'algorithmes de réseaux neuronaux artificiels multicouches à rétropropagation de l'erreur (backpropagation neural network) avec accès à tous ses paramètres : pas d'apprentissage, nombre d'époques etc. Également, l'accès aux fonctions peut se faire à partir de plusieurs langages (C++, PHP, Rubby, Python, Pure Data, .NET et Delphi pour nommer que ceux-là) autant sous Linux que Windows.

Fait à ne pas négliger : il est possible d'ajuster les paramètres du réseaux de manière à l'optimiser au fil de l'apprentissage. Par exemple, cette fonctionalité s'avérerait particulièrement intéressante dans le cas d'un système dynamique d'évitement des minimas locaux.

Installation

L'installation à partir des sources se fait de manière classique. Il faut d'abord récupérer l'archive sur ce site :

http://leenissen.dk/fann/

Décompresser l'archive :

tar xjf fann-1.x.x.tar.bz2

tar xzf fann-1.x.x.tar.gz

Ensuite dans le répertoire :

./configure —prefix=/usr
make
su -c "make install"

La compilation ne devrait pas poser de problèmes particuliers. Si tel est le cas, assurez-vous qu'il ne manque pas de bibliothèques essentielles, ce qui serait fort surprenant compte tenu des demandes minimales de FANN.

Exemple

Le but de cet article n'étant pas de reproduire tout le détail du manuel de référence du projet FANN, je n'élaborerai davantage sur ses fonctions. Le code présenté plus bas sera divisé en deux programmes : l'un permettant d'entraîner le réseau à partir de données, et l'autre d'exécuter le réseau une fois correctement ajusté.

Entraînement


 include "fann.h"
 
 int main()
 {
 const float connection_rate = 1;
 const float learning_rate = 0.5;
 const unsigned int num_input = 2;
 const unsigned int num_output = 1;
 const unsigned int num_layers = 3;
 const unsigned int num_neurons_hidden = 4;
 const float desired_error = 0.0001;
 const unsigned int max_iterations = 500000;
 const unsigned int iterations_between_reports = 1000;
 
 struct fann *ann = fann_create(connection_rate, learning_rate, num_layers,
 num_input, num_neurons_hidden, num_output);
 
 fann_train_on_file(ann, "xor.data", max_iterations,
 iterations_between_reports, desired_error);
 
 fann_save(ann, "xor_float.net");
 
 fann_destroy(ann);
 
 return 0;
 }

Notez ici que cette première partie provient directement du manuel de FANN et nous servira dans le cas présent à vérifier d'abord si nous parvenons à compiler un programme avec la bibliothèque et ensuite à introduire les concepts de l'API.

La compilation peut se faire ainsi :

gcc entrainement.c -o entrainement -lfann -lm -O3

S'il arrivait que vous obteniez un message d'erreur tel que :

ld : can't locate file for -lfann

Cela peut signifier que vous ayez installé FANN dans un répertoire non reconnu par ld (dans /usr/local/lib/ par exemple). Dans ce cas, on peut procéder en définissant une variable d'environnement qui spécifie le répertoire à utiliser :

export LD_LIBRARY_PATH=/usr/local/lib/

Les étapes permettant de parvenir à un résultat sont réduites. Ainsi, suffit-il d'abord de créer un réseau en renseignant un pointeur de structure fann avec la fonction fann_create().

struct fann * fann_create(float connection_rate, float learning_rate, unsigned int num_layers, unsigned int ...);

L'argument connection_rate permet d'indiquer si le réseau sera complètement connecté avec comme valeur 1 pour une structure d'interconnection complète et 0.2 pour une autre à 20% par exemple.

Ensuite est chargé un fichier contenant les données qui formeront le corpus d'apprentissage. Celui-ci respecte la syntaxe suivante :

Syntaxe d'un fichier de données pour la règle XOR

La fonction fann_train_on_file permet d'effectuer cette opération :


 void fann_train_on_file(struct fann * ann, char * filename, unsigned int max_epochs, unsigned int epochs_between_reports, float desired_error);

Il ne reste plus ensuite qu'à enregistrer la structure finale du réseau dans un fichier et à détruire toute instance du réseau dans le programme. Les prototypes des fonctions utilisées à cette fin sont respectivement les suivants :

bool fann_save(resource ann, string filename);

void fann_destroy(struct fann * ann);

Utilisation du réseau
Cette seconde partie permettra d'établir un réseau neuronal artificiel à partir du fichier descriptif obtenu précédemment après entraînement.


 #include <stdio.h>
 #include <stdlib.h>
 #include "floatfann.h"
 
 int main()
 {
 fann_type *calc_out;
 fann_type input[2];
 struct fann *ann = fann_create_from_file("xor_float.net");
 char ligne[10];
 int val;
 
 printf("Entree 1:");
 fgets(ligne,sizeof(ligne),stdin);
 sscanf(ligne,"%d",&val);
 input[0]=(fann_type) val;
 
 printf("\nEntree 2:");
 fgets(ligne,sizeof(ligne),stdin);
 sscanf(ligne,"%d",&val);
 input[1]=(fann_type) val;
 
 calc_out = fann_run(ann, input);
 
 printf("xor test (%f,%f) -> %f\n",
 input[0], input[1], *calc_out);
 
 fann_destroy(ann);
 return 0;
 }

Cette fois encore, les appels de fonctions sont guère plus nombreux. L'allure finale du réseau obtenu après entraînement à été retenu dans un fichier duquel sera chargé le réseau. La fonction fann_create_from_file est donc d'abord appellée à cette fin.

struct fann * fann_create_from_file(const char * configuration_file);

Sans plus d'ennuis sont évalués ensuite les entrées fournis par l'utilisateur avec fann_run.

fann_type * fann_run(struct fann * ann, fann_type * input);

Finalement, quitte le programme après avoir appellé fann_destroy qui libère la mémoire allouée dynamiquement au réseau neuronal artificiel.

Résultat
Ainsi, si vous avez correctement entraîné le réseau avec le programme entrainement.c, vous devriez obtenir un scénario du genre lors de l'exécution du programme ci-haut :

pierre-luc@goll:~/ann$ ./exec 
 Entree 1:1
 
 Entree 2:1
 xor test (1.000000,1.000000) -> 0.009030

On peut donc voir ici que la réponse du système est plus que satisfaisante. En effet, il avait été convenu lors de la phase d'entraînement du réseau que l'erreur devait être minimisée au moins jusqu'à la valeur de 0.0001. Ainsi, après exécution, voici ce qui avait été obtenu :


 pierre-luc@goll:~/ann$ ./entrainement
 Max epochs 500000. Desired error: 0.0001000000
 Epochs 1. Current error: 0.2508315742
 Epochs 350. Current error: 0.0000983779

L'erreur finale après 350 époques est de 0.0000983779 alors qu'elle était de 0.2508315742 initialement. De plus, cette opération s'effectue à une vitesse impressionnante. La commande time pour le programme d'exemple entrainement sur un P4 1.5 ghz montrait ces résultats :


 real 0m0.031s
 user 0m0.000s
 sys 0m0.000s

Le temps réel passait parfois à 0m0.010s mais se tenait généralement en dessous de 0m0.020s.

Considérant à la fois sa facilité d'utilisation ainsi que ses performances, fann est tout indiqué pour un projet en phase de développement ou en processus final. Il est certes beaucoup moins avantageux du côté pédagogique de l'utiliser, mais d'un autre, il est possible plus facilement par cet outil de s'attarder aux véritables préoccupation du projet et à sa recherche, donc d'apprendre.

Projet en suspend d'une bibliothèque pour l'algorithme BPNN :
http://pierreluc.aqra.ca/projet/Bac...

Manuel de référence pour FANN :
http://leenissen.dk/fann/html/index.html

Saisie d'images avec Video For Linux

Pierre-Luc Bacon — 2005-09-02T02:46:11Z

Dans certains cas, l'ajout d'un système de vision à un robot s'avère un élément essentiel à son contrôle. Cependant, l'implantation des techniques d'analyse de l'image peut exiger une programmation complexe ou l'usage de technologies spécialisées. L'article qui suit traite du développement d'un programme de traitement vidéo sous Linux - ou plus précisément de l'étape de capture de l'image - un choix qui, vous l'aurez deviné, allie performance, stabilité et facilité de mise en oeuvre.

Seuillage du vert

Programme d'analyse vidéo en phase de développement.

Sommaire

Avant toute chose, assurez-vous d'avoir à la fois Video For Linux installé sur votre système ainsi que le pilote en charge de votre camera web utilisée pour ce programme. S'il vous faut faire un choix concernant l'achat de matériel, vous pouvez opter simplement pour la Quickcam Express de Logitech, peu coûteuse et bien supportée par le SE. À ce sujet, consultez l'article de ce site « Installation de la Quickcam Express sous Linux » pour obtenir des informations sur son installation. Pour ce qui est de V4L (Video For Linux), il serait fort étonnant que votre distribution ne l'intègre pas dans son noyau. Si toutefois tout semble indiquer que ce support est absent de votre système, la dernière version est disponible à l'adresse http://linux.bytesex.org/v4l2/

Ouverture de la caméra

Considérant que la caméra que nous souhaitons utiliser se situe en /dev/videoX, son ouverture se fera par un appel à la fonction open(const char *chemin, int flags) avec ce chemin en paramètre ainsi qu'un drapeau indiquant le mode d'accès.


 descrpFichier=open("/dev/video0", O_RDWR);
 if(descrpFichier < 0)
 {
 printf("\aAucun peripherique detecte\n");
 printf("Verifiez les droits d'acces a /dev/video0\n");
 exit(-1);
 }

Si l'opération est réussie, la fonction open retournera le descripteur du fichier ouvert. Dans le cas contraire, un message d'erreur s'affichera. Les causes peuvent être multiples, mais la plupart du temps, le problème proviendra des permissions accordées à sur ce dispositif.

Fermeture de la caméra

Intuitivement, la fermeture de la caméra se fera par une fonction close, prenant en paramètre le descripteur de fichier obtenu par la fonction open.


 close(descrpFichier);

Requête sur le dispositif

De manière à rendre l'application plus flexible devant le matériel utilisé, nous allons d'abord nous informer de ses possibilités. Cette opération se fera en effectuant un appel de type ioctl VIDIOCGCAP qui retournera le résultat dans une structure video_capability.


 struct video_capability vidcap;
 if (ioctl (descrpFichier, VIDIOCGCAP, &vidcap) < 0)
 exit (-1);

Les informations que contiendra la structure vidcap sont les suivantes :

struct video_capability
Nom	Description	Commentaires
name[32]	Nom[32]
type	Type	Supporte la capture vidéo ou non
channels	Le nombre de canals	Si applicable (télévision, radio)
audios	Audio	Son disponible
maxheight	Hauteur maximale (pixels)
maxwidth	Largeur maximale (pixels)
minheight	Hauteur minimale (pixels)
minwidth	Largeur minimale (pixels)

Pour nous assurer d'avoir accès à un dispositif supportant la saisie d'images, nous allons utiliser un drapeau spécialement défini dans video for linux pour le comparer au champs type.


 if (!(vidcap.type && VID_TYPE_CAPTURE))
 {
 printf ("Le peripherique detecte ne supporte pas la capture\n");
 exit (-1);
 }

D'autres conditions pourraient être testées pour s'assurer du bon fonctionnement du programme. Pour ce faire, V4L offre beaucoup d'autres drapeaux (flags) qu'on a d'ailleurs documentés adéquatement. [1]

Paramètres de l'image

La zone de capture doit également être contenue dans une structure, cette fois, de type video_window. VIDIOCSWIN servira à fixer la valeur de ses champs. Nous nous intéresserons seulement qu'à ceux-là :

struct video_window
Champs	Commentaire
x	Position en X
y	Position en Y
width	Largeur de l'image
height	Hauteur de l'image


 struct video_window fenetre;
 fenetre.x = 0;
 fenetre.y = 0;
 fenetre.width = WIDTH;
 fenetre.height = HEIGHT;
 fenetre.clipcount = 0;
 fenetre.chromakey = 0;
 
 
 if (ioctl (descrpFichier, VIDIOCSWIN, &fenetre) < 0)
 {
 perror ("VIDIOCSWIN");
 exit (-1);
 }

Si VIDIOCSWIN a pu s'exécuter, cela ne signifie pas pour autant que les valeurs passées ont été supportées. N'oubliez pas de vérifier le résultat de l'opération ! Pour connaître la valeur des paramètres qui y ont été définis, nous appelleront VIDIOCGWIN par ioctl de nouveau.


 if (ioctl (descrpFichier, VIDIOCGWIN, &fenetre) < 0)
 exit (-1);

Aspect de l'image

Tout comme la fonction VIDIOCSWIN permet de régler certains paramètres de l'image, VIDIOCSPICT déterminera l'ajustement et son aspect : contraste, couleur, profondeur etc. Voyons l'organisation de la structure correspondante :

struct video_picture
Champs	Commentaire
brightness	Intensité
hue
color
contrast
whiteness	Réglage des blancs
depth	Profondeur
palette	Mode de représentation des couleurs

Le code qui permettra de modifier ces valeurs sera court :


 image.hue = hue;
 image.colour = colour;
 image.contrast = contrast;
 image.brightness = brightness;
 image.whiteness = whiteness;
 image.depth = depth;
 image.palette = PALETTE;
 if (ioctl (descrpFichier, VIDIOCSPICT, &image) < 0)
 {
 perror ("VIDIOCSPICT");
 exit (-1);
 }

Comme expliqué plus-haut, nous nous assurerons d'avoir pu imposer ces valeurs avec la fonction VIDIOCGPICT :


 if (ioctl (descrpFichier, VIDIOCGPICT, &image) < 0)
 {
 perror ("VIDIOCGPICT");
 exit (-1);
 }

Par la suite, l'affichage des valeurs chargées peut se faire simplement ainsi :


 printf ("Hue: %d\n", image.hue);
 printf ("Color: %d\n", image.colour);
 printf ("Contrast: %d\n", image.contrast);
 printf ("Brightness: %d\n", image.brightness);
 printf ("Whiteness: %d\n", image.whiteness);
 printf ("Depth: %d\n", image.depth);
 printf ("Taille du buffer: %d octets\n", mbuf.size);

Capture en tampon double

Nous voilà finalement rendu à l'étape quasi finale du processus : l'obtention de l'image depuis le pilote de la caméra. Comme le temps d'occupation du processeur est une denrée préciseuse en informatique, nous tacherons ici à optimiser les opérations en implantant un système d'espace mémoire à tampon double de manière à éviter de perdre des images. Notez aussi que les données ne transiteront pas ici directement depuis le framebuffer de la carte vidéo mais passeront plutôt par un espace tampon.

L'idée du principe de capture à tampons multiples est de fournir en tout temps au pilote du périphérique un espace mémoire pour déposer son image. Cela se fait donc d'abord en exécutant une série de requêtes VIDIOCMCAPTURE qui seront mises en file par le pilote. Un appel VIDIOCSYNC permettra ensuite d'attendre jusqu'à la libération de l'image. La séquence des requêtes, placée dans un boucle infinie, devrait être la suivante :


 VIDIOCMCAPTURE(0)
 VIDIOCMCAPTURE(1)
 VIDIOSYNC(0) /*Attends l'arrivée des données pour le buffer 0*"
 [traitement des données du buffer 0]
 VIDIOCMCAPTURE(0)/*Le buffer 0 est remis dans la file*/
 VIDIOSYNC(1)/*Le buffer 1 est en remplissage*/
 [traitement des données du buffer 1]
 VIDIOCMCAPTURE /*Le buffer 1 est remis dans la file*/

L'image peut ensuite être retrouvée en mémoire en effectuant la somme du pointeur sur la MMAP plus l'élément offsets de la sturcture video_mbuf.

Ex :


 unsigned char *buf;
 buf=mmapptr+mbuf.offsets[num_image]

Saisie des images et copie dans un "buffer"

La fonction présentée ci-dessous tire partie d'un système à base de pointeurs de fonction. En effet, un pointeur sur une fonction capable d'effectuer le traitement de l'image sera passé en argument. Ce pointeur pourra ensuite être utilisé pour appeller la fonction appropriée lors du passage de l'image au programme.

Puisque nous utilisons l'interface MMAP, nous devrons d'abord obtenir des informations sur la taille du buffer en MMAP et la position des images dans cet espace.


 if(ioctl(descrpFichier, VIDIOCGMBUF, &mbuf)<0)
 {
 perror("VIDIOCGMBUF");
 exit(-1);
 }

Nous obtiendrons effectivement cet espace en MMAP par la suite de cette manière :


 ptr = (unsigned char*)mmap(0, mbuf.size, PROT_READ|PROT_WRITE, MAP_SHARED,descrpFichier,0);
 if(ptr==(unsigned char*) -1){
 perror("mmap");
 exit(-1);
 }

Nous voyons donc ici, plus-haut, que l'élément size de la structure mbuf informée plus tôt par l'appel VIDIOCGMBUF est utilisé pour déterminer l'espace nécessaire pour un tampon accessible en lecture et en écriture sur notre périphérique, déterminé par descrpFichier.

Vient maitenant une étape nécessaire avant d'effectuer nos appels aux fonctions de capture de V4L : nous devons renseigner une structure de type video_mmap dans ses champs height, width, et format. Cette étape est sans commentaires spéciaux, à l'exception du conseil suivant : il est profitable pour une question d'efficacité d'utiliser des macros (defines) pour donner la valeur à certains paramètres tels que la taille de l'image, le format etc. Ainsi, les mots en majuscules dans le bout de code suivant sont définis dans le fichier d'entête par les valeurs souhaitées.


 mapbuf.height = HEIGHT ;
 mapbuf.width = WIDTH;
 mapbuf.format = PALETTE;

Comme expliqué dans la section « capture en tampon double », nous effecturons une série d'appels VIDIOCMCAPTURE selon le nombre de buffers supportés par le pilote. Ceux-ci seront placés en file avant d'être synchronisés par la fonction VIDIOCSYNC.


 for(image=0; image<mbuf.frames; image++)
 {
 mapbuf.frame = image;
 if(ioctl(descrpFichier, VIDIOCMCAPTURE, &mapbuf))
 {
 perror("VIDIOCMCAPTURE");
 exit(-1);
 }
 }
 image=0;

La variable image, aura été déclarée plus-haut pour indiquer le nombre d'images pouvant être capturés par le pilote : c'est l'indicateur du nombre de buffers. La valeur de cette varible est ensuite changée à 0 car nous la réutiliserons comme argument à la fonction VIDIOCSYNC. Dans une boucle, nous mettons en application le principe expliqué dans le paragraphe précédent :


 while(nbcapture<rep)
 {
 i=-1;
 while(i<0){ /*Tant qu'on obtient une erreur, l'appel doit etre repete. */
 /*On verifie que la fonction a reussi et qu'il n'y a pas eu de signals qui ont interrompu l'appel.*/
 i=ioctl(descrpFichier, VIDIOCSYNC, &image);
 if(i < 0 || errno == EINTR)
 {
 if(i<0)
 {
 perror("VIDIOCSYNC");
 printf("Le programme doit quitter\n\a");
 exit(-1);
 }
 continue;
 }
 break; /*La sync. s'est bien deroule. On sort de la boucle*/
 }
 
 posImg=ptr+mbuf.offsets[image];
 /*La fonction de traitement peut maintenant etre appellee avec posImg comme argument*/
 printf("Adresse image: %p\n", posImg);
 ptrfonction(posImg,HEIGHT,WIDTH);
 /*On remet le buffer a la disposition du driver*/
 
 mapbuf.frame = image;
 if(ioctl(descrpFichier, VIDIOCMCAPTURE, &mapbuf)<0)
 {
 perror("VIDIOCMCAPTURE");
 printf("L'application doit quitter\n\a");
 closeCam();
 exit(-1);
 }
 image++;
 
 if(image>mbuf.frames)image=0;
 
 nbcapture++;
 
 }

Nous effectuons d'abord dans un premier passage la synchronisation de l'image 0 avec VIDIOCSYNC placé dans une boucle conditionelle qui vérifie que la fonction soit bel et bien parvenue à effectuer sa tâche sans avoir été interrompue par un signal ou un problème quelconque. Nous pouvons alors ensuite recueillir notre première image par le simple calcul suivant :


 posImg=ptr+mbuf.offsets[image];

Suite à cette opération, le pointeur de fonction utilisé en paramètre de la fonction de capture peut être utilisé de la sorte :


 ptrfonction(posImg,HEIGHT,WIDTH);

Nous pouvons maintenant remettre le buffer courant à la disposition du driver en utilisant de nouveau VIDIOCMCAPTURE.


 mapbuf.frame = image;
 if(ioctl(descrpFichier, VIDIOCMCAPTURE, &mapbuf)<0)
 {
 perror("VIDIOCMCAPTURE");
 printf("L'application doit quitter\n\a");
 closeCam();
 exit(-1);
 }
 image++;
 
 if(image>mbuf.frames)image=0;

Le champs frame de la structure mapbuf de type video_mmap est défini à la l'indicateur de l'image venant d'être utilisée. Finalement, la dernière ligne s'assure de remettre la valeur de image à 0 si l'on a dépassé le nombre d'images en attente supporté.

Lecture des données de l'image RGB et écriture d'un fichier PPM

Une image saisie en format RGB24 peut être facilement interprétée : un pixel étant décrit par un triplet de valeurs dans l'ordre BGR. Le pointeur de notre image, appelons-le posImg, pointe donc sur la valeur B du premier pixel. Pour effectuer cette opération sur la totalité de l'image, deux boucle for seront utilisées : une première lisant tous les pixels de 1 à n pour une ligne et une seconde boucle passant d'une ligne à l'autre.


 void extractPix(unsigned char* imgbuffer, int hauteur, int largeur)
 {
 printf("En cours d'ecriture de l'image...\n");
 fp = fopen("capturecam.ppm", "w");
 if(fp==NULL)
 {
 printf("Impossible d'ouvrir le fichier\n");
 exit(-1);
 }
 
 fprintf(fp, "P6\n%d %d\n255\n",largeur, hauteur);
 for(y=0;y<hauteur; y++)
 { 
 for(x=0; x<largeur; x++)
 {
 b=imgbuffer[p];p++;
 g=imgbuffer[p];p++;
 r=imgbuffer[p];p++;
 putc(r, fp);
 putc(g, fp);
 putc(b, fp); 
 }
 }
 fflush(fp);
 fclose(fp);

Ce code montre l'ouverture d'un fichier de type PPM [2] et de la scrutation de l'image en mémoire par une double boucle copiant les valeurs RGB dans l'ordre inverse dans les variables correspondantes de type unsigned char. Portez attention ici au prototype de cette fonction qui respecte la déclaration du pointeur de fonctions dans l'étape de capture de l'image.

Qu'est-ce qu'est la MMAP ?

MMAP signifie "memory map" en langue anglaise. Cette fonction sert à représenter de manière localisée (ou "projetter") un fichier dans une zone mémoire selon une indication de longueur de l'espace requis et de positionnement par rapport au descripteur d'un fichier. Vous remarquerez donc ici qu'en la définition de "fichier" sous système UNIX, nous entendons également "périphérique". La MMAP est donc un moyen de recuillir les données d'un certains flux dans une zone mémoire de manière organisée.

[1] Voir Video4Linux Kernel API Reference. Une version du document est accessible sur ce site : www.aqra.ca/pierre-luc/camapp/API.html

[2] Pour plus de renseignements sur la manipulation d'images en format PPM, référez-vous à l'article 35 sur ce site intitulé "Conversion d'images couleur en niveaux de gris". http://www.aqra.ca/article.php3 ?id_article=35

Librairie en C18 pour LCD

Jean-François Duval — 2005-06-03T02:56:52Z

Cette librairie a été écrite pour faciliter l'incorporation d'un afficheur LCD à un projet. Elle est écrite en C18, pour les PICs de la famille 18F. Plutôt que de faire un grand discours, regardons le code :

//Librairie pour afficheur LCD 16*1 charactères
 //Révision du 01/06/2005
 
 //N.B. Le LCD 16*1 est en fait deux LCDs 8*1 sur la même ligne
 //c'est pourquoi on doit choisir entre ligne 1 et 2 (chaque ½ écran) 
 
 /*
 Définitions des pins pour le LCD
 À ajuster selon l'application
 
 LCD => PIC
 -----------
 14 => RD7
 13 => RD6 
 12 => RD5
 11 => RD4
 10 => RD3
 9 => RD2
 8 => RD1
 7 => RD0
 6 => RC4 (En) 
 5 => RC5 (RW)
 4 => RC3 (RS)
 3 => x (contraste)
 2 => x (GND)
 1 => x (5V)
 */
 
 #define LCDdata PORTD
 #define TRIS_LCDdata TRISD
 #define LCDenable PORTCbits.RC4
 #define TRIS_LCDenable TRISCbits.TRISC4
 #define LCDrs PORTCbits.RC3
 #define TRIS_LCDrs TRISCbits.TRISC3
 #define LCDrw PORTCbits.RC5
 #define TRIS_LCDrw TRISCbits.TRISC5
 
 //Defines pour config du lcd
 #define clear 1
 #define home 2
 #define cursorON 3
 #define cursorOFF 4
 #define shift 5
 
 //Délais
 #define wait Delay10KTCYx(1)
 #define longwait Delay10KTCYx(15) 
 #define shortwait Delay1KTCYx(1)
 #define Delay_05ms Delay10TCYx(250)
 
 //variables utilisées ds les routines
 int t; 
 int o;
 
 //fonction d'initialisation de l'écran
 void initlcd (void)
 {
 LCDdata = 0b00000000; //toutes les pins de données à 0
 LCDrw = 0;
 LCDenable = 0; //enable à 0
 LCDrs = 0; //Register Select à 0 (configuration) 
 
 longwait;
 
 //display ON
 LCDdata = 0b00001111;
 wait;
 LCDenable = 1;
 wait;
 LCDenable = 0;
 wait;
 
 // mode 8 bit
 LCDdata = 0b00000001; 
 wait;
 LCDenable = 1;
 wait;
 LCDenable = 0;
 wait;
 
 // effacer l'écran
 LCDdata = 0b00111000; 
 wait;
 LCDenable = 1;
 wait;
 LCDenable = 0;
 wait;
 }
 
 //fonction pour choisir entre quelle ligne d'écran
 void line (int x)
 {
 if (x == 1)
 {
 //set display adress au début de l'écran (ligne 1)
 LCDrs = 0;
 LCDrw = 0;
 LCDdata = 0x80; 
 wait;
 LCDenable = 1;
 wait;
 LCDenable = 0;
 wait;
 }
 
 if (x == 2)
 {
 //set display adress au 9e charactère (ligne 2)
 LCDrs = 0;
 LCDrw = 0;
 LCDdata = 0xC0; 
 wait;
 LCDenable = 1;
 wait;
 LCDenable = 0;
 wait;
 }
 }
 
 //configuration de l'écran (efface, home, etc)
 void configlcd (int config)
 {
 if (config == clear)
 {
 //efface l'écran
 LCDrs = 0;
 LCDdata = 0b00000001; 
 shortwait;
 LCDenable = 1;
 shortwait;
 LCDenable = 0;
 wait; 
 }
 
 if (config == home)
 {
 //curseur et écran home
 LCDrs = 0;
 LCDdata = 0b00000011; 
 wait;
 LCDenable = 1;
 wait;
 LCDenable = 0;
 wait; 
 }
 
 if (config == cursorON)
 {
 //curseur ON
 LCDrs = 0;
 LCDdata = 0b00001111; 
 wait;
 LCDenable = 1;
 wait;
 LCDenable = 0;
 wait;
 }
 
 if (config == cursorOFF)
 {
 //curseur OFF
 LCDrs = 0;
 LCDdata = 0b00001100; 
 wait;
 LCDenable = 1;
 wait;
 LCDenable = 0;
 wait;
 }
 
 if (config == shift)
 {
 //shift display
 LCDrs = 0;
 LCDdata = 0b00011000; 
 wait;
 LCDenable = 1;
 wait;
 LCDenable = 0;
 wait;
 }
 }
 
 //affichage d'un charactère sur l'écran
 void printlcd (char text)
 {
 LCDrs = 1;
 shortwait;
 LCDdata = text; // print text
 shortwait;
 LCDenable = 1;
 shortwait;
 LCDenable = 0;
 LCDdata = 0b00000000; //remet toutes les sorties à 0
 LCDrs = 0; 
 }
 
 //affichage d'une chaine de charactères sur l'écran
 void printstringlcd (char *str)
 {
 line(1);
 
 for(t=0; t<=7; ++t) //imprime les premiers charactères
 {
 printlcd(str[t]);
 }
 
 line(2);
 
 for(t=8; t<=15; ++t) //imprime les derniers charactères
 {
 printlcd(str[t]); 
 }
 }

Le code source de la librairie vous étant maintenant connu, voici un petit exemple de comment l'utiliser pour afficher "Bonjour" sur votre écran LCD.

//includes
 #include <p18f452.h> // for ports declarations
 #include <delays.h> // for delay routines
 #include <timers.h> //for interrupts
 #include "liblcd.c"
 
 //variables
 char bonjour[] = " Bonjour ! ";
 
 //fonction principale du programme
 void main ()
 {
 //On désactive l'acquisition analogique
 ADCON1=6; 
 
 //définitions des I/O
 TRIS_LCDdata = 0; 
 TRIS_LCDenable = 0;
 TRIS_LCDrw = 0;
 TRIS_LCDrs = 0;
 
 initlcd();
 printstringlcd(bonjour);
 
 while(1)
 {
 }
 }
 
 //config du PIC
 #pragma config OSC = HS
 #pragma config PWRT = ON
 #pragma config WDT = OFF
 #pragma config BOR = ON
 #pragma config BORV = 42
 #pragma config LVP = OFF

Tout ce qui est écrit ci-dessus est pour un afficheur 16*1 et pour un PIC18F452. Vous pouvez bien sur changer le modèle de PIC sans problème, en ajustant les pins et le #include en haut du texte. Pour changer le modèle de LCD (par exemple pour utiliser un 16*2), il suffira de changer les valeurs des limites de ligne dans la fonction printstringlcd.

Conversion d'images couleur en niveaux de gris

Pierre-Luc Bacon — 2005-01-17T22:51:53Z

Mon activité éditoriale sur ce site a été réduite ce dernier mois en raison de l'écriture d'un programme de traitement vidéo. Cet article est le premier d'une série qui s'attardera à effectuer diverses opérations de capture et de traitement de l'image. Dans ces lignes sera présenté un programme de conversion d'images en format PPM vers le format PGM.

L'algorithme de transformation de l'espace des valeurs rouge, vert et bleu en sa représentation par niveaux de gris est d'une grande simplicité à réaliser. Son importance en est pas moins considérable puisque l'espace de niveaux de gris d'une image est une étape essentielle de tous traitements car la complexité du programme et le temps de calcul s'en trouvent réduits. Cela permettra par exemple de tirer profit des filtres convolutifs du genre Prewitt ou Sobel.

Pour convertir les valeurs RGB, il suffit d'appliquer la formule suivante :

Y=R*0,299+G*0,587+B*0,114

où Y exprime le niveau de gris pour un pixel donné

Formats PNM

Ce type de format permet de coder une image dans sa plus simple expression. Le terme « PNM » est une généralisation d'un type d'images regroupant les formats réels « PBM », « PGM » et « PPM ». Ces extensions servent à définir trois types d'images : binarisées pour le PBM, en niveaux de gris pour le PGM et en couleur pour le PPM. Tous les fichiers PNM se structurent de la même manière à l'exception près du format PBM. Tout d'abord, une entête détermine le type par un « chiffre magique » (indicateur commençant par P), les dimensions de l'image et son intensité maximale. Les lignes ne peuvent dépasser plus de 70 charactères et tous commentaires doivent être précédés du symbole « # ». Les formats PNM n'introduisent aucune compression les pixels : il suffit donc d'en exprimer la valeur par RVB pour le PPM, niveau de gris dans le cas du PGM ou simplement avec des « 1 » ou « 0 » pour le PBM. Il est important de noter que pour un même format d'image peut correspondre des tailles en mémoire différentes. Cela provient simplement d'une écriture soit en mode binaire ou ASCII beaucoup plus lourde en espace. Le tableau qui suit résume ces formats et leurs indicateurs.

Format	Indicateurs (ASCII,bin.)	Description
PBM	P4,P1	Monochome
PGM	P2,P5	Niveaux de gris
PPM	P3,P6	Couleur

Une image PPM binaire pourrait alors avoir cette forme :

P6
 #Commentaire
 320 292
 255
 [...valeurs RGB...]

Programmation

Pour accéder aux informations du fichier, il suffit d'utiliser une fonction « fopen » qui retournera un descripteur de fichier correspondant à celui ouvert ou créé. Même si l'image peut être représentée en valeurs binaires pour certains formats, il ne sera pas nécessaire d'ouvrir un fichier avec l'attribut binaire « b » ou de gérer la conversion en mode décimal soit-même.

Dans le programme présenté ici, on ouvre un fichier PPM duquel on lit les informations pertinentes qu'on retransmet ensuite dans un second fichier PGM après application de la formule de niveaux de gris. Au lancement, des arguments sur le nom du fichier source et celui produit seront exigés.

int main (int argc, char **argv)
 {
 
 if (argc == 1)
 {
 printf ("Arguments insuffisants\n");
 printf ("nivgris [source] [destination]\n");
 return -1;
 }
 
 fpr = fopen (argv[1], "r");
 if (fpr == NULL)
 {
 printf ("Impossible de lire le fichier\n");
 exit (-1);
 }
 
 
 fpw = fopen (argv[2], "w");
 if (fpw == NULL)
 {
 printf ("Impossible d'ouvrir le fichier en ecriture\n");
 exit (-1);
 }

Un tableau de caractères servira de « buffer » pour comparer les informations d'entête tirées du fichier en usant d'une fonction fgets. Nous nous assurerons d'abord d'avoir affaire au bon format de fichier en regardant le chiffre magique sur la première ligne. Si un commentaire est introduit sur la seconde ligne, il sera absorbé par un fgets supplémentaire. Précision ici qu'il est important d'avoir un fichier organisé de la même manière qu'expliquée plus haut car tous commentaires situés ailleurs que sur la deuxième ligne viendra déranger l'ordre d'analyse. Bien sûr, une version plus robuste de ce programme pourrait être faite, mais rappelons qu'il doit servir d'abord de structure pour visualiser le résultat des opérations de traitement.

fgets (info, 10, fpr);
 if (strncmp (info, "P6", 2) != 0)
 {
 printf ("Mauvais format de fichier\n");
 fclose (fpr);
 fclose (fpw);
 exit (-1);
 }
 fgets (info, 70, fpr);
 
 if ((strncmp (info, "#", 1)) == 0)
 {
 fgets (info, 10, fpr);
 }
 sscanf (info, "%d %d", &largeur, &hauteur);
 fgets (info, 10, fpr);
 sscanf (info, "%d", &valmax);
 if (valmax > 255)
 {
 printf ("Valeur maximale trop eleve\n");
 fclose (fpr);
 fclose (fpw);
 exit (-1);
 }

Pour lire l'ensemble des pixels de l'image, nous utiliserons les informations récupérées dans l'entête pour contrôler le déroulement d'une double boucle : une première s'exécutera pour passer de ligne en ligne alors qu'une seconde avancera sur un même ligne. Une seule boucle aurait pu également être employée pour cette tache où le paramètre de contrôle serait le produit de la hauteur par la largeur.

Les valeurs RGB ainsi extraites seront utilisées pour le calcul du niveau de gris du pixel ensuite réécrit dans le second fichier. Avant d'y placer ce pixel, il aura fallu définir au prélable des informations d'entête pour l'image PGM tirées du fichier PPM à la seule différence que « P5 » sera utilisé plutôt que « P6 ».

fprintf (fpw, "P5\n%d %d\n%d\n", largeur, hauteur, valmax);
 int x, y;
 unsigned char r, g, b, niv;
 
 for (y = 0; y < hauteur; y++)
 {
 for (x = 0; x < largeur; x++)
 {
 r = fgetc (fpr);
 g = fgetc (fpr);
 b = fgetc (fpr);
 niv = r * 0.299 + 0.587 * g + 0.114 * b;
 putc (niv, fpw);
 }
 }

Les fichiers sont finalement fermés et la fonction main retourne.

fclose (fpr);
 fclose (fpw);
 return 0;

Pour compiler, utilisez cette commande :

gcc -Wall niv_gris.c -o nivgris

Une fois l'exécutable créé, le lancement se fera ainsi :

./nivgris fichiersource.ppm fichiersortant.pgm

Ce code peut certainement constituer une base efficace pour tester le résultat de différents filtres d'images. Le passage d'une image de type RGB en niveaux de gris permettra l'application de méthodes de calcul de gradients pour l'extraction de contours. Cette prochaine étape sera d'ailleurs détaillée dans l'article suivant de cette série.

Image originale

Résultat

Port parallèle en C sous Linux

Pierre-Luc Bacon — 2004-06-12T23:03:54Z

Sommaire

Le port parallèle, commun à tous les ordinateurs standards, se présente sous la forme d'un connecteur comptant 25 contacts. Ce connecteur, généralement désigné sous l'appellation « sub-d » ou DB25, a été originellement conçu pour les imprimantes. Comme son nom l'indique, le port parallèle envoie et reçoit ses données en parallèle, donc sur plusieurs broches à la fois. Le tableau suivant dresse la liste des fonctions attribuées à chacune de ces broches.

Numero	Nom	Fonction
1	Strobe	Impulsion à zéro avant envoi
2	D0	Bit de donnée
3	D1	Bit de donnée
4	D2	Bit de donnée
5	D3	Bit de donnée
6	D4	Bit de donnée
7	D5	Bit de donnée
8	D6	Bit de donnée
9	D7	Bit de donnée
10	ACK	Bit d'état
11	Busy	Bit d'état
12	PE	Bit d'état
13	Select	Bit d'état
14	LF	Bit de contrôle en sortie
15	ERR	Entrée
16	INIT	Bit de contrôle en sortie
17	Select	Bit de contrôle en sortie
18 a 25	Masse

Obtention de l'accès

Avant toutes manipulations sur le port, nous devons obtenir les droits d'accès sur celui-ci. Pour ce faire nous utiliserons la fonction ioperm() définie dans la librairie standard unistd.h. La déclaration de cette fonction se présente ainsi :

int ioperm(unsigned long from, unsigned long num, int turn_on) ;

La valeur de retour de cette fonction est 0 en cas de réussite et -1 pour un échec. Lorsque l'opération échoue, errno est aussitôt défini.

Le premier paramètre est celui indiquant le registre sur lequel nous demandons les permissions. Le port parallèle dispose de trois registres :

0x378	Registre de données (D0 a D7)
0x379	Registre d'état
0x37A	Registre de contrôle

Le deuxième élément de ioperm() représenté par la variable num, dans cet exemple, indique le nombres de ports consécutifs devant être ouverts à la suite de from. Quant à l'expression turn_on, elle contient une valeur entière Booléenne spécifiant simplement si les ports doivent être ouverts (1) ou fermés (0). Une attention devra donc être portée de manière à éviter d'omettre la fermeture d'un port dans un programme donné. Voici un exemple d'ouverture et de fermeture à l'aide de la fonction ioperm() :

Opérations sur les ports

L'écriture ou la lecture sur le port peut se faire par l'entremise des fonctions outb() et inb() respectivement. Ces deux fonctions prennent en charge des valeurs codées sur un octet maximum, d'ou le b signifiant byte. Pour des valeurs supérieurs, les fonctions outw() et in(w) issues de l'assembleur sont en mesure d'agir sur le premier port 8 bits (p) et sur le second (p+1). Dans cet article qui se consacre au port parallèle de base, nous utiliserons les fonctions d'octet seulement. Mais sachez que les instructions de manipulations sur un mot (16 bits) pourraient vous être utiles dans des applications où vous utiliserez des ports à plus haut débit comme le port ISA par exemple.

Les fonctions inb() et outb() exigent les arguments suivants :

Comment puis-je agir sur des broches spécifiques ?

Comme nous l'avons vu plus haut, à chaque broche est associé un bit donné. Donc écrire sur une broche spécifique revient simplement à mettre le bit correspondant à 1 ou 0.

Imaginons que l'on veuille mettre au niveau haut les broches 2, 3 et 7. Pour ce faire, nous allons d'abord nous reporter au tableau suivant qui met en correspondance bit et broche.

Broche	2	3	4	5	6	7	8	9
Bit	D0	D1	D2	D3	D4	D5	D6	D7

Dans notre exemple, l'octet qui sera écrit aura ainsi la forme 00100011. Quelques notions de binaire suffisent ensuite pour effectuer la conversion vers la valeur décimale :

1*2exp0 + 1*2exp1 +1*2exp5 = 35

Ces quelques explications conduisent vers une version plus complète du tableau précédent.

Broche	2	3	4	5	6	7	8	9
Bit	D0	D1	D2	D3	D4	D5	D6	D7

|Valeur|1|2|4|8|16|32|64|128|

Programme récapitulatif

Montage d'essais

Vous pouvez visualiser le résultat de vos expérimentation rapidement en effectuant un simple montage à base de DEL.

Si vous comptez réaliser vos essais sur une plaques à insertion, il serait fortement conseillé de vous fabriquer un adapteur DB25 qui demeurera très utile en tout temps. Des circuits imprimés sont téléchargeables sur ce site à la page de l'article concerné.

Adapteur subd pour plaques à insertion

Visionneur d'état

Un outil plutôt utile.

Suivez les prochains articles où vous serons proposés plusieurs programmes, en cours d'écriture, dont vous pourrez vous inspirer dans vos réalisations.

L'exécution des programmes qui requièrent un accès au port parallèle doit se faire avec les privilèges de super-utilisateurs (root).