Mutah/FloatImg4PythonBinding
1
0
Fork 0
forked from tTh/FloatImg
Code Issues Pull Requests Projects Releases Wiki Activity

source tree refactor and build system (to be completed)

Browse Source
This commit is contained in:
John Doe
2021-05-11 22:44:13 +02:00
parent cc79dd5152
commit bbc0309591
121 changed files with 259 additions and 290 deletions
Download Patch File Download Diff File Expand all files Collapse all files

81
src/tools/Makefile Normal file
View File

@@ -0,0 +1,81 @@
#
# makefile for floatimg tools
# use with caution
#
# PLEASE ! update to the 'Global.makefile' concept !
#
COPT = -Wall -fpic -g -DDEBUG_LEVEL=0
LD_OPTS = -lm
STATIC_LIB = ../../build/lib/libfloatimg.a
DEPS = ../floatimg.h $(STATIC_LIB) Makefile
BIN_DIR = ../../build/bin
EXECUTABLES = $(BIN_DIR)/fimg2pnm $(BIN_DIR)/mkfimg $(BIN_DIR)/png2fimg \
$(BIN_DIR)/fimgstats $(BIN_DIR)/fimg2png $(BIN_DIR)/fimg2tiff \
$(BIN_DIR)/fimg2text $(BIN_DIR)/fimg2fits $(BIN_DIR)/addpnm2fimg \
$(BIN_DIR)/cumulfimgs $(BIN_DIR)/fimgops $(BIN_DIR)/fimgfx \
$(BIN_DIR)/fimghalfsize
# ----------
all: fimg2pnm mkfimg png2fimg fimgstats fimg2png \
fimg2tiff fimg2text fimg2fits \
addpnm2fimg cumulfimgs fimgops fimgfx \
fimghalfsize
clean:
rm -rf $(EXECUTABLES)
fimgstats: fimgstats.c $(DEPS)
gcc $(COPT) $< $(STATIC_LIB) -o $(BIN_DIR)/$@ $(LD_OPTS)
cumulfimgs: cumulfimgs.c $(DEPS)
gcc $(COPT) $< $(STATIC_LIB) -o $(BIN_DIR)/$@ $(LD_OPTS)
mkfimg: mkfimg.c $(DEPS)
gcc $(COPT) $< $(STATIC_LIB) -o $(BIN_DIR)/$@ $(LD_OPTS)
fimgops: fimgops.c $(DEPS)
gcc $(COPT) $< $(STATIC_LIB) -o $(BIN_DIR)/$@ $(LD_OPTS)
fimgfx: fimgfx.c $(DEPS)
gcc $(COPT) $< $(STATIC_LIB) -o $(BIN_DIR)/$@ $(LD_OPTS)
fimghalfsize: fimghalfsize.c $(DEPS)
gcc $(COPT) $< $(STATIC_LIB) -o $(BIN_DIR)/$@ $(LD_OPTS)
fimg2pnm: fimg2pnm.c $(DEPS)
gcc $(COPT) $< $(STATIC_LIB) -o $(BIN_DIR)/$@ $(LD_OPTS)
fimg2fits: fimg2fits.c $(DEPS)
gcc $(COPT) $< $(STATIC_LIB) -lcfitsio -o $(BIN_DIR)/$@ $(LD_OPTS)
fimg2png: fimg2png.c $(DEPS)
gcc $(COPT) $< $(STATIC_LIB) -lpnglite -lz -o $(BIN_DIR)/$@ $(LD_OPTS)
fimg2text: fimg2text.c $(DEPS)
gcc $(COPT) $< $(STATIC_LIB) -o $(BIN_DIR)/$@ $(LD_OPTS)
fimg2tiff: fimg2tiff.c $(DEPS)
gcc $(COPT) $< $(STATIC_LIB) -ltiff -o $(BIN_DIR)/$@ $(LD_OPTS)
#
# this tool require an external library
# http://la.buvette.org/devel/libimage/libimage.html
#
addtga2fimg: addtga2fimg.c $(DEPS)
gcc $(COPT) $< $(STATIC_LIB) -limageSO -o $(BIN_DIR)/$@ $(LD_OPTS)
addpnm2fimg: addpnm2fimg.c $(DEPS)
gcc $(COPT) $< $(STATIC_LIB) -o $(BIN_DIR)/$@ $(LD_OPTS)
# if "undefined reference to crc32" then "use -lz"
png2fimg: png2fimg.c $(DEPS)
gcc $(COPT) $< $(STATIC_LIB) -lpnglite -lz -o $(BIN_DIR)/$@ $(LD_OPTS)

20
src/tools/README.md Normal file
View File

@@ -0,0 +1,20 @@
# Images en virgule flottante, les outils.
Dans tous les cas, vous pouvez utiliser l'option `-h` pour avoir des
explications sur ce que vous pouvez faire.
## mkfimg
## fimgops
## fimgfx
## fimgstats
## fimg2pnm - fimg2png
## fimg2text
Nouveau de l'année 2020+1 : exfiltrer toutes des données d'une image flottante
afin de les rendre machinables.

90
src/tools/addpnm2fimg.c Normal file
View File

@@ -0,0 +1,90 @@
/*
* ADDPNM
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "../floatimg.h"
int verbosity;
/* --------------------------------------------------------------------- */
int add_pnm_to_fimg(char *srcname, char *dstname, int notused)
{
FloatImg dst, src;
int foo, x, y, idx;
#if DEBUG_LEVEL
fprintf(stderr, ">>> %s ( '%s' %s' )\n", __func__, srcname, dstname);
#endif
foo = fimg_create_from_dump(dstname, &dst);
if (foo) fprintf(stderr, "create dst fimg from '%s' -> %d\n", dstname, foo);
#if DEBUG_LEVEL
fimg_describe(&dst, "created fimg from dump");
#endif
foo = fimg_load_from_pnm(srcname, &src, 0);
if (foo) fprintf(stderr, "create src fimg from '%s' -> %d\n", dstname, foo);
#if DEBUG_LEVEL
fimg_describe(&src, "created fimg from PNM");
#endif
// fprintf(stderr, "src is %dx%d\n", src.width, src.height);
idx = 0;
for (y=0; y<src.height; y++) {
for (x=0; x<src.width; x++) {
dst.R[idx] += src.R[idx];
dst.G[idx] += src.G[idx];
dst.B[idx] += src.B[idx];
idx++;
}
}
foo = fimg_dump_to_file(&dst, dstname, 0);
if (foo) { fprintf(stderr, "fimg dump -> %d\n", foo); }
return 0;
}
/* --------------------------------------------------------------------- */
int main(int argc, char *argv[])
{
int foo;
// int srcW, srcH;
int infos[3];
if (3 != argc) {
fimg_print_version(1);
fprintf(stderr, "usage:\n\t%s img.fimg cumul.fimg\n", argv[0]);
exit(1);
}
verbosity = 0;
if ( 0==access(argv[2], R_OK|W_OK) ) { /* fimg is readable */
// fprintf(stderr, "%s exist\n", argv[2]);
}
/*
else {
fprintf(stderr, "*** must create '%s' %dx%d first !!!\n",
argv[2], tgaW, tgaH);
exit(1);
} */
foo = fimg_fileinfos(argv[2], infos);
// fprintf(stderr, "get dims of '%s' -> %d\n", argv[2], foo);
if (foo) {
fprintf(stderr, "*** %s is badly broken\n", argv[2]);
exit(2);
}
foo = add_pnm_to_fimg(argv[1], argv[2], 0);
return 0;
}
/* --------------------------------------------------------------------- */

99
src/tools/addtga2fimg.c Normal file
View File

@@ -0,0 +1,99 @@
/*
* ADDTGA
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <tthimage.h>
#include "../floatimg.h"
/* --------------------------------------------------------------------- */
int add_tga_to_fimg(char *srcname, char *dstname, int notused)
{
Image_Desc *src;
FloatImg dst;
int foo, x, y;
#if DEBUG_LEVEL
fprintf(stderr, ">>> %s ( '%s' %s' )\n", __func__, srcname, dstname);
#endif
if (NULL==(src = Image_TGA_alloc_load(srcname))) {
return -2;
}
foo = fimg_create_from_dump(dstname, &dst);
if (foo) fprintf(stderr, "create fimg from '%s' -> %d\n", dstname, foo);
#if DEBUG_LEVEL
fimg_describe(&dst, "created fimg");
#endif
for (y=0; y<src->height; y++) {
for (x=0; x<src->width; x++) {
foo = fimg_add_rgb(&dst, x, y,
(float)Image_R_pixel(src, x, y),
(float)Image_G_pixel(src, x, y),
(float)Image_B_pixel(src, x, y));
}
}
foo = fimg_dump_to_file(&dst, dstname, 0);
if (foo) { fprintf(stderr, "fimg dump -> %d\n", foo); }
return 0;
}
/* --------------------------------------------------------------------- */
int main(int argc, char *argv[])
{
int foo;
int tgaW, tgaH;
int infos[3];
if (3 != argc) {
fimg_print_version(1);
fprintf(stderr, "usage:\n\t%s img.tga cumul.fimg\n", argv[0]);
exit(1);
}
/* first, check the TGA file dimensions */
// Image_print_version(0);
foo = Image_TGA_get_dims(argv[1], &tgaW, &tgaH);
if (foo) {
fprintf(stderr, "get dims of '%s' -> %d\n", argv[1], foo);
Image_print_error("tga get dims", foo);
exit(1);
}
if ( 0==access(argv[2], R_OK) ) { /* fimg is readable */
fprintf(stderr, "%s is ok.\n", argv[2]);
}
else {
fprintf(stderr, "*** must create '%s' %dx%d first !!!\n",
argv[2], tgaW, tgaH);
exit(1);
}
foo = fimg_fileinfos(argv[2], infos);
// fprintf(stderr, "get dims of '%s' -> %d\n", argv[2], foo);
if (foo) {
fprintf(stderr, "*** %s is badly broken\n", argv[2]);
exit(2);
}
if ( (tgaW != infos[0]) || (tgaW != infos[0]) ) {
fprintf(stderr, " TGA %5d %5d\n", tgaW, tgaH);
fprintf(stderr, " FIMG %5d %5d\n", infos[0], infos[1]);
fprintf(stderr, " No dimension match.\n");
exit(3);
}
foo = add_tga_to_fimg(argv[1], argv[2], 0);
return 0;
}
/* --------------------------------------------------------------------- */

134
src/tools/cumulfimgs.c Normal file
View File

@@ -0,0 +1,134 @@
/*
* This thing is just a mess !
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "../floatimg.h"
int verbosity;
int g_width, g_height;
/* --------------------------------------------------------------------- */
int testfile(char *path)
{
int foo, numbers[3];
foo = fimg_fileinfos(path, numbers);
if (foo) {
fprintf(stderr, "fileinfo of '%s' -> err %d\n", path, foo);
return foo;
}
if (verbosity) {
fprintf(stderr, "%-20s %dx%d\n", path, numbers[0], numbers[1]);
}
if (FIMG_TYPE_RGB != numbers[2]) {
fprintf(stderr, "file %s, %d : bad type\n", path, numbers[2]);
return -7;
}
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);
}
/* --------------------------------------------------------------------- */
int main(int argc, char *argv[])
{
int foo, idx;
int opt;
int compte = 0;
int to_gray = 0;
char *output_file = "out.fimg";
FloatImg accu, temp;
int src_loaded = 0;
float vals[6];
g_width = g_height = 0;
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;
}
}
if (verbosity) fprintf(stderr, "------ cumulfimgs ------\n");
#if DEBUG_LEVEL
fprintf(stderr, "argc = %d, optind = %d\n", argc, optind);
#endif
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);
fimg_clone(&accu, &temp, 0);
src_loaded = 1;
}
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);
}
compte++;
}
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);
}
if (verbosity) {
/* show some numbers about resultant picture */
foo = fimg_get_minmax_rgb(&accu, vals);
if (foo) {
fprintf(stderr, "err %d on fimg_get_minmax_rgb\n", foo);
return foo;
}
printf("Count %d\n", compte);
printf("Rmin %12.4g Rmax %12.4g delta %12g\n",
vals[0], vals[1], vals[1]-vals[0]);
printf("Gmin %12.4g Gmax %12.4g %12g\n",
vals[2], vals[3], vals[3]-vals[2]);
printf("Bmin %12.4g Bmax %12.4g %12g\n",
vals[4], vals[5], vals[5]-vals[4]);
}
return 0;
}
/* --------------------------------------------------------------------- */

66
src/tools/fimg2fits.c Normal file
View File

@@ -0,0 +1,66 @@
/*
* exporting a floatimg to a FITS file
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "../floatimg.h"
int verbosity;
/* ----------------------------------------------------------------- */
int export_fimg_plane_as_fits(char *infile, char *outfile, char plane)
{
FloatImg fimg;
int foo;
foo = fimg_create_from_dump(infile, &fimg);
if (foo) {
fprintf(stderr, "%s: create fimg from '%s' -> %d\n", __func__,
infile, foo);
return -1;
}
foo = fimg_save_plane_as_fits(&fimg, outfile, plane, 0);
if (foo) {
fprintf(stderr, "%s: err %d on fits export\n", __func__, foo);
return foo;
}
fimg_destroy(&fimg);
return -1;
}
/* ----------------------------------------------------------------- */
static void help(int k)
{
puts("export to FITS format");
puts("\t-p select colorplane : R, G, B");
}
/* ----------------------------------------------------------------- */
int main(int argc, char *argv[])
{
int foo, opt;
int plane = '?';
while ((opt = getopt(argc, argv, "p:hv")) != -1) {
switch(opt) {
case 'p': plane = optarg[0]; break;
case 'v': verbosity++; break;
case 'h': help(1); exit(1);
}
}
if (2 != argc-optind) {
fprintf(stderr, "error: %s need two filenames\n", argv[0]);
exit(1);
}
export_fimg_plane_as_fits(argv[optind], argv[optind+1], plane);
return 0;
}
/* ----------------------------------------------------------------- */

98
src/tools/fimg2png.c Normal file
View File

@@ -0,0 +1,98 @@
/*
* converting a floatimg to a PNG
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "../floatimg.h"
int verbosity;
/* ----------------------------------------------------------------- */
int convertir_fimg_en_PNG(char *srcname, char *dstname, int grisaille)
{
int foo, infos[3];
FloatImg fimg;
#if DEBUG_LEVEL
fprintf(stderr, ">>> %25s ( '%s' '%s' %d )\n", __func__,
srcname, dstname, notused);
#endif
foo = fimg_fileinfos(srcname, infos);
if (foo) {
if (verbosity) fprintf(stderr, "'%s' get dims -> %d\n", srcname, foo);
return foo;
}
if (verbosity) {
fprintf(stderr, "%s: image '%s' is %dx%d %s\n",
__func__,
srcname, infos[0], infos[1],
fimg_str_type(infos[2]));
}
foo = fimg_create_from_dump(srcname, &fimg);
if (foo) {
fprintf(stderr, "create fimg from '%s' -> %d\n", srcname, foo);
return -1;
}
if (grisaille) {
foo = fimg_desaturate(&fimg, &fimg, 0);
}
foo = fimg_save_as_png(&fimg, dstname, 0);
if (foo) {
fprintf(stderr, "%s: saving as png '%s' -> %d\n", __func__,
dstname, foo);
return -1;
}
fimg_destroy(&fimg);
return 0;
}
/* ----------------------------------------------------------------- */
void help(int k)
{
puts("usage:\n\tfimg2png [options] foo.fimg bar.png");
puts("options:");
puts("\t-g\tconvert to gray");
puts("\t-v\tincrease verbosity");
if (verbosity) fimg_print_version(1);
exit(0);
}
/* ----------------------------------------------------------------- */
int main(int argc, char *argv[])
{
int foo, opt;
int to_gray = 0;
while ((opt = getopt(argc, argv, "ghv")) != -1) {
switch(opt) {
case 'g': to_gray = 1; break;
case 'v': verbosity++; break;
case 'h': help(1); exit(1);
}
}
if (2 != argc-optind) {
fprintf(stderr, "error: %s need two filenames\n", argv[0]);
exit(1);
}
foo = convertir_fimg_en_PNG(argv[optind], argv[optind+1], to_gray);
if (foo) {
fprintf(stderr, "%s : got a %d from convertor\n", argv[0], foo);
}
return 0;
}
/* ----------------------------------------------------------------- */

126
src/tools/fimg2pnm.c Normal file
View File

@@ -0,0 +1,126 @@
/*
* conversion vers le format PNM
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "../floatimg.h"
int verbosity;
/* --------------------------------------------------------------------- */
int convertir_fimg_en_pnm(char *srcname, char *dstname, int to_gray)
{
int foo, infos[3];
FloatImg fimg, gris, *outptr;
#if DEBUG_LEVEL
fprintf(stderr, ">>> %25s ( '%s' '%s' %d )\n", __func__,
srcname, dstname, to_gray);
#endif
foo = fimg_fileinfos(srcname, infos);
if (foo) { fprintf(stderr, "'%s' get dims -> %d\n", srcname, foo); }
if (verbosity) {
fprintf(stderr, "image '%s' is %d x %d %s\n",
srcname, infos[0], infos[1],
fimg_str_type(infos[2]));
}
foo = fimg_create_from_dump(srcname, &fimg);
if (foo) {
fprintf(stderr, "create fimg from '%s' -> %d\n", srcname, foo);
return -1;
}
outptr = &fimg; /* safe default value */
if (to_gray) {
if (verbosity) puts("converting to gray...");
foo = fimg_create(&gris, fimg.width, fimg.height, FIMG_TYPE_GRAY);
if (foo) {
fprintf(stderr, "err create gray %d\n", foo);
return -2;
}
foo = fimg_mk_gray_from(&fimg, &gris, 0);
if (foo) {
fprintf(stderr, "err mk gray %d\n", foo);
return -4;
}
outptr = &gris;
}
#if DEBUG_LEVEL > 1
print_floatimg(outptr, "created fimg");
#endif
foo = fimg_save_as_pnm(outptr, dstname, 0);
if(foo) { fprintf(stderr, "%p to '%s' -> %d\n", &fimg, dstname, foo); }
if (to_gray) {
fimg_destroy(&gris);
outptr = NULL;
/* please run valgrind every hour */
}
return 0;
}
/* --------------------------------------------------------------------- */
static void help(int flag)
{
if (flag) {
fprintf(stderr, "conversion FIMG -> PNM 16 bits\n");
fimg_print_version(1);
}
puts("usage :");
puts("\tfimg2pnm [flags] infile.fimg outfile.pnm");
puts("flags :");
puts("\t-g\tconvert to gray");
puts("\t-v\tenhance your verbosity");
}
/* --------------------------------------------------------------------- */
int main(int argc, char *argv[])
{
int foo, opt;
int to_gray = 0;
if (argc == 1) {
help(0);
exit(0);
}
while ((opt = getopt(argc, argv, "ghv")) != -1) {
switch(opt) {
case 'g': to_gray = 1; break;
case 'v': verbosity++; break;
case 'h': help(1); exit(1);
}
}
#if DEBUG_LEVEL
/* mmmm, is it the good way ? */
printf("argc %d -> %d\n", argc, argc-optind);
for (foo=optind; foo<argc; foo++) {
printf(" %d %s\n", foo, argv[foo]);
}
#endif
if (2 != argc-optind) {
fprintf(stderr, "error: %s need two filenames\n", argv[0]);
exit(1);
}
if ( 0 != access(argv[optind], R_OK) ) { /* fimg is NOT readable */
fprintf(stderr, "%s: %s don't exist.\n", argv[0], argv[optind]);
exit(2);
}
foo = convertir_fimg_en_pnm(argv[optind], argv[optind+1], to_gray);
if (foo) fprintf(stderr, "conversion -> %d\n", foo);
return 0;
}
/* --------------------------------------------------------------------- */

178
src/tools/fimg2text.c Normal file
View File

@@ -0,0 +1,178 @@
/*
* converting a floatimg to a machinable text file
* an ugly software from tTh - february 2021
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include "../floatimg.h"
int verbosity;
/* --------------------------------------------------------------------- */
int export_as_machinable(FloatImg *src, char *fname, int steps, int flags)
{
FILE *fp;
int x, y;
float rgb[3];
#if DEBUG_LEVEL
fprintf(stderr, ">>> %25s ( %p '%s' %d )\n", __func__,
src, fname, flags);
#endif
fp = NULL; /* molly guard */
if (strcmp("-", fname)) { /* real file */
fprintf(stderr, "real file '%s'\n", fname);
}
else {
// fprintf(stderr, "kitchen sink\n");
}
fp = stdout; /* XXX */
for (y=0; y<src->height; y+=steps) {
for (x=0; x<src->width; x+=steps) {
fimg_get_rgb(src, x, y, rgb);
fprintf(fp, "%d %d ", x, y);
fprintf(fp, "%f %f %f\n", rgb[0], rgb[1], rgb[2]);
}
}
return 0;
}
/* --------------------------------------------------------------------- */
static int normalize(FloatImg *pimg, float vmax)
{
float mmv[6], maxi, coef;
int foo, sz, idx;
#if DEBUG_LEVEL
fprintf(stderr, ">>> %s ( %p %g )\n", __func__, pimg, vmax);
#endif
foo = fimg_get_minmax_rgb(pimg, mmv);
if (foo) {
fprintf(stderr, "%s: ABEND\n", __func__);
abort();
}
maxi = mmv[1];
if (mmv[3] > maxi) maxi = mmv[3];
if (mmv[5] > maxi) maxi = mmv[5];
coef = vmax / maxi;
if (verbosity) {
fprintf(stderr, "mins %f %f %f\n", mmv[0], mmv[2], mmv[4]);
fprintf(stderr, "maxs %f %f %f\n", mmv[1], mmv[3], mmv[5]);
fprintf(stderr, "coef = %f\n", coef);
}
sz = pimg->width * pimg->height;
for (idx=0; idx<sz; idx++) {
pimg->R[idx] *= coef;
pimg->G[idx] *= coef;
pimg->B[idx] *= coef;
}
return 0;
}
/* --------------------------------------------------------------------- */
int convertir_fimg_en_machinable(char *srcname, char *dstname,
int steps, float norm)
{
int foo, infos[3];
FloatImg fimg;
#if DEBUG_LEVEL
fprintf(stderr, ">>> %25s ( '%s' '%s' %d )\n", __func__,
srcname, dstname, notused);
#endif
if (steps < 1) {
fprintf(stderr, "%s: steps MUST be > 0\n", __func__);
exit(1);
}
foo = fimg_fileinfos(srcname, infos);
if (foo) {
fprintf(stderr, "'%s' get dims -> %d\n", srcname, foo);
return foo;
}
if (verbosity) {
fprintf(stderr, "%s: image '%s' is %d x %d %s\n",
__func__,
srcname, infos[0], infos[1],
fimg_str_type(infos[2]));
}
foo = fimg_create_from_dump(srcname, &fimg);
if (foo) {
fprintf(stderr, "create fimg from '%s' -> %d\n", srcname, foo);
return -1;
}
if (verbosity) {
fimg_describe(&fimg, srcname);
fprintf(stderr, "normalize to %f\n", norm);
}
if (norm > 0.0) {
// fprintf(stderr, "normalize %p\n", &fimg);
foo = normalize(&fimg, norm);
}
foo = export_as_machinable(&fimg, dstname, steps, 0);
if (foo) {
fprintf(stderr,"%s: err %d on export\n", __func__, foo);
}
fimg_destroy(&fimg);
return 0;
}
/* --------------------------------------------------------------------- */
void help(int k)
{
puts("usage:\n\tfimg2text [options] foo.fimg > bar.csv");
puts("options:");
puts("\t-v\t\tincrease verbosity");
puts("\t-n 3.14\t\tnormalize picture");
puts("\t-s N\t\tsteps on x & y");
if (verbosity) fimg_print_version(1);
exit(0);
}
/* --------------------------------------------------------------------- */
int main(int argc, char *argv[])
{
int foo, opt;
int steps = 1;
float norm_val = 222.0; /* < 0 : don't normalize */
char separator = ' ';
while ((opt = getopt(argc, argv, "f:hn:s:v")) != -1) {
switch(opt) {
case 'f': separator = optarg[0]; break;
case 'v': verbosity++; break;
case 'h': help(1); exit(1);
case 's': steps = atoi(optarg); break;
case 'n': norm_val = atof(optarg); break;
}
}
if (1 != argc-optind) {
fprintf(stderr, "error: %s need one intput filename\n", argv[0]);
exit(1);
}
foo = convertir_fimg_en_machinable(argv[optind], "-", steps, norm_val);
if (foo) {
fprintf(stderr, "%s : got a %d from convertor\n", argv[0], foo);
return 1;
}
return 0;
}
/* --------------------------------------------------------------------- */

98
src/tools/fimg2tiff.c Normal file
View File

@@ -0,0 +1,98 @@
/*
* converting a floatimg to a TIFF
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "../floatimg.h"
int verbosity;
/* ----------------------------------------------------------------- */
int convertir_fimg_en_TIFF(char *srcname, char *dstname, int grisaille)
{
int foo, infos[3];
FloatImg fimg;
#if DEBUG_LEVEL
fprintf(stderr, ">>> %25s ( '%s' '%s' %d )\n", __func__,
srcname, dstname, notused);
#endif
foo = fimg_fileinfos(srcname, infos);
if (foo) {
if (verbosity) fprintf(stderr, "'%s' get dims -> %d\n",
srcname, foo);
return foo;
}
if (verbosity) {
fprintf(stderr, "%s: image '%s' is %d x %d %s\n",
__func__,
srcname, infos[0], infos[1],
fimg_str_type(infos[2]));
}
foo = fimg_create_from_dump(srcname, &fimg);
if (foo) {
fprintf(stderr, "create fimg from '%s' -> %d\n", srcname, foo);
return -1;
}
if (grisaille) {
foo = fimg_desaturate(&fimg, &fimg, 0);
}
foo = fimg_write_as_tiff(&fimg, dstname, 0);
if (foo) {
fprintf(stderr, "%s: saving as tiff '%s' -> %d\n", __func__,
dstname, foo);
return -1;
}
fimg_destroy(&fimg);
return 0;
}
/* ----------------------------------------------------------------- */
void help(int k)
{
puts("usage:\n\tfimg2tiff [options] foo.fimg bar.tiff");
puts("options:");
// puts("\t-g\tconvert to gray");
puts("\t-v\tincrease verbosity");
if (verbosity) fimg_print_version(1);
exit(0);
}
/* ----------------------------------------------------------------- */
int main(int argc, char *argv[])
{
int foo, opt;
int to_gray = 0;
while ((opt = getopt(argc, argv, "ghv")) != -1) {
switch(opt) {
case 'g': to_gray = 1; break;
case 'v': verbosity++; break;
case 'h': help(1); exit(1);
}
}
if (2 != argc-optind) {
fprintf(stderr, "error: %s need two filenames\n", argv[0]);
exit(1);
}
foo = convertir_fimg_en_TIFF(argv[optind], argv[optind+1], to_gray);
if (foo)
fprintf(stderr, "%s : got a %d from convertor\n", argv[0], foo);
return 0;
}
/* ----------------------------------------------------------------- */

305
src/tools/fimgfx.c Normal file
View File

@@ -0,0 +1,305 @@
/*
FIMGFX
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include "../floatimg.h"
/* --------------------------------------------------------------------- */
int verbosity;
float global_fvalue;
typedef struct {
char *name;
int id;
int nbarg;
int flags;
} Fx;
enum fxid { Fx_cos01=5, Fx_cos010, Fx_pow2, Fx_sqrt, Fx_gray0, Fx_halfsz0,
Fx_rot90, Fx_cmixa, Fx_desat, Fx_ctr2x2, Fx_norm,
Fx_classtrial, Fx_mirror, Fx_shift0,
Fx_xper, Fx_binarize, Fx_trinarize,Fx_hilight_R };
Fx fx_list[] = {
{ "cos01", Fx_cos01, 0, 1 },
{ "cos010", Fx_cos010, 0, 1 },
{ "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 },
{ "cmixa", Fx_cmixa, 0, 1 },
{ "xper", Fx_xper, 0, 1 },
{ "desat", Fx_desat, 0, 1 },
{ "ctr2x2", Fx_ctr2x2, 0, 1 },
{ "mirror", Fx_mirror, 0, 1 },
{ "shift0", Fx_shift0, 0, 1 },
// { "norm", Fx_norm, 0, 1 },
{ "classtrial", Fx_classtrial, 0, 1 },
{ "binarize", Fx_binarize, 0, 1 },
{ "trinarize", Fx_trinarize, 0, 1 },
{ "hilightr", Fx_hilight_R, 0, 1 },
{ 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)
{
Fx *fx;
int n;
#if DEBUG_LEVEL
fprintf(stderr, ">>> %s ( '%s' )\n", __func__, txt);
#endif
for (n=0, fx=fx_list; fx->name; fx++, n++) {
#if DEBUG_LEVEL > 1
fprintf(stderr, " -> %3d %s\n", n, fx->name);
#endif
if (!strcmp(fx->name, txt)) {
return n;
}
}
return -1; /* NOT FOUND */
}
/* --------------------------------------------------------------------- */
/*
* this is the mutant function
*/
int do_experiment(FloatImg *S, FloatImg *D, float kf)
{
int foo;
#if DEBUG_LEVEL
fprintf(stderr, ">>> %s ( %p %p %f )\n", __func__, S, D, kf);
#endif
foo = fimg_classif_trial(S, D, kf, 0);
if (foo) {
fprintf(stderr, "%s err %d classif_trial %p\n", __func__,
foo, S);
return -98;
}
return 0;
}
/* --------------------------------------------------------------------- */
static void help(int lvl)
{
Fx *fx;
int foo;
printf("-- fimg special effects -- %s %s --\n", __DATE__, __TIME__);
puts("usage:");
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:");
printf("\t");
foo = 0;
for (fx=fx_list; fx->name; fx++) {
foo += printf("%s ", fx->name);
if (foo > 55) {
printf("\n\t");
foo = 0;
}
}
puts("");
fimg_print_version(1);
exit(0);
}
/* --------------------------------------------------------------------- */
int do_an_effect(char *srcfname, int fxidx, char *dstfname)
{
FloatImg src, dest;
int foo, action;
double maxval;
#if DEBUG_LEVEL
fprintf(stderr, ">>> %s ( '%s' %d '%s' )\n", __func__,
srcfname, action, dstfname);
#endif
foo = fimg_create_from_dump(srcfname, &src);
if (foo) {
fprintf(stderr, "err load '%s' : %d\n", srcfname, foo);
return foo;
}
maxval = (double)fimg_get_maxvalue(&src);
if (fx_list[fxidx].flags & 1) {
foo = fimg_clone(&src, &dest, 0);
if (foo) {
fprintf(stderr, "err clone %p : %d\n", &src, foo);
return foo;
}
}
else {
fprintf(stderr, "%s: ???\n", __func__); /* XXX */
memset(&dest, 0, sizeof(dest));
return -888;
}
action = fx_list[fxidx].id;
switch (action) {
case Fx_cos01:
fimg_cos_01(&src, &dest, maxval); break;
case Fx_cos010:
fimg_cos_010(&src, &dest, maxval); break;
case Fx_pow2:
fimg_power_2(&src, &dest, maxval); break;
case Fx_sqrt:
fimg_square_root(&src, &dest, maxval); break;
case Fx_gray0: /* new 2020 01 10 */
fimg_to_gray(&src); fimg_copy_data(&src, &dest);
break;
case Fx_xper:
do_experiment(&src, &dest, maxval); break;
case Fx_rot90:
foo = fimg_rotate_90(&src, &dest, 0); break;
case Fx_cmixa:
fimg_copy_data(&src, &dest);
foo = fimg_colors_mixer_a(&dest, 2.0); break;
case Fx_halfsz0:
fprintf(stderr, "halfsize was not implemented\n");
fprintf(stderr, "see 'fimghalfsize.c'. \n");
return -3;
case Fx_classtrial:
fprintf(stderr, "classif trial with %f fvalue\n",
global_fvalue);
foo = fimg_classif_trial(&src, &dest, global_fvalue, 0);
break;
case Fx_desat:
fimg_copy_data(&src, &dest);
foo = fimg_mix_rgb_gray(&dest, global_fvalue);
break;
case Fx_mirror:
foo = fimg_mirror(&src, &dest, 0);
break;
case Fx_shift0:
fprintf(stderr, "Krkrk %d\n", action);
foo = fimg_auto_shift_to_zero(&src, &dest);
break;
case Fx_ctr2x2:
foo = fimg_contour_2x2(&src, &dest, 0);
break;
case Fx_binarize:
fimg_copy_data(&src, &dest);
foo = fimg_binarize(&dest, 0);
break;
case Fx_trinarize:
fimg_copy_data(&src, &dest);
foo = fimg_trinarize(&dest, 0);
break;
case Fx_hilight_R:
foo = fimg_highlight_color(&src, &dest, 'R', 1.333);
break;
default:
fprintf(stderr, "%s %s : %d is bad action\n",
__FILE__, __func__, action);
break;
}
// 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);
return foo;
}
fimg_destroy(&src);
if (dest.type) {
fimg_destroy(&dest);
}
return 0;
}
/* --------------------------------------------------------------------- */
int main(int argc, char *argv[])
{
int foo, opt, action;
int nba;
char *operator;
char *srcname = "";
char *dstname = "out.fimg";
while ((opt = getopt(argc, argv, "hk:lv")) != -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;
}
}
#if DEBUG_LEVEL
fprintf(stderr, "argc %d optind %d\n", argc, optind);
for (foo=0; foo<argc; foo++)
fprintf(stderr, "%3d %c %s\n", foo, foo==optind?'*':' ', argv[foo]);
#endif
if (3 > argc-optind) {
fprintf(stderr, "%s need some arguments...\n", argv[0]);
exit(1);
}
if (verbosity>1) fprintf(stderr, "*** fimgfx *** %s %s\n", __DATE__, __TIME__);
operator = argv[optind];
action = lookup_fxidx(operator);
if (action < 0) {
fprintf(stderr, "garbage found in opcode field : %s\n", operator);
exit(1);
}
if (verbosity) {
fprintf(stderr, " global fvalue %f\n", global_fvalue);
fprintf(stderr, " action %d\n", action);
fprintf(stderr, " verbosity %d\n", verbosity);
}
if ((nba=fx_list[action].nbarg)) {
fprintf(stderr, "action '%s' need %d arg\n", operator, nba);
}
srcname = argv[optind+1];
dstname = argv[optind+2];
if (verbosity) fprintf(stderr, "%s ==> %s\n", srcname, dstname);
foo = do_an_effect(srcname, action, dstname);
if (foo) {
fprintf(stderr, "do an effect -> %d\n", foo);
}
return 0;
}
/* --------------------------------------------------------------------- */

95
src/tools/fimghalfsize.c Normal file
View File

@@ -0,0 +1,95 @@
/*
* halfsizing an fimg picture.
*/
#include <stdio.h>
#include <unistd.h> /* pour getopt */
#include <stdlib.h>
#include <string.h>
#include "../floatimg.h"
int verbosity;
/* ------------------------------------------------------------- */
int faire_un_halfsize(char *iname, char *oname, int to_gray)
{
FloatImg src, dst;
int foo;
foo = fimg_create_from_dump(iname, &src);
if (foo) {
fprintf(stderr, "create fimg from '%s' -> %d\n", iname, foo);
return -1;
}
memset(&dst, 0, sizeof(FloatImg));
foo = fimg_halfsize_1(&src, &dst, 0);
if (foo) {
fprintf(stderr, "halfize 1 fail -> %d\n", foo);
return -1;
}
if (to_gray) {
foo = fimg_to_gray(&dst);
/* and ? */
}
foo = fimg_dump_to_file(&dst, oname, 0);
if (foo) {
fprintf(stderr, "save to '%s' -> %d\n", oname, foo);
return -1;
}
return 0;
}
/* ------------------------------------------------------------- */
void help(int u)
{
puts("Usage:\n\tfimghalfsize [options] in.fimg out.fimg");
puts("Options:");
puts("\t-g\tconvert output to gray");
exit(0);
}
/* ------------------------------------------------------------- */
int main(int argc, char *argv[])
{
int foo, opt;
char *srcname = "";
char *dstname = "out.fimg";
int grayed = 0;
while ((opt = getopt(argc, argv, "ghv")) != -1) {
switch(opt) {
case 'g': grayed = 1; break;
case 'h': help(0); break;
case 'v': verbosity++; break;
}
}
if (2 != argc-optind) {
fprintf(stderr, "error: %s need two filenames\n", argv[0]);
exit(1);
}
srcname = argv[optind];
dstname = argv[optind+1];
if (verbosity) {
fprintf(stderr, "%s: src: %s dst: %s\n", argv[0],
srcname, dstname);
}
foo = faire_un_halfsize(srcname, dstname, grayed);
if (foo) {
fprintf(stderr, "in %s: make halfsize give a %d\n", argv[0], foo);
exit(1);
}
return 0;
}
/* ------------------------------------------------------------- */

191
src/tools/fimgops.c Normal file
View File

@@ -0,0 +1,191 @@
/*
FIMGOPS
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include "../floatimg.h"
int verbosity;
/* --------------------------------------------------------------------- */
float global_fvalue;
/* --------------------------------------------------------------------- */
#define OP_ADD 1
#define OP_SUB 2
#define OP_MIX 3
#define OP_MUL 4
#define OP_MINI 5
#define OP_MAXI 6
typedef struct {
int code;
char *op;
} Opcode;
Opcode opcodes[] = {
{ OP_ADD, "add" },
{ OP_SUB, "sub" },
{ OP_MIX, "mix" },
{ OP_MUL, "mul" },
{ OP_MINI, "mini" },
{ OP_MAXI, "maxi" },
{ 0, NULL }
};
static void pr_opcodes(void)
{
Opcode *optr;
puts("operators:");
for (optr = opcodes; optr->code; optr++) {
printf("\t%-15s %d\n", optr->op, optr->code);
}
}
static int look_opcode(char *txt)
{
Opcode *optr;
#if DEBUG_LEVEL
fprintf(stderr, ">>> %s ( '%s' )\n", __func__, txt);
#endif
for (optr = opcodes; optr->code; optr++) {
if (!strcmp(txt, optr->op)) {
// printf("found %s as %d\n", optr->op, optr->code);
return optr->code;
}
}
return -1;
}
/* --------------------------------------------------------------------- */
static void help(int lj)
{
puts("usage:\n\tfimgops [options] A.fimg B.fimg operator D.fimg");
puts("options:");
// puts("\t-g convert output to gray");
printf("\t-k N.N\t\tset float value (def=%.3f)\n", global_fvalue);
puts("\t-v\t\tincrease verbosity");
pr_opcodes();
if (verbosity) fimg_print_version(1);
exit(0);
}
/* --------------------------------------------------------------------- */
int exec_operator(FloatImg *A, FloatImg *B, int action, FloatImg *D)
{
int foo;
switch (action) {
case OP_ADD:
foo = fimg_add_3(A, B, D); break;
case OP_SUB:
foo = fimg_sub_3(A, B, D); break;
case OP_MIX:
if (verbosity) fprintf(stderr, "%s:mix: fvalue is %f\n",
__func__, global_fvalue);
foo = fimg_interpolate(A, B, D, global_fvalue);
break;
case OP_MUL:
foo = fimg_mul_3(A, B, D); break;
case OP_MINI:
foo = fimg_maximum(A, B, D); break;
case OP_MAXI:
foo = fimg_minimum(A, B, D); break;
default:
fprintf(stderr, "fscking action #%d\n", action);
foo = -99; break;
}
return foo;
}
/* --------------------------------------------------------------------- */
int main(int argc, char *argv[])
{
int foo, opt, action;
char *operator;
FloatImg srcA, srcB, dest;
global_fvalue = 0.5;
while ((opt = getopt(argc, argv, "hk:v")) != -1) {
switch(opt) {
case 'g': break;
case 'h': help(0); break;
case 'k': global_fvalue = atof(optarg); break;
case 'v': verbosity++; break;
}
}
#if DEBUG_LEVEL
fprintf(stderr, "argc %d optind %d\n", argc, optind);
for (foo=0; foo<argc; foo++)
fprintf(stderr, "%3d %s\n", foo, argv[foo]);
#endif
if (4 != argc-optind) {
fprintf(stderr, "%s need some arguments...\n", argv[0]);
exit(1);
}
operator = argv[optind+2];
action = look_opcode(operator);
if (action < 0) {
fprintf(stderr, "%s : opcode '%s' unknow\n", argv[0], operator);
exit(1);
}
/*
* load the two source files, and check compatibility
*/
if ((foo=fimg_create_from_dump(argv[optind], &srcA))) {
fprintf(stderr, "read error on '%s' is %d\n", argv[optind], foo);
exit(2);
}
if ((foo=fimg_create_from_dump(argv[optind+1], &srcB))) {
fprintf(stderr, "read error on '%s' is %d\n", argv[optind+1], foo);
exit(3);
}
if (verbosity > 1) { /* please, debug me */
fimg_describe(&srcA, argv[optind]);
fimg_describe(&srcB, argv[optind+1]);
}
foo = fimg_images_not_compatible(&srcA, &srcB);
if (foo) {
fprintf(stderr, "images are not compatibles, %d\n", foo);
exit(4);
}
/*
* we can now create the resultant image, and going coredump...
*/
foo = fimg_create(&dest, srcA.width, srcA.height, srcA.type);
if (foo) {
fprintf(stderr, "%s: crash coredump on create fimg\n", argv[0]);
#if MUST_ABORT
abort();
#endif
exit(1);
}
// fimg_describe(&dest, "destination");
foo = exec_operator(&srcA, &srcB, action, &dest);
if (foo) {
fprintf(stderr, "operator '%s' exec give us a %d\n",
operator, foo);
}
foo = fimg_dump_to_file(&dest, argv[optind+3], 0);
if (foo) {
fprintf(stderr, "dumping datas to file give us a %d\n", foo);
}
return 0;
}
/* --------------------------------------------------------------------- */

117
src/tools/fimgstats.c Normal file
View File

@@ -0,0 +1,117 @@
/*
* FIMGSTATS
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "../floatimg.h"
int verbosity; /* global */
int make_csv;
/* --------------------------------------------------------------------- */
int various_numbers(FloatImg *fimg, int k)
{
float moyennes[4];
int foo;
// float fvalue;
float vals[6];
if (verbosity) {
fprintf(stderr, " numbers from %p :\n", fimg);
}
fimg_printhead(fimg);
fprintf(stderr, "surface %d\n", fimg->width * fimg->height);
fimg_meanvalues(fimg, moyennes);
fprintf(stderr, "mean values:\n");
for (foo=0; foo<4; foo++)
printf(" %c %14.6f\n", "RGBA"[foo], moyennes[foo]);
foo = fimg_count_negativ(fimg);
if (foo) {
fprintf(stderr, "%d negative values\n", foo);
}
foo = fimg_get_minmax_rgb(fimg, vals);
if (foo) {
fprintf(stderr, "%s: err %d on fimg_get_minmax_rgb\n",
__func__, foo);
return foo;
}
printf("Rmin %12.4g Rmax %12.4g delta %12g\n",
vals[0], vals[1], vals[1]-vals[0]);
printf("Gmin %12.4g Gmax %12.4g %12g\n",
vals[2], vals[3], vals[3]-vals[2]);
printf("Bmin %12.4g Bmax %12.4g %12g\n",
vals[4], vals[5], vals[5]-vals[4]);
return 0;
}
/* --------------------------------------------------------------------- */
int various_numbers_from_file(char *fname, int k)
{
FloatImg fimg;
int foo;
fprintf(stderr, "------ numbers from '%s' :\n", fname);
foo = fimg_create_from_dump(fname, &fimg);
if (foo) {
fprintf(stderr, "create fimg from '%s' -> %d\n", fname, foo);
return -2;
}
various_numbers(&fimg, k);
fimg_destroy(&fimg);
return 0;
}
/* --------------------------------------------------------------------- */
static void help(int k)
{
fputs( "usage : fimgstats [options] file.fimg\n"
"\t-c\tmake a machinable csv\n"
"\t-v\tincrease verbosity\n"
, stderr);
}
/* --------------------------------------------------------------------- */
int main(int argc, char *argv[])
{
int foo, opt;
extern char *optarg;
extern int optind, opterr, optopt;
if (argc == 1) {
foo = fimg_print_version(1); help(0);
exit(0);
}
while ((opt = getopt(argc, argv, "chv")) != -1) {
switch(opt) {
case 'c': make_csv++; break;
case 'v': verbosity++; break;
case 'h': /* tombe dedans */
default: help(1); exit(1);
}
}
if (NULL==argv[optind]) {
fprintf(stderr, "optind %d is wtf\n", optind);
return 1;
}
foo = various_numbers_from_file(argv[optind], 0);
if (foo) {
fprintf(stderr, "got a %d ?\n", foo);
}
return 0;
}
/* --------------------------------------------------------------------- */

165
src/tools/mkfimg.c Normal file
View File

@@ -0,0 +1,165 @@
/*
* making a floatimg with some random datas
* an ugly software from tTh - february 2021
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>
#include "../floatimg.h"
int verbosity;
/* --------------------------------------------------------------------- */
#define T_BLACK 1
#define T_DRAND48 2
#define T_GRAY 3
#define T_HDEG_A 4
#define T_VDEG_A 5
#define T_TPAT0 6
typedef struct {
int code;
char *name;
} Type;
Type types[] = {
{ T_BLACK, "black" },
{ T_DRAND48, "drand48" },
{ T_GRAY, "gray" },
{ T_GRAY, "grey" },
{ T_HDEG_A, "hdeg" },
{ T_VDEG_A, "vdeg" },
{ T_TPAT0, "tpat0" },
{ 0, NULL }
};
static int get_type(char *name)
{
Type *type;
#if DEBUG_LEVEL
fprintf(stderr, ">>> %s ( '%s' )\n", __func__, name);
#endif
// #define TEST(str) ( ! strcmp(name, str) )
for (type = types; type->code; type++) {
if (!strcmp(name, type->name)) {
return type->code;
}
}
return -1;
}
/* --------------------------------------------------------------------- */
static void help(int lj)
{
int foo;
puts("Usage:\tmkfimg [options] quux.fimg width height");
puts("\t-k N.N\tgive a float parameter");
fputs("\t-t bla\thowto make the pic :\n\t\t", stdout);
for (foo=0; types[foo].code; foo++) {
printf("%s ", types[foo].name);
}
puts("\n\t-v\tincrease verbosity");
if (verbosity) {
fimg_print_version(1);
printf("*** compiled %s, %s\n", __DATE__, __TIME__);
}
exit(0);
}
/* --------------------------------------------------------------------- */
int main(int argc, char *argv[])
{
int foo, opt, nbargs;
int width, height;
char *fname;
float fvalue = 1.0;
int type = T_BLACK;
char *tname = "wtf?";
FloatImg fimg;
while ((opt = getopt(argc, argv, "hk:t:v")) != -1) {
switch(opt) {
case 'h': help(0); break;
case 'k': fvalue = atof(optarg); break;
case 't': type = get_type(tname=optarg); break;
case 'v': verbosity++; break;
}
}
#if DEBUG_LEVEL
fprintf(stderr, "argc %d optind %d\n", argc, optind);
for (foo=0; foo<argc; foo++)
fprintf(stderr, "%3d %s\n", foo, argv[foo]);
#endif
if (type < 0) {
fprintf(stderr, "type '%s' is unknow\n", tname);
exit(2);
}
nbargs = argc-optind;
switch (nbargs) {
case 2:
if (2!=parse_WxH(argv[optind+1], &width, &height)) {
fprintf(stderr, "%s: parse error on '%s'\n",
argv[0], argv[optind+1]);
exit(1);
}
break;
case 3:
width = atoi(argv[optind+1]);
height = atoi(argv[optind+2]);
break;
default:
fprintf(stderr, "%s need filename, width & height\n", argv[0]);
exit(1);
}
fname = argv[optind];
if (verbosity>1) fprintf(stderr, "*** mkfimg *** %s %s\n", __DATE__, __TIME__);
if (verbosity) fprintf(stderr, "making '%s' %dx%d, type %d\n",
fname, width, height, type);
srand48(getpid() ^ time(NULL));
foo = fimg_create(&fimg, width, height, 3);
if (foo) {
fprintf(stderr, "create floatimg -> %d\n", foo);
exit(3);
}
switch(type) {
default:
case T_BLACK: fimg_clear(&fimg); break;
case T_DRAND48: fimg_drand48(&fimg, fvalue); break;
case T_GRAY: fimg_rgb_constant(&fimg, fvalue, fvalue, fvalue);
break;
case T_HDEG_A: fimg_hdeg_a(&fimg, 1.0); break;
case T_VDEG_A: fimg_vdeg_a(&fimg, 1.0); break;
case T_TPAT0: fimg_test_pattern(&fimg, 0, fvalue); break;
case -1: exit(1);
}
foo = fimg_dump_to_file(&fimg, fname, 0);
if (foo) {
fprintf(stderr, "dump fimg to %s -> %d\n", fname, foo);
exit(1);
}
fimg_destroy(&fimg);
return 0;
}
/* --------------------------------------------------------------------- */

62
src/tools/png2fimg.c Normal file
View File

@@ -0,0 +1,62 @@
/*
* PNG ---> FIMG
*
* Attention : certains fichiers PNG ne passent pas cette
* moulinette, mais le bug est dans la bibliotheque de
* fonctions 'libpnglite'. Une solution de remplacement
* devrait etre a l'etude un de ces jours...
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include "../floatimg.h"
int verbosity = 0;
/* --------------------------------------------------------------------- */
void help(int k)
{
if (verbosity) fimg_print_version(k);
exit(0);
}
/* --------------------------------------------------------------------- */
int main(int argc, char *argv[])
{
FloatImg fimg;
int foo, opt;
while ((opt = getopt(argc, argv, "hv")) != -1) {
switch(opt) {
case 'v': verbosity++; break;
case 'h': help(1); exit(1);
}
}
if (2 != argc-optind) {
fprintf(stderr, "error: %s need two filenames\n", argv[0]);
exit(1);
}
memset(&fimg, 0, sizeof(FloatImg));
foo = fimg_create_from_png(argv[optind], &fimg);
if (foo) {
fprintf(stderr, "%s : err %d, abort.\n", argv[0], foo);
exit(1);
}
if (verbosity) fimg_describe(&fimg, argv[optind+1]);
foo = fimg_dump_to_file(&fimg, argv[optind+1], 0);
if (foo) {
fprintf(stderr, "save as '%s' -> err %d\n", argv[2], foo);
exit(1);
}
return 0;
}
/* --------------------------------------------------------------------- */