1879 lines
68 KiB
TeX
1879 lines
68 KiB
TeX
\documentclass[a4paper,10pt]{article}
|
||
|
||
% \listfiles % pour le debug
|
||
|
||
\usepackage[french]{babel}
|
||
\usepackage[utf8]{inputenc}
|
||
\usepackage[T1]{fontenc}
|
||
\usepackage{makeidx}
|
||
\usepackage{listings}
|
||
|
||
% \lstset{frame=single} % dessin d'un cadre autour du listing
|
||
\lstset{basicstyle=\ttfamily\small}
|
||
\lstset{aboveskip=0.01em,belowskip=0.1em}
|
||
|
||
\usepackage{babel} % ?
|
||
|
||
\usepackage{graphicx} % for gnuplot ylabel rotate
|
||
|
||
\usepackage{pifont} % caractères rigolos
|
||
\usepackage{enumitem}
|
||
\setitemize[1]{label={\ding{87}}}
|
||
\frenchbsetup{CompactItemize=false}
|
||
|
||
% \usepackage{color}
|
||
% \usepackage{url}
|
||
\usepackage{xspace}
|
||
\usepackage[verbose]{layout}
|
||
\usepackage{ulem}
|
||
|
||
\setlength \parskip {0.18em}
|
||
\setcounter{tocdepth}{2} % XXX à regarder un de ces jours ?
|
||
|
||
\makeatletter
|
||
% explication de ce truc ?
|
||
\def\verbatim@font{\normalfont\ttfamily\small}
|
||
\makeatother
|
||
|
||
\setlength{\hoffset}{0em}
|
||
\setlength{\textheight}{640pt}
|
||
\setlength{\textwidth}{422pt}
|
||
\setlength{\marginparwidth}{10pt}
|
||
|
||
\makeindex
|
||
|
||
% ------ a few new commands
|
||
\newcommand{\interparagraphe { \vspace{50pt} } }
|
||
|
||
% -------------------------------------------------------------------
|
||
\title{Floating images processing (for fun and profit ?)}
|
||
\author{tTh}
|
||
|
||
\begin{document}
|
||
\maketitle
|
||
|
||
\section*{Une image flottante ?}
|
||
|
||
\vspace{2em}
|
||
\textsl{Mais de quoi parle-t-on exactement ?}
|
||
\vspace{2em}
|
||
|
||
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. Ce qui correspond
|
||
à la norme IEEE 754-1985.
|
||
|
||
% XXX XXX XXX\vspace{1em}
|
||
|
||
\textbf{Attention !} tout le code que nous allons voir ensemble est en
|
||
perpétuelle évolution\footnote{voir page \pageref{TODO} pour les détails},
|
||
et sa fiablité (surtout sur certains aspects mathématiques)
|
||
reste à démontrer\index{valgrind}.
|
||
Mais le service après-vente est assez réactif. Du moins
|
||
pour ceux qui suivent le canal \texttt{\#tetalab} sur le réseau
|
||
IRC de \textsl{libera.chat}.
|
||
|
||
\textbf{Attention !} ce document commence par une bonne rafale
|
||
de technique parfois \textsl{hardue}\footnote{hard + ardue = private
|
||
joke Usenet}, avec des pointeurs dedans, mais vous êtes déja
|
||
au courant.
|
||
Le pointeur, c'est bien, c'est comme le doigt sur les écrans
|
||
de zombiephones, ça sert juste à dire «~C'est là !~», c'est
|
||
donc gravement utile, mais parfois, le doigt glisse.
|
||
Et là, tout peut arriver.
|
||
Vous avez parfaitement le droit de sauter directement à
|
||
la page \pageref{outils} pour quelque chose de plus concret.
|
||
|
||
% -------------------------------------------------------------------
|
||
%
|
||
% d'après le mail de JearZ, en avril 2021, sur la ml tetalab@
|
||
%
|
||
\subsection*{MiniFaq}\index{FAQ}
|
||
|
||
En avril 2021, pendant la fin d'un monde, on m'a demandé de préciser
|
||
certains points. Je vais tenter de répondre à ces FAQ~:%
|
||
« Fréquentes et Absurdes Questions » avec des réponses
|
||
absurdes et précises.
|
||
|
||
\subsubsection*{c'est quoi une image d'un point de vue physique ?}
|
||
|
||
Une représentation approximative d'un monde physique invisible.
|
||
L'infinie bio-complexité de notre système oculaire et ses interactions
|
||
avec notre multivac neuronal n'est devenue quantifiable qu'avec
|
||
l'arrivée des premiers calculateurs
|
||
numériques quand certains ont songé à passer du flou mental à la grille
|
||
physique.
|
||
|
||
Les détails techniques sur cette représentation sont en page
|
||
\pageref{FloatImg desc}, avec des pointeurs et des
|
||
tableaux dedans.
|
||
Ah, les pointeurs, la pire chose du monde, mais pourquoi s'en passer\dots
|
||
|
||
\subsubsection*{quelques rappels de comment on acquiert et numérise une image}
|
||
|
||
Avant de se l'approprier, il vaut la rendre réelle dans sa vision intérieur.
|
||
Il faut l'imaginer comme des lignes de code interposées entre la grille
|
||
physique dont on vient de parler, et une autre grille, bien réelle, des
|
||
pixels sur notre écran Trinitron de 44cm.
|
||
Et puisque on en parle, je me permet de vous conseiller avec
|
||
\textbf{vigueur} la webcam de Playstation (aka PsEye).
|
||
Moins de 10 Euros
|
||
dans les machin-trocs, et un grain d'image vraiment présent.
|
||
|
||
\texttt{https://fr.wikipedia.org/wiki/PlayStation\_Eye}
|
||
|
||
\subsubsection*{définir les notions de base: canal, pixel, codage couleurs}
|
||
|
||
Ah vous en voulez de la technique ? Oké, on y va.
|
||
En fait, on va tripoter pleins de nombres, plus ou moins rangés dans
|
||
des champs de pixels, pour concrétiser l'existence perceptuelle de ces
|
||
grains de lumière chromatisés.
|
||
|
||
\subsubsection*{quelques belles images / schémas polychromes en intro pour
|
||
illustrer tout ça}
|
||
|
||
Tour cela est dans le grand Ternet
|
||
mondial, je pourrais même vous donner l'url si vous me promettez de ne pas
|
||
la glisser dans le capitalisme de surveillance.
|
||
|
||
% ===================================================================
|
||
|
||
\setlength \parskip {0em}
|
||
|
||
\pagebreak
|
||
\tableofcontents
|
||
\pagebreak
|
||
\setlength \parskip {0.40em}
|
||
|
||
% XXX \layout \pagebreak
|
||
|
||
% ===================================================================
|
||
|
||
\section{Théorie}\index{théorie}
|
||
|
||
Pour le moment, seule la quête de l'empirisme absolu a été
|
||
visée. Les justifications mathématiques attendront le retour
|
||
de monsieur Schmod777.
|
||
Ceci dit, rien ne nous empêche d'aller consulter
|
||
Wikipedia, afin de mieux connaitre ces nombres flottants
|
||
que nous allons utiliser~:
|
||
|
||
\begin{quotation}
|
||
An IEEE 754 32-bit base-2 floating-point variable has
|
||
a maximum value of
|
||
$(2 - 2^{-23}) \times 2^{127} \approx 3.4028235 \times 10^{38}$.
|
||
All integers with 7 or fewer decimal digits, and any $2^{n}$ for
|
||
a whole number $-149 \leq n \leq 127$, can be converted exactly into
|
||
an IEEE 754 single-precision floating-point value.
|
||
|
||
In the IEEE 754-2008 standard, the 32-bit base-2 format is
|
||
officially referred to as binary32; it was called single in
|
||
IEEE 754-1985.
|
||
\end{quotation}
|
||
|
||
% XXX
|
||
% Ce qui nous conduit à estimer qu'il est possible de cumuler environ
|
||
% quelques milliers d'images standard à 256 niveaux, sans trop avoir
|
||
% à se soucier des éventuelles pertes de précision. Mais ça demande
|
||
% à être confirmé par des esprits supérieurs.
|
||
|
||
https://dl.acm.org/doi/pdf/10.1145/103162.103163
|
||
|
||
\subsection{Dynamique}\index{dynamique}
|
||
|
||
Dynamique, précision et \textsl{macheps} ? Peu de gens connaissent
|
||
la fourbitude des calculs en virgule flottante avec les ordinateurs.
|
||
Moi-même compris. Il est évident qu'une étude théorique doit être
|
||
effectuée afin d'éviter les potentiels inconvénients.
|
||
|
||
Ceci dit, le standard \textsl{ieee754}\index{ieee754} nous indique qu'il
|
||
y a 23 bits pour la mantisse, ce qui nous propose déja
|
||
plus de huit millions de valeurs possibles.
|
||
Considérons un cas typique~:
|
||
le cumul de $N$ images ayant un niveau maximum $Vm$.
|
||
|
||
\subsection{Pixel négatif ?}
|
||
|
||
Il est très difficle d'imaginer une lumière négative. Sauf peut-être
|
||
si nous songeons à des coefficients d'absorption, ou un canal
|
||
\textsl{alpha} qui inverserait les valeurs ? Un domaine dont
|
||
l'exploration peut confiner au mysticisme de part la multitude
|
||
des traitement possibles : valeur absolue, \textsl{clamping},
|
||
report sur les autres composantes. Votre imagination est
|
||
la limite.
|
||
|
||
% ===================================================================
|
||
|
||
\section{Premier exemple}\index{exemple}\label{exemple}
|
||
|
||
\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
|
||
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 moyens.
|
||
Nous allons donc directement rentrer au cœur du problème,
|
||
en écrivant quelques lignes de code montrant le fonctionnement
|
||
général de la chose vu du coté de la machine.
|
||
|
||
\subsection{L'idée}
|
||
|
||
Pour commencer par quelque 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\footnote{Enfin, non, il y a déja longtemps,
|
||
avant la grande pandémie.}.
|
||
|
||
Tout d'abord, nous devons déclarer et garnir quelques variables
|
||
pour gérer la machinerie interne.
|
||
|
||
\begin{lstlisting}
|
||
int width = 640, height = 480;
|
||
char *fname = "quux.fimg";
|
||
FloatImg fimg;
|
||
\end{lstlisting}
|
||
|
||
Ensuite, nous enchainerons trois étapes : la création de l'image
|
||
en mémoire centrale, l'initialisation des valeurs de chaque pixel à 0.0
|
||
(une valeur que certains associent au noir complet, et d'autres à une
|
||
impossibilité quantique),
|
||
et pour conclure, l'enregistrement de cette image dans un
|
||
fichier\footnote{Au format ésotérique, mais très véloce.}
|
||
binaire.
|
||
|
||
\begin{lstlisting}
|
||
memset(fimg, 0, sizeof(FloatImg));
|
||
foo = fimg_create(&fimg, width, height, FIMG_TYPE_RGB);
|
||
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{lstlisting}
|
||
|
||
Une fois ce code enrobé dans un \texttt{main()}, compilé puis exécuté,
|
||
nous pouvons entrevoir, grâce au logiciel
|
||
\texttt{fimgstats} (décrit en 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}
|
||
|
||
\subsection{Action ?}
|
||
|
||
Nous avons donc sous la main un ensemble d'outils mécaniques qui ne demande
|
||
qu'à faire des trucs futiles et des images qui clignotent.
|
||
Avec un bon script bash, il y a déja de quoi faire.
|
||
La suite vers la page \pageref{codaz}.
|
||
|
||
Vous trouverez dans le répertoire \texttt{tools/}\index{tools/}
|
||
d'autres exemples de mise en œuvre de quelques fonctions disponibles
|
||
sous formes d'outils en ligne de commande,
|
||
lesquels outils sont approximativement décrits en page \pageref{outils}.
|
||
|
||
% ===================================================================
|
||
\section{Installation}
|
||
|
||
Sauf indications contraires, ces instructions se réfèrent à
|
||
une distribution Debian\index{Debian} récente (amd64 et x86),
|
||
mais ça marche quasiment pareil avec Fedora\index{Fedora} 64,
|
||
et
|
||
probablement Raspbian\index{Raspbian}, modulo les éventuels
|
||
soucis de boutisme que j'ai absolument négligés de prendre
|
||
en compte.
|
||
\textit{Attention, ça va devenir un peu gore\dots}
|
||
|
||
\subsection{Prérequis}
|
||
|
||
Vous devez, en dehors des outils classiques (gcc, Awk, make\dots),
|
||
avoir quelques bibliothèques installées~:
|
||
\textsf{
|
||
libv4l2, libpnglite, libtiff,
|
||
libnetpbm\footnote{package libnetpbm10-dev},
|
||
libz\footnote{package zlib1g-dev}, libcurses,
|
||
libcfitsio...
|
||
} % end of textsf
|
||
éventuellement avec le \textsf{-dev} correspondant, qui contient, entre
|
||
autres, les fichiers \texttt{.h} associés
|
||
et probablement d'autres choses.
|
||
|
||
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.
|
||
|
||
Il faut aussi savoir où trouver le code. Il est dans le Git du
|
||
Tetalab\footnote{\texttt{https://git.tetalab.org/tTh/FloatImg}}.
|
||
Mais comme je ne comprend rien à Git, c'est pas la peine
|
||
de m'envoyer des trucs genre \textsl{pull-request} auquels je ne
|
||
comprend rien.
|
||
|
||
\subsection{Compilation}
|
||
|
||
La première chose à faire est d'aller regarder le contenu du fichier
|
||
\texttt{Global.makefile} à la racine du projet. Il contient des
|
||
informations pertinentes pour la suite des choses.
|
||
Ensuite, un script \texttt{build.sh} permet de construire approximativement
|
||
le bouzin. Il est loin d'être parfait\footnote{Il doit être possible
|
||
de faire un Makefile récursif, mais\dots}.
|
||
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.
|
||
|
||
Pour le moment, la procédure d'installation est un peu rude,
|
||
pour ne pas dire clairement sommaire.
|
||
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
|
||
\texttt{/usr/local/include} et \texttt{/usr/local/lib}.
|
||
|
||
Le script \texttt{install.sh}, à la racine du projet, est censé
|
||
faciliter un peu la chose. Il prend également en compte la copie
|
||
des divers binaires du dossier \texttt{tools/} (cf page \pageref{outils})
|
||
dans le répertoire prévu à cet effet~: \texttt{/usr/local/bin}.
|
||
|
||
Il reste enfin quelques exemples d'utilisation des outils de la
|
||
ligne de commande depuis un shell
|
||
dans le répertoire \texttt{scripts/}.
|
||
Ils sont décrits plus en détail page
|
||
\pageref{scripts}, et c'est à vous de les adapter à votre \textsl{usecase}.
|
||
Faites-en ce que vous voulez.
|
||
|
||
% =================================================================
|
||
|
||
\section{Utilisation coté codeur}\label{codaz}
|
||
|
||
Classiquement, il y a un fichier \texttt{.h} à inclure dans chacun
|
||
de vos codes source,
|
||
\texttt{floatimg.h}, généralement logé dans \texttt{/usr/local/include}
|
||
et contenant un certain nombre de définition de structures, de macros,
|
||
de constantes\footnote{À l'ancienne, via le pré-processeur}
|
||
et les prototypes des fonctions utilisables par vos logiciels.
|
||
|
||
Au niveau du code source, ces fonctions sont très 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 indécement arbitraire.
|
||
D'autant plus qu'il y a aussi un répertoire nommé « experimental ».
|
||
|
||
\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{metadatas}) regroupées
|
||
dans une jolie structure que nous allons examiner dès maintenant.
|
||
|
||
\label{FloatImg desc}
|
||
|
||
\begin{lstlisting}
|
||
/* in memory descriptor */
|
||
typedef struct {
|
||
unsigned long magic;
|
||
int width;
|
||
int height;
|
||
int type;
|
||
float fval;
|
||
int count;
|
||
float *R, *G, *B, *A;
|
||
int reserved;
|
||
} FloatImg;
|
||
\end{lstlisting}\index{FloatImg desc}
|
||
|
||
Le premier champ, \texttt{magic}, servira un de ces jours à
|
||
robustifier l'ensemble du machin.
|
||
Les deux suivants sont \textsl{obvious}.
|
||
Le troisième est le type d'image : pour le moment, il y en a % trois
|
||
un certain nombre
|
||
qui sont définis\footnote{et plus ou moins bien gérés\dots} :
|
||
gris, rgb et rgba/rgbz\index{rgba}\index{rgbz}.
|
||
Les constantes adéquates sont déclarées dans \texttt{floatimg.h}~:
|
||
|
||
\begin{lstlisting}
|
||
#define FIMG_TYPE_GRAY 1
|
||
#define FIMG_TYPE_RGB 3
|
||
#define FIMG_TYPE_RGBA 4
|
||
#define FIMG_TYPE_RGBZ 99
|
||
\end{lstlisting}
|
||
|
||
Un peu plus loin, nous avons les pointeurs vers les
|
||
différents \textsl{pixmaps} de l'image. En principe l'organisation
|
||
interne de ces zones est improbable, puisque elle dérive
|
||
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.
|
||
|
||
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
|
||
chose : imaginons un périphérique de capture qui nous fournisse des
|
||
images en gris sur 4 bits (et linéaire).
|
||
Et que nous voulions cumuler\index{cumul}
|
||
quelques images...
|
||
|
||
Le champ \textsl{count} sera mis à 0 et
|
||
le champ \textsl{fval} sera initialisé à 15.0
|
||
(ce qui est la valeur maximale que peut renvoyer ce capteur).
|
||
Ensuite, dans la boucle capture/cumul, \textsl{count} sera
|
||
incrémenté à chaque passe, et nous aurons donc, en finale,
|
||
toutes les informations nécessaires pour exploiter au mieux la dynamique
|
||
de notre image dans les étapes ultérieures, puisque la valeur
|
||
maximale théorique est égale à $fval * count$.
|
||
|
||
La fonction \texttt{fimg\_printhead(FloatImg *h)} affiche
|
||
sommairement le contenu de ce descripteur,
|
||
et \texttt{fimg\_describe(FloatImg *head, char *txt)} propose
|
||
un affichage plus détaillé. Ça peut parfois aider.
|
||
|
||
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. Mais après tout, ce n'est
|
||
encore qu'un concept en devenir, n'est-il pas ?
|
||
|
||
% ----------------------------------
|
||
|
||
\subsection{Les fondations}\index{lib/}
|
||
|
||
La première chose que nous devons absolument voir est la gestion
|
||
dynamique de la mémoire qui sera occupée par tous ces pixels flottants,
|
||
ce qui est un sujet parfois délicat\footnote{GC or not GC ?} parce que
|
||
les pixels sont précieux et doivent être bien rangés.
|
||
Cette gestion est donc faite, à la base, par ces deux fonctions~:
|
||
|
||
\begin{lstlisting}
|
||
int fimg_create(FloatImg *fimg, int w, int h, int type);
|
||
int fimg_destroy(FloatImg *fimg);
|
||
\end{lstlisting}
|
||
|
||
L'appelant doit lui-même gérer le descripteur d'image (une structure
|
||
C décrite plus haut) en le considérant comme un type semi-opaque dont
|
||
la forme \emph{peut} varier, mais qu'il convient de mettre à zéro
|
||
avant le moindre usage\footnote{\texttt{man 3 memset}}.
|
||
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 : niveau de gris, rouge-vert-bleu et rgb avec un canal alpha,
|
||
et expliquées quelques lignes plus haut.
|
||
|
||
XXX\index{XXX} raconter fimg\_clone
|
||
|
||
Comme vous allez le voir plus loin, il y a plein de fonctions qui
|
||
prennent en argument deux images: la source et la destination.
|
||
Dans la plupart des cas, ces deux images doivent être compatibles,
|
||
c'est à dire de même type et de mêmes dimensions.
|
||
|
||
\begin{lstlisting}
|
||
/* return 0 if pictures are compatible */
|
||
int fimg_images_not_compatible(FloatImg *a, FloatImg *b);
|
||
\end{lstlisting}
|
||
|
||
C'est bien beau d'être enfin une image résidente 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.
|
||
Le format de ces fichiers est décrit page \pageref{formatfimg}.
|
||
|
||
\begin{lstlisting}
|
||
int fimg_dump_to_file(FloatImg *fimg, char *fname, int notused);
|
||
int fimg_load_from_dump(char *fname, FloatImg *where);
|
||
\end{lstlisting}
|
||
|
||
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 mémoire centrale doit être
|
||
pré-allouée. On peut connaitre ces valeurs en appelant
|
||
\texttt{int fimg\_fileinfos(char *fname, int datas[3])}.
|
||
|
||
Si tout s'est bien passé (valeur retournée égale à 0),
|
||
on va trouver la largeur dans \texttt{datas[0]},
|
||
la hauteur dans \texttt{datas[1]} et le type dans
|
||
\texttt{datas[2]}\footnote{La fonction
|
||
\texttt{fimg\_type\_is\_valid(int type)} peut vous aider\dots}.
|
||
|
||
Je sais aussi que certains d'entre vous aiment la facilité, aussi
|
||
je vais vous révéler l'existence d'un nouveau truc bien plus
|
||
simple, une fonction qui enchaine ces deux actions
|
||
(allocation, puis lecture), et s'utilise
|
||
comme ça :
|
||
|
||
\begin{lstlisting}
|
||
FloatImg head;
|
||
memset(&head, 0, sizeof(FloatImg));
|
||
foo = fimg_create_from_dump("lena.fimg", &head);
|
||
\end{lstlisting}
|
||
|
||
Si la valeur retournée est différente de 0, c'est que quelque
|
||
chose s'est probablement mal passé.
|
||
Certains messages sont parfois explicites. Mais parfois non.
|
||
Quand aux valeurs retournées en cas d'erreur, c'est le désordre
|
||
intégral\footnote{Un vrai désastre, même...}.
|
||
|
||
% _________
|
||
|
||
\subsection{Dessiner}
|
||
|
||
Bon, vous avez en mémoire centrale une image latente,
|
||
et vous souhaitez dessiner dessus (ou dedans ?) avec vos encres flottantes ?
|
||
Il y a actuellement deux fonctions pour ça, légèrement différentes~:
|
||
|
||
\begin{lstlisting}
|
||
int fimg_plot_rgb(FloatImg *head, int x, int y, float r, float g, float b);
|
||
int fimg_put_rgb(FloatImg *head, int x, int y, float rgb[3]);
|
||
\end{lstlisting}
|
||
|
||
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},
|
||
qui ajoute du rgb à un pixel, laquelle fonction a d'ailleurs été
|
||
à la base de la seconde génération de la
|
||
photographie\index{photographie} en cumul\index{cumul}.
|
||
|
||
Inversement, la fonction
|
||
\texttt{fimg\_get\_rgb(FloatImg *head, int x, int y, float *rgb)}
|
||
permet de lire les valeurs des trois canaux d'un pixel donné.
|
||
Là aussi, il n'y a aucun contrôle sur la validité des valeurs
|
||
$x$ et $y$ de la demande.
|
||
|
||
Quand au canal \textsl{alpha}\index{alpha}, il est pour le moment
|
||
superbement ignoré. Ceci dit, on vient de me faire remarquer qu'il
|
||
peut être utilisable aussi pour faire du
|
||
\textsl{z-buffer}\index{z-buffer}\index{rgbz}, une technique
|
||
classique dans la génération d'images en trois dimensions.\dots
|
||
|
||
% ----------------------------------
|
||
|
||
\subsection{Contraste}\index{contraste}\label{contraste}
|
||
|
||
Certaines opérations d'ajustement du contraste d'une image
|
||
semblent cohérentes avec la notion d'image flottante.
|
||
Certaines d'entre elles, les plus simples, sont disponibles.
|
||
Les autres sont à imaginer.
|
||
|
||
\begin{figure}[h]
|
||
\input{cos01.tex} % XXX XXX XXX
|
||
\caption{Correcteur cos01}
|
||
\end{figure}
|
||
|
||
Ils prennent chacun trois paramètres, d'abord les images
|
||
source et destination (\texttt{* FloatImg}),
|
||
ensuite le troisième
|
||
qui est un nombre en double précision donnant la valeur
|
||
maximale \textsl{supposée} de l'image source,
|
||
valeur qui peut être déterminée de plusieurs manières.
|
||
|
||
\begin{lstlisting}
|
||
/* 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);
|
||
int fimg_cos_010(FloatImg *s, FloatImg *d, double maxval);
|
||
\end{lstlisting}
|
||
|
||
|
||
Si vous souhaitez rajouter votre propre méthode de modification
|
||
de contraste, il y a quelques explication en page \pageref{exemplefunc}.
|
||
Mais rien ne vous oblige à le faire. Sauf vos envies.
|
||
|
||
|
||
\begin{figure}[h]
|
||
\input{cos010.tex} % XXX XXX XXX
|
||
\caption{Correcteur cos010}
|
||
\end{figure}
|
||
|
||
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.
|
||
|
||
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.
|
||
|
||
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
|
||
prévue pour ça de façon sommaire.
|
||
C'est actuellement la méthode utilisée par l'outil qui
|
||
sert à faire les modifications de contraste (page \pageref{fimgfx}).
|
||
On pourra aussi envisager d'utiliser
|
||
\texttt{fimg\_get\_minmax\_rgb(FloatImg *head, float mmvals[6])},
|
||
qui permet un contrôle bien plus fin des dérives.
|
||
|
||
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. \textsl{Et c'est pas gagné...}
|
||
|
||
% ----------------------------------
|
||
|
||
\subsection{Géométrie}\index{géométrie}\label{geometrie}
|
||
|
||
Très prochainement, le retour du blitter\index{blitter}.
|
||
Et pour attendre, un truc improbable, voire même
|
||
inutile, en fait l'inverse de l'upscaling.
|
||
|
||
\begin{lstlisting}
|
||
int fimg_halfsize_0(FloatImg *src, FloatImg *dst, int notused);
|
||
int fimg_halfsize_1(FloatImg *src, FloatImg *dst, int notused);
|
||
\end{lstlisting}
|
||
|
||
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.
|
||
|
||
La première propose un résultat très moyen : il n'y a pas d'interpolation,
|
||
alors que la seconde semble bien mieux.
|
||
|
||
\begin{lstlisting}
|
||
int fimg_extract_0(FloatImg *src, FloatImg *dst, int x, int y);
|
||
\end{lstlisting}
|
||
|
||
Contrairement à la fonction précédente, celle-ci demande absolument une
|
||
image de destination initialisée aux dimensions (largeur et hauteur)
|
||
désirées.
|
||
|
||
\begin{lstlisting}
|
||
int fimg_rotate_90(FloatImg *src, FloatImg *dst, int notused);
|
||
\end{lstlisting}
|
||
|
||
Rotation\index{rotation} de 90 degrés dans le sens
|
||
horlogique\footnote{ou trigonométrique,le code et la doc
|
||
ne semblent pas d'accord.} d'une image RGB.
|
||
L'image de destination peut être soit vierge, soit pré-allouée
|
||
aux bonnes dimensions (échange W et H).
|
||
|
||
% ----------------------------------
|
||
|
||
\subsection{Format du fichier \textsc{fimg}}\index{format}\label{formatfimg}
|
||
|
||
D'un design très empirique, c'est certainement à revoir pour l'avenir.
|
||
La force du \textsl{legacy} va-t-elle dominer le monde ?
|
||
Il faudrait normaliser l'endianess et le packing dans les
|
||
structuress\footnote{Directives du compilateur ?}, et surtout l'ajout
|
||
de données sur la prise de vue, du genre type de capteur, date et heure,
|
||
réglages divers. Nous appelerons ça les metadonnées, et
|
||
nous en parlons dans quelques pages.\dots
|
||
|
||
\begin{lstlisting}
|
||
typedef struct {
|
||
char magic[8];
|
||
int32_t w, h, t;
|
||
} FimgFileHead;
|
||
\end{lstlisting}
|
||
|
||
|
||
Le champ \texttt{magic[8]} doit contenir une valeur magique~:
|
||
les quatre premiers octets doivent contenir les quatre caractères
|
||
\texttt{'FIMG'}, et les quatre derniers doivent être à 0, sauf que,
|
||
voir plus bas, le cinquième vas vous étonner.
|
||
Le champ \texttt{t} (le type de l'image) doit avoir les trois octets
|
||
de poids fort à 0\footnote{Pourquoi ? Je n'en sais rien.}.
|
||
|
||
Ensuite, nous aurons (dans le cas courant) : 1, 2 ou 4 blocs
|
||
de WxH pixels sous forme de Float32. La première ligne lue
|
||
est la ligne du haut de l'image. Les valeurs négatives sont
|
||
tolérées.
|
||
|
||
Vous trouverez les constantes de type pertinentes dans le
|
||
fichier \texttt{floatimg.h}, et quelques informations
|
||
(non-)essentielles qui ne vous serviront probablement à rien.
|
||
|
||
|
||
% ----------------------------------
|
||
% new février 2022
|
||
|
||
\subsection{Métadonnées}
|
||
\index{metadata} \index{timestamp}
|
||
|
||
Attention, ce n'est pas encore une version définitive, beaucoup de
|
||
choses restent à préciser sur le contenu de cette structure, mais
|
||
l'essentiel est déja là. On reconnait un fichier avec metadata
|
||
quand l'octet \texttt{magic[4]} du premier header est égal à
|
||
la lettre \texttt{'a'}.
|
||
|
||
\begin{lstlisting}
|
||
typedef struct {
|
||
char magic[8];
|
||
struct timeval timestamp;
|
||
int32_t count;
|
||
float fval;
|
||
char idcam[32];
|
||
int32_t origin; // enum ?
|
||
} FimgMetaData;
|
||
\end{lstlisting}
|
||
|
||
Voyons maintenant chacun des champs de cette structure, en prenant bien
|
||
en compte qu'à ce moment\footnote{4 avril 2022}, tout n'est pas figé.
|
||
Ceci dit, nous allons aussi retrouver de vieilles connaissances.
|
||
|
||
\textbf{to be continued}
|
||
|
||
% ----------------------------------
|
||
|
||
\subsection{Exportation \& Importation}\index{export}\label{export}
|
||
|
||
Notre format de fichier étant totalement inconnu%
|
||
\footnote{Du monde extérieur, vous l'aurez compris.},
|
||
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.
|
||
|
||
Et dans le sens inverse, il serait bien de savoir importer
|
||
le monde extérieur dans nos sombres caves à pixel.
|
||
Il faut quand même reconnaitre que c'est un peu la jungle dans les
|
||
formats de fichiers d'image, ce qui explique le retard
|
||
du développement dans ce domaine\dots
|
||
|
||
\subsubsection{Vers PNM}\index{PNM}
|
||
|
||
Nous avons ici 16 bits par composante, soit 65536 valeurs différentes,
|
||
ce qui est bien au-delà de ce que peuvent percevoir vos yeux.
|
||
Hélas, c'est au prix
|
||
d'une taille énorme sur les fichiers. D'un autre coté,
|
||
l'utilisation du codage \textsc{ascii}\index{ascii}
|
||
(alors qu'on pourrait mettre du binaire, plus compact) y est
|
||
pour quelque chose.
|
||
|
||
\begin{lstlisting}
|
||
int fimg_save_as_pnm(FloatImg *head, char *fname, int flags);
|
||
\end{lstlisting}
|
||
|
||
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.
|
||
|
||
Le bit \texttt{1} permettra bientôt\index{vaporware} de demander
|
||
l'enregistrement de métadonnées\index{metadata} pertinentes, telle
|
||
que l'epochtime de l'enregistrement.
|
||
|
||
Les autres bits ne sont pas utilisés et doivent être à zéro.
|
||
|
||
\subsubsection{Vers PNG}\index{PNG}
|
||
|
||
Actuellement, on ne peut enregistrer qu'en mode RGB uniquement,
|
||
avec 8 bits par composante,
|
||
mais on a quand même une bonne compression, ça compense.
|
||
|
||
J'utilise \textsl{libpnglite} avec qui j'ai un peu de mal à suivre.
|
||
Mais je me soigne. Le mode 16 bits va bientôt arriver.
|
||
On peut aussi songer à l'export des metadonnées, pour celles qui
|
||
sont compatibles avec le standard PNG.
|
||
|
||
\begin{lstlisting}
|
||
int fimg_save_as_png(FloatImg *src, char *outname, int flags);
|
||
\end{lstlisting}
|
||
|
||
Tous les flags doivent être à zéro. Sinon, ça foire parfois.
|
||
Et en fait (mars 2021) je ne suis pas très content de
|
||
\texttt{pnglite}, donc un de ces jours, je prendrais
|
||
\sout{cinq} quelques jours pour
|
||
régler ce souci en passant à la bibliothèque canonique.
|
||
|
||
\subsubsection{Vers TIFF}\index{TIFF}
|
||
|
||
Le format canonique de la PAO\index{PAO} du siècle dernier. Il permet
|
||
de gérer une foultitude de formats numériques. C'est aussi un format
|
||
classique proposé par les gros scanners corporates.
|
||
|
||
\begin{lstlisting}
|
||
int fimg_write_as_tiff(FloatImg *src, char *outname, int flags);
|
||
\end{lstlisting}
|
||
|
||
Tous les flags doivent être à zéro. Pour le moment.
|
||
Un premier jet pas forcément parfait.
|
||
|
||
\subsubsection{Vers FITS}\index{FITS}
|
||
|
||
Ce format est essentiellement utilisé pour stocker des images
|
||
d'astronomie, donc il peut aussi servir pour des images floues.
|
||
Cette partie est basée sur la bibliothèque \texttt{cfitsio} de
|
||
la NASA.
|
||
|
||
\begin{lstlisting}
|
||
int fimg_save_R_as_fits(FloatImg *src, char *outname, int flags);
|
||
int fimg_save_G_as_fits(FloatImg *src, char *outname, int flags);
|
||
int fimg_save_B_as_fits(FloatImg *src, char *outname, int flags);
|
||
\end{lstlisting}
|
||
|
||
Bizarrement, l'image est stockée \textsl{upside-down} et je ne
|
||
sais pas encore comment régler ce petit détail.
|
||
|
||
Tous les flags doivent être à zéro.
|
||
|
||
% =============================================================
|
||
|
||
\subsection{Utilitaires}
|
||
|
||
Commençons par quelques petits trucs pour nous faciliter la vie
|
||
dans des domaines annexes,
|
||
tels que l'interprétation d'arguments dans la ligne de commande ou un
|
||
fichier de configuration.
|
||
|
||
\begin{lstlisting}
|
||
int parse_WxH(char *str, int *pw, int *ph)
|
||
int parse_double(char *str, double *dptr)
|
||
\end{lstlisting}
|
||
% XXX rjouter quelques explication, please !
|
||
|
||
La fonction \texttt{int format\_from\_extension(char *fname)} examine un
|
||
nom de fichier tel que \texttt{lena.xxx}, et retourne, si la partie
|
||
\texttt{xxx} est connue, un éventuel nombre positif, dont les valeurs sont
|
||
déclarées dans floatimg.h
|
||
le valeureux.
|
||
Les extensions actuellement connues sont :
|
||
fimg, png, pnm, pgm, fits et tiff. Le bmp est plus ou moins prévu\dots
|
||
|
||
To be continued\index{XXX}\dots
|
||
|
||
% =============================================================
|
||
|
||
\subsection{Effets}\index{sfx}
|
||
|
||
Quelques routines qui servent futilement à \textsl{brotcher} les images
|
||
en tripotant les flux visuels chromatiques.
|
||
|
||
\begin{lstlisting}
|
||
int fimg_killcolors_a(FloatImg *fimg, float fval);
|
||
int fimg_killcolors_b(FloatImg *fimg, float fval);
|
||
int fimg_colors_mixer_a(FloatImg *fimg, float fval);
|
||
\end{lstlisting}
|
||
|
||
\subsection{Glitches}\index{glitch}
|
||
|
||
Un \textsl{glitch} peut-il être classé dans la catégorie des effets
|
||
spéciaux ou non ? \textsc{Hmha}, non. un fx est paramétrable
|
||
et surtout répétitif. Un glitch est quasiment souvent un phénomène
|
||
aléatoire\index{drand48} et tout aussi paramétrable.
|
||
|
||
J'ai commencé à étudier ces objets étranges quand j'ai commencé
|
||
à travailler sur l'interpolator\index{interpolator} à l'automne 2020.
|
||
Hélas, j'ai vite réalisé que c'était assez délicat.
|
||
Pour ce genre de \textsl{usecase}, le numérique est pitoyable si on
|
||
le compare au (hélas défunt) \textsc{Betamax}\index{Betamax}.
|
||
|
||
% =============================================================
|
||
|
||
\subsection{Filtrages}\index{filtrage}
|
||
|
||
Pour commencer, il faut que je réfléchisse au traitement
|
||
des bordures des images.
|
||
Ensuite que je débuggue\index{bug} ces deux fonctions~:
|
||
|
||
\begin{lstlisting}
|
||
int fimg_lissage_2x2(FloatImg *img);
|
||
int fimg_killborders(FloatImg *img);
|
||
\end{lstlisting}
|
||
|
||
Bon, oké, ça marche ? Passons à l'étape suivante.
|
||
La convolution avec une matrice 3x3, c'est possible.
|
||
Et pas trop compliqué à faire.
|
||
Bon, il reste le souci avec les bordures, souci qui ne peut
|
||
être que temporaire, mais ésotérique à fixer.
|
||
|
||
Passons maintenant aux choses sérieuses, et définissons la
|
||
description d'un filtre 3x3.
|
||
|
||
\begin{lstlisting}
|
||
typedef struct {
|
||
float matrix[9];
|
||
float mult;
|
||
float offset;
|
||
} FimgFilter3x3;
|
||
\end{lstlisting}
|
||
|
||
L'usage des champs \texttt{mult} et \texttt{offset} n'est pas
|
||
clairement défini. Le prototype de la fonction de filtrage
|
||
non plus, mais assez simple quand même. Source et destination
|
||
ne peuvent désigner la même image, et le champ \texttt{matrix}
|
||
du filtre doit contenir des valeurs cohérentes.
|
||
|
||
\begin{lstlisting}
|
||
int fimg_filter_3x3(FloatImg *src, FloatImg *dst, FimgFilter3x3 *filtr)
|
||
\end{lstlisting}
|
||
|
||
Comme dans la plupart des cas, la gestion des valeurs négatives
|
||
de pixel est laissé au hasard, qui fait souvent du portnawak.
|
||
Quoique, il doit bien exister
|
||
quelques solutions de contournement :
|
||
valeur absolue, clamping ou shiftup ?
|
||
|
||
\textsl{To be continued\index{XXX}\dots}
|
||
|
||
% ----------------------------------
|
||
|
||
\subsection{Exemple de fonction}\index{exemple}\label{exemplefunc}
|
||
|
||
Nous allons maintenant écrire une fonction intégrable dans
|
||
le répertoire \texttt{funcs/}.
|
||
Elle aura donc accès aux \textsl{internals}%
|
||
\footnote{que je peux décider de changer n'importe quand}
|
||
de \textsc{FloatImg},
|
||
une chose qui est en principe interdite aux programmes
|
||
\textsl{enduser}. Soyez donc prudents.
|
||
|
||
Cette fonction 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 par les temps qui courent.
|
||
|
||
\begin{lstlisting}
|
||
int fimg_example(FloatImg *s, FloatImg *d, float value)
|
||
{
|
||
int size, index;
|
||
|
||
if ( s->type!=FIMG_TYPE_RGB || d->type!=FIMG_TYPE_RGB) {
|
||
perror("fimg_example");
|
||
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{lstlisting}
|
||
|
||
Je vous laisse imaginer les dégats que peut faire cette
|
||
fonction en utilisation réelle. Mieux, je vous propose
|
||
d'essayer par vous-même, vous allez voir, c'est assez créatif.
|
||
En particulier tout le reste du code qui suppose qu'un pixel
|
||
ne peut \textbf{pas} être négatif va peut-être exploser de rire.
|
||
Vous pouvez aussi remarquer qu'il n'y a pas de controle
|
||
de cohérence sur les dimensions des deux images, malgré l'existence
|
||
de fonctions prévues à cet effet, mais il fallait rester simple\dots
|
||
|
||
|
||
% ===================================================================
|
||
\section{Les outils}\label{outils}
|
||
|
||
\textsf{3615mavie} : pour des projets comme celui-ci, qui travaillent
|
||
\textit{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 des compilations.}
|
||
et construire
|
||
des briques de base qui mettent en action le code primitif pour
|
||
partir sur des bases stables, documentées (ahem\dots), et
|
||
directement utilisables.
|
||
|
||
Ces cliwares\index{cliware} ont en commun quelques options bien pratiques~:
|
||
\texttt{-h} pour avoir un résumé des options disponibles,
|
||
\texttt{-v} qui augmente la puissance de bavardage, et
|
||
\texttt{-K nn.nn} pour un paramètre flottant.
|
||
Dans un avenir incertain, il existera des pages de man\index{man}.
|
||
|
||
% ---------------------
|
||
|
||
\subsection{mkfimg}\index{mkfimg}\label{mkfimg}
|
||
|
||
Propose la création d'un fichier contenant une image de « teinte »
|
||
constante (ou pas).
|
||
Cette notion de teinte est assez inconsistante pour le moment,
|
||
mais ça n'est pas si grave que ça.
|
||
|
||
\begin{verbatim}
|
||
tth@debian:~/Devel/FloatImg/tools$ ./mkfimg -h
|
||
Usage: mkfimg [options] quux.fimg width height
|
||
-k N.N give a float parameter
|
||
-t type howto make the pic
|
||
black, drand48...
|
||
-v increase verbosity
|
||
\end{verbatim}
|
||
|
||
Il y a deux syntaxes possibles pour les dimensions de l'image générée~:
|
||
deux nombres séparés ou la notation \texttt{WIDTHxHEIGHT}.
|
||
|
||
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$, ce qui n'est pas toujours une bonne valeur, ymmv\index{ymmv}.
|
||
|
||
\begin{description} \index{XXX}
|
||
\item [black/gray/grey:] efface avec 0.0 (black) ou avec la valeur
|
||
\texttt{-k} (niveau de gris).
|
||
\item [drand48:] beaucoup de bruit dans chacun des canaux.
|
||
\item [hdeg/vdeg:] dégradé du noir au blanc (relatif à \texttt{-k}).
|
||
\end{description}
|
||
|
||
% ---------------------
|
||
|
||
\subsection{png2fimg}\index{png2fimg}\label{png2fimg}
|
||
|
||
Grosse panne\index{bug} à 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}
|
||
|
||
Il faut peut-être envisager le passage à \texttt{libpng}\index{libpng},
|
||
la bibliothèque actuellement utilisée (\texttt{pnglite}) ayant tendance
|
||
à borker en lecture sur certains fichiers pourtant corrects.
|
||
|
||
% ---------------------
|
||
|
||
\subsection{fimgstats}\index{fimgstats}\label{fimgstats}
|
||
|
||
Affichage de quelques valeurs calculées à partir du contenu d'un fichier
|
||
\texttt{.fimg}\index{.fimg}.
|
||
|
||
\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
|
||
en première approche, alors commençont par le plus simple,
|
||
les valeurs moyennes de chaque composante.
|
||
|
||
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}.
|
||
|
||
% ---------------------
|
||
|
||
\subsection{fimgfx}\index{fimgfx}\label{fimgfx}
|
||
|
||
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
|
||
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 gray0 cmixa xper desat
|
||
\end{verbatim}
|
||
|
||
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}.
|
||
|
||
\begin{description}
|
||
\item [Ajustements de contraste:] cos01 cos010 pow2 sqrt
|
||
\item [Distorsions chromatiques:] gray0
|
||
\item [Déformations géométriques:] r90
|
||
\end{description}
|
||
|
||
Et pour les aventureux, la commande \texttt{xper} (abréviation
|
||
de \textsl{expérimental}) permet de tester la plus récente tentative
|
||
de friture du moment. D'autre part un set bien plus complet d'effets
|
||
àlc est disponible dans les logiciels de flou temporel, décrits
|
||
plus loin dans ce document.
|
||
|
||
% ---------------------
|
||
|
||
\subsection{fimgops}\index{fimgops}\label{fimgops}
|
||
|
||
Quelques opérations diverses entre deux images, qui doivent être
|
||
de la même taille, et uniquement du type \textsl{RGB}. Certaines
|
||
de ces opérations peuvent avoir un effet étrange sur vos images,
|
||
par exemple si un pixel se retrouve avec une valeur négative.
|
||
|
||
\begin{verbatim}
|
||
usage:
|
||
fimgops [options] A.fimg B.fimg operator D.fimg
|
||
operators:
|
||
add 1
|
||
sub 2
|
||
mix 3
|
||
mul 4
|
||
mini 5
|
||
maxi 6
|
||
options:
|
||
-g convert output to gray
|
||
-k N.N set float value
|
||
-v increase verbosity
|
||
-X explosive action
|
||
\end{verbatim}
|
||
|
||
Pour des operateurs paramétrable (comme \texttt{mix}), le paramêtre
|
||
flottant doit être fourni en utilisant l'option \texttt{-k}.
|
||
La véracité mathématique n'est pas garantie. Et n'oubliez pas que
|
||
les valeurs négatives peuvent être la cause de \textsl{glitches}
|
||
de qualitay.
|
||
|
||
La liste des opérations est susceptible d'être agrémenté de quelques
|
||
possibilités bien féroces\footnote{Stay tuned, flim at 11.}.
|
||
|
||
% -------------------------
|
||
|
||
\subsection{fimg2png, fimg2pnm, fimg2tiff, fimg2fits}
|
||
\index{fimg2png}\label{fimg2png}
|
||
\index{fimg2pnm}\label{fimg2pnm}
|
||
\index{fimg2tiff}\label{fimg2tiff}
|
||
\index{fimg2fits}\label{fimg2fits}
|
||
|
||
Quelques petits proggies pour exporter notre format\index{.fimg} secret
|
||
vers des choses plus directement utilisables. À condition que le
|
||
code soit écrit et documenté.
|
||
|
||
D'un autre coté, écrire un greffon d'import/export pour
|
||
Gimp\index{Gimp} ou ImageMagick\index{ImageMagick} ou Krita\index{krita}
|
||
ne devrait pas être trop difficile. Des volontaires ?
|
||
|
||
D'ailleurs, pourquoi $N$ logiciels indépendants alors q'un
|
||
seul devrait être nécessaire ?, ce qui me conduit à envisager
|
||
un \textsl{exporter} universel, mais dont l'ergonomie et les
|
||
paramètres possibles doivent être réfléchis avec vigueur et nonchalance.
|
||
|
||
% -------------------------
|
||
|
||
\subsection{fimg2text}
|
||
|
||
Voici donc quelque chose qui retourne vers la bonne vieille
|
||
tradition Unix\index{Unix} et permet de traiter des images
|
||
flottantes avec des outils classiques comme l'injustement
|
||
méconnu \texttt{Awk}\index{Awk}.
|
||
Dans le comportement par défaut (le seul actuellement) cet outil
|
||
sort, pour chaque pixel, cinq valeurs~:
|
||
|
||
\begin{itemize}
|
||
\item Les coordonnées entières $x,y$ du pixel
|
||
\item Les valeurs flottantes des composantes \textsc{rgb}
|
||
\end{itemize}
|
||
|
||
On peut même espérer qu'un jour, il soit possible de faire
|
||
la transformation inverse. Quelle joie de générer des images
|
||
flottantes avec un programme écrit en \textit{gw-basic} :)
|
||
|
||
\begin{verbatim}
|
||
tth@fubar:~/Devel/FloatImg/doc$ fimg2text -h
|
||
usage:
|
||
fimg2text [options] foo.fimg > bar.csv
|
||
options:
|
||
-v increase verbosity
|
||
-n 3.14 normalize picture
|
||
-s N steps on x & y
|
||
\end{verbatim}
|
||
|
||
Vous voulez un petit exemple ?
|
||
|
||
\begin{verbatim}
|
||
tth@fubar:~/Devel/FloatImg/doc$ mkfimg -t drand48 quux.fimg 4 2
|
||
tth@fubar:~/Devel/FloatImg/doc$ fimg2text -s 1 quux.fimg
|
||
0 0 142.518127 84.036987 20.688946
|
||
1 0 164.273315 68.397079 138.501587
|
||
2 0 45.887970 25.905518 93.683243
|
||
3 0 53.292942 222.000000 111.711548
|
||
0 1 82.289795 113.054855 180.530014
|
||
1 1 42.051765 114.543625 4.249123
|
||
2 1 71.826775 96.219109 63.222294
|
||
3 1 160.535675 136.104919 204.020691
|
||
tth@fubar:~/Devel/FloatImg/doc$
|
||
\end{verbatim}
|
||
|
||
Et maintenant, vous voulez un gros exemple ? Bah, ça doit demander
|
||
l'utilisation de Povray\index{Povray}.
|
||
|
||
|
||
% -------------------------
|
||
|
||
% beaucoup trop de maths approximative dans ce passage.
|
||
|
||
\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,
|
||
voire même tenter de les faire se rencontrer, se combiner et
|
||
s'influencer mutuellement.
|
||
|
||
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.
|
||
\index{procrastination}
|
||
Et face à l'incertitude du choix, j'ai reporté l'écriture de ce
|
||
logiciel aux calendes grecques, voire même plus tard,
|
||
après la grande pandémie\dots
|
||
|
||
% -------------------------
|
||
|
||
\subsection{cumulfimgs}\index{cumulfimgs}\label{cumulfimgs}
|
||
|
||
Cet outil accumule\index{cumul} une quantité d'images flottantes
|
||
(de même taille et de même type) afin d'obtenir
|
||
un flou temporel de meilleure qualité.
|
||
Aucune mise à l'échelle n'etant
|
||
effectuée, les pixels de sortie peuvent atteindre des valeurs
|
||
considérables\footnote{Faut-il prévoir une gestion des \textsf{overflows} ?}
|
||
|
||
\begin{verbatim}
|
||
tth@delirium:~/Devel/FloatImg/tools$ ./cumulfimgs -h
|
||
usage :
|
||
cumulfimgs a.fimg b.fimg c-fimg ...
|
||
cumulator options :
|
||
-v increase verbosity
|
||
-o name of output file
|
||
-g convert to gray level
|
||
\end{verbatim}
|
||
|
||
Le nom par défaut du fichier résultant est \texttt{out.fimg}.
|
||
L'exportation « multiformat » est enfin fonctionnelle, dans la
|
||
mesure des formats connus.
|
||
|
||
% ===================================================================
|
||
\section{Debug}\index{Debug}
|
||
|
||
\textit{Et quand plus rien ne fonctionne normalement ?}
|
||
|
||
Ayant une attirance marquée pour la méthode de développement dite
|
||
de \textsl{larache}, que je pratique intensément, j'ai quand même
|
||
besoin de m'équiper de quelques garde-fous. Avec l'expérience, j'ai
|
||
découvert quelques méthodes bien utile quand on est à court de
|
||
poudre verte.
|
||
|
||
\subsection{À la compilation}
|
||
|
||
Première de cordée, la méthode \texttt{DEBUG\_LEVEL}\index{DEBUG\_LEVEL}.
|
||
Elle me sert
|
||
essentiellement à tracer les appels de fonctions, et les paramètres
|
||
qu'elles reçoivent. Ça fait vraiment partie de la création
|
||
des \textsl{boiler-plates}.
|
||
C'est une valeur numérique entière définie dans chaque
|
||
\texttt{Makefile}\index{Makefile}
|
||
qui sera ensuite utilisée
|
||
par le préprocesseur afin de rajouter ce genre de code dans l'exécutable~:
|
||
|
||
\begin{verbatim}
|
||
int fimg_export_picture(FloatImg *pic, char *fname, int flags)
|
||
{
|
||
int filetype, foo;
|
||
#if DEBUG_LEVEL
|
||
fprintf(stderr, ">>> %s ( %p '%s' 0x%X )\n", __func__, pic, fname, flags);
|
||
#endif
|
||
...
|
||
\end{verbatim}
|
||
|
||
Le principe est simple, n'est-il pas, alors pourquoi s'en priver ?
|
||
Bien entendu, la même constante peut être utilisée plus agressivement
|
||
avec une condition comme \texttt{\#if DEBUG\_LEVEL > 2} permettant
|
||
de générer encore plus de messages traçants.
|
||
|
||
Ensuite, pour les cas les plus graves, qui nécessiteront l'utilisation
|
||
du dévermineur \texttt{gdb}\index{gdb}, il y a la directive
|
||
\texttt{MUST\_ABORT} qui est bien plus violente, mais parfois bien
|
||
pratique. Voici le cas classique d'utilisation~:
|
||
|
||
\begin{verbatim}
|
||
foo = fimg_strange_function(&picture, 13.37);
|
||
if (foo) {
|
||
fprintf(stderr, "epic fail %d in %s\n", foo, __func__);
|
||
#if MUST_ABORT
|
||
abort();
|
||
#endif
|
||
...
|
||
\end{verbatim}
|
||
|
||
À condition d'avoir bien réglé votre ulimit pour la génération d'un coredump,
|
||
vous aurez sous la main un fichier \texttt{core} qui vous permettra
|
||
de, par exemple, remonter la pile d'appel avec la commande \texttt{back} de
|
||
gdb. Mais pour le moment, juste une infime partie du code est instrumentée
|
||
avec ce dispositif.
|
||
|
||
|
||
\subsection{À l'exécution}
|
||
|
||
De l'utilisation des nombres magiques dans la détection des structures
|
||
corrompues par un pointeur ayant perdu le nord\dots
|
||
|
||
De l'utilisation des variables d'environnement pour transformer des warnings
|
||
en erreurs fatales\dots
|
||
|
||
% ===================================================================
|
||
\section{TODO}\index{TODO}\label{TODO}\
|
||
\index{XXX}
|
||
|
||
Il reste plein de choses à faire pour que ce soit vraiment utilisable,
|
||
surtout dans un contexte artistique à grande porosité.
|
||
C'est par ces frottements de techniques ayant du sens que les
|
||
choses seront acquises, pour le pire, le meilleur et la
|
||
techno-futilité du monde futur..
|
||
|
||
\begin{itemize}
|
||
\item Import/export au format \textsc{tiff}\index{TIFF} à continuer.
|
||
\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}).
|
||
\item Formaliser les codes d'erreur. \textbf{Urgent}.
|
||
\item Faire une passe complète de Valgrind\index{valgrind}.
|
||
\item Intégrer la fonderie, l'interpolator et le singlepass.
|
||
\item Vérifier le gestion des images mono-canal et de la transparence.
|
||
\end{itemize}
|
||
|
||
% ===================================================================
|
||
\section{Exemples pour yusers}\index{exemple}
|
||
|
||
Nous allons \textsl{essayer d'improviser} un exemple presque réel,
|
||
avec un peu de rache\index{rache} dedans, et beaucoup de simplification.
|
||
Ce qui est autorisé dans les exemples, mais dans la vrai vie, il ne faut
|
||
jamais négliger le traitement des éventuelles erreurs.
|
||
|
||
Nous savons générer une image contenant des pixels aux valeurs
|
||
probablement aléatoires, avec la commande \texttt{mkfimg},
|
||
qui utilise le \texttt{drand48}\index{drand48} de \textsc{posix}\index{POSIX}.
|
||
Maintenant, posons-nous une question de statisticien : que se passe-t-il si
|
||
nous faisons la somme de plusieurs centaines de ces images ?
|
||
|
||
\begin{lstlisting}
|
||
#!/bin/bash
|
||
ACCU="quux.fimg"
|
||
TMPF="tmp.fimg"
|
||
DIMS="320 240"
|
||
mkfimg $ACCU $DIMS
|
||
for i in {0..1000}
|
||
do
|
||
mkfimg -t drand48 ${TMPF} ${DIMS}
|
||
fname=$( printf "xx%04d.pnm" $i )
|
||
fimgops $ACCU $TMPF add $ACCU
|
||
fimg2pnm -v -g $ACCU $fname
|
||
done
|
||
convert -delay 10 xx*.pnm foo.gif
|
||
\end{lstlisting}
|
||
|
||
Voilà, si les choses se passent mal, vous allez découvrir
|
||
que votre \texttt{drand48} n'est pas si "drand" que ça.
|
||
Et ce n'est pas à moi d'en tirer les conclusions...
|
||
|
||
\subsection{Scripts}\index{scripts}\label{scripts}
|
||
|
||
Le script bash\index{bash} \texttt{scripts/shoot.sh} est un front-end
|
||
encore un peu 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}. Le premier est, en fait,
|
||
un bout de shell affectant quelques variables, ou plutôt, les surchargeant.
|
||
|
||
Voici un exemple de réglage~:
|
||
|
||
\begin{lstlisting}
|
||
OPTIONS="${OPTIONS} -v -c pow2 "
|
||
SHOW="yes"
|
||
NBRE=1000
|
||
PERIOD=0
|
||
OFORMAT="p_%04d.png"
|
||
\end{lstlisting}
|
||
|
||
La première ligne demande, en plus des options par défaut, plus de
|
||
bavardage, et un changement de contraste. La seconde demande
|
||
l'affichage de la photo. Les deux suivantes demandent la
|
||
capture de 1000 images à la cadence méga-blast.
|
||
La dernière est moins simple~: \texttt{man sprintf}\index{printf}
|
||
pour comprendre.
|
||
|
||
Quand au second fichier, il contient un compteur (stocké en ascii) qui
|
||
est incrémenté après chaque capture réussie. Et ce compteur est
|
||
utilisable par la variable \texttt{OFORMAT} que nous avons
|
||
vue quelques lignes plus haut.
|
||
|
||
\lstinputlisting[language=sh]{../scripts/shoot.sh}
|
||
|
||
\subsection{Fonderie}\index{fonderie}\label{fonderie}
|
||
|
||
Ce projet externe\footnote{... pour le moment, j'ai des soucis sur
|
||
l'architecture du \textbf{pipdeprod} à adopter\dots} est destiné à la confection
|
||
de films flous\index{film} à partir de photos floues.
|
||
Le script \texttt{scripts/echomix.sh} est une première expérimentation
|
||
en bash, utilisant deux outils en \textsc{cli},
|
||
le premier pouvant salement brotcher une image, et le second capable de
|
||
mélanger harmonieusement deux images, la balance est équilibrée.
|
||
|
||
Il s'agit donc d'un petit programme écrit en Bash\index{bash}, un langage
|
||
dont la connaissance est, pour moi, indispensable à qui veut faire des
|
||
images kitchies\index{kitchy}. Mais ne vous inquiétez pas, c'est en
|
||
fait assez simple à comprendre. Et comprendre, c'est apprendre.
|
||
|
||
Voici donc le script, décomposé et expliqué :
|
||
|
||
\begin{verbatim}
|
||
#!/bin/bash
|
||
|
||
SRCDIR="Fist"
|
||
DSTDIR="Pong"
|
||
FTMP="/dev/shm/tmp.fimg"
|
||
FDST="/dev/shm/foo.fimg"
|
||
|
||
# count the nomber of picz in the source directory
|
||
NBRE=$(ls -1 ${SRCDIR}/*.fimg | wc -l)
|
||
# compute the echo picz offset
|
||
OFFS=$(( NBRE / 4 ))
|
||
\end{verbatim}
|
||
|
||
|
||
Dans ce préliminaire logiciel, nous avons nommé le répertoire
|
||
\textsc{srcdir} contenant les captures d'image au format fimg, le répertoire
|
||
\textsc{dstdir} dans lequel seront rangées les images calculées,
|
||
et l'emplacement de deux fichiers de travail, placés dans ce qui
|
||
peut être vu comme un \textsl{ramdisk}\index{ramdisk}\index{/dev/shm/}
|
||
et qui accélère un peu les opérations.
|
||
|
||
Les quelques lignes suivantes, qui semble bien magiques, ne sont en fait
|
||
que de la magie Unix\index{Unix}. Elles nous permettent d'avoir
|
||
\textsc{nbre}, le nombre d'images à traiter, et \textsc{offs}, un décalage
|
||
dépendant du nombre d'image. Muni de toutes ces informations, nous
|
||
pouvons rentrer dans le lard du sujet, la boucle qui travaille.
|
||
|
||
|
||
\begin{verbatim}
|
||
# MAIN LOOP
|
||
for idx in $(seq 0 $NBRE)
|
||
do
|
||
# build the two input filenames ...
|
||
#
|
||
imgA=$(printf "$SRCDIR/%04d.fimg" $idx)
|
||
vb=$(( $(( idx + OFFS )) % NBRE))
|
||
imgB=$(printf "$SRCDIR/%04d.fimg" $vb)
|
||
|
||
# ... and the output filename
|
||
#
|
||
dst=$(printf "%s/%05d.png" ${DSTDIR} $idx)
|
||
\end{verbatim}
|
||
|
||
Dans cette première partie de la boucle nous avons construit plusieurs
|
||
noms de fichier à partir du rang de la boucle en cours d'exécution,
|
||
des deux valeurs \textsc{nbre} et \textsc{offs} calculées en préambule.
|
||
|
||
\begin{verbatim}
|
||
# trying to autocompute the mixing coefficient
|
||
#
|
||
compute=" s(${idx} / 16) "
|
||
K=$(echo $compute | bc -l)
|
||
printf " %25s => %8.3f\n" "$compute" $K
|
||
\end{verbatim}
|
||
|
||
Cette seconde partie sert à calculer avec la commande
|
||
\texttt{bc}\index{bc}%
|
||
\footnote{\texttt{bc}, c'est vraiment un truc à découvrir.}
|
||
un coefficient variable en fonction du temps :
|
||
$sin(idx/16)$ afin d'avoir une oscillation du coefficient entre
|
||
-1.0 et 1.0, deux valeurs probablement glitchantes.
|
||
|
||
\begin{verbatim}
|
||
# do the hard floating computation
|
||
#
|
||
fimgfx -v cos010 ${imgB} ${FTMP}
|
||
fimgops -k ${K} ${FTMP} ${imgA} mix ${FDST}
|
||
\end{verbatim}
|
||
|
||
Étape suivante, étape cruciale : le brassage d'une multitude de
|
||
pixels flottants.
|
||
|
||
Tout d'abord, nous faisons subir à l'image-echo
|
||
(\texttt{imgB}, définie au début du script) un distorsion
|
||
chromatique de type \textsl{cos010}, le résultat étant écrit
|
||
dans un fichier temporaire. Ensuite, nous mixons l'image
|
||
primaire et son echo en utilisant le rapport de mixage
|
||
calculé quelques lignes plus haut.
|
||
|
||
|
||
\begin{verbatim}
|
||
# write the output as PNG for video encoding
|
||
#
|
||
fimg2png ${FDST} ${dst}
|
||
done
|
||
\end{verbatim}
|
||
|
||
Et en fin de boucle, nous convertissons le résultat de nos
|
||
savants calculs au format PNG, et nous écrivons le fichier dans le
|
||
répertoire de destination fixé au début.
|
||
C'est le moment de passer la main à ffmpeg\index{ffmpeg}.
|
||
|
||
C'est juste une POC\index{POC}, et une implémentation bien plus
|
||
complète écrite en \textbf{C}\index{C} est déja en chantier,
|
||
avec une complexité prévue à un niveau assez réjouissant.
|
||
|
||
% ===================================================================
|
||
%
|
||
% V4L2 is a trap.
|
||
%
|
||
\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.
|
||
|
||
En fait, notre désir secret (enfin, surtout le mien)
|
||
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.
|
||
|
||
\subsection{grabvidseq}\index{grabvidseq}\label{grabvidseq}
|
||
|
||
Un logiciel en évolution (vraiment trop) lente, 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 d'images. (\textsl{workaround}~: écrire une boucle en shell)
|
||
|
||
\begin{verbatim}
|
||
tth@debian:~/Devel/FloatImg/v4l2$ ./grabvidseq -h
|
||
options :
|
||
-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
|
||
-p NN.N delay between frames
|
||
-r 90 mode portrait
|
||
-s WxH size of capture
|
||
-u try upscaling...
|
||
-v increase verbosity
|
||
-X arg Xperiment option
|
||
\end{verbatim}
|
||
|
||
La plupart de ces options ont un usage quasi-évident.
|
||
L'option \texttt{-s} doit correspondre à une des
|
||
résolutions possibles de votre capteur. Le type du
|
||
fichier en sortie (option \texttt{-o}) est déterminé par
|
||
l'extension du nom.
|
||
Actuellement
|
||
seulement \texttt{.fimg}, \texttt{.pnm}, \texttt{.fits},
|
||
\texttt{.tiff} et \texttt{.png}
|
||
sont reconnus.
|
||
|
||
La conversion en gris (option \texttt{-g}) mérite un
|
||
peu plus de travail, et une paramétrisation plus facile.
|
||
L'ajustement de contraste (option\texttt{-c}) est
|
||
vaguement expliqué page \pageref{contraste}.
|
||
|
||
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
|
||
(ou même moyen) terme.
|
||
|
||
\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
|
||
ê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.
|
||
|
||
\textbf{Là, il manque un schéma\dots}
|
||
|
||
\subsection{video-infos}\index{video-infos}\label{video-infos}
|
||
|
||
Que contient, que peut faire mon périphérique \textsl{àlc} ?
|
||
Quelles sont ses possibilités de réglage ?
|
||
|
||
\begin{verbatim}
|
||
tth@debian:~/Devel/FloatImg$ v4l2/video-infos -h
|
||
Options :
|
||
-d select the video device
|
||
-K nnn set the K parameter
|
||
-l list video devices
|
||
-T bla add a title
|
||
-v increase verbosity
|
||
\end{verbatim}
|
||
|
||
Je me sens obligé d'avouer qu'il reste quelques points mystérieux dans
|
||
l'\textsc{api} de \textsc{v4l2}, et donc, que ce que raconte
|
||
ce logiciel doit être pris avec des pincettes. En particulier
|
||
des choses essentielles comme la liste des résolutions disponibles.
|
||
|
||
\subsection{nc-camcontrol}
|
||
|
||
Ajustement \textsl{Brightness Contrast Saturation Hue\dots}
|
||
|
||
Probablement pilotable au joystick\index{joystick} et surtout
|
||
par OSC (Open Sound Control).
|
||
|
||
% ===================================================================
|
||
\section{À l'extérieur}
|
||
|
||
Il existe une foultitude de logiciels (composants ou end-yuser) et
|
||
il est souvent nécessaire de pouvoir communiquer facilement
|
||
avec eux. Nous avons déja quelques possibilité d'exportation,
|
||
mais passer par cette étape intermédiaire est parfois délicat
|
||
à gérer dans un \textsl{pipedeprod} autrement bien huilé.
|
||
De même, nos capacités d'importation sont vraiment trop
|
||
réduites, Jpeg et PNG étant les deux priorités.
|
||
|
||
\subsection{ImageMagick}\index{ImageMagick}
|
||
|
||
Pour afficher notre format .fimg exotique avec \texttt{display}, un
|
||
des éléments du package ImageMagick, vous
|
||
devez mettre ce bout de XML\index{XML} dans le fichier
|
||
\texttt{\$HOME/.magick/delegates.xml}~:
|
||
|
||
\begin{lstlisting}
|
||
<?xml version="1.0" encoding="UTF-8"?>
|
||
<delegatemap>
|
||
<delegate decode="fimg" command="fimg2png '%i' '%o'"/>
|
||
</delegatemap>
|
||
\end{lstlisting}
|
||
|
||
C'est juste un hack rapide, qui ne fonctionne pas très bien avec
|
||
d'autres commande de IM, comme \texttt{identify}\index{identify},
|
||
qui a tendance à
|
||
raconter un peu n'importe quoi, puisqu'elle se base sur le
|
||
résultat de la conversion.
|
||
Je compte donc sur le bouquin de \textsl{Brunus}\index{Brunus}
|
||
pour avancer\dots
|
||
|
||
\subsection{Gimp}\index{Gimp}
|
||
|
||
Mmmmm... Ça semble un peu plus compliqué.
|
||
La documentation à ce sujet me semble ésotérique.
|
||
D'un autre coté, il
|
||
faut faire ça en \textbf{C}, ce qui ne peut pas être totalement négatif.
|
||
Sauf pour les riiRistes.
|
||
|
||
\subsection{ffmpeg}\index{ffmpeg}
|
||
|
||
Un petit aide-mémoire pour encoder vos superbes
|
||
timelapses\index{timelapse} :
|
||
|
||
\begin{lstlisting}
|
||
ffmpeg -nostdin \
|
||
-y -r 30 -f image2 -i stereo/S%04d.png \
|
||
-c:v libx264 \
|
||
-pix_fmt yuv420p \
|
||
-tune film \
|
||
-metadata artist='---[ tTh ]---' \
|
||
-metadata title='awesome video' \
|
||
stereo.mp4
|
||
\end{lstlisting}
|
||
|
||
Il existe environ un gazillion d'options pour encoder avec ffmpeg.
|
||
Bon courage pour toutes les explorer, voire même juste les comprendre.
|
||
|
||
\subsection{Et encore ?}\index{krita}\index{geeqie}
|
||
|
||
Il y a d'autres logiciels pour lesquels écrire une fonction d'importation
|
||
serait bien~: \textsl{Geeqie}, un visualiseur d'image fort pratique, ou
|
||
\textsl{Krita} qui semble avoir les faveurs de
|
||
dessinateurs de talent.
|
||
Ce qui nous conduit à une question importante~: quels sont les logiciels
|
||
qui gèrent le chargement d'image par un système de
|
||
\textsl{plugin}\index{plugin},
|
||
parce que recompiler tout Gimp juste pour ça, c'est un peu overkill.
|
||
|
||
% ===================================================================
|
||
\section{Le flou temporel}
|
||
|
||
\textit{\hspace{7em}Et si nous jouions sur l'axe du temps ?}
|
||
|
||
Nous avons déja plus ou moins la magie du cumul sur la prise de vue
|
||
d'\textbf{image} en enchainant plusieurs captures d'image accumulées
|
||
en une seule.
|
||
Maintenant, voyons ce que l'on peut faire à partir de plusieurs images.
|
||
On peut d'abord penser faire une moyenne (ou la somme, en fait) de toutes
|
||
ces images. Mais ce n'est qu'une façon déguisée de faire du cumul.
|
||
C'est à ce moment que nous changeons l'axe de vue du défi.
|
||
|
||
Par ailleurs, il m'a semblé pertinent d'inclure dans le projet une
|
||
foultitude d'effets spéciaux%
|
||
\footnote{\textsl{aka} IBM\index{IBM} (image brotching module)}.
|
||
Qui manquent cruellement de possibilités de paramétrage.
|
||
Mais peuvent être enchainés dans ce que j'appelle des
|
||
\textsl{filter-chains}~: ces effets seront appliqués dans
|
||
l'ordre aux image traitées soit en entrée soit en sortie.
|
||
Je pense qu'un schéma\footnote{omg, apprendre un nouveau truc en
|
||
\LaTeX, quel challenge étourdissant !} s'impose.
|
||
|
||
|
||
\subsection{\texttt{./fonderie} : \textsl{moving average}}
|
||
|
||
Basé sur la moyenne mobile, avec une structure de
|
||
fifo\index{fifo} particulièrement mal conçue.
|
||
Qui, en fait, n'est pas vraiment un fifo, mais plutôt un buffer
|
||
circulaire. Pour chaque image source, elle est lue, passe dans la chaine de
|
||
filtre d'entrée et est insérée dans ce buffer.
|
||
Ensuite on calcule la moyenne des images contenues dans ce buffer.
|
||
Et pour conclure, cette image moyennée passe au travers de la
|
||
chaine de filtre de sortie, avant d'être enregistrée en PNG\index{PNG}
|
||
dans le répertoire de destination.
|
||
|
||
\begin{verbatim}
|
||
*** fonderie compiled Jan 23 2023, 10:43:56, pid 23366
|
||
options:
|
||
-E input:filter:chain
|
||
-F output:filter:chain
|
||
-I input glob pattern
|
||
-L list available filters
|
||
-O output directory
|
||
-T fifo size
|
||
-v increase verbosity
|
||
\end{verbatim}
|
||
|
||
Euh, c'est quoi un '\textsl{input glob pattern}' ?
|
||
|
||
C'est ce qui vous permet
|
||
de sélectionner un peu les images que vous voulez traiter, exactement
|
||
comme vous pourriez le faire avec un shell classique.
|
||
Par exemple pour choisir une image sur dix, le glob-pattern sera
|
||
'\texttt{frames/????0.fimg}', et vous trouverez les explications détaillées
|
||
dans le manuel~: \texttt{glob(7)}, et \texttt{glob(3)} pour la
|
||
fonction utilisée.
|
||
|
||
% -------------------------------------------------------------------
|
||
|
||
\subsection{Interpolator}\index{interpolator}
|
||
|
||
Pour le moment, juste des calculs pas si simple que ça.
|
||
Je pense qu'il faudra
|
||
se lancer dans des calculs splinesques pour améliorer les choses dans
|
||
la création des images intermédiaires.
|
||
Voyons d'abord le principe actuel.
|
||
|
||
Nous avons une série de centaines, voire de milliers, de photos.
|
||
En parcourant cette liste, nous allons en prélever une sur $N$,
|
||
et entre celle-ci et la
|
||
précédente prélevée, nous allons calculer par interpolation
|
||
\textbf{linéaire} $N - 1$ images intermédiaires, et les
|
||
intercaler entre nos deux sélections pour générer le
|
||
flux de sortie,
|
||
ce qui devrait nous donner un ralenti de bon aloi.
|
||
|
||
\begin{verbatim}
|
||
usage:
|
||
interpolator [options] <inglob> <outdir> <nbsteep>
|
||
options:
|
||
-E i:bla:k input filter chain
|
||
-F name:j output filter chain
|
||
-n make negative
|
||
-S nn mysterious sort
|
||
-L list available filters
|
||
-v increase verbosity
|
||
\end{verbatim}
|
||
|
||
L'option « mysterious sort » mérite bien son nom. Cette friture a
|
||
été écrite il y a bien longtemps pour un projet précis, et les
|
||
résultats ont été décevants. Je pense qu'il est toxique de
|
||
l'utiliser pour le moment\footnote{Ou le repenser différent ?}.
|
||
|
||
% -------------------------------------------------------------------
|
||
|
||
|
||
\subsection{Singlepass}
|
||
|
||
Ce programme \texttt{singlepass} prétend vous permettre de tester
|
||
tous les filtres disponibles, et dont on peut avoir la liste
|
||
avec l'option \texttt{-L}\footnote{liste hélas peu machinable.}
|
||
|
||
\begin{verbatim}
|
||
usage:
|
||
-F define:the:filter:chain
|
||
-g input glob pattern
|
||
-L list available filters
|
||
-O /output/directory (default ./p8)
|
||
-r N repetiiing factor
|
||
-v spit more messages
|
||
\end{verbatim}
|
||
|
||
Il n'y a pas de moyenne mobile, pas d'interpolation, mais un facteur de
|
||
répétition qui permet de dupliquer $N$ fois une image dans le flux de
|
||
sortie. Si vous globez \texttt{rush/????[02468]}, vous prenez
|
||
en compte une image sur deux de la séquence capturée,
|
||
alors un facteur de répétition à $2$ conservera
|
||
la 'vitesse' de la séquence, mais avec une petite saccade régulière
|
||
de bon aloi \textit{:)}
|
||
|
||
% -------------------------------------------------------------------
|
||
|
||
\subsection{Déviance dans le flou ?}
|
||
|
||
Là, nous tombons dans de la \textsl{troiD}\index{3d} de haut niveau,
|
||
avec plein de maths compliquées à l'intérieur.
|
||
Et surtout quelque chose qui n'est encore qu'une idée abstraite,
|
||
mais il y aura du zbuffer\index{zbuffer} dedans.
|
||
|
||
% ===================================================================
|
||
|
||
\section{Expérimentations} \index{experimental}
|
||
|
||
Il m'arrive parfois d'avoir de vagues idées d'image, et donc de logiciel,
|
||
qui tournent dans un coin de la tête.
|
||
Parfois je songe à une fonction qui me
|
||
serait bien utile, mais j'ai des doutes sur son
|
||
\textsc{api}\footnote{Application Programming Interface}\index{api}
|
||
qui soit à la fois simple et complète. Je fais donc des essais.
|
||
Parfois j'imagine confusément un algorithme\index{algorithme} tordu
|
||
et sans but précis. Je le \textit{runne} et je le \textit{re-runne}
|
||
un gazillion de fois dans mon cerveau processique.
|
||
Quel va être son facteur $O$ ? Je fais donc des essais.
|
||
|
||
\subsection{movepixels}
|
||
|
||
\subsection{muxplanes}
|
||
|
||
% ===================================================================
|
||
|
||
\section{Et pour la suite ?}
|
||
|
||
En fait, je fait de la photo par la méthode du « cumul »\index{cumul}
|
||
depuis plusieurs années, au début avec vgrabbj et convert,
|
||
puis avec floatimg et ses satellites.
|
||
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
|
||
|
||
L'idée est donc de construire un appareil autonome, basé sur un Raspi et
|
||
une webcam \textsc{usb}\index{USB}, pilotable par \textsc{lirc}\index{LIRC},
|
||
alimenté par une (grosse) batterie et permettant d'aller
|
||
faire des images au bord d'un lac ou dans la campagne du Gers%
|
||
\footnote{Aux Bourtoulots, par exemple.}.
|
||
Et comme le dit la sagesse populaire : « fimg at 11 ».
|
||
|
||
% -------------------------------------------------------------------
|
||
|
||
% XXX
|
||
% maintenant, comment faire un index sur trois colonnes ?
|
||
%
|
||
|
||
\printindex
|
||
|
||
\end{document}
|