tTh/FloatImg
2
2
Fork 1
Code Issues 2 Pull Requests Releases Wiki Activity

Compare commits

base: tTh:ce6d6e58bba3a63ef8f7d420fc0cc4cd196603c2
Branches Tags
tTh:master
..
compare: tTh:2bd44fa853196453670af6651e160b155209491e
Branches Tags
tTh:master

No commits in common. "ce6d6e58bba3a63ef8f7d420fc0cc4cd196603c2" and "2bd44fa853196453670af6651e160b155209491e" have entirely different histories.
ce6d6e58bb ... 2bd44fa853

18 changed files with 89 additions and 312 deletions
Show Stats Expand all files Collapse all files

30
Fonderie/fifo.c
View File

@ -79,7 +79,7 @@ return 0;
/* -------------------------------------------------------------- */
/* called by 'fonderie.c'
*/
int export_fifo(char *fname, int notused)
int export_fifo(char *fname, int step)
{
int foo, type;
@ -136,18 +136,13 @@ if (verbosity > 2) fprintf(stderr, "%s : next slot %d\n",
return 0;
}
/* -------------------------------------------------------------- */
/*
* this function must have a lot of new parameters,
* -- filetype of exported pictures...
*/
int create_fifo(int nbslot, int w, int h, int imgtype)
int create_fifo(int nbslot, int w, int h, int t)
{
int foo, idx;
#if DEBUG_LEVEL
fprintf(stderr, ">>> %s ( %d %dx%d %d )\n", __func__,
nbslot, w, h, imgtype);
nbslot, w, h, t);
#endif
memset(&g_fifo, 0, sizeof(A_Fifo));
@ -157,32 +152,17 @@ g_fifo.nbslots = nbslot;
g_fifo.slots = calloc(nbslot, sizeof(FloatImg));
if (NULL==g_fifo.slots) abort();
for (idx=0; idx<nbslot; idx++) {
foo = fimg_create(&g_fifo.slots[idx], w, h, imgtype);
foo = fimg_create(&g_fifo.slots[idx], w, h, t);
if (foo) {
fprintf(stderr, "%s idx %d err%d\n", __func__, idx, foo);
return foo;
}
fimg_clear(&g_fifo.slots[idx]);
}
foo = fimg_create(&g_fifo.total, w, h, imgtype);
foo = fimg_create(&g_fifo.total, w, h, t);
g_fifo.next = 0;
g_fifo.magic = MAGIC_FIFO;
return 0;
}
/* -------------------------------------------------------------- */
/*
* omfg ! I've write a setter !
*/
int set_fifo_output_format(int filetype)
{
#if DEBUG_LEVEL
fprintf(stderr, ">>> %s ( %d )\n", __func__, filetype);
#endif
g_fifo.export_type = filetype;
return -1;
}

14
Fonderie/fifo.h
View File

@ -1,21 +1,15 @@
/*
* Machine qui fait des fils flous par la
* méthode de la moyenne mobile.
* Machine qui fait des fils flous
*/
/* -------------------------------------------------------------- */
typedef struct {
unsigned long magic;
int nbslots; /* how many pics used ? */
FloatImg total; /* computing workspace */
FloatImg wspace; /* computing workspace */
FloatImg *slots; /* circular buffer */
int next; /* incremented with modulo */
int export_type; /* fimg/png/pnm/... */
} A_Fifo;
#define MAGIC_FIFO 0xabcd9876
@ -35,13 +29,11 @@ typedef struct {
/* -------------------------------------------------------------- */
int create_fifo(int nbslot, int w, int h, int t);
int set_fifo_output_format(int filetype);
int export_fifo(char *fname, int notused);
int export_fifo(char *fname, int step);
int insert_picture(FloatImg *src);
int create_fifo(int nbslot, int w, int h, int t);
/* -------------------------------------------------------------- */
/*

12
Fonderie/fonderie.c
View File

@ -77,7 +77,7 @@ return 0;
/* -------------------------------------------------------------- */
int demarre_la_machine(char *pattern, char *outdir, int szfifo,
int outfmt, int blk)
int step, int blk)
{
int foo, idx, width, height;
glob_t globbuf;
@ -92,6 +92,8 @@ fprintf(stderr, "\n>>> %s ( '%s' -> '%s' %d )\n", __func__,
pattern, outdir, szfifo);
#endif
if (1 != step) fprintf(stderr, "\tstep is %d\n", step);
(void)fimg_timer_set(0);
memset(&globbuf, 0, sizeof(glob_t));
@ -195,7 +197,7 @@ int foo, opt;
int fifosize = 10;
char *in_pattern = "capture/?????.fimg";
char *out_dir = "p8";
int outfmt = FILE_TYPE_PNG;
int steps = 1;
int blanks = 20;
char *InFchain = "none";
char *OutFchain = "none";
@ -204,7 +206,7 @@ fprintf(stderr, "*** %s\n\tcompiled %s, %s, pid %d\n",
argv[0], __DATE__, __TIME__, getpid());
fimg_print_version(2);
while ((opt = getopt(argc, argv, "B:E:F:ghI:LO:T:vw:x:")) != -1) {
while ((opt = getopt(argc, argv, "B:E:F:ghI:LO:s:T:vw:x:")) != -1) {
switch(opt) {
case 'E': InFchain = optarg; break;
case 'F': OutFchain = optarg; break;
@ -225,6 +227,8 @@ while ((opt = getopt(argc, argv, "B:E:F:ghI:LO:T:vw:x:")) != -1) {
break;
case 'v': verbosity++;
break;
case 's': steps = atoi(optarg);
break;
}
}
@ -252,7 +256,7 @@ if (verbosity) {
fprintf(stderr, ".\n");
}
foo = demarre_la_machine(in_pattern, out_dir, fifosize, outfmt, blanks);
foo = demarre_la_machine(in_pattern, out_dir, fifosize, steps, blanks);
fprintf(stderr, "retour du big-run de la machine -> %d\n", foo);

4
Fonderie/metriques.c
View File

@ -85,10 +85,6 @@ FloatImg image;
int foo;
float fval;
#if DEBUG_LEVEL
fprintf(stderr, ">>> %s ( '%s' %p %d )\n", __func__, fname, where, mode);
#endif
foo = fimg_create_from_dump(fname, &image);
if (foo) {
fprintf(stderr, "%s: err %d loading %s\n", __func__, foo, fname);

5
Fonderie/single.c
View File

@ -23,7 +23,6 @@
static int nextpng, counter;
static char *destination;
static int chainfilter;
static int outtype;
/* and the classic global var */
extern int verbosity;
@ -61,7 +60,6 @@ int single_push_picture(FloatImg *pimg)
{
int foo;
char line[1000], buff[100];
char *extension = ".png";
#if DEBUG_LEVEL
fprintf(stderr, ">>> %s ( %p )\n", __func__, pimg);
@ -73,7 +71,8 @@ if ('/' != line[strlen(line)-1]) {
strcat(line, "/");
}
sprintf(buff, "%05d.%s", nextpng, extension);
// fprintf(stderr, " destdir = '%s'\n", line);
sprintf(buff, "%05d.png", nextpng);
strcat(line, buff);
// fprintf(stderr, "writing %p to '%s'\n", pimg, line);

11
Fonderie/single.h
View File

@ -1,21 +1,16 @@
/*
SINGLE
experimental and/or testing code, do not use in
serious production.
production.
*/
/* -------------------------------------------------------------- */
/*
* next:
* dest:
* fxchain:
* outfmt: see floatimg.h for FILE_TYPE_XXX constants
*/
int single_init(int next, char *dest, int fxchain, int outfmt);
int single_init(int next, char *dest, int fxchain, int outfmt);
int single_push_picture(FloatImg *pimg);
int single_print_state(char *title, int k);
/* -------------------------------------------------------------- */
/* -------------------------------------------------------------- */

5
Fonderie/singlepass.c
View File

@ -142,7 +142,7 @@ int foo, opt;
char *filterchain = "none";
char *globbing = "./capture/?????.fimg";
char *outdir = "./p8";
// char *outtype = ".png";
char *outtype = ".png";
int do_xper = 0;
fprintf(stderr, "*** %s : compiled %s %s\n", __FILE__,
@ -189,11 +189,10 @@ if (verbosity) {
fprintf(stderr, "\tinput glob %s\n", globbing);
fprintf(stderr, "\tfilter chain %s\n", filterchain);
fprintf(stderr, "\toutput dir %s\n", outdir);
// fprintf(stderr, "\toutput type %s\n", outtype);
fprintf(stderr, "\tdo xper %d\n", do_xper);
}
foo = run_the_singlepass(globbing, outdir, FILTERS, FILE_TYPE_PNG);
foo = run_the_singlepass(globbing, outdir, FILTERS, -1);
fprintf(stderr, "\n\tRun the single pass --> %d\n", foo);
return 0;

6
Global.makefile
View File

@ -1,6 +0,0 @@
#
# This file is the 'grandmasta' of the compilation process.
# for now, this is juste a wip idea.
#

172
doc/the_floatimg_hack.tex
View File

@ -44,15 +44,15 @@
\newcommand{\interparagraphe { \vspace{60pt} } }
% -------------------------------------------------------------------
\title{Floating images processing (for fun and profit ?)}
\title{Floating images processing}
\author{tTh}
\begin{document}
\maketitle
\section*{Une image flottante ?}
\section*{Image flottante ?}
\textsl{Mais de quoi parle-t-on exactement ?}
Mais de quoi parle-t-on exactement ?
% XXX XXX XXX\vspace{1em}
@ -120,9 +120,7 @@ quelques milliers d'images standard à 256 niveaux, sans trop avoir
\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.
Dynamique, précision et \textsl{macheps} ?
\subsection{Pixel négatif ?}
@ -147,7 +145,7 @@ 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.
Enfin, non, il y a déja longtemps, avant la grande pandémie.
Enfin, non, il y a déja longtemps, avant la pandémie.
Tout d'abord, nous devons déclarer et garnir quelques variables
pour gérer la machinerie interne.
@ -193,29 +191,25 @@ mean values:
G 0.000000
B 0.000000
A 0.000000
max value 0.000000
max value 0.000000
\end{verbatim}
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.
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}.
Vous trouverez dans le répertoire \texttt{tools/}\index{tools/}
d'autres exemples de mise en œuvre des fonctions disponibles
sous formes d'outils en ligne de commande,
lesquels sont approximativement décrits en page \pageref{outils}.
lesquels sont 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.
\textit{Attention, ça va devenir un peu gore\dots}
une distribution Debian\index{Debian} récente, mais ça marche
quasiment pareil avec Fedora\index{Fedora}.
\textit{Attention, ça devient un peu gore\dots}
\subsection{Prérequis}
@ -240,10 +234,7 @@ Il faut aussi savoir où trouver le code.
\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
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
@ -280,12 +271,11 @@ 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
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 indécement arbitraire.
D'autant plus qu'il y a aussi un répertoire nommé « experiemental ».
\subsection{Structures, macros\dots}
@ -315,7 +305,7 @@ 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}~:
Les constantes adéquates sont dans \texttt{floatimg.h}
\begin{lstlisting}
#define FIMG_TYPE_GRAY 1
@ -357,7 +347,7 @@ 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 ?
encore qu'un concept en devenir, n'est-ce pas ?
% ----------------------------------
@ -365,9 +355,8 @@ encore qu'un concept en devenir, n'est-il pas ?
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~:
ce qui est un sujet parfois délicat\footnote{GC or not GC ?}.
Elle est donc faite, à la base, par ces deux fonctions~:
\begin{lstlisting}
int fimg_create(FloatImg *fimg, int w, int h, int type);
@ -376,8 +365,7 @@ int fimg_destroy(FloatImg *fimg);
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}}.
la forme \emph{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
@ -394,10 +382,10 @@ 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
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.
est tout aussi pertinent. Il y a deux opérations qui supportent le
reste des transits ram/ps.
Le format des fichiers est décrit page \pageref{formatfimg}.
\begin{lstlisting}
@ -593,13 +581,9 @@ typedef struct {
la valeur maximale, la date de création, une longueur d'onde,
et bien plus encore.
Le champ \texttt{magic[8]} doit contenir une valeur magique~:
les quatre premier octets doivent contenir les quatre caractères
\texttt{'FIMG'}, et les quatre dernier doivent être à 0.
Le champ \texttt{magic[8]} doit contenir une valeur magique.
Le champ \texttt{t} (le type de l'image) doit avoir les trois octets
de poids fort à 0. Vous trouverez les constantes de type dans le
fichier \texttt{floatimg.h}, et quelques informations
(non-)essentielles.
de poids fort à 0.
% ----------------------------------
@ -730,14 +714,11 @@ int fimg_colors_mixer_a(FloatImg *fimg, float fval);
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
et surtout répétitif. Un glitch est quasiment souvbent 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 \textsc{Betamax}\index{Betamax}.
sur l'interpolator\index{interpolator} à l'automne 2020.
% ----------------------------------
@ -828,12 +809,12 @@ return 0;
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.
d'essayer par vous-même.
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\dots
de fonctions prévues à cet effet..
% ===================================================================
@ -871,7 +852,7 @@ Usage: mkfimg [options] quux.fimg width height
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.
à $1.0$.
\begin{description} \index{XXX}
\item [black/gray/grey:] efface avec 0.0 (black) ou avec la valeur
@ -1010,10 +991,10 @@ logiciel aux calendes grecques, voire même plus tard.
\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} ?}
(même taille et même type) afin d'obtenir
un flou de meilleure qualité. Aucune mise à l'échelle n'etant
effctuée, les pixels de sortie peuvent atteindre des valeurs
considérables\footnote{Prévoir une gestion des \textsf{overflows} ?}
\begin{verbatim}
tth@delirium:~/Devel/FloatImg/tools$ ./cumulfimgs -h
@ -1028,74 +1009,6 @@ cumulator options :
Le nom par défaut du fichier résultant est \texttt{out.fimg}.
L'exportation « multiformat » est pour bientôt.
% ===================================================================
\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 \textsc{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}
@ -1103,17 +1016,16 @@ en erreurs fatales\dots
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
futilité du monde futur..
choses seront acquises.
\begin{itemize}
\item Import/export au format \textsc{tiff}\index{TIFF} à continuer.
\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}).
\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 Intégrer la fonderie et l'interpolator.
\item Vérifier le gestion des images mono-canal.
\end{itemize}
@ -1462,8 +1374,7 @@ foultitude d'effets spéciaux.
\subsection{\textsl{moving average}}
\texttt{./fonderie} : Basé sur la moyenne mobile, avec une structure de
fifo\index{fifo} particulièrement mal conçue.
\texttt{./fonderie} : Basé sur la moyenne mobile.
\subsection{Interpolator}\index{interpolator}
@ -1477,11 +1388,8 @@ avec l'option \texttt{-L}\footnote{liste hélas peu machinable.}
\subsection{Déviance}
Là, nous tombons dans de la \textsl{troiD}\index{3d} de haut niveau,
avec plein de maths compliquées
Là, nous tombons dans la troiD de haut niveau, avec plein de maths
à l'intérieur.
Et surtout quelque chose qui n'est encore qu'une idée abstraite,
mais il y aura du zbuffer dedans.
% ===================================================================
@ -1501,10 +1409,6 @@ faire des images au bord d'un lac ou dans la campagne de l'Ariège.
% -------------------------------------------------------------------
% XXX
% maintenant, comment faire un index sur trois colonnes ?
%
\printindex
\end{document}

3
funcs/Makefile
View File

@ -1,8 +1,5 @@
#---------------------------------------------------------------
# Please, use the 'Gloabl.makefile' system !
COPT = -Wall -fpic -g -no-pie -DDEBUG_LEVEL=0
DEPS = ../floatimg.h Makefile

6
funcs/t.c
View File

@ -22,7 +22,7 @@ float global_fvalue;
enum nCmd { Equalize=1, Rotate, Sfx0, F3x3, MIRE, Wfits, Wpng, Wtiff,
Histo, Hsv, Classif, Ctr2x2, Qsortrgb,
Displace, ReadPNG, Plasmas, Hilight, OpenEXR,
Geometrie, FileType };
Geometrie };
typedef struct {
char *name;
int Cmd;
@ -48,7 +48,6 @@ Command commands[] = {
{ "hilight", Hilight },
{ "openexr", OpenEXR },
{ "geometrie", Geometrie, },
{ "filetype", FileType },
{ NULL, 0 }
} ;
@ -208,9 +207,6 @@ switch(opt) {
case Geometrie:
foo = essai_geometrie(filename, 0);
break;
case FileType:
foo = essai_detect_type();
break;
default:
fprintf(stderr, "'%s' is a bad command\n", command);
exit(1);

19
funcs/tests.c
View File

@ -616,22 +616,22 @@ int foo;
char *fname;
foo = format_from_extension(fname="foo.fimg");
printf("%-10s %3d\n", fname, foo);
printf("%-10s %d\n\n", fname, foo);
foo = format_from_extension(fname="foo.pnm");
printf("%-10s %3d\n", fname, foo);
printf("%-10s %d\n\n", fname, foo);
foo = format_from_extension(fname="foo.png");
printf("%-10s %3d\n", fname, foo);
printf("%-10s %d\n\n", fname, foo);
foo = format_from_extension(fname="foo.tiff");
printf("%-10s %3d\n", fname, foo);
printf("%-10s %d\n\n", fname, foo);
foo = format_from_extension(fname="foo.fits");
printf("%-10s %3d\n", fname, foo);
printf("%-10s %d\n\n", fname, foo);
foo = format_from_extension(fname="foo.xyzzy");
printf("%-10s %3d\n", fname, foo);
printf("%-10s %d\n\n", fname, foo);
return 0;
}
@ -639,7 +639,7 @@ return 0;
int essai_mire(char *outname, int notused)
{
FloatImg fimg;
int re, foo;
int re;
fimg_create(&fimg, 1280, 960, FIMG_TYPE_RGB);
@ -647,10 +647,9 @@ re = fimg_test_pattern(&fimg, 9, 1.0);
if (re) {
fprintf(stderr, "fimg_test_pattern -> %d\n", re);
}
foo = fimg_export_picture(&fimg, "mire.pnm", 0);
fprintf(stderr, "in %s, export give a %d value\n", __func__, foo);
fimg_export_picture(&fimg, "mire.pnm", 0);
return 0;
return -1;
}
/* --------------------------------------------------------------------- */
int essai_rampes(void)

2
funcs/tests.h
View File

@ -20,7 +20,7 @@ int fimg_essai_hsv(char *infile);
int essai_classif(char *infile, char *outfile, float fvalue);
int essai_contour_2x2(char *filename, char *outfile);
int essai_geometrie(char *infile, int notused);
int essai_detect_type(void);
int fimg_essai_histo(FloatImg *src, char *outpic, int k); /* histogram.c */
int essai_histogramme(char *fname, int k);

55
funcs/utils.c
View File

@ -49,25 +49,6 @@ if (1 == foo) {
*dptr = value;
return 1;
}
return -1;
}
/* --------------------------------------------------------------------- */
int file_type_from_name(char *name)
{
#if DEBUG_LEVEL
fprintf(stderr, ">>> %s ( '%s' )\n", __func__, name);
#endif
if (!strcasecmp(name, "pnm" )) return FILE_TYPE_PNM;
if (!strcasecmp(name, "fimg")) return FILE_TYPE_FIMG;
if (!strcasecmp(name, "tga" )) return FILE_TYPE_TGA;
if (!strcasecmp(name, "png" )) return FILE_TYPE_PNG;
if (!strcasecmp(name, "tiff")) return FILE_TYPE_TIFF;
if (!strcasecmp(name, "tif" )) return FILE_TYPE_TIFF;
if (!strcasecmp(name, "fits")) return FILE_TYPE_FITS;
if (!strcasecmp(name, "exr")) return FILE_TYPE_EXR;
return -1;
}
/* --------------------------------------------------------------------- */
@ -75,10 +56,6 @@ int format_from_extension(char *fname)
{
char *cptr;
#if DEBUG_LEVEL
fprintf(stderr, ">>> %s ( '%s' )\n", __func__, fname);
#endif
cptr = rindex(fname, '.');
if (NULL==cptr) {
fprintf(stderr, "No dot in %s\n", fname);
@ -86,28 +63,18 @@ if (NULL==cptr) {
}
#if DEBUG_LEVEL
fprintf(stderr, "\t[%s] --> [%s]\n", fname, cptr);
fprintf(stderr, "[%s] --> [%s]\n", fname, cptr);
#endif
return file_type_from_name(cptr+1);
}
/* --------------------------------------------------------------------- */
char * extension_from_format(int fmt)
{
switch (fmt) {
case FILE_TYPE_FIMG: return ".fimg"; break;
case FILE_TYPE_PNM: return ".pnm"; break;
case FILE_TYPE_PNG: return ".png"; break;
case FILE_TYPE_TIFF: return ".tiff"; break;
case FILE_TYPE_FITS: return ".fits"; break;
case FILE_TYPE_TGA: return ".tga"; break;
default:
fprintf(stderr, "%s: bad %d fmt type\n", __func__, fmt);
return NULL;
}
return "???";
if (!strcasecmp(cptr, ".pnm" )) return FILE_TYPE_PNM;
if (!strcasecmp(cptr, ".fimg")) return FILE_TYPE_FIMG;
if (!strcasecmp(cptr, ".tga" )) return FILE_TYPE_TGA;
if (!strcasecmp(cptr, ".png" )) return FILE_TYPE_PNG;
if (!strcasecmp(cptr, ".tiff")) return FILE_TYPE_TIFF;
if (!strcasecmp(cptr, ".tif" )) return FILE_TYPE_TIFF;
if (!strcasecmp(cptr, ".fits")) return FILE_TYPE_FITS;
if (!strcasecmp(cptr, ".exr")) return FILE_TYPE_EXR;
return -1;
}
/* --------------------------------------------------------------------- */

2
tools/Makefile
View File

@ -2,8 +2,6 @@
# makefile for floatimg tools
# use with caution
#
# PLEASE ! update to the 'Global.makefile' concept !
#
COPT = -Wall -fpic -g -DDEBUG_LEVEL=0 -lm
DEPS = ../floatimg.h ../libfloatimg.a Makefile

22
tools/fimgfx.c
View File

@ -31,13 +31,13 @@ Fx fx_list[] = {
{ "pow2", Fx_pow2, 0, 1 },
{ "sqrt", Fx_sqrt, 0, 1 },
{ "gray0", Fx_gray0, 0, 1 },
// { "halfsz0", Fx_halfsz0, 0, 1 },
// { "rot90", Fx_rot90, 0, 0 },
{ "halfsz0", Fx_halfsz0, 0, 1 },
{ "rot90", Fx_rot90, 0, 0 },
{ "cmixa", Fx_cmixa, 0, 1 },
{ "xper", Fx_xper, 0, 1 },
{ "desat", Fx_desat, 0, 1 },
{ "ctr2x2", Fx_ctr2x2, 0, 1 },
// { "norm", Fx_norm, 0, 1 },
{ "norm", Fx_norm, 0, 1 },
{ "classtrial", Fx_classtrial, 0, 1 },
{ "binarize", Fx_binarize, 0, 1 },
{ "trinarize", Fx_trinarize, 0, 1 },
@ -45,14 +45,6 @@ Fx fx_list[] = {
{ NULL, 0, 0, 0 }
};
/* --------------------------------------------------------------------- */
static void list_of_effects(void)
{
Fx *fx;
for (fx=fx_list; fx->name; fx++) {
printf("%s\n", fx->name);
}
}
/* --------------------------------------------------------------------- */
int lookup_fxidx(char *txt)
{
@ -113,7 +105,6 @@ puts("\tfimgfx [options] <effect> source.fimg resultat.fimg");
puts("options:");
puts("\t-k N.N\tset the floating value");
puts("\t-l\tlist effects");
puts("\t-v\tincrease verbosity");
puts("effects:");
@ -226,11 +217,9 @@ switch (action) {
}
// foo = fimg_export_picture(&dest, dstfname, 0);
foo = fimg_dump_to_file(&dest, dstfname, 0);
if (foo) {
fprintf(stderr, "dumping datas to file '%s' give us a %d\n",
dstfname, foo);
fprintf(stderr, "dumping datas to file give us a %d\n", foo);
return foo;
}
@ -251,11 +240,10 @@ char *operator;
char *srcname = "";
char *dstname = "out.fimg";
while ((opt = getopt(argc, argv, "hk:lv")) != -1) {
while ((opt = getopt(argc, argv, "hk:v")) != -1) {
switch(opt) {
case 'h': help(0); break;
case 'k': global_fvalue = atof(optarg); break;
case 'l': list_of_effects(); exit(0);
case 'v': verbosity++; break;
}
}

26
tools/fx_demo.sh
View File

@ -1,26 +0,0 @@
#!/bin/bash
SRC="in.fimg"
K="0.414"
TMP="/tmp/foo.fimg"
for fx in $(./fimgfx -l)
do
printf "========== %-12s =========\n" $fx
outfile=$(printf "/tmp/fx_%s.png" $fx)
echo $outfile
rm $TMP
./fimgfx -v -k $K $fx $SRC $TMP
if [ $? \!= 0 ] ; then
echo error $?
exit 1
fi
./fimg2png -v $TMP $outfile
echo ; sleep 1
done

7
v4l2/rgb2fimg.c
View File

@ -24,12 +24,7 @@ static unsigned short modz;
* check in image sizes are correct
*/
if ( d->width != w*2 || d->height != h*2 ) {
fprintf(stderr, "%s: dimension error\n", __func__);
fprintf(stderr, "\tw = %d h = %d\n", w, h);
fprintf(stderr, "\tdest image is %dx%d\n", d->width, d->height);
#if MUST_ABORT
abort();
#endif
fprintf(stderr, "%s : dimension error\n", __func__);
return -2;
}