FloatImg4PythonBinding/doc/the_floatimg_hack.tex

191 lines
6.0 KiB
TeX
Raw Normal View History

2019-08-07 11:10:12 +02:00
\documentclass[a4paper,11pt]{article}
2019-05-20 08:47:13 +02:00
% \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
% -------------------------------------------------------------------
2019-08-02 04:22:48 +02:00
\title{Floating images processing}
2019-05-20 08:47:13 +02:00
\author{tTh}
\begin{document}
\maketitle
2019-08-02 04:22:48 +02:00
\section{Image flottante ?}
De quoi parle-t-on exactement ?
2019-08-03 14:27:21 +02:00
\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.
2019-08-02 04:22:48 +02:00
% -------------------------------------------------------------------
2019-05-20 08:47:13 +02:00
\tableofcontents
2019-08-03 14:27:21 +02:00
\pagebreak
2019-05-20 08:47:13 +02:00
2019-08-02 04:22:48 +02:00
% -------------------------------------------------------------------
2019-08-07 11:52:04 +02:00
\section{Example}\index{example}\label{example}
2019-05-20 08:47:13 +02:00
2019-08-07 11:10:12 +02:00
Pour commencer par quelques chose de simple,
2019-08-03 14:27:21 +02:00
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;
2019-08-06 21:22:12 +02:00
char *fname = "exemple.fimg";
2019-08-03 14:27:21 +02:00
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}
2019-08-07 11:10:12 +02:00
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}.
2019-08-03 14:27:21 +02:00
% -------------------------------------------------------------------
2019-08-07 11:10:12 +02:00
\section{Installation}
2019-08-03 14:27:21 +02:00
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.
2019-08-06 21:22:12 +02:00
\vspace{1em}
2019-08-03 14:27:21 +02:00
2019-08-06 21:22:12 +02:00
Si le résultat vous semble correct, vous pouvez copier
2019-08-07 11:52:04 +02:00
les deux fichiers \texttt{floatimg.h} et \texttt{libfloatimg.a}
dans un emplacement
2019-08-06 21:22:12 +02:00
approprié, par exemple
\texttt{/usr/local/include} et \texttt{/usr/local/lib}.
2019-08-03 14:27:21 +02:00
2019-08-02 04:22:48 +02:00
% -------------------------------------------------------------------
2019-08-07 11:10:12 +02:00
\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.
2019-08-07 11:52:04 +02:00
\vspace{1em}
2019-08-07 11:10:12 +02:00
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{lib/}\index{lib/}
2019-08-07 11:52:04 +02:00
Première chose, la gestion dynamique de la mémoire occupées
par tous ces pixels flottants est faite par ces deux fonctions~:
2019-08-07 11:10:12 +02:00
\begin{verbatim}
2019-08-07 11:52:04 +02:00
int fimg_create(FloatImg *fimg, int w, int h, int type);
2019-08-07 11:10:12 +02:00
int fimg_destroy(FloatImg *fimg);
\end{verbatim}
2019-08-07 11:52:04 +02:00
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}.
2019-08-07 11:10:12 +02:00
\subsection{funcs/}\index{funcs/}
% -------------------------------------------------------------------
\section{Les outils}\label{outils}
2019-05-20 08:47:13 +02:00
2019-08-03 14:27:21 +02:00
\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.
2019-08-06 21:22:12 +02:00
% \vspace{1em}
2019-08-03 14:27:21 +02:00
\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}.
% -------------------------------------------------------------------
\section{Video for Linux}\index{v4l2}
Donc, maintenant, nous savons un peu tripoter des images flottantes.
Et nous devons nous poser une question fondamentale\footnote{primitive ?}
2019-08-06 21:22:12 +02:00
sur la provenance de ces données prétendant être des images.
2019-08-03 14:27:21 +02:00
% -------------------------------------------------------------------
\section{Et pour la suite ?}
2019-08-06 21:22:12 +02:00
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\dots
2019-05-20 08:47:13 +02:00
% -------------------------------------------------------------------
\printindex
\end{document}