\documentclass[a4paper,11pt]{article} % \listfiles % pour le debug \usepackage[french]{babel} \usepackage[utf8]{inputenc} \usepackage[T1]{fontenc} % XXX \usepackage{lipsum} \usepackage{makeidx} \usepackage{listings} % \usepackage{color} % \usepackage{url} \usepackage{xspace} \usepackage[verbose]{layout} \makeindex % ------------------------------------------------------------------- \title{Floating images processing} \author{tTh} \begin{document} \maketitle \section{Image flottante ?} De quoi parle-t-on exactement ? \vspace{1em} Traditionnellement, les valeurs des pixels dans les images informatiques sont mémorisées sur 8 bits, un octet\index{octet}, soit 256 valeurs différentes. Ceci dit, on trouve parfois des images codées sur 16 bits par composante, mais c'est loin d'être le cas général. J'ai donc souhaité aller plus loin, et coder chaque canal de chaque pixel en virgule flottante sur 32bits, le type \texttt{float}\index{float} du langage C. % ------------------------------------------------------------------- \tableofcontents \pagebreak % ------------------------------------------------------------------- \section{Example}\index{example}\label{example} Pour commencer par quelques chose de simple, nous allons créer une image RGB\index{RGB} complètement noire, puis l'enregistrer dans un fichier \texttt{.fimg}\index{.fimg}, un format complètement inconnu, puisque je viens de l'inventer à l'instant même. Tout d'abord, nous devons déclarer et garnir quelques variables pour gérer la machinerie interne. \begin{verbatim} int width = 640, height = 480; char *fname = "exemple.fimg"; FloatImg fimg; \end{verbatim} Ensuite, nous enchainerons trois étapes : création de l'image en mémoire centrale, initialisations des valeurs de pixel à 0.0, et pour conclure, enregistrement dans un fichier. \begin{verbatim} foo = fimg_create(&fimg, width, height, 3); if (foo) { fprintf(stderr, "create floatimg -> %d\n", foo); exit(1); } fimg_clear(&fimg); foo = fimg_dump_to_file(&fimg, fname, 0); if (foo) { fprintf(stderr, "dump fimg -> %d\n", foo); exit(1); } \end{verbatim} Une fois ce code enrobé dans un \texttt{main()}, compilé et exécuté, nous pouvons entrevoir, grâce au logiciel \texttt{fimgstats} (voir page \pageref{fimgstats}), le résultat sous forme de chiffres divers, et/ou inutiles~: \begin{verbatim} $ ./fimgstats quux.img ----------- numbers from 'quux.img' : 640 480 3 0x7f3718c4f010 0x7f3718d7b010 0x7f3718ea7010 surface 307200 mean values: R 0.000000 G 0.000000 B 0.000000 A 0.000000 max value 0.000000 \end{verbatim} Vous trouverez dans le répertoire \texttt{tools/}\index{tools/} d'autres exemples de mise en œuvre des fonctions disponibles sous formes d'outils en ligne de commande, décrits page \pageref{outils}. % ------------------------------------------------------------------- \section{Installation} Pour le moment, la procédure d'installation est un peu rude, pour ne pas dire clairement sommaire. Un script \texttt{build.sh} permet de construire approximativement le bouzin. Il est loin d'être parfait. \vspace{1em} Si le résultat vous semble correct, vous pouvez copier les deux fichiers \texttt{floatimg.h} et \texttt{libfloatimg.a} dans un emplacement approprié, par exemple \texttt{/usr/local/include} et \texttt{/usr/local/lib}. % ------------------------------------------------------------------- \section{Utilisation} Classiquement, il y a un fichier à inclure, \texttt{floatimg.h}, contenant un certain nombre de définition de structures, de macros, de constantes\footnote{À l'ancienne, via le pré-processur} et les prototypes des fonctions utilisables. \vspace{1em} Au niveau du code source, ces fonctions sont approximativement classées en deux catégories : \texttt{lib/} et \texttt{funcs/}. La première contient les choses qui sont relativement figées, et la seconde celles qui risquent de bouger. Cette classification est en fait arbitraire. \subsection{Structures, macros\dots} Les pixels flottants d'une image résidant en mémoire centrale sont décrits par un ensemble de données (certains appelent ça des \textsl{metadats}) regroupées dans une jolie structure que nous allons examiner dès maintenant. \begin{verbatim} /* in memory descriptor */ typedef struct { int width; int height; int type; float fval; int count; float *R, *G, *B, *A; int reserved; } FloatImg; \end{verbatim}\index{FloatImg} Les deux premiers champs sont \textsl{obvious}. Le troisième est le type d'image : pour le moment, il y en a trois qui sont définis\footnote{et plus ou moins bien gérés\dots} : gris, rgb et rgba\index{rgba}. \begin{verbatim} #define FIMG_TYPE_GRAY 1 #define FIMG_TYPE_RGB 3 #define FIMG_TYPE_RGBA 4 \end{verbatim} Les deux champs suivants (fval et count) sont à la disposition du yuser qui peut jouer avec à loisir. Et pour finir dans la joie, nous avons les pointeurs vers les différents \textsl{pixmaps} de l'image. \subsection{lib/}\index{lib/} Première chose, la gestion dynamique de la mémoire occupées par tous ces pixels flottants est faite par ces deux fonctions~: \begin{verbatim} int fimg_create(FloatImg *fimg, int w, int h, int type); int fimg_destroy(FloatImg *fimg); \end{verbatim} Les types d'images actuellement gérés sont les trois grands classiques : gray, rgb et rgba. Il y a les constantes adéquates dans \texttt{floatimg.h}. Les codes d'erreur sont disparates et non documenté. \vspace{1em} Bon, vous avez une image latente, et vous souhaité dessiner dessus (ou dedans ?) avec vos encres flottantes ? \subsection{funcs/}\index{funcs/} Une bonne partie de ces fonctions est indéterministe. Ce qui veut dire, en langage de tous les soirs, que ça risque de ne pas être la même chose dans l'avenir. % ------------------------------------------------------------------- \section{Les outils}\label{outils} \textsl{3615mavie} : sur des projets comme celui-ci, qui travaillent in-fine sur des objets que l'on peut considérer comme « physiques », il est important de passer à une utilisation normale\footnote{Il y a une vie en dehors de git.} et construire des trucs qui mettent en action le code primitif. \vspace{1em} Ces machins ont en commun deux options bien pratiques~: \texttt{-h} pour avoir un résumé des options disponibles et \texttt{-v} qui augmente la puissance de bavardage. Dans un avenir incertain, il existera des pages de man\index{man}. \subsection{mkfimg}\index{mkfimg}\label{mkfimg} Création d'un fichier contenant une image de teinte constante. \subsection{fimgstats}\index{fimgstats}\label{fimgstats} Affichage de quelques valeurs calculées à partir d'un fichier \texttt{.fimg}\index{.fimg}. \subsection{fimg2png et fimg2pnm} \index{fimg2png}\label{fimg2png} \index{fimg2pnm}\label{fimg2pnm} Deux petits proggies pour exporter notre format\index{.fimg} secret vers des choses plus directement utilisables. % ------------------------------------------------------------------- \section{Video for Linux}\index{v4l2} Donc, maintenant, nous savons un peu tripoter ces images flottantes. Et nous devons nous poser une question fondamentale\footnote{primitive ?} sur la provenance de ces données prétendant être des images. \vspace{1em} En fait, notre désir secret est la découverte des choses cachées du monde qui nous entoure. Nous voulons des images du \textbf{réel} et pour cela, l'outil le plus commun, le plus répandu, est la webcam\index{webcam}. L'universelle webcam. Et l'incontournable v4l2. % ------------------------------------------------------------------- \section{Et pour la suite ?} En fait, je fait de la photo par la méthode du « cumul » depuis plusieurs années. Une webcam\index{webcam}, un Linux\index{Linux}, et ça \textsl{juste marche}. Sauf que c'est quand même un peu galère à déplacer, il faut avoir un shell pour déclencher, c'est pas facile à utiliser en mode portnawak\dots % ------------------------------------------------------------------- \printindex \end{document}