FloatImg4PythonBinding/doc/the_floatimg_hack.tex

863 lines
28 KiB
TeX
Raw Normal View History

\documentclass[a4paper,10pt]{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}
2019-09-05 15:51:30 +02:00
\usepackage{babel}
\usepackage{pifont} % caractères rigolos
\usepackage{enumitem}
2020-02-13 20:44:22 +01:00
\setitemize[1]{label={\ding{87}}}
2019-09-05 15:51:30 +02:00
\frenchbsetup{CompactItemize=false}
2019-05-20 08:47:13 +02:00
% \usepackage{color}
% \usepackage{url}
\usepackage{xspace}
\usepackage[verbose]{layout}
2020-02-11 17:33:38 +01:00
\setlength{\textheight}{640pt}
\setlength{\textwidth}{422pt}
\setlength{\marginparwidth}{10pt}
2019-05-20 08:47:13 +02:00
\makeindex
2019-11-12 00:19:32 +01:00
% ------ a few new commands
\newcommand{\interparagraphe { \vspace{60pt} } }
2019-05-20 08:47:13 +02:00
% -------------------------------------------------------------------
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 ?}
2019-09-07 11:05:37 +02:00
Mais de quoi parle-t-on exactement ?
2019-11-12 00:19:32 +01:00
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
2020-02-11 17:33:38 +01:00
\texttt{float}\index{float} du langage C. Ce qui correspond
à la norme IEEE 754-1985.
2019-11-12 00:19:32 +01:00
2019-09-11 06:19:32 +02:00
\vspace{1em}
Attention, tout le code que nous allons voir ensemble est en
perpétuelle évolution\footnote{voir page \pageref{TODO}},
2019-11-29 17:06:40 +01:00
et sa fiablité (surtout sur certains aspects mathématiques)
reste à démontrer\index{valgrind}.
2019-11-12 00:19:32 +01:00
Mais le service après-vente est assez réactif. Du moins
2019-11-29 17:06:40 +01:00
pour ceux qui suivent le canal \texttt{\#tetalab} sur le réseau
2019-11-12 00:19:32 +01:00
IRC de Freenode.
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
2020-02-13 12:13:07 +01:00
% XXX \layout
% XXX \pagebreak
2020-02-11 17:33:38 +01:00
2019-08-02 04:22:48 +02:00
% -------------------------------------------------------------------
2020-02-13 20:44:22 +01:00
\section{Théorie}\index{théorie}
XXX\index{XXX}
Pour le moment, seule la quête de l'empirisme absolu a été
visée. Les justifications mathématiques attendent le retour
du schmod777.
% -------------------------------------------------------------------
2020-02-11 17:33:38 +01:00
\section{Premier exemple}\index{exemple}\label{exemple}
2019-05-20 08:47:13 +02:00
2019-09-11 06:19:32 +02:00
\textsc{FloatImg} a débuté sous la forme de quelques fonctions
basiques en C, gérant la structure des données d'image en mémoire
2019-11-12 00:19:32 +01:00
et sur disque. Ça a été imaginé de façon presque empirique,
mais nous sommes tous là pour améliorer les choses, dans
la mesure de nos moyes.
2019-09-11 06:19:32 +02:00
Nous allons donc directement rentrer au cœur du problème.
\vspace{1em}
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.
2019-11-29 17:06:40 +01:00
\vspace{1em}
2019-08-03 14:27:21 +02:00
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
2019-11-29 17:06:40 +01:00
en mémoire centrale, initialisation des valeurs de chaque pixel à 0.0,
et pour conclure, enregistrement dans un fichier\footnote{Au format
ésotérique, mais très véloce.} binaire.
2019-08-03 14:27:21 +02:00
\begin{verbatim}
2019-09-11 06:19:32 +02:00
foo = fimg_create(&fimg, width, height, FIMG_TYPE_RGB);
2019-08-03 14:27:21 +02:00
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}
2019-09-11 06:19:32 +02:00
$ ./fimgstats quux.img
2019-08-03 14:27:21 +02:00
----------- 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-09-11 06:19:32 +02:00
Nous avons donc sous la main une mécanique qui ne demande qu'à
faire des trucs futiles et des images qui clignotent.
La suite vers la page \pageref{codaz}.
\vspace{1em}
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
2019-09-11 06:19:32 +02:00
sous formes d'outils en ligne de commande,
2019-11-12 00:19:32 +01:00
lesquels sont décrits en page \pageref{outils}.
2019-08-07 11:10:12 +02:00
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
2019-11-29 17:06:40 +01:00
\textit{Attention, ça devient un peu gore.}
\subsection{Prérequis}
2019-09-11 06:19:32 +02:00
Vous devez, en dehors des outils classiques (bash, gcc, make\dots),
avoir quelques bibliothèques installées\footnote{Les \texttt{-dev}
2020-01-23 12:50:37 +01:00
pour Debian et dérivées}~: libv4l2, libpnglite, libtiff, libnetpbm,
2020-02-11 17:33:38 +01:00
libz,
et probablement d'autres choses.
2019-11-12 00:19:32 +01:00
\vspace{1em}
Il est même quasiment certain que Bash soit indispensable, tout
comme \textsc{gnu}/make\index{make}.
Une connaissance de base de l'utilisation du shell\index{shell}
et de l'écriture de Makefile's sera un plus.
\subsection{Compilation}
2019-08-03 14:27:21 +02:00
Un script \texttt{build.sh} permet de construire approximativement
2019-09-11 06:19:32 +02:00
le bouzin. Il est loin d'être parfait\footnote{Il doit être possible
de faire un Makefile récursif, mais\dots}.
2020-01-23 12:50:37 +01:00
Dans chacun des répertoires à traiter, ce script devrait trouver
un Makefile et un fichier \texttt{t.c} qui est le source de la cible
par défaut du make.
2019-11-12 00:19:32 +01:00
2019-08-06 21:22:12 +02:00
\vspace{1em}
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.
2019-12-21 13:50:15 +01:00
Si le résultat de l'étape compilation vous semble correct,
vous pouvez copier les deux fichiers \texttt{floatimg.h} et \texttt{libfloatimg.a}
dans un emplacement approprié, par exemple
2019-08-06 21:22:12 +02:00
\texttt{/usr/local/include} et \texttt{/usr/local/lib}.
2019-08-03 14:27:21 +02:00
2019-12-21 13:50:15 +01:00
\vspace{1em}
2019-11-12 00:19:32 +01:00
2019-12-21 13:50:15 +01:00
Le script \texttt{install.sh}, à la racine du projet, est censé
faciliter un peu la chose. Il prend également en compte la copie
2020-01-23 12:50:37 +01:00
des divers binaires du dossier \texttt{tools/} (cf. page \pageref{outils})
dans le répertoire prévu à cet effet : \texttt{/usr/local/bin}.
2019-11-12 00:19:32 +01:00
2020-02-11 17:33:38 +01:00
% =================================================================
2019-09-11 06:19:32 +02:00
\section{Utilisation coté codeur}\label{codaz}
2019-08-07 11:10:12 +02:00
2020-02-11 17:33:38 +01:00
Classiquement, il y a un fichier \texttt{.h} à inclure dans chacun
de vos codes source,
2019-12-21 13:50:15 +01:00
\texttt{floatimg.h}, généralement logé dans \texttt{/usr/local/include}
contenant un certain nombre de définition de structures, de macros,
2020-02-11 17:33:38 +01:00
de constantes\footnote{À l'ancienne, via le pré-processeur}
2019-12-21 13:50:15 +01:00
et les prototypes des fonctions utilisables par vos logiciels.
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.
2019-08-08 17:16:20 +02:00
\subsection{Structures, macros\dots}
2019-08-10 18:37:52 +02:00
Les pixels flottants d'une image résidant en mémoire centrale
sont décrits par un ensemble
2019-12-21 13:50:15 +01:00
de données (certains appelent ça des \textsl{metadatas}) regroupées
2019-08-10 18:37:52 +02:00
dans une jolie structure que nous allons examiner dès maintenant.
2019-08-08 17:16:20 +02:00
\begin{verbatim}
2019-08-10 18:37:52 +02:00
/* in memory descriptor */
2019-08-08 17:16:20 +02:00
typedef struct {
int width;
int height;
int type;
float fval;
int count;
float *R, *G, *B, *A;
int reserved;
} FloatImg;
\end{verbatim}\index{FloatImg}
2019-08-10 18:37:52 +02:00
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}.
2020-02-11 17:33:38 +01:00
Les constantes adéquates sont dans \texttt{floatimg.h}
2019-08-10 18:37:52 +02:00
\begin{verbatim}
#define FIMG_TYPE_GRAY 1
#define FIMG_TYPE_RGB 3
#define FIMG_TYPE_RGBA 4
2020-02-11 17:33:38 +01:00
#define FIMG_TYPE_RGBZ 99
2019-08-10 18:37:52 +02:00
\end{verbatim}
Un peu plus loin, nous avons les pointeurs vers les
différents \textsl{pixmaps} de l'image. En principe l'organisation
2019-12-21 13:50:15 +01:00
interne de ces zones est improbable, puisque elle dérive
2020-02-11 17:33:38 +01:00
d'idées approximatives. C'est cette utilisation constructive de larache
qui fait que seuls les champs documentés de cette structure ne sont
pas explosifs.
2019-12-21 13:50:15 +01:00
\vspace{1em}
2019-08-10 18:37:52 +02:00
2020-02-11 17:33:38 +01:00
Mais revenons aux choses sérieuses\dots
Les deux champs suivants (fval et count) sont à la disposition du
\textsl{yuser}
qui peut jouer avec à loisir pour faire, par exemple, ce genre de
2019-12-21 13:50:15 +01:00
chose : imaginons un périphérique de capture qui nous fournisse des
images en gris sur 4 bits. Et que nous voulions cumuler\index{cumul}
quelques images...
2019-12-21 13:50:15 +01:00
\vspace{1em}
2019-08-10 18:37:52 +02:00
Le champ \textsl{count} sera mis à 0 et
le champ \textsl{fval} sera initialisé à 15.0
2019-12-21 13:50:15 +01:00
(qui est la valeur maximale que peut renvoyer le capteur).
Ensuite, dans la boucle capture/cumul, \textsl{count} sera
incrémenté à chaque passe, et nous aurons donc, en finale,
2019-08-28 21:08:59 +02:00
toutes les informations nécessaires pour exploiter au mieux la dynamique
2019-12-21 13:50:15 +01:00
de notre image dans les étapes ultérieures, puisque la valeur
maximale théorique est égale à $fval * count$.
2019-08-10 18:37:52 +02:00
2020-02-11 17:33:38 +01:00
Une bonne partie des fonctions que nous allons voir 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.
2019-12-21 13:50:15 +01:00
2020-02-11 17:33:38 +01:00
% ----------------------------------
2019-08-10 18:37:52 +02:00
2020-02-11 17:33:38 +01:00
\subsection{Les fondations}\index{lib/}
2019-08-07 11:10:12 +02:00
2020-02-11 17:33:38 +01:00
La première chose à voir est la gestion dynamique de la mémoire occupée
par tous ces pixels flottants, ce est un sujet parois
délicat\footnote{GC}.
Elle est donc faite, à la base, 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}
2020-02-11 17:33:38 +01:00
L'appelant doit lui-même gérer le descripteur d'image (une structure
C décrite plus haur) en le considérant comme un type semi-opaque dont
la forme peut varier. Certains membres de cette structure sont
documentés dans ce document, et les autres sont dangereux à
toucher. Les types d'images actuellement gérés sont les trois grands
classiques : gray, rgb et rgba. et expliquées quelques lignes plus haut.
2019-08-10 18:37:52 +02:00
\vspace{1em}
2020-02-11 17:33:38 +01:00
C'est bien beau d'être enfin résident en mémoire centrale, mais
pouvoir aussi exister à long terme en étant stocké dans la matrice
est tout aussi pertinent. Il y a deux opérations qui supportent le
reste des transits ram/ps.
\begin{verbatim}
int fimg_dump_to_file(FloatImg *fimg, char *fname, int notused);
int fimg_load_from_dump(char *fname, FloatImg *where);
\end{verbatim}
Recharger une image depuis un fichier nécessite que celle-ci et
l'image de destination en mémoire
ait précisément les mêmes caractéristiques
(taille, type...), donc l'image en ram doit être
pré-allouée. Mias comment peut-on connaitre ces valeurs ?
\begin{verbatim}
int fimg_fileinfos(char *fname, int *datas);
\end{verbatim}
% _________
\subsection{Dessiner}
2019-08-31 18:06:09 +02:00
Bon, vous avez une image latente, et vous souhaitez dessiner dessus
(ou dedans ?) avec vos encres flottantes ?
2020-02-11 17:33:38 +01:00
Il y a des fonctions pour ça, par exemple~:
2019-08-07 11:52:04 +02:00
2019-10-19 07:03:47 +02:00
\begin{verbatim}
int fimg_plot_rgb (FloatImg *head, int x, int y,
float r, float g, float b);
\end{verbatim}
Les paramètres sont explicites, mais leur validité doit être
sévèrement controlée par l'appelant. Il y a une fonction
soeur, \texttt{fimg\_add\_rgb}\index{fimg\_add\_rgb},
2020-02-11 17:33:38 +01:00
qui ajoute du rgb à un pixel, laquelle fonction a d'ailleurs été
2020-01-23 12:50:37 +01:00
à la base de la seconde génération de la
2019-11-29 17:06:40 +01:00
photographie\index{photographie} en cumul\index{cumul}.
2020-02-11 17:33:38 +01:00
% ----------------------------------
\subsection{Contraste}\index{contraste}\label{contraste}
2019-11-29 17:06:40 +01:00
Certaines opérations d'ajustement du contraste d'une image
semblent cohérents avec la notion d'image flottante.
Certains d'entre eux, les plus simples, sont disponibles.
Ils prennent chacun trois paramètres, d'abord les images
source et destination (\texttt{* FloatImg}), et le troisième
est un nombre en double précision donnant la valeur
maximale \textsl{supposée} de l'image source.
\begin{verbatim}
/* source in lib/contrast.c */
int fimg_square_root(FloatImg *s, FloatImg *d, double maxval);
int fimg_power_2(FloatImg *s, FloatImg *d, double maxval);
int fimg_cos_01(FloatImg *s, FloatImg *d, double maxval);
2020-01-10 17:22:58 +01:00
int fimg_cos_010(FloatImg *s, FloatImg *d, double maxval);
2019-11-29 17:06:40 +01:00
\end{verbatim}
Rappelons qu'il est possible pour un logiciel applicatif
comme \texttt{grabvidseq} (Cf page \pageref{grabvidseq})
de renseigner deux champs du descripteur d'image avec des
données pertinentes.
Ces deux champs sont \textit{fval} et \textit{count}.
Dans ce cas particulier, le premier indique la valeur
maximale du capteur, et le second sert à compter le
nombre de capture\footnote{Et c'est bien géré aussi
dans l'upscaling.} effectuées.
2020-02-11 17:33:38 +01:00
\vspace{1em}
2020-01-10 17:22:58 +01:00
La fonction
\texttt{fimg\_normalize(FloatImg *fi, double maxima, int notused);}
tente de gérer ce cas d'utilisation. Son ajout au captureur d'images
floues sera probablement le bienvenue. Je me suis bien rendu compte
à l'usage\footnote{Une histoire de \textit{fonderie}, un logiciel
censé faire des films flous à partir d'images floues} en situation
festive qu'il manquait des données dans la chaine de traitement.
2019-11-29 17:06:40 +01:00
\vspace{1em}
2019-11-29 20:35:23 +01:00
L'autre façon de procéder est d'explorer notre image à la
recherche de la valeur maximale.
La fonction \texttt{float fimg\_get\_maxvalue(\&fimg)} est
faite pour ça.
C'est actuellement la méthode utilisée par l'outil qui
2020-01-10 17:22:58 +01:00
sert à faire les modifications de contraste (page \pageref{fimgfx}).
2019-11-29 20:35:23 +01:00
\vspace{1em}
2019-11-29 17:06:40 +01:00
La prochaine étape consistera à trouver une façon de faire
une égalisation\index{égalisation} par histogramme\index{histogramme}
qui respecte, dans toute sa futilité, le concept\index{concept}
de pixel flottant.
2019-10-19 07:03:47 +02:00
2020-02-11 17:33:38 +01:00
% ----------------------------------
2019-08-07 11:10:12 +02:00
2020-02-13 20:44:22 +01:00
\subsection{Géométrie}\index{géométrie}\label{geometrie}
Très prochainement, le retour du blitter\index{blitter}.
\begin{verbatim}
/* module funcs/geometry.c */
int fimg_halfsize_0(FloatImg *src, FloatImg *dst, int notused);
\end{verbatim}
Attention lors de l'appel, le descripteur \texttt{dst} ne doit pas
contenir d'image, et doit être effacé avec un bon
\texttt{memset(\&result, 0, sizeof(FloatImg));} bien senti.
Et le résultat est très moyen : il n'y a pas d'interpolation.
% ----------------------------------
2020-02-11 17:33:38 +01:00
\subsection{Exportation}\index{export}\label{export}
2019-11-29 20:35:23 +01:00
2020-02-11 17:33:38 +01:00
Notre format de fichier étant totalement inconnu, il nous
faut bien exporter nos images en quelque chose de plus
connu. Bien entendu, c'est toujours affaire de compromis
entre précision de valeurs et taille des fichiers.
\subsubsection{Vers PNM}\index{PNM}
Nous avons ici 16 bits par composante, mais au prix
d'une taille énorme sur les fichiers. D'autre coté,
l'utilisation du codage \textsc{ascii}\index{ascii}
(alors qu'on peut mettre du binaire) y est pour quelque chose.
\begin{verbatim}
int fimg_save_as_pnm(FloatImg *head, char *fname, int flags);
\end{verbatim}
2019-08-28 21:08:59 +02:00
2020-02-11 17:33:38 +01:00
Le bit \texttt{0} du paramètre \texttt{flags} mis à \texttt{1} demande
à la fonction de faire la mise à l'échelle avec le couple
\textsl{fvalue/count} décrit plus haut dans cette doc.
Et si il est à zéro, c'est la fonction de recherche de valeur
maximale (cf page \pageref{contraste}) qui est utilisée.
2019-08-07 11:10:12 +02:00
2020-02-11 17:33:38 +01:00
Les autres bits ne sont pas utilisés et doivent être à zéro.
\subsubsection{Vers PNG}\index{PNG}
Actuellement, uniquement en 8 bits par composante, mais bonne
compression.
\subsubsection{Vers TIFF}\index{TIFF}
To be done\index{XXX}
\subsection{Utilitaires}
\begin{verbatim}
int parse_WxH(char *str, int *pw, int *ph)
int parse_double(char *str, double *dptr)
int format_from_extension(char *fname)
\end{verbatim}
To be continued\index{XXX}
\subsection{Effets}\index{sfx}
2020-02-13 12:13:07 +01:00
Quelques routines qui servent futilement à \textsl{brotcher} les images.
\begin{verbatim}
int fimg_killcolors_a(FloatImg *fimg, float fval);
int fimg_killcolors_b(FloatImg *fimg, float fval);
\end{verbatim}
2020-02-11 17:33:38 +01:00
% ----------------------------------
\subsection{Filtrages}
To be done\index{XXX}
% ----------------------------------
\subsection{Exemple de fonction}\index{exemple}
2019-10-31 15:02:27 +01:00
Nous allons écrire une fonction qui va faire quelque chose
à partir d'une image source et d'une valeur, et écrire le
résultat dans une image de destination.
Pour simplifier les choses, nous n'allons traiter que les
images de type \textsc{FIMG\_TYPE\_RGB}, de loin le plus
répandu.
\begin{verbatim}
int fimg_example(FloatImg *s, FloatImg *d, float value)
{
int size, index;
if ( s->type!=FIMG_TYPE_RGB || d->type!=FIMG_TYPE_RGB) {
return -1;
}
size = s->width * s->height;
for (idx=0; idx<size; idx++) {
d->R[idx] = s->R[idx] - value;
d->G[idx] = s->G[idx] - value;
d->B[idx] = s->B[idx] - value;
}
return 0;
}
\end{verbatim}
Je vous laisse imaginer les dégats que peut faire cette
fontion en utilisation réelle. Mieux, je vous propose
d'essayer par vous-même.
2019-10-31 15:02:27 +01:00
En particulier tout le reste du code qui suppose qu'un pixel
ne peut \textbf{pas} être négatif.
Vous pouvez aussi remarquer qu'il n'y a pas de controle
2020-01-14 18:00:10 +01:00
de cohérence sur les dimensions des deux images, malgré l'existence
de fonctions prévues à cet effet..
2019-10-31 15:02:27 +01:00
2019-08-07 11:10:12 +02:00
% -------------------------------------------------------------------
\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-10 18:37:52 +02:00
\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}.
2019-08-03 14:27:21 +02:00
2020-02-11 17:33:38 +01:00
% ---------------------
2019-08-03 14:27:21 +02:00
\subsection{mkfimg}\index{mkfimg}\label{mkfimg}
2019-09-29 01:57:25 +02:00
Création d'un fichier contenant une image de « teinte » constante
(ou pas).
Cette notion de teinte est assez inconsistante pour le moment,
2020-02-11 17:33:38 +01:00
mais ça n'est pas si grave que ça.
2019-09-29 01:57:25 +02:00
\begin{verbatim}
2020-02-11 17:33:38 +01:00
tth@debian:~/Devel/FloatImg/tools$ ./mkfimg -h
2019-09-29 01:57:25 +02:00
Usage: mkfimg [options] quux.fimg width height
-k N.N give a float parameter
2020-02-13 12:13:07 +01:00
-t type howto make the pic
2019-09-29 01:57:25 +02:00
black, drand48...
-v increase verbosity
\end{verbatim}
2019-08-03 14:27:21 +02:00
2020-02-13 12:13:07 +01:00
La plupart des types d'image générée prennent un paramètre flottant qui
devra être donné avec l'option \texttt{-k F.F} avec une valeur par défaut
à $1.0$.
\begin{description}
\item [black/gray/grey:] efface avec 0.0 (black) ou avec la valeur
\texttt{-k} (gray).
\item [drand48:] beaucoup de bruit dans chacun des canaux.
\item [hdeg/vdeg:] dégradé du noir au blanc (relatif à \texttt{-k}).
\end{description}
2020-02-11 17:33:38 +01:00
% ---------------------
\subsection{png2fimg}\index{png2fimg}\label{png2fimg}
Grosse panne à réparer.
\begin{verbatim}
tth@debian:~/TMP/floatimg$ png2fimg A.png foo.fimg
error in 'fimg_create_from_png' : read png -> -1 File error
png2fimg : err -1, abort.
\end{verbatim}
2019-12-21 13:50:15 +01:00
Il faut peut-être envisager le passage à \texttt{libpng}\index{libpng}.
2019-08-03 14:27:21 +02:00
\subsection{fimgstats}\index{fimgstats}\label{fimgstats}
2019-09-29 13:45:33 +02:00
Affichage de quelques valeurs calculées à partir du contenu d'un fichier
2019-08-03 14:27:21 +02:00
\texttt{.fimg}\index{.fimg}.
2019-09-11 06:19:32 +02:00
\begin{verbatim}
usage : fimgstats [options] file.fimg
-c make a machinable csv
-v increase verbosity
\end{verbatim}
À vrai dire, je ne sais pas encore quelles métriques seront utiles
2019-09-29 13:45:33 +02:00
en première approche, alors commençont par le plus simple,
les valeurs moyennes de chaque composante.
2019-10-31 15:02:27 +01:00
Puis nous rajouterons\footnote{Les patchs sont les bienvenus}
le calcul de la variance\index{variance}. Les compétences
de \texttt{schmod777} sont attendues au dd2\index{dd2}.
2020-02-11 17:33:38 +01:00
% ---------------------
2019-11-29 17:06:40 +01:00
2020-02-11 17:33:38 +01:00
\subsection{fimgfx}\index{fimgfx}\label{fimgfx}
2020-02-11 17:33:38 +01:00
Ce programme, \textit{en cours de création\index{XXX}}, applique
un effet spécial à une image.
À l'heure actuelle\footnote{janvier 2019, vers 13:37}, nous avons
2019-12-21 13:50:15 +01:00
déja quelques ajustements basiques de contraste, qui ne tiennent
pas vraiment compte du contenu de l'image.
\begin{verbatim}
tth@daubian:~/Devel/FloatImg/tools$ ./fimgfx -v -h
--- fimg special effects ---
cos01 cos010 pow2 sqrt
\end{verbatim}
2020-02-11 17:33:38 +01:00
Certaines de ces opérations ont besoin d'un paramètre flottant.
Celui-ci peut être fixé avec l'option \texttt{-k}.
Une liste détaillée des opérations possibles
sera lisible avec le sélecteur \texttt{-L}.
2020-02-13 12:13:07 +01:00
\begin{description}
\item [Ajustements de contraste:] cos01 cos010 pow2 sqrt
\item [Distorsions chromatiques:] gray0
\item [Déformations géométriques:] r90
\end{description}
2020-02-11 17:33:38 +01:00
2019-08-28 21:08:59 +02:00
\subsection{fimgops}\index{fimgops}\label{fimgops}
2019-11-29 17:06:40 +01:00
Quelques opérations diverses entre deux images, qui doivent être
2019-11-20 11:12:16 +01:00
de la même taille, et du même type \textsl{pour le moment,
uniquement RGB}.
2019-08-28 21:08:59 +02:00
2019-09-11 06:19:32 +02:00
\begin{verbatim}
2019-09-11 18:58:39 +02:00
usage:
2019-09-11 06:19:32 +02:00
fimgops [options] A.fimg B.fimg operator D.fimg
2019-09-11 18:58:39 +02:00
operators:
add 1
sub 2
mix 3
mul 4
2019-11-20 11:12:16 +01:00
mini 5
maxi 6
2019-09-11 18:58:39 +02:00
options:
-g convert output to gray
-k N.N set float value
-v increase verbosity
2019-09-11 06:19:32 +02:00
\end{verbatim}
2019-08-28 21:08:59 +02:00
2019-11-20 11:12:16 +01:00
Pour des operateurs paramétrable (comme \texttt{mix}), le paramêtre
flottant doit être fourni en utilisant l'option \texttt{-k}.
2019-11-12 00:19:32 +01:00
La véracité mathématique n'est pas garantie.
2019-08-28 21:08:59 +02:00
\subsection{fimg2png, fimg2pnm, fimg2tiff}
2019-08-10 18:37:52 +02:00
\index{fimg2png}\label{fimg2png}
\index{fimg2pnm}\label{fimg2pnm}
\index{fimg2tiff}\label{fimg2tiff}
Quelques petits proggies pour exporter notre format\index{.fimg} secret
vers des choses plus directement utilisables. À condition que le
2020-02-11 17:33:38 +01:00
code soit écrit et documenté.
2019-12-21 13:50:15 +01:00
\vspace{1em}
2019-11-12 00:19:32 +01:00
D'un autre coté, écrire un greffon d'import/export pour
2020-01-14 18:00:10 +01:00
Gimp\index{Gimp} ou Imagemagick\index{Imagemagick} ou Krita\index{Krita}
2019-11-12 00:19:32 +01:00
ne devrait pas être trop difficile. Des volontaires ?
2019-08-10 18:37:52 +02:00
\subsection{fimg2gray}\index{fimg2gray}\label{fimg2gray}
Nous avons vu dans ce document que chaque image flottante pouvait
avoir plusieurs plans de réalité. Il ne faut en négliger aucun.
\vspace{1em}
2019-08-10 18:37:52 +02:00
Il faut quand même deviner que pour passer de l'espace RGB\index{RGB}
à une abstraction linéaire mono-dimensionnelle, il existe une foultitude
de méthodes, toutes plus légitimes que les autres.
2019-08-10 18:37:52 +02:00
2019-08-28 21:08:59 +02:00
% -------------------------------------------------------------------
\section{TODO}\index{TODO}\label{TODO}
Il reste plein de choses à faire pour que ce soit vraiment utilisable.
\vspace{1em}
2019-09-05 15:51:30 +02:00
\begin{itemize}
2019-08-28 21:08:59 +02:00
\item Import/export au format \textsc{tiff}\index{tiff}.
\item Remplacer le « fait-maison » par \textsc{libnetpnm}\index{pnm}.
\textsl{[en cours]}.
\item Compléter les traitements mathémathiques (eg le gamma\index{gamma}).
2020-01-10 17:22:58 +01:00
\item Formaliser les codes d'erreur. \textbf{Urgent}.
2019-11-29 17:06:40 +01:00
\end{itemize}
2019-08-28 21:08:59 +02:00
2019-09-11 06:19:32 +02:00
% -------------------------------------------------------------------
2020-02-11 17:33:38 +01:00
\section{Exemples pour yusers}\index{exemple}
2019-09-11 06:19:32 +02:00
2019-11-12 00:19:32 +01:00
Nous allons \textsl{essayer d'improviser} un exemple presque réel,
2019-11-29 17:06:40 +01:00
avec un peu de rache\index{rache} dedans. Ce qui est autorisé dans
2020-01-23 12:50:37 +01:00
les exemples, mais dans la vrai vie, il ne faut jamais négliger
le traitement des éventuelles erreurs.
2019-11-12 00:19:32 +01:00
\vspace{1em}
Nous savons générer une image contenant des pixels aux valeurs
probablement aléatoires (drand48\index{drand48}). Que se passe-t-il si
nous faisons la somme de plusieurs centaines\footnote{Des erreurs toxiques ?}
de ces images ?
2019-09-11 06:19:32 +02:00
\begin{verbatim}
#!/bin/bash
ACCU="quux.fimg"
TMPF="tmp.fimg"
2019-11-12 00:19:32 +01:00
DIMS="320 240"
2019-09-11 06:19:32 +02:00
2019-11-12 00:19:32 +01:00
mkfimg $ACCU $DIMS
for i in {0..1000}
2019-09-11 06:19:32 +02:00
do
mkfimg -t drand48 ${TMPF} ${DIMS}
2019-11-12 00:19:32 +01:00
fname=$( printf "xx%04d.pnm" $i )
fimgops $ACCU $TMPF add $ACCU
fimg2pnm -v -g $ACCU $fname
2019-09-11 06:19:32 +02:00
done
2019-11-12 00:19:32 +01:00
convert -delay 10 xx*.pnm foo.gif
2019-09-11 06:19:32 +02:00
\end{verbatim}
2019-11-12 00:19:32 +01:00
Voilà, si les choses se passent mal, vous allez découvrir
2019-11-29 20:35:23 +01:00
que votre \texttt{drand48} n'est pas si drand que ça. Séquence angoisse.
\subsection{Scripts}\index{scripts}\label{scripts}
2019-11-12 00:19:32 +01:00
2020-02-13 12:13:07 +01:00
Le script bash\index{bash} \texttt{shoot.sh} est un front-end rudimentaire
vers le programme de capture d'image décrit page \pageref{grabvidseq}.
Il utilise deux fichiers dans le répertoire de travail~:
\textit{reglages} et \textit{compteur}.
2019-10-30 20:09:32 +01:00
2020-01-23 12:50:37 +01:00
\subsection{Fonderie}\index{fonderie}\label{fonderie}
2020-02-13 12:13:07 +01:00
Projet externe en cours d'expérimentation.
2020-01-23 12:50:37 +01:00
2019-08-03 14:27:21 +02:00
% -------------------------------------------------------------------
\section{Video for Linux}\index{v4l2}
2019-08-10 18:37:52 +02:00
Donc, maintenant, nous savons un peu tripoter ces images flottantes.
2019-08-03 14:27:21 +02:00
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-10 18:37:52 +02:00
\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,
2019-08-12 01:53:17 +02:00
est la webcam\index{webcam}. L'universelle webcam. Et l'incontournable
v4l2.
2019-08-03 14:27:21 +02:00
\subsection{grabvidseq}\index{grabvidseq}\label{grabvidseq}
2019-11-12 00:19:32 +01:00
Un logiciel en évolution, qui permet déja la capture d'images en
\textsl{longue pose} selon la méthode du cumul\index{cumul}, et
devrait bientôt retrouver sa capacité à enregistrer des
séquences.
\begin{verbatim}
tth@debian:~/Devel/FloatImg/v4l2$ ./grabvidseq -h
options :
2020-01-23 12:50:37 +01:00
-c quux contrast adjustement
-d /dev/? select video device
-g convert to gray
-n NNN how many frames ?
-O ./ set Output dir
-o bla set output filename
2019-10-30 20:09:32 +01:00
-p NN.N delay between frames
-s WxH size of capture
-u try upscaling...
-v increase verbosity
2019-11-12 00:19:32 +01:00
-X arg Xperiment option
\end{verbatim}
2019-10-31 15:02:27 +01:00
La plupart de ces options ont un usage quasi-évident.
2019-10-30 20:09:32 +01:00
L'option \texttt{-s} doit correspondre à une des
2019-10-31 15:02:27 +01:00
résolutions possibles de votre capteur. Le type du
fichier en sortie (option \texttt{-o}) est déterminé par
2019-11-12 00:19:32 +01:00
l'extension, actuellement
seulement \texttt{.fimg} et \texttt{.pnm} sont reconnus.
La conversion en gris (option \texttt{-g}) mérite un
peu plus de travail, et une paramétrisation plus facile.
L'option \texttt{-X} me permet d'intégrer des \textit{fritures}
expérimentales dans le binaire, et ne doit donc pas être
utilisée dans des scripts si on a des visions à long
terme.
2019-10-30 20:09:32 +01:00
\subsubsection{Upscaling}\index{upscaling}\label{upscaling}
La fonction que j'ai appelée \textsl{upscaling} est un petit
hack qui permet de doubler artificiellement la résolution
de l'image, en profitant du fait que l'on est capable
de prendre $N$ images en rafale.
Pour être rigoureux dans la prise de vue, ce $N$ doit
2019-11-29 17:06:40 +01:00
être un multiple de 4, surtout si le nombre de capture est faible.
N'hésitez pas à faire des essais, le résultat est parfois
aléatoire, surtout avec une caméra qui bouge.
2019-11-12 00:19:32 +01:00
\vspace{1em}
\textbf{Là, il manque un schéma\dots}
2019-09-11 06:19:32 +02:00
\subsection{video-infos}\index{video-infos}\label{video-infos}
Que contient, que peut faire mon périphérique \textsl{àlc} ?
2019-10-30 20:09:32 +01:00
Quelles sont ses possibilités de réglage ?
\begin{verbatim}
tth@debian:~/Devel/FloatImg$ v4l2/video-infos -h
Options :
-d select the video device
2019-11-12 00:19:32 +01:00
-K nnn set the K parameter
2019-10-30 20:09:32 +01:00
-l list video devices
-T bla add a title
-v increase verbosity
\end{verbatim}
2020-01-23 12:50:37 +01:00
Je me sens obligé d'avouer qu'il reste quelques points mystérieux dans
2019-11-12 00:19:32 +01:00
l'\textsc{api} de \textsc{v4l2}, et donc, que ce que raconte
ce logiciel doit être pris avec des pincettes. En particulier
la liste des résolutions disponibles.
2019-09-11 06:19:32 +02:00
2019-08-03 14:27:21 +02:00
% -------------------------------------------------------------------
\section{Et pour la suite ?}
En fait, je fait de la photo par la méthode du « cumul »\index{cumul}
2019-08-06 21:22:12 +02:00
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
2019-08-10 18:37:52 +02:00
avoir un shell pour déclencher, c'est pas facile à utiliser
en mode portnawak\dots
2019-08-28 21:08:59 +02:00
\vspace{1em}
L'idée est donc de construire un appareil autonome, basé sur un Raspi et
2020-01-23 12:50:37 +01:00
une webcam \textsc{usb}\index{USB}, pilotable par \textsc{lirc}\index{LIRC},
alimenté par une (grosse) batterie et permettant d'aller
2019-11-29 17:06:40 +01:00
faire des images au bord d'un lac ou dans la campagne de l'Ariège.
2019-08-06 21:22:12 +02:00
2019-05-20 08:47:13 +02:00
% -------------------------------------------------------------------
\printindex
\end{document}