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

Compare commits

base: tTh:b9d963dfa26f815460539106ea8a686bccb45367
Branches Tags
tTh:master
..
compare: tTh:10c92cc2126350c44710d27c14dd1248c9b261d3
Branches Tags
tTh:master

No commits in common. "b9d963dfa26f815460539106ea8a686bccb45367" and "10c92cc2126350c44710d27c14dd1248c9b261d3" have entirely different histories.
b9d963dfa2 ... 10c92cc212

15 changed files with 105 additions and 179 deletions
Show Stats Expand all files Collapse all files

2
floatimg.h
View File

@ -3,7 +3,7 @@
* ugly code from tTh * ugly code from tTh
*/ */
#define FIMG_VERSION 122 #define FIMG_VERSION 120
/* /*
* in memory descriptor * in memory descriptor

6
funcs/contour2x2.c
View File

@ -49,12 +49,8 @@ else {
} }
foo = fimg_meanvalues(psrc, avg); foo = fimg_meanvalues(psrc, avg);
if (foo) {
fprintf(stderr, "%s: err %d on fimg_meanvalues\n", __func__, foo);
return foo;
}
if (verbosity > 1) { if (verbosity > 1) {
fprintf(stderr, "%s: %f %f %f\n", __func__, avg[0], avg[1], avg[2]); 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 RP(ix, iy) ( psrc->R[((iy)*psrc->width)+(ix)] < avg[0] )

4
funcs/qsortrgb.c
View File

@ -38,10 +38,6 @@ if (fimg_images_not_compatible(psrc, pdst)) {
if (psrc != pdst) { /* optimize or futurbug ? */ if (psrc != pdst) { /* optimize or futurbug ? */
foo = fimg_copy_data(psrc, pdst); foo = fimg_copy_data(psrc, pdst);
if (foo) {
fprintf(stderr, "%s: err %d on copy data\n", __func__, foo);
return foo;
}
} }
szimg = pdst->width * pdst->height; szimg = pdst->width * pdst->height;

4
funcs/rotate.c
View File

@ -15,7 +15,7 @@ extern int verbosity;
int fimg_rotate_90(FloatImg *src, FloatImg *dst, int notused) int fimg_rotate_90(FloatImg *src, FloatImg *dst, int notused)
{ {
int foo; int foo;
int x, y, k; int x, y, j, k;
float rgb[3]; float rgb[3];
#if DEBUG_LEVEL #if DEBUG_LEVEL
@ -56,7 +56,7 @@ if ( (src->type != dst->type) ||
for (y=0; y<src->height; y++) { for (y=0; y<src->height; y++) {
for (x=0; x<src->width; x++) { for (x=0; x<src->width; x++) {
fimg_get_rgb(src, x, y, rgb); fimg_get_rgb(src, x, y, rgb);
// XXX ??? j = (dst->height - x) - 1; j = (dst->height - x) - 1;
k = (dst->width - y) - 1; k = (dst->width - y) - 1;
#if DEBUG_LEVEL > 1 #if DEBUG_LEVEL > 1
fprintf(stderr, "%6d %6d\n", k, j); fprintf(stderr, "%6d %6d\n", k, j);

2
lib/Makefile
View File

@ -2,7 +2,7 @@
# building the base library # building the base library
# #
COPT = -Wall -fpic -g -no-pie -DDEBUG_LEVEL=1 COPT = -Wall -fpic -g -no-pie -DDEBUG_LEVEL=0
OBJS = fimg-core.o fimg-pnm.o fimg-file.o fimg-math.o \ OBJS = fimg-core.o fimg-pnm.o fimg-file.o fimg-math.o \
fimg-timers.o operators.o fimg-2gray.o \ fimg-timers.o operators.o fimg-2gray.o \

30
lib/contrast.c
View File

@ -51,15 +51,11 @@ else {
} }
nbre = s->width * s->height; nbre = s->width * s->height * 3;
for (idx=0; idx<nbre; idx++) { for (idx=0; idx<nbre; idx++) {
dval = s->R[idx] / maxval; dval = s->R[idx] / maxval;
d->R[idx] = maxval * sqrt(dval); d->R[idx] = maxval * sqrt(dval);
dval = s->G[idx] / maxval;
d->G[idx] = maxval * sqrt(dval);
dval = s->B[idx] / maxval;
d->B[idx] = maxval * sqrt(dval);
} }
return -1; return -1;
@ -71,7 +67,7 @@ int nbre, idx;
double dval; double dval;
if (s->type != FIMG_TYPE_RGB) { if (s->type != FIMG_TYPE_RGB) {
fprintf(stderr, "%s: src type %d invalide\n", fprintf(stderr, "%s : src type %d invalide\n",
__func__, s->type); __func__, s->type);
return -4; return -4;
} }
@ -81,22 +77,18 @@ if (NULL==d) {
} }
else { else {
if (d->type != FIMG_TYPE_RGB) { if (d->type != FIMG_TYPE_RGB) {
fprintf(stderr, "%s: dst type %d invalide\n", fprintf(stderr, "%s : dst type %d invalide\n",
__func__, d->type); __func__, d->type);
return -4; return -4;
} }
} }
nbre = s->width * s->height; nbre = s->width * s->height * 3;
for (idx=0; idx<nbre; idx++) { for (idx=0; idx<nbre; idx++) {
dval = s->R[idx] / maxval; dval = s->R[idx] / maxval;
d->R[idx] = maxval * dval * dval; d->R[idx] = maxval * dval * dval;
dval = s->G[idx] / maxval;
d->G[idx] = maxval * dval * dval;
dval = s->B[idx] / maxval;
d->B[idx] = maxval * dval * dval;
} }
return 0; return 0;
@ -130,15 +122,12 @@ else {
} }
} }
nbre = s->width * s->height; nbre = s->width * s->height * 3;
for (idx=0; idx<nbre; idx++) { for (idx=0; idx<nbre; idx++) {
dval = s->R[idx] / maxval; dval = s->R[idx] / maxval;
d->R[idx] = maxval * (0.5 - 0.5 * cos(3.141592654*dval)); d->R[idx] = maxval * (0.5 - 0.5 * cos(3.141592654*dval));
dval = s->G[idx] / maxval;
d->G[idx] = maxval * (0.5 - 0.5 * cos(3.141592654*dval));
dval = s->B[idx] / maxval;
d->B[idx] = maxval * (0.5 - 0.5 * cos(3.141592654*dval));
} }
return 0; return 0;
@ -166,15 +155,12 @@ else {
} }
} }
nbre = s->width * s->height; nbre = s->width * s->height * 3;
for (idx=0; idx<nbre; idx++) { for (idx=0; idx<nbre; idx++) {
dval = s->R[idx] / maxval; dval = s->R[idx] / maxval;
d->R[idx] = maxval * (0.5 - 0.5 * cos(2*3.141592654*dval)); d->R[idx] = maxval * (0.5 - 0.5 * cos(2*3.141592654*dval));
dval = s->G[idx] / maxval;
d->G[idx] = maxval * (0.5 - 0.5 * cos(2*3.141592654*dval));
dval = s->B[idx] / maxval;
d->B[idx] = maxval * (0.5 - 0.5 * cos(2*3.141592654*dval));
} }
return 0; return 0;

84
lib/fimg-core.c
View File

@ -19,8 +19,7 @@ int fimg_type_is_valid(int type)
switch (type) { switch (type) {
case FIMG_TYPE_GRAY: case FIMG_TYPE_GRAY:
case FIMG_TYPE_RGB: case FIMG_TYPE_RGB:
case FIMG_TYPE_RGBA: case FIMG_TYPE_RGBA: return 1;
case FIMG_TYPE_RGBZ: return 1;
} }
return 0; return 0;
} }
@ -31,14 +30,13 @@ switch (type) {
case FIMG_TYPE_GRAY: return "gray"; case FIMG_TYPE_GRAY: return "gray";
case FIMG_TYPE_RGB: return "rgb"; case FIMG_TYPE_RGB: return "rgb";
case FIMG_TYPE_RGBA: return "rgba"; case FIMG_TYPE_RGBA: return "rgba";
case FIMG_TYPE_RGBZ: return "rgbz";
} }
return "???"; return "???";
} }
/* --------------------------------------------------------------------- */ /* --------------------------------------------------------------------- */
int fimg_print_version(int k) int fimg_print_version(int k)
{ {
fprintf(stderr, "*** FloatImg library, alpha %d (%s, %s)\n", fprintf(stderr, "*** FloatImg library, alpha v%d (%s, %s)\n",
FIMG_VERSION, __DATE__, __TIME__); FIMG_VERSION, __DATE__, __TIME__);
if (51 == k) { if (51 == k) {
@ -54,7 +52,6 @@ void fimg_print_sizeof(void)
{ {
fprintf(stderr, " sz FloatImg = %lu\n", sizeof(FloatImg)); fprintf(stderr, " sz FloatImg = %lu\n", sizeof(FloatImg));
fprintf(stderr, " sz filehead = %lu\n", sizeof(FimgFileHead)); fprintf(stderr, " sz filehead = %lu\n", sizeof(FimgFileHead));
fprintf(stderr, " sz filter = %lu\n", sizeof(FimgFilter3x3));
} }
/* --------------------------------------------------------------------- */ /* --------------------------------------------------------------------- */
void fimg_printhead(FloatImg *h) void fimg_printhead(FloatImg *h)
@ -84,35 +81,19 @@ printf(" pixels@ %p %p %p %p\n",
return 0; return 0;
} }
/* ---------------------------------------------------------------- */ /* ---------------------------------------------------------------- */
static float *plane_alloc(int size) /*
* values for the parameter 't' are defined in 'floatimg.h'
*/
int fimg_create(FloatImg *fimg, int w, int h, int t)
{ {
int surface, size;
float *fptr; float *fptr;
#if DEBUG_LEVEL #if DEBUG_LEVEL
fprintf(stderr, ">>> %s ( %d )\n", __func__, size); fprintf(stderr, ">>> %-25s ( %p %d %d %d )\n", __func__, fimg, w, h, t);
#endif #endif
fptr = calloc(size, sizeof(float)); if ( ! fimg_type_is_valid(t) ) {
if (NULL==fptr) {
fprintf(stderr, "no more memory available, ABEND\n");
abort();
}
return fptr;
}
/* ---------------------------------------------------------------- */
/*
* values for the parameter 'type' are defined in 'floatimg.h'
*/
int fimg_create(FloatImg *fimg, int w, int h, int type)
{
int size;
#if DEBUG_LEVEL
fprintf(stderr, ">>> %s ( %p %d %d %d )\n", __func__, fimg, w, h, type);
#endif
if ( ! fimg_type_is_valid(type) ) {
fprintf(stderr, "%s: type %d invalid\n", __func__, type);
return -2; return -2;
} }
@ -120,24 +101,35 @@ if ( ! fimg_type_is_valid(type) ) {
* what to do if we've got a descriptor for an image * what to do if we've got a descriptor for an image
* already allocated ? * already allocated ?
*/ */
memset(fimg, 0, sizeof(FloatImg)); memset(fimg, 0, sizeof(FloatImg));
size = w * h; surface = w * h;
size = surface * t * sizeof(float);
#if DEBUG_LEVEL > 1
fprintf(stderr, "surface is %d pixels, need %d bytes\n", surface, size);
#endif
fptr = (float *)malloc(size);
if (NULL==fptr) {
fprintf(stderr, "%s : no mem, exiting.\n", __func__);
exit(1);
}
#if DEBUG_LEVEL > 1
fprintf(stderr, " %s: got %d bytes at %p\n", __func__, size, fptr);
#endif
fimg->width = w; fimg->height = h; fimg->width = w; fimg->height = h;
fimg->type = type; fimg->type = t;
/* the red channel is allway allocated */ fimg->R = fptr;
fimg->R = (float *)plane_alloc(size); if ( (t==FIMG_TYPE_RGB) || (t==FIMG_TYPE_RGBA) ) {
fimg->G = fptr + surface;
if (FIMG_TYPE_RGB == type) { fimg->B = fptr + surface + surface;
fimg->G = (float *)plane_alloc(size);
fimg->B = (float *)plane_alloc(size);
} }
if ( t==FIMG_TYPE_RGBA ) fimg->A = fptr + (3 * surface);
if (FIMG_TYPE_RGBA == type) { /* ok this a really WTF fragment of code */
fimg->A = (float *)plane_alloc(size);
}
return 0; return 0;
} }
@ -164,8 +156,6 @@ if (NULL == fimg->R) {
fprintf(stderr, "%s : %p already freed ?\n", __func__, fimg); fprintf(stderr, "%s : %p already freed ?\n", __func__, fimg);
return -3; return -3;
} }
free(fimg->R); free(fimg->R);
memset(fimg, 0, sizeof(FloatImg)); memset(fimg, 0, sizeof(FloatImg));
@ -177,7 +167,7 @@ int fimg_clone(FloatImg *old, FloatImg *new, int flags)
int foo; int foo;
#if DEBUG_LEVEL #if DEBUG_LEVEL
fprintf(stderr, ">>> %s ( %p %p 0x%x )\n", __func__, old, new, flags); fprintf(stderr, ">>> %-25s ( %p %p 0x%x)\n", __func__, old, new, flags);
#endif #endif
if ( ! fimg_type_is_valid(old->type) ) { if ( ! fimg_type_is_valid(old->type) ) {
@ -207,7 +197,7 @@ int size;
int foo; int foo;
#if DEBUG_LEVEL #if DEBUG_LEVEL
fprintf(stderr, ">>> %s ( %p %p )\n", __func__, from, to); fprintf(stderr, ">>> %-25s ( %p %p )\n", __func__, from, to);
#endif #endif
foo = fimg_images_not_compatible(from, to); foo = fimg_images_not_compatible(from, to);
@ -216,10 +206,8 @@ if (foo) {
return foo; return foo;
} }
size = from->width * from->height * sizeof(float); size = from->width * from->height * from->type * sizeof(float);
memcpy(to->R, from->R, size); memcpy(to->R, from->R, size);
memcpy(to->G, from->G, size);
memcpy(to->B, from->B, size);
return 0; return 0;
} }

59
lib/fimg-file.c
View File

@ -52,9 +52,6 @@ datas[2] = filehead.t;
return 0; return 0;
} }
/* ---------------------------------------------------------------- */ /* ---------------------------------------------------------------- */
/*
* /!\ thi func work ONLY on RGB image
*/
int fimg_dump_to_file(FloatImg *fimg, char *fname, int notused) int fimg_dump_to_file(FloatImg *fimg, char *fname, int notused)
{ {
FILE *fp; FILE *fp;
@ -78,7 +75,7 @@ if (NULL==fp) {
} }
memset(&filehead, 0, sizeof(filehead)); memset(&filehead, 0, sizeof(filehead));
memcpy(filehead.magic, "FIMG", 4); strcpy(filehead.magic, "FIMG");
filehead.w = fimg->width; filehead.h = fimg->height; filehead.w = fimg->width; filehead.h = fimg->height;
filehead.t = fimg->type; filehead.t = fimg->type;
@ -88,19 +85,16 @@ if (1 != foo) {
fclose(fp); fclose(fp);
return -2; return -2;
} }
nbre = fimg->width * fimg->height; /* pixels per frame */ nbre = fimg->width*fimg->height*3;
#if DEBUG_LEVEL
fprintf(stderr, " %s : data at %p\n", __func__, fimg->R);
#endif
foo = fwrite(fimg->R, sizeof(float), nbre, fp); foo = fwrite(fimg->R, sizeof(float), nbre, fp);
if (nbre != foo) { if (nbre != foo) {
perror(fname); fclose(fp); return -3; perror(fname);
} fclose(fp);
foo = fwrite(fimg->G, sizeof(float), nbre, fp); return -3;
if (nbre != foo) {
perror(fname); fclose(fp); return -3;
}
foo = fwrite(fimg->B, sizeof(float), nbre, fp);
if (nbre != foo) {
perror(fname); fclose(fp); return -3;
} }
fclose(fp); fclose(fp);
@ -136,27 +130,18 @@ if (1 != foo) {
if ( (filehead.w != where->width) || if ( (filehead.w != where->width) ||
(filehead.h != where->height) || (filehead.h != where->height) ||
(filehead.t != where->type) ) { (filehead.t != where->type) ) {
fprintf(stderr, "%s: file '%s' incompatible\n",
__func__, fname); fprintf(stderr, "%s: file '%s' incompatible\n", __func__, fname);
fclose(fp); fclose(fp);
return -17; return -17;
} }
nbre = filehead.w * filehead.h; /* number of pixels per frame */ nbre = filehead.w*filehead.h*filehead.t; /* ugly quirk */
foo = fread(where->R, sizeof(float), nbre, fp); foo = fread(where->R, sizeof(float), nbre, fp);
if (nbre != foo) { if (nbre != foo) {
fprintf(stderr, "%s: err read '%s' : %d\n", __func__, fname, foo); fprintf(stderr, "%s: err read '%s' : %d\n", __func__, fname, foo);
fclose(fp); return -18; fclose(fp);
} return -18;
foo = fread(where->G, sizeof(float), nbre, fp);
if (nbre != foo) {
fprintf(stderr, "%s: err read '%s' : %d\n", __func__, fname, foo);
fclose(fp); return -18;
}
foo = fread(where->B, sizeof(float), nbre, fp);
if (nbre != foo) {
fprintf(stderr, "%s: err read '%s' : %d\n", __func__, fname, foo);
fclose(fp); return -18;
} }
fclose(fp); fclose(fp);
@ -168,7 +153,7 @@ return 0;
int fimg_create_from_dump(char *fname, FloatImg *head) int fimg_create_from_dump(char *fname, FloatImg *head)
{ {
FILE *fp; FILE *fp;
int foo, size; int foo;
FimgFileHead filehead; FimgFileHead filehead;
#if DEBUG_LEVEL #if DEBUG_LEVEL
@ -188,14 +173,13 @@ if (NULL==fp) {
foo = fread(&filehead, sizeof(FimgFileHead), 1, fp); foo = fread(&filehead, sizeof(FimgFileHead), 1, fp);
if (1 != foo) { if (1 != foo) {
fprintf(stderr, "%s: short read on '%s'\n", __func__, fname); fprintf(stderr, "%s : short read\n", fname);
fclose(fp); fclose(fp);
return -16; return -16;
} }
#if DEBUG_LEVEL #if DEBUG_LEVEL
fprintf(stderr, "%s : got [ %dx%d %s ] from '%s'\n", __func__, fprintf(stderr, "%s : got [ %d %d %d ] from '%s'\n", __func__,
filehead.w, filehead.h, fimg_str_type(filehead.t), filehead.w, filehead.h, filehead.t, fname);
fname);
#endif #endif
foo = fimg_create(head, filehead.w, filehead.h, filehead.t); foo = fimg_create(head, filehead.w, filehead.h, filehead.t);
@ -204,11 +188,10 @@ if (foo) {
return foo; return foo;
} }
size = filehead.w * filehead.h; /* NO No no !!! don't do that !!! */
foo = 0; foo = fread(head->R, sizeof(float),
foo += fread(head->R, sizeof(float), size, fp); filehead.w*filehead.h*filehead.t, fp);
foo += fread(head->G, sizeof(float), size, fp);
foo += fread(head->B, sizeof(float), size, fp);
fclose(fp); fclose(fp);

25
lib/fimg-math.c
View File

@ -98,7 +98,7 @@ memset(accus, 0, 4*sizeof(double));
for (idx=0; idx<surface; idx++) { for (idx=0; idx<surface; idx++) {
accus[0] += head->R[idx]; accus[0] += head->R[idx];
if (head->type > 2) { /* WTF ? */ if (head->type > 2) {
accus[1] += head->G[idx]; accus[1] += head->G[idx];
accus[2] += head->B[idx]; accus[2] += head->B[idx];
} }
@ -123,6 +123,8 @@ Mais c,a ne semble pas etre la bonne methode. Il faut aller voir :
https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance
*/ */
/* ---------------------------------------------------------------- */ /* ---------------------------------------------------------------- */
/* /*
* more elaborate functions are in fimg-2gray.c * more elaborate functions are in fimg-2gray.c
@ -157,14 +159,12 @@ if (fi->type != FIMG_TYPE_RGB) {
return; return;
} }
nbre = fi->width * fi->height ; nbre = fi->width * fi->height * fi->type;
#if DEBUG_LEVEL #if DEBUG_LEVEL
fprintf(stderr, "%s, nbre is %d\n", __func__, nbre); fprintf(stderr, "%s, nbre is %d\n", __func__, nbre);
#endif #endif
for (idx=0; idx<nbre; idx++) { for (idx=0; idx<nbre; idx++) {
fi->R[idx] += value; fi->R[idx] += value;
fi->G[idx] += value;
fi->B[idx] += value;
} }
} }
/* ---------------------------------------------------------------- */ /* ---------------------------------------------------------------- */
@ -179,13 +179,11 @@ if (fi->type != FIMG_TYPE_RGB) {
return -1; return -1;
} }
nbre = fi->width * fi->height; nbre = fi->width * fi->height * fi->type;
count = 0; count = 0;
for (idx=0; idx<nbre; idx++) { for (idx=0; idx<nbre; idx++) {
if (fi->R[idx] < 0.0) count++; if (fi->R[idx] < 0.0) count++;
if (fi->G[idx] < 0.0) count++;
if (fi->B[idx] < 0.0) count++;
} }
return count; return count;
@ -239,21 +237,12 @@ if ( (fi->type != FIMG_TYPE_RGB) && (fi->type != FIMG_TYPE_GRAY) ) {
return; return;
} }
nbre = fi->width * fi->height; nbre = fi->width * fi->height * fi->type;
#if DEBUG_LEVEL #if DEBUG_LEVEL
fprintf(stderr, "%s, nbre of datum is %d\n", __func__, nbre); fprintf(stderr, "%s, nbre of datum is %d\n", __func__, nbre);
#endif #endif
if (fi->type == FIMG_TYPE_RGB) { for (idx=0; idx<nbre; idx++) {
for (idx=0; idx<nbre; idx++) {
fi->R[idx] *= value; fi->R[idx] *= value;
fi->G[idx] *= value;
fi->B[idx] *= value;
}
}
if (fi->type == FIMG_TYPE_GRAY) {
for (idx=0; idx<nbre; idx++) {
fi->R[idx] *= value;
}
} }
} }
/* ---------------------------------------------------------------- */ /* ---------------------------------------------------------------- */

16
lib/t.c
View File

@ -153,8 +153,6 @@ int essai_clone_et_copy(int unused)
FloatImg A, B, C; FloatImg A, B, C;
int foo; int foo;
fprintf(stderr, "-------- %s ( %d ) --------\n", __func__, unused);
foo = fimg_create(&A, TAILLE, TAILLE, FIMG_TYPE_RGB); foo = fimg_create(&A, TAILLE, TAILLE, FIMG_TYPE_RGB);
if (foo) { if (foo) {
fprintf(stderr, "%s err create A %d\n", __func__, foo); fprintf(stderr, "%s err create A %d\n", __func__, foo);
@ -232,8 +230,6 @@ int foo;
FloatImg dessin, copy; FloatImg dessin, copy;
double maxi; double maxi;
fprintf(stderr, "-------- %s ( '%s' ) --------\n", __func__, fname);
foo = fimg_create_from_dump(fname, &dessin); foo = fimg_create_from_dump(fname, &dessin);
if (foo) { if (foo) {
fprintf(stderr, "in %s, error %d loading '%s'\n", fprintf(stderr, "in %s, error %d loading '%s'\n",
@ -242,7 +238,6 @@ if (foo) {
} }
foo = fimg_clone(&dessin, &copy, 0); foo = fimg_clone(&dessin, &copy, 0);
fimg_save_as_pnm(&dessin, "dessin.pnm", 0);
maxi = (double)fimg_get_maxvalue(&dessin); maxi = (double)fimg_get_maxvalue(&dessin);
fprintf(stderr, "image source valeur maxi = %f\n", maxi); fprintf(stderr, "image source valeur maxi = %f\n", maxi);
@ -295,14 +290,17 @@ if (verbosity) {
fimg_print_sizeof(); fimg_print_sizeof();
} }
foo = essai_contraste("quux.fimg"); // foo = essai_normalize();
fprintf(stderr, "retour essai contraste -> %d\n", foo); // fprintf(stderr, "retour essai normalize -> %d\n", foo);
// foo = essai_contraste("quux.fimg");
// fprintf(stderr, "retour essai contraste -> %d\n", foo);
// foo = essai_clone_et_copy(0); // foo = essai_clone_et_copy(0);
// fprintf(stderr, "retour essai clone'n'copy -> %d\n", foo); // fprintf(stderr, "retour essai clone'n'copy -> %d\n", foo);
// foo = essai_timer(0); foo = essai_timer(0);
// fprintf(stderr, "retour essai timer -> %d\n", foo); fprintf(stderr, "retour essai -> %d\n", foo);
return 0; return 0;
} }

9
tools/README.md
View File

@ -1,8 +1,5 @@
# Images en virgule flottante, les outils. # 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 ## mkfimg
## fimgops ## fimgops
@ -12,9 +9,3 @@ explications sur ce que vous pouvez faire.
## fimgstats ## fimgstats
## fimg2pnm - fimg2png ## fimg2pnm - fimg2png
## fimg2text
Nouveau de l'année 2020+1 : exfiltrer toutes des données d'une image flottante
afin de les rendre machinables.

20
tools/fimg2text.c
View File

@ -12,7 +12,7 @@
int verbosity; int verbosity;
/* --------------------------------------------------------------------- */ /* ------------------------------------------------------------------------- */
int export_as_machinable(FloatImg *src, char *fname, int steps, int flags) int export_as_machinable(FloatImg *src, char *fname, int steps, int flags)
{ {
FILE *fp; FILE *fp;
@ -44,7 +44,7 @@ for (y=0; y<src->height; y+=steps) {
return 0; return 0;
} }
/* --------------------------------------------------------------------- */ /* ------------------------------------------------------------------------- */
static int normalize(FloatImg *pimg, float vmax) static int normalize(FloatImg *pimg, float vmax)
{ {
float mmv[6], maxi, coef; float mmv[6], maxi, coef;
@ -79,7 +79,7 @@ for (idx=0; idx<sz; idx++) {
return 0; return 0;
} }
/* --------------------------------------------------------------------- */ /* ------------------------------------------------------------------------- */
int convertir_fimg_en_machinable(char *srcname, char *dstname, int convertir_fimg_en_machinable(char *srcname, char *dstname,
int steps, float norm) int steps, float norm)
{ {
@ -125,18 +125,18 @@ fimg_destroy(&fimg);
return 0; return 0;
} }
/* --------------------------------------------------------------------- */ /* ------------------------------------------------------------------------- */
void help(int k) void help(int k)
{ {
puts("usage:\n\tfimg2text [options] foo.fimg > bar.csv"); puts("usage:\n\tfimg2text [options] foo.fimg > bar.csv");
puts("options:"); puts("options:");
puts("\t-v\t\tincrease verbosity"); puts("\t-v\tincrease verbosity");
puts("\t-n 3.14\t\tnormalize picture"); puts("\t-n 3.14\tnormalize picture");
puts("\t-s N\t\tsteps on x & y"); puts("\t-s N\nsteps on x & y");
if (verbosity) fimg_print_version(1); if (verbosity) fimg_print_version(1);
exit(0); exit(0);
} }
/* --------------------------------------------------------------------- */ /* ------------------------------------------------------------------------- */
int main(int argc, char *argv[]) int main(int argc, char *argv[])
{ {
@ -154,7 +154,7 @@ while ((opt = getopt(argc, argv, "hn:s:v")) != -1) {
} }
if (1 != argc-optind) { if (1 != argc-optind) {
fprintf(stderr, "error: %s need one intput filename\n", argv[0]); fprintf(stderr, "error: %s need one filename\n", argv[0]);
exit(1); exit(1);
} }
@ -165,5 +165,5 @@ if (foo) {
return 0; return 0;
} }
/* --------------------------------------------------------------------- */ /* ------------------------------------------------------------------------- */

3
tools/fimgops.c
View File

@ -65,7 +65,7 @@ static void help(int lj)
puts("usage:\n\tfimgops [options] A.fimg B.fimg operator D.fimg"); puts("usage:\n\tfimgops [options] A.fimg B.fimg operator D.fimg");
puts("options:"); puts("options:");
// puts("\t-g convert output to gray"); puts("\t-g convert output to gray");
puts("\t-k N.N set float value"); puts("\t-k N.N set float value");
puts("\t-v increase verbosity"); puts("\t-v increase verbosity");
pr_opcodes(); pr_opcodes();
@ -112,7 +112,6 @@ FloatImg srcA, srcB, dest;
while ((opt = getopt(argc, argv, "hk:v")) != -1) { while ((opt = getopt(argc, argv, "hk:v")) != -1) {
switch(opt) { switch(opt) {
case 'g': break;
case 'h': help(0); break; case 'h': help(0); break;
case 'k': global_fvalue = atof(optarg); break; case 'k': global_fvalue = atof(optarg); break;
case 'v': verbosity++; break; case 'v': verbosity++; break;

5
tools/fimgstats.c
View File

@ -32,6 +32,11 @@ fprintf(stderr, "mean values:\n");
for (foo=0; foo<4; foo++) for (foo=0; foo<4; foo++)
printf(" %c %14.6f\n", "RGBA"[foo], moyennes[foo]); printf(" %c %14.6f\n", "RGBA"[foo], moyennes[foo]);
/*
fvalue = fimg_get_maxvalue(fimg);
printf("max value %f\n", fvalue);
*/
foo = fimg_count_negativ(fimg); foo = fimg_count_negativ(fimg);
if (foo) { if (foo) {
fprintf(stderr, "%d negative values\n", foo); fprintf(stderr, "%d negative values\n", foo);

7
tools/mkfimg.c
View File

@ -1,8 +1,3 @@
/*
* making a floatimg with some random datas
* an ugly software from tTh - february 2021
*/
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include <stdlib.h> #include <stdlib.h>
@ -142,7 +137,7 @@ switch(type) {
foo = fimg_dump_to_file(&fimg, fname, 0); foo = fimg_dump_to_file(&fimg, fname, 0);
if (foo) { if (foo) {
fprintf(stderr, "dump fimg to %s -> %d\n", fname, foo); fprintf(stderr, "dump fimg -> %d\n", foo);
exit(1); exit(1);
} }