Bibliothèque de traitements d'images en virgule flottante.
http://la.buvette.org/photos/cumul/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
221 lines
5.3 KiB
221 lines
5.3 KiB
/* |
|
* FONDERIE |
|
*/ |
|
|
|
#include <stdio.h> |
|
#include <string.h> |
|
#include <stdlib.h> |
|
#include <unistd.h> |
|
#include <glob.h> |
|
#include <floatimg.h> |
|
|
|
#include "fonctions.h" |
|
#include "glitches.h" |
|
#include "crapulator.h" |
|
|
|
int verbosity; |
|
int convert_to_gray; |
|
|
|
/* -------------------------------------------------------------- */ |
|
int traite_une_image(FloatImg *image, int proc, int step) |
|
{ |
|
static int numero; |
|
int foo; |
|
char ligne[200]; |
|
|
|
/* here, we put the picz in the fifo machinery */ |
|
foo = insert_picture(image); |
|
if (foo) { |
|
fprintf(stderr, "%s: err %d on insert\n", __func__, foo); |
|
return foo; |
|
} |
|
sprintf(ligne, "p8/%05d.png", numero); |
|
/* ^^^ |
|
XXX hardcoded value ? wtf ? |
|
*/ |
|
foo = export_fifo(ligne, proc, step); |
|
if (foo) { |
|
fprintf(stderr, "%s: err %d on export\n", __func__, foo); |
|
return foo; |
|
} |
|
numero++; /* VERY IMPORTANT :) */ |
|
return 0; |
|
} |
|
/* -------------------------------------------------------------- */ |
|
int insert_blank(FloatImg *image, int nbre, int pproc, float fval) |
|
{ |
|
int idx, foo; |
|
|
|
fimg_clear(image); |
|
for (idx=0; idx<nbre; idx++) { |
|
fimg_vdeg_a(image, fval); |
|
// brotche_rand48_b(image, drand48()*0.10, 1e5); |
|
if ((foo=traite_une_image(image, pproc, 1))) { |
|
fprintf(stderr, "%s : err %d from 'traite_une_image'\n", |
|
__func__, foo); |
|
break; |
|
} |
|
printf("\t%c\r", "ABCDEF"[idx%6]); fflush(stdout); |
|
} |
|
puts(""); |
|
|
|
return 0; |
|
} |
|
/* -------------------------------------------------------------- */ |
|
#define BLANK 50 |
|
|
|
int demarre_la_machine(char *pattern, char *outdir, int szfifo, |
|
int infx, int outfx, int step) |
|
{ |
|
int foo, idx, width, height; |
|
glob_t globbuf; |
|
char *cptr; |
|
FloatImg input; |
|
double fin; |
|
float maxvalue; |
|
int datas[3]; |
|
|
|
#if DEBUG_LEVEL |
|
fprintf(stderr, ">>> %s ( '%s' -> '%s' %d eff:%d:%d)\n", __func__, |
|
pattern, outdir, szfifo, infx, outfx); |
|
#endif |
|
|
|
if (1 != step) fprintf(stderr, "\tstep is %d\n", step); |
|
|
|
(void)fimg_timer_set(0); |
|
|
|
if (infx) fprintf(stderr, "\tin fx #%d\n", infx); |
|
else fprintf(stderr, "\tno in fx\n"); |
|
if (outfx) fprintf(stderr, "\tout fx #%d\n", outfx); |
|
else fprintf(stderr, "\tno out fx\n"); |
|
|
|
memset(&globbuf, 0, sizeof(glob_t)); |
|
foo = glob(pattern, 0, NULL, &globbuf); |
|
fprintf(stderr, "glob '%s' -> %d, %ld files found\n", pattern, foo, |
|
globbuf.gl_pathc); |
|
|
|
/* get the size of the inputs images */ |
|
foo = fimg_fileinfos(globbuf.gl_pathv[0], datas); |
|
width = datas[0]; height = datas[1]; |
|
fprintf(stderr, "image size %dx%d\n", width, height); |
|
|
|
fimg_create(&input, width, height, 3); |
|
|
|
/* get the maximum value of the first pic */ |
|
foo = fimg_load_from_dump(globbuf.gl_pathv[0], &input); |
|
if (foo) { |
|
fprintf(stderr, "%s: err %d loading %s\n", |
|
__func__, foo, globbuf.gl_pathv[0]); |
|
exit(1); |
|
} |
|
maxvalue = fimg_get_maxvalue(&input); |
|
fprintf(stderr, "maxvalue %f\n", maxvalue); |
|
|
|
foo = create_fifo(szfifo, width, height, FIMG_TYPE_RGB); |
|
fprintf(stderr, "init fifo (%d slots) --> %d\n", szfifo, foo); |
|
|
|
/* XXX inject a few strange pics in the fifo */ |
|
insert_blank(&input, BLANK, outfx, maxvalue); |
|
|
|
for (idx=0; idx<globbuf.gl_pathc; idx++) { |
|
cptr = globbuf.gl_pathv[idx]; |
|
/* first step : read the current grabed picz from disk, |
|
and put it in our private buffer */ |
|
foo = fimg_load_from_dump(cptr, &input); |
|
if (foo) { |
|
fprintf(stderr, "load #%d from dump -> %d\n", idx, foo); |
|
continue; |
|
} |
|
/* ========================= */ |
|
/* FSCKING INPUT FILTER HERE */ |
|
foo = crapulator(&input, infx, 0.42); |
|
if (foo) { |
|
fprintf(stderr, "%s crapulator -> %d\n", __func__, foo); |
|
exit(1); |
|
} |
|
foo = traite_une_image(&input, outfx, step); |
|
if (foo) { |
|
fprintf(stderr, "traitement %s -> %d WTF?\n", cptr, foo); |
|
break; |
|
} |
|
fprintf(stderr, "\t%5d\r", idx); |
|
} |
|
fputs("\n", stderr); |
|
|
|
insert_blank(&input, BLANK*2, outfx, maxvalue); |
|
|
|
/* |
|
* PLEASE, FLUSH THE FIFO ! |
|
*/ |
|
|
|
fin = fimg_timer_get(0); |
|
if (idx) { |
|
fprintf(stderr, "\nelapsed %.2f seconds, %.2f s/pic\n", fin, fin/idx); |
|
} |
|
else { |
|
fprintf(stderr, "\nelapsed %.2f seconds\n", fin); |
|
} |
|
|
|
return 8; /* why 9 ? */ |
|
} |
|
/* -------------------------------------------------------------- */ |
|
void help(void) |
|
{ |
|
puts("\tFONDERIE\noptions:"); |
|
|
|
puts("\t-g\tconvert to gray"); |
|
puts("\t-I\tinput glob pattern"); |
|
puts("\t-O\toutput directory"); |
|
puts("\t-T\tfifo size"); |
|
puts("\t-v\tincrease verbosity"); |
|
puts("\t-w\tinput effect"); |
|
puts("\t-x\toutput effect"); |
|
|
|
exit(0); |
|
} |
|
/* -------------------------------------------------------------- */ |
|
int main (int argc, char *argv[]) |
|
{ |
|
int foo, opt; |
|
int fifosize = 10; |
|
char *in_pattern = "capture/?????.fimg"; |
|
char *out_dir = "p8"; |
|
int in_effect = 0; |
|
int out_effect = 0; |
|
int steps = 1; |
|
|
|
fprintf(stderr, "*** %s :\n\tcompiled by tTh, %s %s\n\tpid %d\n", |
|
argv[0], __DATE__, __TIME__, getpid()); |
|
fimg_print_version(2); |
|
|
|
while ((opt = getopt(argc, argv, "ghI:O:s:T:vw:x:")) != -1) { |
|
switch(opt) { |
|
|
|
case 'g': convert_to_gray = 1; |
|
break; |
|
case 'h': help(); |
|
break; |
|
case 'I': in_pattern = optarg; |
|
break; |
|
case 'O': out_dir = optarg; |
|
break; |
|
case 'T': fifosize = atoi(optarg); |
|
break; |
|
case 'v': verbosity++; |
|
break; |
|
case 'w': in_effect = atoi(optarg); |
|
break; |
|
case 'x': out_effect = atoi(optarg); |
|
break; |
|
case 's': steps = atoi(optarg); |
|
break; |
|
} |
|
} |
|
|
|
foo = demarre_la_machine(in_pattern, out_dir, fifosize, in_effect, |
|
out_effect, steps); |
|
fprintf(stderr, "retour du big-run de la machine -> %d\n", foo); |
|
|
|
return 0; |
|
} |
|
/* -------------------------------------------------------------- */
|
|
|