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

Merge branch 'master' of ssh://tetalab.org:2213/tTh/FloatImg

Browse Source 
something is broken ?
This commit is contained in:
tonton th 2020-10-10 01:26:19 +02:00
commit aa42aa99fb
16 changed files with 559 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -27,6 +27,7 @@ doc/co*.tex
funcs/t
funcs/*.o
funcs/*.png
funcs/V/*
funcs/*.gif
funcs/*.fits
funcs/*.tiff

40
doc/the_floatimg_hack.tex
View File

@ -412,7 +412,7 @@ 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 mal passé.
chose s'est probablement mal passé.
Certains messages sont parfois explicites.
% _________
@ -884,7 +884,7 @@ 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 xper
cos01 cos010 pow2 sqrt gray0 cmixa xper desat
\end{verbatim}
Certaines de ces opérations ont besoin d'un paramètre flottant.
@ -898,6 +898,12 @@ sera lisible avec le sélecteur \texttt{-L}.
\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.
% ---------------------
\subsection{fimgops}\index{fimgops}\label{fimgops}
Quelques opérations diverses entre deux images, qui doivent être
@ -955,9 +961,34 @@ avoir plusieurs plans de réalité. Il ne faut en négliger aucun.
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.
\subsection{cumulfimgs}\index{cumulfimgs}\label{cumulfimgs}
Cet outil accumule\index{cumul} une quantité d'images flottantes
(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
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 pour bientôt.
% -------------------------------------------------------------------
\section{TODO}\index{TODO}\label{TODO}
\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é.
@ -971,7 +1002,8 @@ choses seront acquises.
\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 Integrer la fonderie et l'interpolator.
\item Intégrer la fonderie et l'interpolator.
\item Vérifier le gestion des images mono-canal.
\end{itemize}
% -------------------------------------------------------------------

11
floatimg.h
View File

@ -3,7 +3,7 @@
* ugly code from tTh
*/
#define FIMG_VERSION 106
#define FIMG_VERSION 109
/*
* in memory descriptor
@ -97,6 +97,9 @@ int fimg_killborders(FloatImg *img);
int fimg_lissage_2x2(FloatImg *img);
int fimg_filter_3x3(FloatImg *s, FloatImg *d, FimgFilter3x3 *filtr);
int fimg_contour_2x2(FloatImg *psrc, FloatImg *pdst, int notused);
/* 'sfx0' module */
int fimg_killcolors_a(FloatImg *fimg, float fval);
int fimg_killcolors_b(FloatImg *fimg, float fval);
@ -124,6 +127,10 @@ int fimg_cos_010(FloatImg *s, FloatImg *d, double maxval);
int fimg_mix_rgb_gray(FloatImg *img, float mix);
int fimg_shift_to_zero(FloatImg *s, FloatImg *d, float coefs[6]);
/* * * * experimental ! */
int fimg_classif_trial(FloatImg *src, FloatImg*dst, float fval, int notused);
int fimg_qsort_rgb_a(FloatImg *psrc, FloatImg *pdst, int notused);
int fimg_qsort_rgb_b(FloatImg *psrc, FloatImg *pdst, int notused);
/* module funcs/geometry.c */
int fimg_equalize_compute(FloatImg *src, void *vptr, float vmax);
@ -158,7 +165,7 @@ int fimg_meanvalues(FloatImg *head, float means[4]);
int fimg_to_gray(FloatImg *head);
void fimg_add_cste(FloatImg *fi, float value);
void fimg_mul_cste(FloatImg *fi, float value);
int fimg_normalize(FloatImg *fi, double maxima, int notused);
int fimg_ajust_from_grab(FloatImg *fi, double maxima, int notused);
void fimg_drand48(FloatImg *fi, float kmul);
int fimg_count_negativ(FloatImg *fi);
int fimg_clamp_negativ(FloatImg *fi);

12
funcs/Makefile
View File

@ -5,7 +5,7 @@ DEPS = ../floatimg.h Makefile
OBJS = fimg-png.o fimg-tiff.o misc-plots.o filtrage.o utils.o \
fimg-libpnm.o rampes.o sfx0.o geometry.o rotate.o \
equalize.o fimg-fits.o saturation.o histogram.o \
hsv.o
hsv.o classif.o contour2x2.o qsortrgb.o
#---------------------------------------------------------------
@ -55,9 +55,19 @@ equalize.o: equalize.c $(DEPS)
sfx0.o: sfx0.c $(DEPS)
gcc $(COPT) -c $<
contour2x2.o: contour2x2.c $(DEPS)
gcc $(COPT) -c $<
rampes.o: rampes.c $(DEPS)
gcc $(COPT) -c $<
classif.o: classif.c $(DEPS)
gcc $(COPT) -c $<
qsortrgb.o: qsortrgb.c $(DEPS)
gcc $(COPT) -c $<
hsv.o: hsv.c $(DEPS)
gcc $(COPT) -c $<

93
funcs/classif.c Normal file
View File

@ -0,0 +1,93 @@
/*
* classif.c
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include "../floatimg.h"
int verbosity;
/* --------------------------------------------------------------------- */
/* nouveau 2 octobre 2020, juste avant sonoptic de la pluie craignos */
int fimg_classif_trial(FloatImg *psrc, FloatImg *pdst, float fval, int notused)
{
float minmax[6], delta[3], baryc[3];
float range, dist, rgb[3], dr, dg, db;
int x, y, on, off;
#if DEBUG_LEVEL
fprintf(stderr, ">>> %s ( %p %p %f %d )\n", __func__, psrc, pdst, fval, notused);
#endif
/* calculer les amplitudes RGB de l'image source */
fimg_get_minmax_rgb(psrc, minmax);
delta[0] = minmax[1] - minmax[0];
delta[1] = minmax[3] - minmax[2];
delta[2] = minmax[5] - minmax[4];
/* chercher le plus petit des deltas */
range = delta[0]; if (delta[1]<range) range=delta[1];
if (delta[2]<range) range=delta[2];
/* convertir le diametre en rayon (magic inside) */
range *= fval;
if (verbosity ) fprintf(stderr, "deltas : %f %f %f / %f\n",
delta[0], delta[1], delta[2], range);
/* calcul du "barycentre" chromatique */
baryc[0] = (minmax[1] + minmax[0]) / 2;
baryc[1] = (minmax[3] + minmax[2]) / 2;
baryc[2] = (minmax[5] + minmax[4]) / 2;
if (verbosity) fprintf(stderr, "barycs : %f %f %f\n",
baryc[0], baryc[1], baryc[2]);
on = off = 0;
for (y=0; y<psrc->height; y++) {
for (x=0; x<psrc->width; x++) {
fimg_get_rgb(psrc, x, y, rgb);
/* calcul de la distance chromatique */
dr = rgb[0] - baryc[0];
dg = rgb[1] - baryc[1];
db = rgb[2] - baryc[2];
dist = sqrtf( (dr*dr) + (dg*dg) + (db*db) );
#if DEBUG_LEVEL
if (x==y) fprintf(stderr, "%4d %4d %f\n", x, y, dist);
#endif
/* action !!! */
if (dist > range) {
/* make our pixel gray-level */
rgb[0] = rgb[1] = rgb[2] = 0.0;
// (rgb[0] + rgb[1] + rgb[2]) / 3.0;
on++;
}
else {
/* the easy part : do nothing */
off++;
}
fimg_put_rgb(pdst, x, y, rgb);
/* MUST BE MORE CREATIVE HERE !!! */
}
}
fprintf(stderr, "on %d off %d\n", on, off);
return 0;
}
/* --------------------------------------------------------------------- */

71
funcs/contour2x2.c Normal file
View File

@ -0,0 +1,71 @@
/*
* classif.c
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include "../floatimg.h"
int verbosity;
/* --------------------------------------------------------------------- */
/* nouveau 4 octobre 2020, juste avant sonoptic de la pluie craignos */
int fimg_contour_2x2(FloatImg *psrc, FloatImg *pdst, int notused)
{
float avg[4];
int foo, x, y, q;
int tbl[] = /* deep magic inside */
{
0, 1, 1, 1,
1, 1, 0, 1,
1, 0, 1, 1,
1, 1, 1, 0
};
#if DEBUG_LEVEL
fprintf(stderr, ">>> %s ( %p %p %d )\n", __func__, psrc, pdst, notused);
#endif
foo = fimg_meanvalues(psrc, avg);
if (verbosity) {
fprintf(stderr, "mean values : %f %f %f\n", avg[0], avg[1], avg[2]);
}
#define RP(ix, iy) ( psrc->R[((iy)*psrc->width)+(ix)] < avg[0] )
#define GP(ix, iy) ( psrc->G[((iy)*psrc->width)+(ix)] < avg[1] )
#define BP(ix, iy) ( psrc->B[((iy)*psrc->width)+(ix)] < avg[2] )
for (y=0; y<psrc->height-1; y++) {
for (x=0; x<psrc->width-1; x++) {
q = ( ( RP(x, y) << 3 ) |
( RP(x+1, y) << 2 ) |
( RP(x, y+1) << 1 ) |
( RP(x+1, y+1) ) );
pdst->R[(y*psrc->width)+x] = tbl[q] ? 1.0 : 0.0 ;
q = ( ( GP(x, y) << 3 ) |
( GP(x+1, y) << 2 ) |
( GP(x, y+1) << 1 ) |
( GP(x+1, y+1) ) );
pdst->G[(y*psrc->width)+x] = tbl[q] ? 1.0 : 0.0 ;
q = ( ( BP(x, y) << 3 ) |
( BP(x+1, y) << 2 ) |
( BP(x, y+1) << 1 ) |
( BP(x+1, y+1) ) );
pdst->B[(y*psrc->width)+x] = tbl[q] ? 1.0 : 0.0 ;
}
}
return 0;
}
/* --------------------------------------------------------------------- */

8
funcs/equalize.c
View File

@ -19,7 +19,7 @@ int foo;
float dr, dg, db;
#if DEBUG_LEVEL
fprintf(stderr, ">>> %s ( %p )\n", __func__, src);
fprintf(stderr, ">>> %s ( %p %p %f )\n", __func__, src, vptr, vmax);
#endif
memset(minmax, 0, 6*sizeof(float));
@ -34,9 +34,9 @@ dr = minmax[1] - minmax[0];
dg = minmax[3] - minmax[2];
db = minmax[5] - minmax[4];
printf("Rmin %12.4g Rmax %12.4g delta %12.4g\n", minmax[0], minmax[1], dr);
printf("Gmin %12.4g Gmax %12.4g delta %12.4g\n", minmax[2], minmax[3], dg);
printf("Bmin %12.4g Bmax %12.4g delta %12.4g\n", minmax[4], minmax[5], db);
printf("Rmin %12.4g max %12.4g delta %12.4g\n", minmax[0], minmax[1], dr);
printf("Gmin %12.4g max %12.4g delta %12.4g\n", minmax[2], minmax[3], dg);
printf("Bmin %12.4g max %12.4g delta %12.4g\n", minmax[4], minmax[5], db);
if ( (minmax[0]<0.0) || (minmax[2]<0.0) || (minmax[4]<0.0) ) {
fprintf(stderr, "%s: negative value ?\n", __func__);

104
funcs/qsortrgb.c Normal file
View File

@ -0,0 +1,104 @@
/*
* qsort_rgb.c
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include "../floatimg.h"
int verbosity;
/* --------------------------------------------------------------------- */
/* nouveau 7 octobre 2020, juste avant sonoptic de la pluie craignos */
static int compare_a(const void *p1, const void *p2)
{
return ( *(float *)p1 < *(float *)p2 );
}
int fimg_qsort_rgb_a(FloatImg *psrc, FloatImg *pdst, int notused)
{
int foo, szimg;
#if DEBUG_LEVEL
fprintf(stderr, ">>> %s ( %p %p %d )\n", __func__, psrc, pdst, notused);
#endif
foo = fimg_copy_data(psrc, pdst);
szimg = pdst->width * pdst->height;
fprintf(stderr, "%s : %d pixels\n", __func__, szimg);
qsort(pdst->R, szimg, sizeof(float), compare_a);
qsort(pdst->G, szimg, sizeof(float), compare_a);
qsort(pdst->B, szimg, sizeof(float), compare_a);
return 0;
}
/* --------------------------------------------------------------------- */
typedef struct {
float sum;
float r, g, b;
} pix;
static compare_b(const void *p1, const void *p2)
{
pix *s1, *s2;
s1 = (pix *)p1;
s2 = (pix *)p2;
return ( s1->sum < s2->sum );
}
int fimg_qsort_rgb_b(FloatImg *psrc, FloatImg *pdst, int notused)
{
int x, y, szimg;
pix *ppix, *ptr;
float rgb[3];
// #if DEBUG_LEVEL
fprintf(stderr, ">>> %s ( %p %p %d )\n", __func__, psrc, pdst, notused);
// #endif
szimg = pdst->width * pdst->height;
fprintf(stderr, "%s : %d pixels\n", __func__, szimg);
ppix = calloc(szimg, sizeof(pix));
ptr = ppix; /* mobile pointer */
for (y=0; y<psrc->height; y++) {
for (x=0; x<psrc->width; x++) {
fimg_get_rgb(psrc, x, y, rgb);
ptr->sum = rgb[0] + rgb[1] + rgb[2];
ptr->r = rgb[0];
ptr->g = rgb[1];
ptr->b = rgb[2];
ptr++; /* next pixel */
}
}
qsort(ppix, szimg, sizeof(pix), compare_b);
ptr = ppix; /* mobile pointer */
for (y=0; y<psrc->height; y++) {
for (x=0; x<psrc->width; x++) {
rgb[0] = ptr->r;
rgb[1] = ptr->g;
rgb[2] = ptr->b;
fimg_put_rgb(pdst, x, y, rgb);
ptr++; /* next pixel */
}
}
free(ppix);
return 0;
}
/* --------------------------------------------------------------------- */

139
funcs/t.c
View File

@ -14,6 +14,126 @@ int verbosity;
float global_fvalue;
/* --------------------------------------------------------------------- */
/*
* nouveau 7 octobre 2020 pendant sonoptic
*/
//
int essai_qsort_rgb(char *infile)
{
FloatImg src, dst;
int foo;
if (NULL != infile) {
fprintf(stderr, "%s : loading %s\n", __func__, infile);
foo = fimg_create_from_dump(infile, &src);
if (foo) {
fprintf(stderr, "%s: error loading '%s'\n", __func__, infile);
return foo;
}
}
else {
fprintf(stderr, "%s : NOT INPUT FILE, FUBAR\n", __func__);
abort();
}
fimg_clone(&src, &dst, 1);
foo = fimg_qsort_rgb_b(&src, &dst, 0);
if (foo) {
fprintf(stderr, "%s: err %d in qsort_rgb\n", __func__, foo);
return foo;
}
foo = fimg_dump_to_file(&dst, "out.fimg", 0);
if (foo) {
fprintf(stderr, "%s : err %d saving result\n", __func__, foo);
return foo;
}
return 0;
}
/* --------------------------------------------------------------------- */
/*
* nouveau 5 octobre 2020 pendant sonoptic
*/
int essai_contour_2x2(char *infile)
{
FloatImg src, dst;
int foo;
if (NULL != infile) {
fprintf(stderr, "%s : loading %s\n", __func__, infile);
foo = fimg_create_from_dump(infile, &src);
if (foo) {
fprintf(stderr, "%s: error loading '%s'\n", __func__, infile);
return foo;
}
}
else {
fprintf(stderr, "%s : NOT INPUT FILE, FUBAR\n", __func__);
abort();
}
fimg_clone(&src, &dst, 1);
foo = fimg_contour_2x2(&src, &dst, 0);
if (foo) {
fprintf(stderr, "%s: err %d in contour_2x2\n", __func__, foo);
return foo;
}
foo = fimg_save_as_pnm(&dst, "out.pnm", 0);
if (foo) {
fprintf(stderr, "%s : err %d saving result\n", __func__, foo);
return foo;
}
return 0;
}
/* --------------------------------------------------------------------- */
/*
* nouveau 5 octobre 2020 pendant sonoptic
*/
int essai_classif(char *infile)
{
FloatImg src, dst;
int foo;
if (NULL != infile) {
fprintf(stderr, "%s : loading %s\n", __func__, infile);
foo = fimg_create_from_dump(infile, &src);
if (foo) {
fprintf(stderr, "%s: error loading '%s'\n", __func__, infile);
return foo;
}
}
else {
fprintf(stderr, "%s : NOT INPUT FILE, FUBAR\n", __func__);
abort();
}
fimg_clone(&src, &dst, 1);
fprintf(stderr, "%s : fvalue is %f\n", __func__, global_fvalue);
foo = fimg_classif_trial(&src, &dst, global_fvalue, 0);
if (foo) {
fprintf(stderr, "%s: err %d in classif_trial\n", __func__, foo);
return foo;
}
foo = fimg_save_as_pnm(&dst, "out.pnm", 0);
if (foo) {
fprintf(stderr, "%s : err %d saving result\n", __func__, foo);
return foo;
}
return 0;
}
/* --------------------------------------------------------------------- */
/* nouveau 19 aout 2020, le matin avant la canicule */
@ -31,7 +151,6 @@ if (foo) {
return foo;
}
return -7;
}
/* --------------------------------------------------------------------- */
@ -434,7 +553,7 @@ return 0;
}
/* --------------------------------------------------------------------- */
enum nCmd { Equalize=1, Rotate, Sfx0, F3x3, MIRE, Wfits, Wpng, Wtiff,
Histo, Hsv };
Histo, Hsv, Classif, Ctr2x2, Qsortrgb };
typedef struct {
char *name;
int Cmd;
@ -451,6 +570,9 @@ Command commands[] = {
{ "wtiff", Wtiff },
{ "histo", Histo },
{ "hsv", Hsv },
{ "classif", Classif },
{ "ctr2x2", Ctr2x2 },
{ "qsortrgb", Qsortrgb },
{ NULL, 0 }
} ;
@ -514,7 +636,9 @@ command = argv[optind];
filename = argv[optind+1];
if (verbosity) {
fprintf(stderr, "running command '%s' on '%s'\n", command, filename);
fprintf(stderr, "%s : running command '%s' on '%s'\n",
argv[0], command, filename);
fprintf(stderr, "global fvalue : %f\n", global_fvalue);
}
opt = lookup_cmd(command);
@ -547,6 +671,15 @@ switch(opt) {
case Hsv:
foo = fimg_essai_hsv(filename);
break;
case Classif:
foo = essai_classif(filename);
break;
case Ctr2x2:
foo = essai_contour_2x2(filename);
break;
case Qsortrgb:
foo = essai_qsort_rgb(filename);
break;
default:
fprintf(stderr, "%s : bad command\n", command);
exit(1);

32
funcs/vroum.sh Executable file
View File

@ -0,0 +1,32 @@
#!/bin/bash
src=/dev/shm/foo.fimg
out=out.fimg
maxi=99
W="640"
H="480"
grabopt=" -s 640x480 -v -p 0 -n 100 -c cos01 "
mkdir /tmp/V
G=$(printf "%dx%d+0+0" $W $H)
for foo in $(seq 0 $maxi)
do
echo
grabvidseq -$grabopt -o $src
fval=$(echo "$foo / $maxi" | bc -l)
./t -k $fval -v qsortrgb $src
echo $foo ' = ' $fval
dst=$(printf "/tmp/V/%03d.png" $foo)
montage $src $out -geometry $G $dst
done
convert -delay 10 V/*.png foo.gif

3
install.sh
View File

@ -4,8 +4,9 @@ cp libfloatimg.a /usr/local/lib
cp floatimg.h /usr/local/include
cp tools/mkfimg tools/fimg2pnm tools/fimgops \
tools/fimg2png tools/fimg2tiff \
tools/fimg2png tools/fimg2tiff tools/fimg2fits \
tools/png2fimg tools/fimgstats tools/fimgfx \
tools/cumulfimgs \
/usr/local/bin
cp v4l2/grabvidseq v4l2/video-infos \

2
lib/fimg-2gray.c
View File

@ -70,7 +70,7 @@ for (foo=0; foo<nbb; foo++) {
(src->R[foo] + src->G[foo] + src->B[foo]) / 3.0;
}
return -99;
return 0;
}
/* --------------------------------------------------------------------- */

2
lib/fimg-math.c
View File

@ -246,7 +246,7 @@ for (idx=0; idx<nbre; idx++) {
}
}
/* ---------------------------------------------------------------- */
int fimg_normalize(FloatImg *fi, double maxima, int notused)
int fimg_ajust_from_grab(FloatImg *fi, double maxima, int notused)
{
double coef;

39
tools/cumulfimgs.c
View File

@ -19,12 +19,12 @@ int foo, numbers[3];
foo = fimg_fileinfos(path, numbers);
if (foo) {
#if DEBUG_LEVEL
fprintf(stderr, "%s -> err %d\n", path, foo);
fprintf(stderr, "fileinfo of '%s' -> err %d\n", path, foo);
#endif
return foo;
}
fprintf(stderr, "%s \t%d x %d\n",path, numbers[0], numbers[1]);
if (verbosity) fprintf(stderr, "%-20s %d x %d\n",path, numbers[0], numbers[1]);
if (FIMG_TYPE_RGB != numbers[2]) {
fprintf(stderr, "file %s, %d : bad type\n", path, numbers[2]);
@ -36,10 +36,13 @@ return 0;
/* --------------------------------------------------------------------- */
void help(int v)
{
puts("");
puts("$ cumulfimgs a.fimg b.fimg c-fimg ...");
puts("cumulator options :");
puts("\t-v\tincrease verbosity");
puts("\t-o\tname of output file");
puts("\t-g\tconvert to gray level");
puts("");
if (verbosity) { puts(""); fimg_print_version(1); }
exit(0);
}
@ -48,14 +51,17 @@ int main(int argc, char *argv[])
{
int foo, idx;
int opt;
int to_gray = 0;
char *output_file = "out.fimg";
FloatImg accu, temp;
int src_loaded = 0;
g_width = g_height = 0;
while ((opt = getopt(argc, argv, "ho:v")) != -1) {
while ((opt = getopt(argc, argv, "gho:v")) != -1) {
switch(opt) {
case 'g': to_gray = 1; break;
case 'h': help(0); break;
case 'o': output_file = optarg; break;
case 'v': verbosity++; break;
@ -67,16 +73,17 @@ if (verbosity) fprintf(stderr, "------ cumulfimgs ------\n");
fprintf(stderr, "argc = %d, optind = %d\n", argc, optind);
#endif
// foo = testfile(output_file);
// fprintf(stderr, "Output %s -> %d\n", output_file, foo);
for (idx=optind; idx<argc; idx++) {
#if DEBUG_LEVEL
fprintf(stderr, "%5d %s\n", idx, argv[idx]);
#endif
foo = testfile(argv[idx]);
if (foo) {
fprintf(stderr, "testfile %s -> %d\n", argv[idx],foo);
exit(1);
}
if ( ! src_loaded ) {
foo = fimg_create_from_dump(argv[idx], &accu);
@ -85,13 +92,29 @@ for (idx=optind; idx<argc; idx++) {
}
else {
foo = fimg_load_from_dump(argv[idx], &temp);
if (foo) {
fprintf(stderr, "load from dump -> %d\n", foo);
exit(1);
}
fimg_add_2(&temp, &accu);
}
}
if (to_gray) {
foo = fimg_desaturate(&accu, &accu, 0);
if (foo) {
fprintf(stderr, "desaturate: error %d\n", foo);
}
}
foo = fimg_dump_to_file(&accu, output_file, 0);
if (foo) {
fprintf(stderr, "error %d while saving '%s'\n", foo, output_file);
exit(1);
}
return 0;
}

13
tools/essai.sh
View File

@ -27,7 +27,6 @@ function essai_cmixa
{
./mkfimg -vv -t tpat0 $TMPF 800 600
./fimgfx -vv cmixa $TMPF bar.fimg
}
# -----------------------------------------------------
function essai_cumulator
@ -36,11 +35,19 @@ D=" 800 600 "
./mkfimg -v -t hdeg hdeg.fimg $D
./mkfimg -v -t vdeg vdeg.fimg $D
./mkfimg -v -t drand48 rand.fimg $D
./mkfimg -v -t tpat0 pat0.fimg $D
./cumulfimgs -vv -o foo.fimg hdeg.fimg rand.fimg vdeg.fimg
./cumulfimgs -v -g -o foo.fimg \
hdeg.fimg pat0.fimg rand.fimg vdeg.fimg
}
# -----------------------------------------------------
function essai_contour
{
./mkfimg -vv -t tpat0 $TMPF 800 600
./fimgfx -vv ctr2x2 $TMPF bar.fimg
}
# -----------------------------------------------------
essai_cumulator
essai_contour
# -----------------------------------------------------

21
tools/fimgfx.c
View File

@ -21,7 +21,7 @@ typedef struct {
} Fx;
enum fxid { Fx_cos01=5, Fx_cos010, Fx_pow2, Fx_sqrt, Fx_gray0, Fx_halfsz0,
Fx_rot90, Fx_cmixa, Fx_Desat,
Fx_rot90, Fx_cmixa, Fx_desat, Fx_ctr2x2, Fx_norm,
Fx_xper };
Fx fx_list[] = {
@ -34,7 +34,9 @@ Fx fx_list[] = {
{ "rot90", Fx_rot90, 0, 0 },
{ "cmixa", Fx_cmixa, 0, 1 },
{ "xper", Fx_xper, 0, 1 },
{ "desat", Fx_Desat, 0, 1 },
{ "desat", Fx_desat, 0, 1 },
{ "ctr2x2", Fx_ctr2x2, 0, 1 },
{ "norm", Fx_norm, 0, 1 },
{ NULL, 0, 0 }
};
@ -59,6 +61,9 @@ for (n=0, fx=fx_list; fx->name; fx++, n++) {
return -1; /* NOT FOUND */
}
/* --------------------------------------------------------------------- */
/*
* this is the mutant function
*/
int do_experiment(FloatImg *S, FloatImg *D, float kf)
{
int foo;
@ -74,10 +79,10 @@ if (foo) {
return -98;
}
foo = fimg_killcolors_a(D, kf);
foo = fimg_classif_trial(S, D, kf, 0);
if (foo) {
fprintf(stderr, "%s err %d killcolors %p %f\n", __func__,
foo, S, kf);
fprintf(stderr, "%s err %d classif_trial %p\n", __func__,
foo, S);
return -98;
}
@ -167,11 +172,15 @@ switch (action) {
fprintf(stderr, "halfsize was not implemented\n");
return -3;
case Fx_Desat:
case Fx_desat:
fimg_copy_data(&src, &dest);
foo = fimg_mix_rgb_gray(&dest, global_fvalue);
break;
case Fx_ctr2x2:
foo = fimg_contour_2x2(&src, &dest, 0);
break;
default:
fprintf(stderr, "%s %s : %d is bad action\n",
__FILE__, __func__, action);