Tonton Th
4 years ago
commit
5a72327882
@ -0,0 +1,12 @@ |
||||
|
||||
lib/*.o |
||||
funcs/*.o |
||||
|
||||
*.a |
||||
|
||||
tools/fimg2png |
||||
tools/fimg2pnm |
||||
tools/fimgstats |
||||
tools/mkfimg |
||||
tools/png2fimg |
||||
tools/addtga2fimg |
||||
@ -0,0 +1,33 @@ |
||||
|
||||
# Before running make, you must have
|
||||
# a look to the 'build.sh' script !
|
||||
|
||||
COPT = -Wall -fpic -g -pg -DDEBUG_LEVEL=0
|
||||
LDOPT = libfloatimg.a -pg -lm
|
||||
|
||||
all: essai |
||||
|
||||
#---------------------------------------------------------------
|
||||
|
||||
exemple: exemple.c libfloatimg.a floatimg.h Makefile |
||||
gcc $(COPT) $< $(LDOPT) -o $@
|
||||
|
||||
essai: essai.c libfloatimg.a floatimg.h Makefile |
||||
gcc $(COPT) $< $(LDOPT) -lpnglite -o $@
|
||||
|
||||
#---------------------------------------------------------------
|
||||
|
||||
TOTAR = *.[ch] Makefile *.sh *.txt doc/*.tex \
|
||||
funcs/*.[ch] funcs/Makefile \
|
||||
tools/*.[ch] tools/Makefile \
|
||||
lib/*.[ch] lib/Makefile
|
||||
|
||||
lines: $(TOTAR) |
||||
@wc $(TOTAR) | sort -n
|
||||
|
||||
tarball: $(TOTAR) |
||||
date > tarball
|
||||
ls $(TOTAR) | sed 's/^/Fimg\//' > MANIFEST
|
||||
( cd .. ; tar zcvf floatimg.tar.gz `cat Fimg/MANIFEST` )
|
||||
|
||||
#---------------------------------------------------------------
|
||||
@ -0,0 +1,33 @@ |
||||
#!/bin/bash |
||||
|
||||
cd lib |
||||
echo EEEEEEEEEE we are in $PWD |
||||
make |
||||
error=$? |
||||
if [ 0 -ne $error ]; then |
||||
printf "in %s err %d in %s\n" $PWD $error $0 |
||||
exit $error |
||||
fi |
||||
cd .. |
||||
|
||||
cd funcs |
||||
echo EEEEEEEEEE we are in $PWD |
||||
make |
||||
error=$? |
||||
if [ 0 -ne $error ]; then |
||||
printf "in %s err %d in %s\n" $PWD $error $0 |
||||
exit $error |
||||
fi |
||||
cd .. |
||||
|
||||
cd tools |
||||
echo |
||||
make fimg2pnm addtga2fimg mkfimg png2fimg fimgstats fimg2png |
||||
error=$? |
||||
cd .. |
||||
|
||||
echo |
||||
|
||||
|
||||
|
||||
|
||||
@ -0,0 +1,100 @@ |
||||
/*
|
||||
testing some random funcs. |
||||
|
||||
*/ |
||||
|
||||
#include <stdio.h> |
||||
#include <stdlib.h> |
||||
#include <math.h> |
||||
#include <string.h> |
||||
|
||||
#include "floatimg.h" |
||||
|
||||
/* --------------------------------------------------------------------- */ |
||||
int add(FloatImg *a, FloatImg *b) |
||||
{ |
||||
int x, y; |
||||
int offset; |
||||
double tb; |
||||
|
||||
fimg_timer_set(0); |
||||
|
||||
for (x=0; x<a->width; x++) { |
||||
for (y=0; y<a->height; y++) { |
||||
offset = x + (y * a->width); |
||||
a->R[offset] += b->R[offset]; |
||||
a->G[offset] += b->G[offset]; |
||||
a->B[offset] += b->B[offset]; |
||||
} |
||||
} |
||||
|
||||
tb = fimg_timer_get(0); |
||||
fprintf(stderr, "%s = %f seconds\n", __func__, tb); |
||||
|
||||
return 0; |
||||
} |
||||
/* --------------------------------------------------------------------- */ |
||||
void fait_un_dessin(char *fname) |
||||
{ |
||||
FloatImg dessin; |
||||
double tb; |
||||
|
||||
puts(""); |
||||
fimg_timer_set(0); |
||||
fimg_create(&dessin, 3200, 2400, 3); |
||||
fimg_draw_something(&dessin); |
||||
fimg_dump_to_file(&dessin, "dessin.fimg", 0); |
||||
fimg_destroy(&dessin); |
||||
tb = fimg_timer_get(0); |
||||
fprintf(stderr, "%s = %f seconds\n", __func__, tb); |
||||
|
||||
puts(""); |
||||
} |
||||
/* --------------------------------------------------------------------- */ |
||||
|
||||
int main(int argc, char *argv[]) |
||||
{ |
||||
FloatImg fimgA, fimgB; |
||||
int foo; |
||||
double tb; |
||||
|
||||
fimg_print_version(0); |
||||
|
||||
#define W 2000 |
||||
#define H 1700 |
||||
|
||||
fait_un_dessin("dessin.fimg"); |
||||
|
||||
fimg_create(&fimgA, W, H, 3); |
||||
fimg_create(&fimgB, W, H, 3); |
||||
|
||||
fimg_draw_something(&fimgA); |
||||
|
||||
fimg_timer_set(0); |
||||
fimg_drand48(&fimgB, 100.0); |
||||
tb = fimg_timer_get(0); |
||||
fprintf(stderr, "%s = %f seconds\n", __func__, tb); |
||||
|
||||
foo = fimg_save_as_pnm(&fimgB, "drand48.pnm", 0); |
||||
|
||||
/*
|
||||
fimg_printhead(&fimgA); fimg_printhead(&fimgB); |
||||
fimg_describe(&fimgA, "image A"); |
||||
*/ |
||||
|
||||
add(&fimgA, &fimgB); |
||||
|
||||
foo = fimg_save_as_pnm(&fimgA, "t.pnm", 0); |
||||
fprintf(stderr, "save as pnm -> %d\n", foo); |
||||
foo = fimg_dump_to_file(&fimgA, "t.fimg", 0); |
||||
fprintf(stderr, "save as fimg -> %d\n", foo); |
||||
|
||||
fimg_destroy(&fimgA); |
||||
fimg_destroy(&fimgB); |
||||
|
||||
|
||||
return 0; |
||||
} |
||||
|
||||
/* --------------------------------------------------------------------- */ |
||||
|
||||
@ -0,0 +1,71 @@ |
||||
/*
|
||||
* floatimg.h |
||||
*/ |
||||
|
||||
#define FIMG_VERSION 58 |
||||
|
||||
/*
|
||||
* in memory descriptor |
||||
*/ |
||||
typedef struct { |
||||
int width; |
||||
int height; |
||||
int type; |
||||
float fval; |
||||
int count; |
||||
|
||||
float *R, *G, *B, *A; |
||||
|
||||
int reserved; |
||||
} FloatImg; |
||||
|
||||
/*
|
||||
* fimg file header |
||||
*/ |
||||
typedef struct { |
||||
// char magic[8];
|
||||
int w, h, t; |
||||
} FimgFhead; |
||||
|
||||
/*
|
||||
* core module |
||||
*/ |
||||
int fimg_create(FloatImg *fimg, int w, int h, int t); |
||||
int fimg_destroy(FloatImg *fimg); |
||||
|
||||
int fimg_print_version(int k); |
||||
void fimg_printhead(FloatImg *h); |
||||
int fimg_describe(FloatImg *head, char *txt); |
||||
int fimg_fileinfo(char *fname, int *datas); |
||||
int fimg_plot_rgb (FloatImg *head, int x, int y, float r, float g, float b); |
||||
int fimg_clear(FloatImg *fimg); |
||||
int fimg_add_rgb(FloatImg *head, int x, int y, float r, float g, float b); |
||||
|
||||
/* PNM files module */ |
||||
int fimg_save_as_pnm(FloatImg *head, char *fname, int notused); |
||||
|
||||
double fimg_timer_set(int whot); |
||||
double fimg_timer_get(int whot); |
||||
|
||||
|
||||
/* FIMG files module */ |
||||
int fimg_fileinfos(char *fname, int *datas); |
||||
int fimg_dump_to_file(FloatImg *head, char *fname, int notused); |
||||
int fimg_create_from_dump(char *fname, FloatImg *head); |
||||
|
||||
/* mathematics oprations */ |
||||
float fimg_get_maxvalue(FloatImg *head); |
||||
int fimg_meanvalues(FloatImg *head, float means[4]); |
||||
int fimg_to_gray(FloatImg *head); |
||||
void fimg_add_cste(FloatImg *fi, float value); |
||||
void fimg_drand48(FloatImg *fi, float kmul); |
||||
|
||||
/* variuos funcs modules */ |
||||
int fimg_load_from_png(char *filename, FloatImg *fimg); |
||||
int fimg_create_from_png(char *filename, FloatImg *fimg); |
||||
int fimg_save_as_png(FloatImg *src, char *outname, int flags); |
||||
|
||||
int fimg_draw_something(FloatImg *fimg); |
||||
|
||||
|
||||
|
||||
@ -0,0 +1,22 @@ |
||||
#---------------------------------------------------------------
|
||||
|
||||
COPT = -Wall -fpic -g -no-pie -pg -DDEBUG_LEVEL=0
|
||||
DEPS = ../floatimg.h Makefile
|
||||
OBJS = fimg-png.o fimg-tiff.o misc-plots.o filtrage.o
|
||||
|
||||
#---------------------------------------------------------------
|
||||
|
||||
../libfloatimg.a: $(OBJS) |
||||
$(AR) r $@ $?
|
||||
|
||||
fimg-png.o: fimg-png.c $(DEPS) |
||||
gcc $(COPT) -c $<
|
||||
|
||||
fimg-tiff.o: fimg-tiff.c $(DEPS) |
||||
gcc $(COPT) -c $<
|
||||
|
||||
misc-plots.o: misc-plots.c $(DEPS) |
||||
gcc $(COPT) -c $<
|
||||
|
||||
filtrage.o: filtrage.c $(DEPS) |
||||
gcc $(COPT) -c $<
|
||||
@ -0,0 +1,17 @@ |
||||
#include <stdio.h> |
||||
#include <stdlib.h> |
||||
#include <string.h> |
||||
#include <fcntl.h> |
||||
#include <float.h> |
||||
|
||||
#include "floatimg.h" |
||||
|
||||
/* -------------------------------------------------------------------- */ |
||||
int fimg_lissage_2x2(FloatImg *img) |
||||
{ |
||||
|
||||
|
||||
return -1; |
||||
} |
||||
/* -------------------------------------------------------------------- */ |
||||
|
||||
@ -0,0 +1,162 @@ |
||||
/*
|
||||
* Lecture des images PNG |
||||
*/ |
||||
|
||||
#include <stdio.h> |
||||
#include <stdlib.h> |
||||
#include <string.h> |
||||
|
||||
#include <pnglite.h> |
||||
|
||||
#include "../floatimg.h" |
||||
|
||||
/* --------------------------------------------------------------------- */ |
||||
/*
|
||||
* warning : this func has been tested only with |
||||
* RGB (3x8bits) PNG files |
||||
*/ |
||||
int fimg_create_from_png(char *filename, FloatImg *fimg) |
||||
{ |
||||
png_t png; |
||||
int foo, idx; |
||||
unsigned char *datas, *ptr; |
||||
int datasize; |
||||
|
||||
#if DEBUG_LEVEL |
||||
fprintf(stderr, ">>> %-25s ( '%s' %p )\n", __func__, filename, fimg); |
||||
#endif |
||||
|
||||
memset(&png, 0, sizeof(png_t)); |
||||
png_init(NULL, NULL); /* this is VITAL ! */ |
||||
|
||||
foo = png_open_file_read(&png, filename); |
||||
if (PNG_NO_ERROR != foo) { |
||||
fprintf(stderr, "%s open_file '%s' -> %d\n", __func__, filename, foo); |
||||
return foo; |
||||
} |
||||
#if DEBUG_LEVEL > 1 |
||||
fprintf(stderr, "%s opened\n", filename); |
||||
#endif |
||||
|
||||
datasize = png.width * png.height * png.bpp; |
||||
|
||||
if ( 3 != png.bpp ) { |
||||
fprintf(stderr, "format %d of '%s' not supported\n", |
||||
png.color_type, filename); |
||||
return -21; |
||||
} |
||||
|
||||
#if DEBUG_LEVEL |
||||
printf("\t%s is %d x %d\n", filename, png.width, png.height); |
||||
printf("\tdatalen %d\n", png.png_datalen); |
||||
printf("\tcolor type %d\n", png.color_type); |
||||
printf("\tbyte/pixel %d\n", png.bpp); |
||||
printf("\tdatasize %d\n", datasize); |
||||
puts(""); png_print_info(&png); puts(""); |
||||
#endif |
||||
|
||||
datas = malloc(datasize); |
||||
if (NULL==datas) { |
||||
fprintf(stderr, "%s : fatal memory failure\n", __func__); |
||||
exit(1); |
||||
} |
||||
|
||||
memset(fimg, 0, sizeof(FloatImg)); |
||||
foo = fimg_create(fimg, png.width, png.height, 3); |
||||
if (foo) { |
||||
fprintf(stderr, "can't create fimg\n"); |
||||
exit(1); |
||||
} |
||||
|
||||
foo = png_get_data(&png, datas); |
||||
if (PNG_NO_ERROR != foo) { |
||||
fprintf(stderr, "error in '%s' : read png -> %d\n", |
||||
__func__, foo); |
||||
return foo; |
||||
} |
||||
|
||||
ptr = datas; |
||||
for (idx=0; idx<png.width * png.height; idx++) { |
||||
fimg->R[idx] = (float)*ptr++; |
||||
fimg->G[idx] = (float)*ptr++; |
||||
fimg->B[idx] = (float)*ptr++; |
||||
} |
||||
free(datas); |
||||
|
||||
png_close_file(&png); |
||||
// fprintf(stderr, "png closed...\n");
|
||||
return foo; |
||||
} |
||||
/* --------------------------------------------------------------------- */ |
||||
/*
|
||||
* warning : this func has been tested only with |
||||
* RGB (3x8bits) PNG files |
||||
*/ |
||||
int fimg_load_from_png(char *filename, FloatImg *fimg) |
||||
{ |
||||
png_t png; |
||||
int foo, idx, datasize; |
||||
unsigned char *datas, *ptr; |
||||
|
||||
#if DEBUG_LEVEL |
||||
fprintf(stderr, ">>> %-25s ( '%s' %p )\n", __func__, filename, fimg); |
||||
#endif |
||||
|
||||
memset(&png, 0, sizeof(png_t)); |
||||
png_init(NULL, NULL); /* this is VITAL ! */ |
||||
|
||||
foo = png_open_file_read(&png, filename); |
||||
if (PNG_NO_ERROR != foo) { |
||||
#if DEBUG_LEVEL |
||||
fprintf(stderr, "open png -> %d\n", foo); |
||||
#endif |
||||
return foo; |
||||
} |
||||
|
||||
// puts(""); png_print_info(&png); puts("");
|
||||
|
||||
if ( 3 != png.bpp ) { /* TO BE PATCHED */ |
||||
fprintf(stderr, "format of '%s' not supported\n", filename); |
||||
return -21; |
||||
} |
||||
|
||||
/* check if floatimg and PNG have the same size */ |
||||
if ((fimg->width != png.width) || (fimg->height != png.height)) { |
||||
fprintf(stderr, "%s : fatal error on images sizes\n", __func__); |
||||
exit(1); |
||||
} |
||||
|
||||
datasize = png.width * png.height * png.bpp; |
||||
datas = malloc(datasize); |
||||
if (NULL==datas) { |
||||
fprintf(stderr, "%s : fatal memory failure\n", __func__); |
||||
exit(1); |
||||
} |
||||
foo = png_get_data(&png, datas); |
||||
if (PNG_NO_ERROR != foo) { |
||||
fprintf(stderr, "error in '%s' : read png -> %d\n", |
||||
__func__, foo); |
||||
return foo; |
||||
} |
||||
ptr = datas; |
||||
for (idx=0; idx<png.width * png.height; idx++) { |
||||
fimg->R[idx] = (float)*ptr++; |
||||
fimg->G[idx] = (float)*ptr++; |
||||
fimg->B[idx] = (float)*ptr++; |
||||
} |
||||
|
||||
free(datas); |
||||
png_close_file(&png); |
||||
return 0; |
||||
} |
||||
/* --------------------------------------------------------------------- */ |
||||
|
||||
int fimg_save_as_png(FloatImg *src, char *outname, int flags) |
||||
{ |
||||
png_t png; |
||||
|
||||
|
||||
|
||||
return -1; |
||||
} |
||||
/* --------------------------------------------------------------------- */ |
||||
@ -0,0 +1,12 @@ |
||||
/*
|
||||
* FLOATIMG |
||||
* import/export to/from TIFF files
|
||||
*/ |
||||
|
||||
#include <stdio.h> |
||||
|
||||
#include "../floatimg.h" |
||||
|
||||
/* --------------------------------------------------------------------- */ |
||||
/* --------------------------------------------------------------------- */ |
||||
/* --------------------------------------------------------------------- */ |
||||
@ -0,0 +1,57 @@ |
||||
/*
|
||||
testing some random funcs. |
||||
|
||||
*/ |
||||
|
||||
#include <stdio.h> |
||||
#include <stdlib.h> |
||||
#include <math.h> |
||||
|
||||
#include "../floatimg.h" |
||||
|
||||
/* --------------------------------------------------------------------- */ |
||||
|
||||
int fimg_draw_something(FloatImg *fimg) |
||||
{ |
||||
int x, y; |
||||
float fx, fy; |
||||
|
||||
#define K (3.14159*13.456) |
||||
#define M 100.0 |
||||
|
||||
for (x=0; x<fimg->width; x++) { |
||||
fimg_plot_rgb(fimg, x, 0, |
||||
(float)x, |
||||
(float)x + 5.678, |
||||
(float)x * 1.33333); |
||||
} |
||||
|
||||
for (y=1; y<fimg->height; y++) { |
||||
fy = (float)y / (float)fimg->height; |
||||
for (x=0; x<fimg->width; x++) { |
||||
fx = (float)x / (float)fimg->width; |
||||
fimg_plot_rgb(fimg, x, y, |
||||
M*(cos(fx*K)+1.2), |
||||
M*(cos(fy*K)+1.2), |
||||
M*(cos(fx*fy)+1.2)); |
||||
} |
||||
} |
||||
return 0; |
||||
} |
||||
/* --------------------------------------------------------------------- */ |
||||
int fimg_multirandom(FloatImg *fimg) |
||||
{ |
||||
int foo, x, y; |
||||
|
||||
#define RI ( (rand()/7) + (rand()/9) ) |
||||
#define RD ( (drand48()/7) + (drand48()/7) ) |
||||
|
||||
for (foo=0; foo<100000000; foo++) |
||||
{ |
||||
x = RI % fimg->width; |
||||
y = RI % fimg->height; |
||||
fimg_add_rgb(fimg, x, y, RD, RD, RD); |
||||
} |
||||
return 0; |
||||
} |
||||
/* --------------------------------------------------------------------- */ |
||||
@ -0,0 +1,12 @@ |
||||
#!/bin/bash |
||||
|
||||
cp libfloatimg.a /usr/local/lib |
||||
cp floatimg.h /usr/local/include |
||||
|
||||
cp tools/mkfimg tools/fimg2pnm tools/addtga2fimg \ |
||||
tools/png2fimg tools/fimgstats \ |
||||
/usr/local/bin |
||||
|
||||
|
||||
|
||||
|
||||
@ -0,0 +1,35 @@ |
||||
#
|
||||
# building the base library
|
||||
#
|
||||
|
||||
COPT = -Wall -fpic -g -pg -no-pie -DDEBUG_LEVEL=0
|
||||
OBJS = fimg-core.o fimg-pnm.o fimg-file.o fimg-math.o \
|
||||
fimg-timers.o
|
||||
DEPS = Makefile ../floatimg.h
|
||||
|
||||
# modify it 'as you like'
|
||||
AR=ar
|
||||
|
||||
all: $(OBJS) ../libfloatimg.a |
||||
|
||||
# --------------------------------------------
|
||||
|
||||
../libfloatimg.a: $(OBJS) |
||||
$(AR) r $@ $?
|
||||
|
||||
fimg-core.o: fimg-core.c $(DEPS) |
||||
gcc $(COPT) -c $<
|
||||
|
||||
fimg-pnm.o: fimg-pnm.c $(DEPS) |
||||
gcc $(COPT) -c $<
|
||||
|
||||
fimg-file.o: fimg-file.c $(DEPS) |
||||
gcc $(COPT) -c $<
|
||||
|
||||
fimg-math.o: fimg-math.c $(DEPS) |
||||
gcc $(COPT) -c $<
|
||||
|
||||
fimg-timers.o: fimg-timers.c $(DEPS) |
||||
gcc $(COPT) -c $<
|
||||
|
||||
# --------------------------------------------
|
||||
@ -0,0 +1,189 @@ |
||||
/*
|
||||
* fimg-core.c |
||||
* |
||||
* |
||||
*/ |
||||
|
||||
#include <stdio.h> |
||||
#include <stdlib.h> |
||||
#include <unistd.h> |
||||
#include "string.h" |
||||
|
||||
#include "../floatimg.h" |
||||
|
||||
extern int verbosity; /* must be declared around main() */ |
||||
|
||||
/* ---------------------------------------------------------------- */ |
||||
static int fimg_type_is_valid(int t) |
||||
{ |
||||
switch (t) { |
||||
case 1: case 3: case 4: return 1; |
||||
} |
||||
return 0; |
||||
} |
||||
/* --------------------------------------------------------------------- */ |
||||
int fimg_print_version(int k) |
||||
{ |
||||
fprintf(stderr, "*** FloatImg library, alpha v%d (%s, %s)\n", |
||||
FIMG_VERSION, __DATE__, __TIME__); |
||||
|
||||
if (51 == k) { |
||||
puts("+--------------------+"); |
||||
puts("| Pastis is coming. |"); |
||||
puts("+--------------------+"); |
||||
} |
||||
|
||||
return 0; |
||||
} |
||||
/* --------------------------------------------------------------------- */ |
||||
void fimg_printhead(FloatImg *h) |
||||
{ |
||||
printf("%5d %5d %2d %p %p %p %p\n", h->width, h->height, h->type, |
||||
h->R, h->G, h->B, h->A); |
||||
} |
||||
/* --------------------------------------------------------------------- */ |
||||
int fimg_describe(FloatImg *head, char *txt) |
||||
{ |
||||
printf("----- '%s' at %p -----\n", txt, head); |
||||
|
||||
if( ! fimg_type_is_valid(head->type) ) { |
||||
fprintf(stderr, "*** %s *** type %d invalid *** %s ***\n", |
||||
__func__, head->type, txt); |
||||
return -1; |
||||
} |
||||
|
||||
printf(" size %d x %d x %d\n", |
||||
head->width, head->height, head->type); |
||||
printf(" fval/count %f %d\n", head->fval, head->count); |
||||
printf(" pixels@ %p %p %p %p\n", |
||||
head->R, head->G, head->B, head->A); |
||||
|
||||
return 0; |
||||
} |
||||
/* ---------------------------------------------------------------- */ |
||||
|
||||
int fimg_create(FloatImg *fimg, int w, int h, int t) |
||||
{ |
||||
int surface, size; |
||||
float *fptr; |
||||
|
||||
#if DEBUG_LEVEL |
||||
fprintf(stderr, ">>> %-25s ( %p %d %d %d )\n", __func__, fimg, w, h, t); |
||||
#endif |
||||
|
||||
if ( ! fimg_type_is_valid(t) ) { |
||||
return -2; |
||||
} |
||||
memset(fimg, 0, sizeof(FloatImg)); |
||||
|
||||
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 : nom mem, exiting.\n", __func__); |
||||
exit(1); |
||||
} |
||||
|
||||
#if DEBUG_LEVEL > 1 |
||||
fprintf(stderr, " got %d bytes at %p\n", size, fptr); |
||||
#endif |
||||
|
||||
fimg->width = w; fimg->height = h; |
||||
fimg->type = t; |
||||
|
||||
fimg->R = fptr;
|
||||
if ( (t==3) || (t==4) ) { |
||||
fimg->G = fptr + surface; |
||||
fimg->B = fptr + surface + surface; |
||||
} |
||||
if ( t==4 ) fimg->A = fptr + (3 * surface);
|
||||
|
||||
return 0; |
||||
} |
||||
|
||||
/* --------------------------------------------------------------------- */ |
||||
|
||||
int fimg_destroy(FloatImg *fimg) |
||||
{ |
||||
|
||||
#if DEBUG_LEVEL |
||||
fprintf(stderr, ">>> %-25s ( %p )\n", __func__, fimg); |
||||
#endif |
||||
|
||||
if ( ! fimg_type_is_valid(fimg->type) ) { |
||||
return -2; |
||||
} |
||||
|
||||
free(fimg->R); |
||||
memset(fimg, 0, sizeof(FloatImg)); |
||||
|
||||
return 0; |
||||
} |
||||
/* --------------------------------------------------------------------- */ |
||||
int fimg_clear(FloatImg *fimg) |
||||
{ |
||||
int size; |
||||
|
||||
#if DEBUG_LEVEL |
||||
fprintf(stderr, ">>> %-25s ( %p )\n", __func__, fimg); |
||||
#endif |
||||
if ( ! fimg_type_is_valid(fimg->type) ) { |
||||
fprintf(stderr, "invalid type %d in %s\n", fimg->type, __func__); |
||||
return -2; |
||||
} |
||||
|
||||
size = fimg->width * fimg->height * fimg->type * sizeof(float);
|
||||
memset(fimg->R, 0, size); |
||||
|
||||
return -1; |
||||
} |
||||
/* --------------------------------------------------------------------- */ |
||||
|
||||
int fimg_plot_rgb (FloatImg *head, int x, int y,
|
||||
float r, float g, float b) |
||||
{ |
||||
int offset; |
||||
|
||||
if (head->type < 3) { |
||||
#if DEBUG_LEVEL > 1 |
||||
fprintf(stderr, "%s : type %d is bad.\n", __func__, head->type); |
||||
#endif |
||||
return -1; |
||||
} |
||||
|
||||
offset = x + (y * head->width); |
||||
|
||||
#if DEBUG_LEVEL > 1 |
||||
fprintf(stderr, ">>> %s ( %p %d %d %f )\n", __func__, head, x, y, gray); |
||||
fprintf(stderr, " offset %d\n", offset); |
||||
#endif |
||||
|
||||
head->R[offset] = r; |
||||
head->G[offset] = g; |
||||
head->B[offset] = b; |
||||
|
||||
return 0; |
||||
} |
||||
/* ---------------------------------------------------------------- */ |
||||
int fimg_add_rgb(FloatImg *head, int x, int y, float r, float g, float b) |
||||
{ |
||||
int offset; |
||||
offset = x + (y * head->width); |
||||
head->R[offset] += r; |
||||
head->G[offset] += g; |
||||
head->B[offset] += b; |
||||
return 0; |
||||
} |
||||
|
||||
/* --------------------------------------------------------------------- */ |
||||
|
||||
|
||||
/* --------------------------------------------------------------------- */ |
||||
|
||||
|
||||
|
||||
|
||||
@ -0,0 +1,125 @@ |
||||
/*
|
||||
* fimg-file.c |
||||
* |
||||
* |
||||
*/ |
||||
|
||||
#include <stdio.h> |
||||
#include <stdlib.h> |
||||
#include <unistd.h> |
||||
#include "string.h" |
||||
|
||||
#include "../floatimg.h" |
||||
|
||||
extern int verbosity; /* must be declared around main() */ |
||||
|
||||
/* ---------------------------------------------------------------- */ |
||||
int fimg_fileinfos(char *fname, int *datas) |
||||
{ |
||||
FILE *fp; |
||||
|
||||
#if DEBUG_LEVEL |
||||
fprintf(stderr, ">>> %-25s ( '%s' %p )\n", __func__, fname, datas); |
||||
#endif |
||||
|
||||
fp = fopen(fname, "r"); |
||||
if (NULL==fp) { |
||||
perror(fname); |
||||
return -1; |
||||
} |
||||
if (3 != fread(datas, sizeof(int), 3, fp)) { |
||||
fprintf(stderr, "%s: %s short read\n", __func__, fname); |
||||
fclose(fp); |
||||
return -2; |
||||
} |
||||
|
||||
fclose(fp); |
||||
|
||||
return 0; |
||||
} |
||||
/* ---------------------------------------------------------------- */ |
||||
int fimg_dump_to_file(FloatImg *head, char *fname, int notused) |
||||
{ |
||||
FILE *fp; |
||||
int foo, nbre, dims[3]; |
||||
|
||||
#if DEBUG_LEVEL |
||||
fprintf(stderr, ">>> %-25s ( %p '%s' %d )\n", __func__, head, |
||||
fname, notused); |
||||
#endif |
||||
|
||||
if (3 != head->type) { |
||||
fprintf(stderr, "%s : bat type %d\n", __func__, head->type); |
||||
return -8; |
||||
}
|
||||
|
||||
fp = fopen(fname, "w"); |
||||
if (NULL==fp) { |
||||
perror(fname); |
||||
return -1; |
||||
} |
||||
|
||||
dims[0] = head->width; dims[1] = head->height; |
||||
dims[2] = head->type; |
||||
|
||||
foo = fwrite(dims, sizeof(int), 3, fp); |
||||
if (3 != foo) { |
||||
perror(fname); |
||||
fclose(fp); |
||||
return -2; |
||||
} |
||||
nbre = head->width*head->height*3; |
||||
#if DEBUG_LEVEL |
||||
fprintf(stderr, " %s : data at %p\n", __func__, head->R); |
||||
#endif |
||||
|
||||
foo = fwrite(head->R, sizeof(float), nbre, fp); |
||||
if (nbre!=foo) { |
||||
perror(fname); |
||||
fclose(fp); |
||||
return -3; |
||||
} |
||||
|
||||
fclose(fp); |
||||
|
||||
return 0; |
||||
} |
||||
/* ---------------------------------------------------------------- */ |
||||
int fimg_create_from_dump(char *fname, FloatImg *head) |
||||
{ |
||||
FILE *fp; |
||||
int foo, dims[3]; |
||||
|
||||
#if DEBUG_LEVEL |
||||
fprintf(stderr, ">>> %-25s ( '%s' %p )\n", __func__, fname, head); |
||||
#endif |
||||
|
||||
fp = fopen(fname, "r"); |
||||
if (NULL==fp) { |
||||
perror(fname); |
||||
exit(1); |
||||
} |
||||
|
||||
foo = fread(dims, sizeof(int), 3, fp);
|
||||
if (3 != foo) { |
||||
fprintf(stderr, "%s : short read\n", fname); |
||||
fclose(fp); |
||||
return -1; |
||||
} |
||||
#if DEBUG_LEVEL |
||||
fprintf(stderr, "%s : got [ %d %d %d ] from '%s'\n", __func__, |
||||
dims[0], dims[1], dims[2], fname); |
||||
#endif |
||||
|
||||
foo = fimg_create(head, dims[0], dims[1], dims[2]);
|
||||
if (foo) { |
||||
fprintf(stderr, "%s : create -> %d\n", __func__, foo); |
||||
return foo; |
||||
} |
||||
|
||||
foo = fread(head->R, sizeof(float), dims[0]*dims[1]*3, fp); |
||||
|
||||
fclose(fp); |
||||
|
||||
return 0; |
||||
} |
||||
@ -0,0 +1,99 @@ |
||||
/*
|
||||
* fimg-core.c |
||||
* |
||||
* |
||||
*/ |
||||
|
||||
#include <stdio.h> |
||||
#include <stdlib.h> |
||||
#include <unistd.h> |
||||
#include "string.h" |
||||
|
||||
#include "../floatimg.h" |
||||
|
||||
extern int verbosity; /* must be declared around main() */ |
||||
|
||||
/* ---------------------------------------------------------------- */ |
||||
float fimg_get_maxvalue(FloatImg *head) |
||||
{ |
||||
float maxval; |
||||
int foo; |
||||
|
||||
maxval = 0.0; /* no negative values allowed */ |
||||
|
||||
for (foo=0; foo<(head->width*head->height); foo++) { |
||||
if (head->R[foo] > maxval) maxval = head->R[foo]; |
||||
if (head->G[foo] > maxval) maxval = head->G[foo]; |
||||
if (head->B[foo] > maxval) maxval = head->B[foo]; |
||||
} |
||||
|
||||
return maxval; |
||||
} |
||||
/* ---------------------------------------------------------------- */ |
||||
int fimg_meanvalues(FloatImg *head, float means[4]) |
||||
{ |
||||
int idx, surface; |
||||
|
||||
surface = head->width * head->height; |
||||
if (surface < 1) return -1; |
||||
|
||||
memset(means, 0, 4*sizeof(float)); |
||||
|
||||
for (idx=0; idx<surface; idx++) { |
||||
means[0] += head->R[idx]; |
||||
if (head->type > 2) { |
||||
means[1] += head->G[idx]; |
||||
means[2] += head->B[idx]; |
||||
} |
||||
} |
||||
|
||||
for (idx=0; idx<4; idx++) means[idx] /= (float)surface; |
||||
|
||||
return 0; |
||||
} |
||||
/* ---------------------------------------------------------------- */ |
||||
int fimg_to_gray(FloatImg *head) |
||||
{ |
||||
float add; |
||||
int foo; |
||||
|
||||
for (foo=0; foo<(head->width*head->height); foo++) { |
||||
add = head->R[foo]; |
||||
add += head->G[foo]; |
||||
add += head->B[foo]; |
||||
head->R[foo] = head->G[foo] = head->B[foo] = add; |
||||
} |
||||
return -1; |
||||
} |
||||
/* ---------------------------------------------------------------- */ |
||||
void fimg_add_cste(FloatImg *fi, float value) |
||||
{ |
||||
int nbre, idx; |
||||
|
||||
nbre = fi->width * fi->height * fi->type; |
||||
#if DEBUG_LEVEL |
||||
fprintf(stderr, "%s, nbre is %d\n", __func__, nbre); |
||||
#endif |
||||
for (idx=0; idx<nbre; nbre++) { |
||||
fi->R[idx] += value; |
||||
} |
||||
} |
||||
/* ---------------------------------------------------------------- */ |
||||
/* Warning: this function is _very_ slow */ |
||||
void fimg_drand48(FloatImg *fi, float kmul) |
||||
{ |
||||
int nbre, idx; |
||||
|
||||
#if DEBUG_LEVEL |
||||
fprintf(stderr, ">>> %s ( %p %g )\n", __func__, fi, kmul); |
||||
#endif |
||||
|
||||
nbre = fi->width * fi->height * fi->type; |
||||
for (idx=0; idx<nbre; idx++) { |
||||
fi->R[idx] = drand48() * kmul; |
||||
} |
||||
|
||||
} |
||||
/* ---------------------------------------------------------------- */ |
||||
|
||||
|
||||
@ -0,0 +1,76 @@ |
||||
/*
|
||||
* fimg-pnm.c |
||||
* |
||||
* |
||||
*/ |
||||
|
||||
#include <stdio.h> |
||||
#include <stdlib.h> |
||||
#include <unistd.h> |
||||
#include "string.h" |
||||
|
||||
#include "../floatimg.h" |
||||
|
||||
extern int verbosity; /* must be declared around main() */ |
||||
|
||||
/* ---------------------------------------------------------------- */ |
||||
/* ---------------------------------------------------------------- */ |
||||
|
||||
int fimg_save_as_pnm(FloatImg *head, char *fname, int notused) |
||||
{ |
||||
FILE *fp; |
||||
float maximum, fk; |
||||
int idx, sz, Rv, Gv, Bv, foo; |
||||
|
||||
#if DEBUG_LEVEL |
||||
fprintf(stderr, ">>> %-25s ( %p '%s' %d )\n", __func__, head, |
||||
fname, notused); |
||||
#endif |
||||
|
||||
if (head->type != 3) { |
||||
#if DEBUG_LEVEL |
||||
fprintf(stderr, "%s : type %d is bad.\n", __func__, head->type); |
||||
#endif |
||||
return -1; |
||||
} |
||||
|
||||
if (NULL==(fp=fopen(fname, "w"))) { |
||||
perror(fname); |
||||
return -1; |
||||
} |
||||
|
||||
fprintf(fp, "P3\n%d %d\n", head->width, head->height); |
||||
|
||||
maximum = fimg_get_maxvalue(head); |
||||
fprintf(fp, "# maxval %15f\n", maximum); |
||||
fk = maximum / 65536.0; |
||||
fprintf(fp, "# divisor %15f\n", fk); |
||||
fprintf(fp, "65535\n"); |
||||
sz = head->width*head->height; |
||||
|
||||
foo = 0; |
||||
for (idx=0; idx<sz; idx++) { |
||||
if (fk > 0) { |
||||
Rv = (int)(head->R[idx] / fk); |
||||
Gv = (int)(head->G[idx] / fk); |
||||
Bv = (int)(head->B[idx] / fk); |
||||
} |
||||
else { |
||||
Rv = Gv = Bv = 0; |
||||
} |
||||
foo += fprintf(fp, "%d %d %d", Rv, Gv, Bv); |
||||
if (foo > 60) { |
||||
fputs("\n", fp); foo = 0; |
||||
} |
||||
else { |
||||
fputs(" ", fp); foo++; |
||||
} |
||||
} |
||||
fputs("\n", fp); |
||||
|
||||
|
||||
fclose(fp); |
||||
|
||||
return 0; |
||||
} |
||||
/* ---------------------------------------------------------------- */ |
||||
@ -0,0 +1,43 @@ |
||||
/*
|
||||
* timers.c |
||||
*/ |
||||
|
||||
#include <stdio.h> |
||||
#include <sys/time.h> |
||||
|
||||
extern int verbosity; |
||||
|
||||
/* ----------------------------------------------------------------- */ |
||||
static double dtime(void) |
||||
{ |
||||
struct timeval t; |
||||
double d; |
||||
(void)gettimeofday(&t, NULL); |
||||
d = (double)t.tv_sec + (double)t.tv_usec / 1e6; |
||||
return d; |
||||
} |
||||
/* ----------------------------------------------------------------- */ |
||||
|
||||
|
||||
static double memory_time; |
||||
|
||||
double fimg_timer_set(int whot) |
||||
{ |
||||
double current; |
||||
|
||||
current = dtime(); |
||||
|
||||
#if DEBUG_LEVEL |
||||
fprintf(stderr, "%s ( %d ) -> current %f\n", __func__, whot, current); |
||||
#endif |
||||
memory_time = current; |
||||
return memory_time; |
||||
} |
||||
/* ----------------------------------------------------------------- */ |
||||
double fimg_timer_get(int whot) |
||||
{ |
||||
double current; |
||||
current = dtime(); |
||||
return current - memory_time; |
||||
} |
||||
/* ----------------------------------------------------------------- */ |
||||
@ -0,0 +1,29 @@ |
||||
#
|
||||
# makefile for floatimg tools
|
||||
# use with caution
|
||||
#
|
||||
|
||||
COPT = -Wall -fpic -g -DDEBUG_LEVEL=1
|
||||
DEPS = ../floatimg.h ../libfloatimg.a Makefile
|
||||
|
||||
# ----------
|
||||
|
||||
fimgstats: fimgstats.c $(DEPS) |
||||
gcc -g $< ../libfloatimg.a -o $@
|
||||
|
||||
mkfimg: mkfimg.c $(DEPS) |
||||
gcc -g $< ../libfloatimg.a -o $@
|
||||
|
||||
fimg2pnm: fimg2pnm.c $(DEPS) |
||||
gcc -g $< ../libfloatimg.a -o $@
|
||||
|
||||
fimg2png: fimg2png.c $(DEPS) |
||||
gcc -g $< ../libfloatimg.a -o $@
|
||||
|
||||
addtga2fimg: addtga2fimg.c $(DEPS) |
||||
gcc -g $< ../libfloatimg.a -limageSO -lm -o $@
|
||||
|
||||
# if "undefined reference to crc32" then "use -lz"
|
||||
png2fimg: png2fimg.c $(DEPS) |
||||
gcc -g $< ../libfloatimg.a -lpnglite -o $@
|
||||
|
||||
@ -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|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); |
||||
} |
||||
|
||||
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; |
||||
} |
||||
/* --------------------------------------------------------------------- */ |
||||
|
||||
|
||||
@ -0,0 +1,21 @@ |
||||
#include <stdio.h> |
||||
#include <stdlib.h> |
||||
#include <unistd.h> |
||||
|
||||
#include "../floatimg.h" |
||||
|
||||
/* --------------------------------------------------------------------- */ |
||||
int main(int argc, char *argv[]) |
||||
{ |
||||
int foo; |
||||
|
||||
if (3 != argc) { |
||||
fimg_print_version(1); |
||||
fprintf(stderr, "usage:\n\t%s foo.fimg bar.pnm\n", argv[0]); |
||||
exit(1); |
||||
} |
||||
|
||||
return 0; |
||||
} |
||||
/* --------------------------------------------------------------------- */ |
||||
|
||||
@ -0,0 +1,62 @@ |
||||
#include <stdio.h> |
||||
#include <stdlib.h> |
||||
#include <unistd.h> |
||||
|
||||
#include "../floatimg.h" |
||||
|
||||
int verbosity; |
||||
|
||||
/* --------------------------------------------------------------------- */ |
||||
int convertir_fimg_en_pnm(char *srcname, char *dstname, int notused) |
||||
{ |
||||
int foo, infos[3]; |
||||
FloatImg fimg; |
||||
|
||||
#if DEBUG_LEVEL |
||||
fprintf(stderr, ">>> %25s ( '%s' '%s' )\n", __func__, srcname, dstname); |
||||
#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\n", |
||||
srcname, infos[0], infos[1]); |
||||
} |
||||
|
||||
foo = fimg_create_from_dump(srcname, &fimg); |
||||
if (foo) { |
||||
fprintf(stderr, "create fimg from '%s' -> %d\n", srcname, foo); |
||||
return -1; |
||||
} |
||||
|
||||
#if DEBUG_LEVEL > 1 |
||||
print_floatimg(&fimg, "created fimg"); |
||||
#endif |
||||
|
||||
foo = fimg_save_as_pnm(&fimg, dstname, 0); |
||||
if(foo) { fprintf(stderr, "%p to '%s' -> %d\n", &fimg, dstname, foo); } |
||||
|
||||
return 0; |
||||
} |
||||
/* --------------------------------------------------------------------- */ |
||||
int main(int argc, char *argv[]) |
||||
{ |
||||
int foo; |
||||
|
||||
if (3 != argc) { |
||||
fimg_print_version(1); |
||||
fprintf(stderr, "usage:\n\t%s foo.fimg bar.pnm\n", argv[0]); |
||||
exit(1); |
||||
} |
||||
|
||||
if ( 0 != access(argv[1], R_OK|W_OK) ) { /* fimg is NOT readable */ |
||||
fprintf(stderr, "%s: %s don't exist.\n", argv[0], argv[1]); |
||||
exit(2); |
||||
} |
||||
|
||||
foo = convertir_fimg_en_pnm(argv[1], argv[2], 0); |
||||
if (foo) fprintf(stderr, "conversion -> %d\n", foo); |
||||
|
||||
return 0; |
||||
} |
||||
@ -0,0 +1,91 @@ |
||||
/*
|
||||
* 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; |
||||
|
||||
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]); |
||||
|
||||
fvalue = fimg_get_maxvalue(fimg); |
||||
printf("max value %f\n", fvalue); |
||||
|
||||
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, "cv")) != -1) { |
||||
switch(opt) { |
||||
case 'c': make_csv++; break; |
||||
case 'v': verbosity++; break; |
||||
|
||||
default: help(1); exit(1); |
||||
} |
||||
} |
||||
|
||||
foo = various_numbers_from_file(argv[optind], 0); |
||||
|
||||
| ||||