.gitignore

@@ -70,7 +70,6 @@ Fonderie/*.gif
 Fonderie/fonderie
 Fonderie/interpolator
 Fonderie/t
-Fonderie/singlepass
 Fonderie/crapdef.h
 Fonderie/crapstr.h
 

Fonderie/Makefile

@@ -21,7 +21,7 @@ t:	t.c Makefile ${OBJS}
 
 # ---------------------------------------------------------
 #
-#	the three main programms
+#	the two main programms
 #
 
 fonderie:	fonderie.c ${DEPS} ${OBJS} Makefile
@@ -31,9 +31,6 @@ fonderie:	fonderie.c ${DEPS} ${OBJS} Makefile
 interpolator:	interpolator.c ${DEPS} ${OBJS} Makefile
 	gcc ${COPT} $< ${OBJS}  ${LIBS} -lz -o $@
 
-singlepass:	singlepass.c ${DEPS} ${OBJS} Makefile
-	gcc ${COPT} $< ${OBJS}  ${LIBS} -lz -o $@
-
 # ---------------------------------------------------------
 #
 #	some files are magically generated, sorry.

Fonderie/README.md

@@ -99,19 +99,6 @@ Un logiciel dont l'inspiration vient du passé et les améliorations
 d'une résidence à Terre-Blanque, ça ne peut pas être complètement
 malsain.
 
-```
-*** interpolator.c : compiled by tTh, Jan 12 2021 16:18:58
-*** FloatImg library, alpha v116 (Dec 27 2020, 22:39:28)
-        INTERPOLATOR
-usage:
-        interpolator [options] <inglob> <outdir> <nbsteep>
-options:
-        -S nn           mysterious sort
-        -E i:bla:k      input  filter chain
-        -F name:j       output filter chain
-        -L              list available filters
-        -v              increase verbosity
-```
 
 
 ## Conclusion

Fonderie/crapulator.c

@@ -22,7 +22,7 @@ int		foo;
 
 fimg_clone(pimg, &copy, 1);
 
-foo = fimg_qsort_rgb_a(pimg, &copy, 0);
+foo = fimg_qsort_rgb_b(pimg, &copy, 0);
 if (foo) {
 	fprintf(stderr, "%s: err qsort rgb = %d\n", __func__, foo);
 	return foo;
@@ -209,7 +209,7 @@ switch (idFx) {
 						image->height/20);
 		break;
 	case CR_water:
-		retval = bouger_les_pixels(image, 12);
+		retval = bouger_les_pixels(image, 8);
 		break;
 	case CR_mirsplit:
 		retval = mirror_split(image, 0);

Fonderie/essai.sh

@@ -28,24 +28,24 @@ echo ; echo "making gif89a..."
 convert -delay 200 /tmp/fstack*.png foo.gif
 }
 # ------------------------------------------------------------
-essai_singlepass ()
+essai_single ()
 {
 MP4="/home/tth/Essais/FondageDePlomb/foo.mp4"
-INPUT="/home/tth/Essais/FondageDePlomb/capture/???[04]0.fimg"
+INPUT="/home/tth/Essais/FondageDePlomb/capture/?[23]???.fimg"
-FILTRE="water:water:liss3x3"
+FILTRE="classtrial:liss3x3"
-OUTDIR="/tmp/x8/"
 
 echo '********* essai single *********'
 
-rm $OUTDIR/*.png
 
-time ./singlepass -v -g "$INPUT" -F $FILTRE -O $OUTDIR -s
+rm /tmp/x8/*.png
 
-echo ; echo "encoding picz to " $MP4
+time ./t -v -g "$INPUT" -F $FILTRE -s
+
+echo ; echo "encoding to " $MP4
 
 ffmpeg	-nostdin				\
 	-loglevel error					\
-	-y -r 25 -f image2 -i /tmp/x8/%05d.png	 	\
+	-y -r 30 -f image2 -i /tmp/x8/%05d.png	 	\
 	-c:v libx264 -pix_fmt yuv420p			\
 	$MP4
 
@@ -53,6 +53,6 @@ ffmpeg	-nostdin				\
 # ------------------------------------------------------------
 #			MAIN
 
-essai_singlepass
+essai_single
 
 # ------------------------------------------------------------

Fonderie/filterstack.c

@@ -233,7 +233,7 @@ for (;;) {
 		}
 	}
 
-if (verbosity > 1) filterstack_list(numid, __func__);
+if (verbosity) filterstack_list(numid, __func__);
 return 0;
 }
 /* ----------------------------------------------------------- */

Fonderie/fonctions.c

@@ -79,6 +79,14 @@ int		foo, type;
 
 foo = faire_la_somme(&g_fifo, NULL, step);
 
+/* BEGIN GRUIK CODE */
+extern int	convert_to_gray;
+/* END OF THE KLUGE */
+if (convert_to_gray) {
+	fimg_to_gray(&g_fifo.total);
+	// fprintf(stderr, "%p gray-washed\n", &fifo.total);
+	}
+
 if (postproc)
 	foo = crapulator(&g_fifo.total, postproc, 0.0);
 else

Fonderie/fonderie.c

@@ -15,6 +15,7 @@
 #include  "filterstack.h"
 
 int			verbosity;
+int			convert_to_gray;
 
 /* -------------------------------------------------------------- */
 int traite_une_image(FloatImg *image, int proc, int step, char *outd)
@@ -167,7 +168,7 @@ puts("\tFONDERIE\noptions:");
 
 puts("\t-E\tinput:filter:chain");
 puts("\t-F\toutput:filter:chain");
-// puts("\t-g\tconvert to gray");
+puts("\t-g\tconvert to gray");
 puts("\t-I\tinput glob pattern");
 puts("\t-L\tlist available filters");
 puts("\t-O\toutput directory");
@@ -200,7 +201,7 @@ while ((opt = getopt(argc, argv, "B:E:F:ghI:LO:s:T:vw:x:")) != -1) {
 		case 'F':	OutFchain = optarg;		break;
 		case 'B':	blanks = atoi(optarg);
 				break;
-		case 'g':	// convert_to_gray = 1;
+		case 'g':	convert_to_gray = 1;
 				break;
 		case 'h':	help();	
 				break;

Fonderie/interpolator.c

@@ -23,6 +23,7 @@
 #include  "filterstack.h"
 
 int		verbosity;
+int		convert_to_gray;	/* needed by fonctions.c */
 
 /* -------------------------------------------------------------- */
 /*  on va essayer de trier l'ordre d'apparition des images

Fonderie/sfx.c

@@ -21,9 +21,7 @@
 extern	int		verbosity;
 
 /* -------------------------------------------------------------- */
-/*
+
- *		please, add some parameters !
- */
 int incrustation_0(FloatImg *src, FloatImg *dst, int k)
 {
 int		x, y, x4, y4;
@@ -38,7 +36,7 @@ x4 = dst->width / 4,	y4 = dst->height / 4;
 for (y=0; y<y4; y++) {
 	for (x=0; x<x4; x++) {
 		fimg_get_rgb(src, x*4,  y*4,  rgb);
-		fimg_put_rgb(dst, x+39, y+39, rgb);
+		fimg_put_rgb(dst, x+19, y+19, rgb);
 		}
 	}
 
@@ -242,7 +240,6 @@ for (x=0; x<pimg->width; x++) {
                               || ny>=pimg->height )
 					continue;
 
-		/* XXX optimize here ? */
 	    fimg_get_rgb(pimg, nx, ny, rgb);
 	    fimg_put_rgb(pimg,  x,  y, rgb);
 

Fonderie/single.c

@@ -31,10 +31,7 @@ int single_init(int next, char *dest, int fxchain)
 int			foo;
 struct stat		stbuf;
 
-#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %d '%s' )\n", __func__, next, dest);
-fprintf(stderr, ">>> %s ( %d '%s' %d )\n", __func__,
-			next, dest, fxchain);
-#endif
 
 nextpng = next;
 chainfilter = fxchain;
@@ -98,10 +95,6 @@ fprintf(stderr, "   chainfilter      %d\n", chainfilter);
 
 fprintf(stderr, "   destination      %s\n", destination);
 
-if (k) {
-
-	}
-
 return -1;
 }
 /* -------------------------------------------------------------- */

Fonderie/singlepass.c

@@ -1,166 +0,0 @@
-/*
- *		+-------------------------+
- *		|   S I N G L E P A S S   |
- *		+-------------------------+
- */
-
-#include  <stdio.h>
-#include  <stdlib.h>
-#include  <unistd.h>
-#include  <string.h>
-#include  <glob.h>
-
-#include  "../floatimg.h"
-
-#include  "crapulator.h"
-#include  "filterstack.h"
-#include  "single.h"
-
-/* ----------------------------------------------------------- */
-
-#define   FILTERS	0
-
-int		verbosity;
-
-/* ----------------------------------------------------------- */
-int run_the_singlepass(char *globber, char *destdir, int fchain)
-{
-FloatImg	image = { 0 };
-int		idx, foo;
-glob_t		globbuf;
-char		*fname;
-
-#if DEBUG_LEVEL
-fprintf(stderr, ">>> %s ( '%s' '%s' %d )\n", __func__,
-				globber, destdir, fchain);
-#endif
-
-// filterstack_list(fchain, "Run the single pass");
-
-foo = single_init(0, destdir, fchain);
-if (foo) {
-	fprintf(stderr, "erreur %d single_init\n", foo);
-	return foo;
-	}
-// single_print_state("just after init", 0);
-
-memset(&globbuf, 0, sizeof(glob_t));
-foo = glob(globber, 0, NULL, &globbuf);
-// fprintf(stderr, "globbing '%s' -> %d, %d files found\n",
-//			globber, foo, (int)globbuf.gl_pathc);
-switch (foo) {
-	case GLOB_NOSPACE:
-		fprintf(stderr, "%s: glob run out of memory\n", __func__);
-		break;
-	case GLOB_ABORTED:
-		fprintf(stderr, "%s: glob read error\n", __func__);
-		break;
-	case GLOB_NOMATCH:
-		fprintf(stderr, "%s: glob found no matches\n", __func__);
-		break;
-	}
-
-if (0 == globbuf.gl_pathc) {
-	fprintf(stderr, "%s: no file found, aborting\n", __func__);
-	return -1;
-	}
-
-for (idx=0; idx<globbuf.gl_pathc; idx++) {
-
-	fname = globbuf.gl_pathv[idx];		/* alias of filename */
-	fprintf(stderr, "  %6d  %s\r", globbuf.gl_pathc-idx, fname);
-
-	if (0==image.width && 0==image.height) {
-		foo = fimg_create_from_dump(fname, &image);
-		}
-	else	{
-		foo = fimg_load_from_dump(fname, &image);
-		}
-	if (foo) {
-		fprintf(stderr, "get image -> %d\n", foo);
-		return -1;
-		}
-
-	foo = filterstack_run(fchain, &image, 0);
-	if (foo) {
-		fprintf(stderr, "%s: filterstack run --> %d\n",
-				__func__,                 foo);
-		return foo;
-		}
-
-	foo = single_push_picture(&image);
-	if (foo) {
-		fprintf(stderr, "error %d on push_picture\n", foo);
-		return foo;
-		}
-	}
-
-fprintf(stderr, "\n");
-single_print_state("end of run :)", 0);
-
-fimg_destroy(&image);
-
-return -1;
-}
-/* ----------------------------------------------------------- */
-static void help(void)
-{
-puts("--- Single pass serial filter ---\nusage:");
-
-puts("\t-F\tdefine:the:filter:chain");
-puts("\t-g\tinput glob pattern");
-puts("\t-L\tlist available filters");
-puts("\t-O\t/output/directory");
-// puts("\t-s\tdo single test");
-puts("\t-v\tspit more messages");
-
-exit(0);
-}
-/* ----------------------------------------------------------- */
-
-int main(int argc, char *argv[])
-{
-int		foo, opt;
-char		*filterchain =   "none";
-char		*globbing    =   "./capture/?????.fimg";
-char		*outdir      =   "./p8";
-int		do_xper = 0;
-
-fprintf(stderr, "*** %s : compiled %s %s\n", __FILE__,
-                        __DATE__, __TIME__);
-fimg_print_version(2);
-
-while ((opt = getopt(argc, argv, "hF:g:LO:svx")) != -1) {
-	switch (opt) {
-		case 'h':	help();			break;
-
-		case 'F':	filterchain = optarg;	break;
-		case 'g':	globbing = optarg;	break;
-
-		case 'L':
-			list_crapulors("available filters");
-			exit(0);
-
-		case 'O':	outdir = optarg;	break;
-
-		case 'v':	verbosity++;		break;
-
-		case 'x':	do_xper = 1;		break;
-
-		}
-
-	}
-
-foo = parse_filter_chain(FILTERS, filterchain);
-if (foo) {
-	fprintf(stderr, "err %d in parse_filter_chain\n", foo);
-	exit(1);
-	}
-
-foo = run_the_singlepass(globbing, outdir, FILTERS);
-fprintf(stderr, "\n\tRun the single pass --> %d\n", foo);
-
-return 0;
-}
-
-/* ----------------------------------------------------------- */

Fonderie/t.c

@@ -18,6 +18,7 @@
 /* ----------------------------------------------------------- */
 
 int		verbosity;
+int		convert_to_gray;	/* WTF ? */
 
 #define		PNG	"out.png"
 #define		W	800
@@ -82,10 +83,9 @@ int		idx, foo;
 glob_t		globbuf;
 char		*fname;
 
-#if DEBUG_LEVEL
 fprintf(stderr, ">>> %s ( '%s' '%s' %d )\n", __func__,
 			globpattern, destdir, chain);
-#endif
+
 
 filterstack_list(chain, "essai du single");
 
@@ -137,11 +137,11 @@ for (idx=0; idx<globbuf.gl_pathc; idx++) {
 
 fprintf(stderr, "\n");
 
-single_print_state("end of run :)", 0);
+single_print_state("end of run", 0);
 
 fimg_destroy(&image);
 
-return 0;
+return -1;
 }
 /* ----------------------------------------------------------- */