forked from tTh/FloatImg
source tree refactor and build system (to be completed)
This commit is contained in:
John Doe
138
src/funcs/Makefile
Normal file
138
src/funcs/Makefile
Normal file
@@ -0,0 +1,138 @@
|
||||
#---------------------------------------------------------------
|
||||
|
||||
# Please, use the 'Gloabl.makefile' system !
|
||||
|
||||
LIB_DIR = ../../build/lib
|
||||
|
||||
OBJ_DIR = ../../build/obj
|
||||
|
||||
STATIC_LIB = $(LIB_DIR)/libfloatimg.a
|
||||
|
||||
DYN_OBJ = $(OBJ_DIR)/libfloatimg-funcs.o
|
||||
|
||||
COPT = -Wall -fpic -g -no-pie -DDEBUG_LEVEL=0
|
||||
|
||||
DEPS = ../floatimg.h Makefile
|
||||
|
||||
OBJS = fimg-png.o fimg-tiff.o misc-plots.o filtrage.o utils.o \
|
||||
fimg-libpnm.o rampes.o sfx0.o sfx1.o sfx2.o \
|
||||
geometry.o rotate.o fimg-openexr.o \
|
||||
equalize.o fimg-fits.o saturation.o histogram.o \
|
||||
hsv.o classif.o contour2x2.o qsortrgb.o exporter.o \
|
||||
displacement.o dithering.o plasmas.o incrustator.o \
|
||||
recurse.o
|
||||
|
||||
|
||||
all: $(OBJS) $(STATIC_LIB) $(DYN_OBJ)
|
||||
#---------------------------------------------------------------
|
||||
|
||||
t: t.c $(DEPS) ../libfloatimg.a tests.o
|
||||
gcc $(COPT) $< \
|
||||
tests.o \
|
||||
-I/usr/include/netpbm/ \
|
||||
-I/usr/include/cfitsio/ \
|
||||
../libfloatimg.a -lnetpbm -lpnglite -lcfitsio \
|
||||
-ltiff \
|
||||
-lz -lm -o $@
|
||||
|
||||
tests.o: tests.c tests.h $(DEPS)
|
||||
gcc $(COPT) -I/usr/include/netpbm -c $<
|
||||
|
||||
#---------------------------------------------------------------
|
||||
# upper-level functions
|
||||
|
||||
$(STATIC_LIB): $(OBJS)
|
||||
$(AR) r $@ $?
|
||||
|
||||
|
||||
$(DYN_OBJ): $(OBJS)
|
||||
mkdir -p $(OBJ_DIR)
|
||||
ld -Ur -o $@ $?
|
||||
|
||||
clean:
|
||||
rm -rf $(OBJS) $(STATIC_LIB) $(DYN_OBJ)
|
||||
|
||||
recurse.o: recurse.c $(DEPS)
|
||||
gcc $(COPT) -c $<
|
||||
|
||||
incrustator.o: incrustator.c $(DEPS)
|
||||
gcc $(COPT) -c $<
|
||||
|
||||
displacement.o: displacement.c $(DEPS)
|
||||
gcc $(COPT) -c $<
|
||||
|
||||
fimg-png.o: fimg-png.c $(DEPS)
|
||||
gcc $(COPT) -c $<
|
||||
|
||||
fimg-bmp.o: fimg-bmp.c $(DEPS)
|
||||
gcc $(COPT) -c $<
|
||||
|
||||
fimg-tiff.o: fimg-tiff.c $(DEPS)
|
||||
gcc $(COPT) -c $<
|
||||
|
||||
fimg-openexr.o: fimg-openexr.c $(DEPS)
|
||||
gcc $(COPT) -c $<
|
||||
|
||||
fimg-fits.o: fimg-fits.c $(DEPS)
|
||||
gcc $(COPT) -I/usr/include/cfitsio/ -c $<
|
||||
|
||||
fimg-libpnm.o: fimg-libpnm.c $(DEPS)
|
||||
gcc $(COPT) -I/usr/include/netpbm -c $<
|
||||
|
||||
misc-plots.o: misc-plots.c $(DEPS)
|
||||
gcc $(COPT) -c $<
|
||||
|
||||
filtrage.o: filtrage.c $(DEPS)
|
||||
gcc $(COPT) -c $<
|
||||
|
||||
geometry.o: geometry.c $(DEPS)
|
||||
gcc $(COPT) -c $<
|
||||
|
||||
rotate.o: rotate.c $(DEPS)
|
||||
gcc $(COPT) -c $<
|
||||
|
||||
saturation.o: saturation.c $(DEPS)
|
||||
gcc $(COPT) -c $<
|
||||
|
||||
histogram.o: histogram.c $(DEPS)
|
||||
gcc $(COPT) -c $<
|
||||
|
||||
equalize.o: equalize.c $(DEPS)
|
||||
gcc $(COPT) -c $<
|
||||
|
||||
dithering.o: dithering.c $(DEPS)
|
||||
gcc $(COPT) -c $<
|
||||
|
||||
plasmas.o: plasmas.c $(DEPS)
|
||||
gcc $(COPT) -c $<
|
||||
|
||||
sfx0.o: sfx0.c $(DEPS)
|
||||
gcc $(COPT) -c $<
|
||||
|
||||
sfx1.o: sfx1.c $(DEPS)
|
||||
gcc $(COPT) -c $<
|
||||
|
||||
sfx2.o: sfx2.c $(DEPS)
|
||||
gcc $(COPT) -c $<
|
||||
|
||||
contour2x2.o: contour2x2.c $(DEPS)
|
||||
gcc $(COPT) -c $<
|
||||
|
||||
rampes.o: rampes.c $(DEPS)
|
||||
gcc $(COPT) -c $<
|
||||
|
||||
classif.o: classif.c $(DEPS)
|
||||
gcc $(COPT) -c $<
|
||||
|
||||
qsortrgb.o: qsortrgb.c $(DEPS)
|
||||
gcc $(COPT) -c $<
|
||||
|
||||
exporter.o: exporter.c $(DEPS)
|
||||
gcc $(COPT) -c $<
|
||||
|
||||
|
||||
hsv.o: hsv.c $(DEPS)
|
||||
gcc $(COPT) -c $<
|
||||
|
||||
utils.o: utils.c $(DEPS)
|
||||
gcc $(COPT) -c $<
|
||||
26
src/funcs/README.md
Normal file
26
src/funcs/README.md
Normal file
@@ -0,0 +1,26 @@
|
||||
# Fonctions
|
||||
|
||||
Plein de fonctions qu'il serait bon de documenter :)
|
||||
|
||||
## PNG
|
||||
|
||||
__Attention__ : la bibliothèque `pnglite`actuellement utiilsée pour lire les
|
||||
fichiers PNG n'accepte que **certains** types de fichiers.
|
||||
Et en particulier, elle brotche sur ceux produits par ImageMagick !
|
||||
|
||||
## Contours
|
||||
|
||||
Détecter des contours est une activité respectable.
|
||||
|
||||
## Exporter
|
||||
|
||||
Une méta-fonction qui va sauvegarder (dans la mesure de ses conséquences)
|
||||
une image en fonction de l'extension du nom de fichier.
|
||||
|
||||
## Sfx
|
||||
|
||||
Effets spéciaux divers.
|
||||
|
||||
## Dithering
|
||||
|
||||
Work in progress...
|
||||
33
src/funcs/alltests.sh
Executable file
33
src/funcs/alltests.sh
Executable file
@@ -0,0 +1,33 @@
|
||||
#!/bin/bash
|
||||
|
||||
#
|
||||
# trying to run a maximum of ugly code
|
||||
#
|
||||
|
||||
for trial in $(./t -l)
|
||||
do
|
||||
|
||||
printf "============ %-10s ============\n" $trial
|
||||
|
||||
make t
|
||||
error=$?
|
||||
if [ 0 -ne $error ]
|
||||
then
|
||||
echo "make error is " $error
|
||||
exit 1
|
||||
fi
|
||||
|
||||
|
||||
./t -v $trial
|
||||
error=$?
|
||||
if [ 0 -ne $error ]
|
||||
then
|
||||
echo "run error is " $error
|
||||
exit 1
|
||||
fi
|
||||
|
||||
printf "\t=== return code %d\n" $error
|
||||
echo
|
||||
sleep 10
|
||||
|
||||
done
|
||||
103
src/funcs/classif.c
Normal file
103
src/funcs/classif.c
Normal file
@@ -0,0 +1,103 @@
|
||||
/*
|
||||
* classif.c
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <math.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
extern int verbosity;
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
/* nouveau 2 octobre 2020, juste avant sonoptic de la pluie craignos */
|
||||
|
||||
int fimg_classif_trial(FloatImg *psrc, FloatImg *pdst, float fval, int notused)
|
||||
{
|
||||
float minmax[6], delta[3], baryc[3];
|
||||
float range, dist, rgb[3], dr, dg, db;
|
||||
int x, y, on, off;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p %p %f %d )\n", __func__,
|
||||
psrc, pdst, fval, notused);
|
||||
#endif
|
||||
|
||||
if (FIMG_TYPE_RGB != psrc->type) {
|
||||
fprintf(stderr, "%s: bad src type %d\n", __func__, psrc->type);
|
||||
return -7;
|
||||
}
|
||||
if (fimg_images_not_compatible(psrc, pdst)) {
|
||||
fprintf(stderr, "%s: bad dst type %d\n", __func__, pdst->type);
|
||||
return -8;
|
||||
}
|
||||
|
||||
/* calculer les amplitudes RGB de l'image source */
|
||||
fimg_get_minmax_rgb(psrc, minmax);
|
||||
delta[0] = minmax[1] - minmax[0];
|
||||
delta[1] = minmax[3] - minmax[2];
|
||||
delta[2] = minmax[5] - minmax[4];
|
||||
|
||||
/* chercher le plus petit des deltas */
|
||||
range = delta[0]; if (delta[1]<range) range=delta[1];
|
||||
if (delta[2]<range) range=delta[2];
|
||||
|
||||
/* convertir le diametre en rayon (magic inside) */
|
||||
range *= fval;
|
||||
|
||||
if (verbosity > 1) fprintf(stderr, "deltas : %f %f %f / %f\n",
|
||||
delta[0], delta[1], delta[2], range);
|
||||
|
||||
|
||||
/* calcul du "barycentre" chromatique */
|
||||
baryc[0] = (minmax[1] + minmax[0]) / 2;
|
||||
baryc[1] = (minmax[3] + minmax[2]) / 2;
|
||||
baryc[2] = (minmax[5] + minmax[4]) / 2;
|
||||
if (verbosity > 1) fprintf(stderr, "barycs : %f %f %f\n",
|
||||
baryc[0], baryc[1], baryc[2]);
|
||||
|
||||
on = off = 0;
|
||||
|
||||
for (y=0; y<psrc->height; y++) {
|
||||
for (x=0; x<psrc->width; x++) {
|
||||
|
||||
fimg_get_rgb(psrc, x, y, rgb);
|
||||
|
||||
/* calcul de la distance chromatique */
|
||||
dr = rgb[0] - baryc[0];
|
||||
dg = rgb[1] - baryc[1];
|
||||
db = rgb[2] - baryc[2];
|
||||
dist = sqrtf( (dr*dr) + (dg*dg) + (db*db) );
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
if (x==y) fprintf(stderr, "%4d %4d %f\n", x, y, dist);
|
||||
#endif
|
||||
|
||||
/* action !!! */
|
||||
if (dist > range) {
|
||||
/* make our pixel gray-level */
|
||||
rgb[0] = rgb[1] = rgb[2] = 0.0;
|
||||
// (rgb[0] + rgb[1] + rgb[2]) / 3.0;
|
||||
on++;
|
||||
}
|
||||
else {
|
||||
/* the easy part : do nothing */
|
||||
off++;
|
||||
}
|
||||
|
||||
fimg_put_rgb(pdst, x, y, rgb);
|
||||
|
||||
/* MUST BE MORE CREATIVE HERE !!! */
|
||||
}
|
||||
}
|
||||
|
||||
if (verbosity > 1) fprintf(stderr, "on %d off %d\n", on, off);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
|
||||
|
||||
95
src/funcs/contour2x2.c
Normal file
95
src/funcs/contour2x2.c
Normal file
@@ -0,0 +1,95 @@
|
||||
/*
|
||||
* Detection de contours
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <math.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
extern int verbosity;
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
/* nouveau 4 octobre 2020, juste avant sonoptic de la pluie craignos */
|
||||
|
||||
int fimg_contour_2x2(FloatImg *psrc, FloatImg *pdst, int reverse)
|
||||
{
|
||||
float avg[4];
|
||||
int foo, x, y, q;
|
||||
float v1, v2;
|
||||
|
||||
int tbl[] = /* deep magic inside */
|
||||
{
|
||||
0, 1, 1, 1,
|
||||
1, 1, 0, 1,
|
||||
1, 0, 1, 1,
|
||||
1, 1, 1, 0
|
||||
}; /* please explain */
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p %p %d )\n", __func__, psrc, pdst, reverse);
|
||||
#endif
|
||||
|
||||
if (FIMG_TYPE_RGB != psrc->type) {
|
||||
fprintf(stderr, "%s: bad src type %d\n", __func__, psrc->type);
|
||||
return -7;
|
||||
}
|
||||
if (fimg_images_not_compatible(psrc, pdst)) {
|
||||
fprintf(stderr, "%s: bad dst type %d\n", __func__, pdst->type);
|
||||
return -8;
|
||||
}
|
||||
|
||||
if (reverse) {
|
||||
v1 = 0.0; v2 = 1.0;
|
||||
}
|
||||
else {
|
||||
v1 = 1.0; v2 = 0.0;
|
||||
}
|
||||
|
||||
foo = fimg_meanvalues(psrc, avg);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: err %d on fimg_meanvalues\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
if (verbosity > 1) {
|
||||
fprintf(stderr, "%s: %f %f %f\n", __func__, avg[0], avg[1], avg[2]);
|
||||
}
|
||||
|
||||
#define RP(ix, iy) ( psrc->R[((iy)*psrc->width)+(ix)] < avg[0] )
|
||||
#define GP(ix, iy) ( psrc->G[((iy)*psrc->width)+(ix)] < avg[1] )
|
||||
#define BP(ix, iy) ( psrc->B[((iy)*psrc->width)+(ix)] < avg[2] )
|
||||
|
||||
for (y=0; y<psrc->height-1; y++) {
|
||||
|
||||
for (x=0; x<psrc->width-1; x++) {
|
||||
|
||||
q = ( ( RP(x, y) << 3 ) |
|
||||
( RP(x+1, y) << 2 ) |
|
||||
( RP(x, y+1) << 1 ) |
|
||||
( RP(x+1, y+1) ) );
|
||||
pdst->R[(y*psrc->width)+x] = tbl[q] ? v1 : v2 ;
|
||||
|
||||
q = ( ( GP(x, y) << 3 ) |
|
||||
( GP(x+1, y) << 2 ) |
|
||||
( GP(x, y+1) << 1 ) |
|
||||
( GP(x+1, y+1) ) );
|
||||
pdst->G[(y*psrc->width)+x] = tbl[q] ? v1 : v2 ;
|
||||
|
||||
q = ( ( BP(x, y) << 3 ) |
|
||||
( BP(x+1, y) << 2 ) |
|
||||
( BP(x, y+1) << 1 ) |
|
||||
( BP(x+1, y+1) ) );
|
||||
pdst->B[(y*psrc->width)+x] = tbl[q] ? v1 : v2 ;
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/* kill potential NaN values in last row or last column */
|
||||
fimg_killborders(pdst);
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
92
src/funcs/displacement.c
Normal file
92
src/funcs/displacement.c
Normal file
@@ -0,0 +1,92 @@
|
||||
/*
|
||||
* displacement.c
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <math.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
extern int verbosity;
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
/* nouveau 24 octobre 2020, pendant le masque-flamme coronavidique */
|
||||
|
||||
int fimg_displacement_0(FloatImg *psrc, FloatImg *pdst, int flags)
|
||||
{
|
||||
int x, y, foo;
|
||||
float minmax[6];
|
||||
float rgb[3];
|
||||
float dltr, dltg, dltb; /* delta des minmax */
|
||||
float dispx, dispy;
|
||||
|
||||
int dstx, dsty;
|
||||
int in, out;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p %p 0x%04x )\n", __func__, psrc, pdst, flags);
|
||||
#endif
|
||||
|
||||
if (FIMG_TYPE_RGB != psrc->type) {
|
||||
fprintf(stderr, "%s: bad src type %d\n", __func__, psrc->type);
|
||||
return -7;
|
||||
}
|
||||
if (fimg_images_not_compatible(psrc, pdst)) {
|
||||
fprintf(stderr, "%s: bad dst type %d\n", __func__, pdst->type);
|
||||
return -8;
|
||||
}
|
||||
|
||||
foo = fimg_get_minmax_rgb(psrc, minmax);
|
||||
if (verbosity) {
|
||||
fimg_print_minmax(minmax, (char *)__func__);
|
||||
}
|
||||
dltr = minmax[1] - minmax[0];
|
||||
dltg = minmax[3] - minmax[2];
|
||||
dltb = minmax[5] - minmax[4];
|
||||
|
||||
in = out = 0;
|
||||
/*
|
||||
* BE WARNED !
|
||||
* This code doesn't work as expected, so I have to
|
||||
* rewrite it, maybe when the pandemic is closed...
|
||||
*/
|
||||
for (y=0; y<psrc->height; y++) {
|
||||
|
||||
for (x=0; x<psrc->width; x++) {
|
||||
|
||||
fimg_get_rgb(psrc, x, y, rgb);
|
||||
|
||||
dispx = (float)x + (rgb[1]/dltg * 20.0);
|
||||
dispy = (float)y + (rgb[2]/dltb * 10.0);
|
||||
dstx = (int)roundf(dispx - 10.0);
|
||||
dsty = (int)roundf(dispy - 10.0);
|
||||
|
||||
if ( (dstx < 0) || (dsty < 0) ||
|
||||
(dstx >= psrc->width) ||
|
||||
(dsty >= psrc->height) )
|
||||
{
|
||||
/* OUT OF DESTINATION PICTURE */
|
||||
out++;
|
||||
}
|
||||
else {
|
||||
if (flags & 1) {
|
||||
/* going monochrome */
|
||||
rgb[1] = rgb[2] = rgb[0];
|
||||
}
|
||||
fimg_put_rgb(pdst, dstx, dsty, rgb);
|
||||
in++;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
if (verbosity) fprintf(stderr, "%s -> in %d out %d\n", __func__, in, out);
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
|
||||
|
||||
31
src/funcs/dithering.c
Normal file
31
src/funcs/dithering.c
Normal file
@@ -0,0 +1,31 @@
|
||||
/*
|
||||
* FloatImg : some dithering experiments
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <math.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
extern int verbosity;
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
int fimg_dither_0(FloatImg *psrc, FloatImg *pdst, int flags)
|
||||
{
|
||||
int x, y;
|
||||
|
||||
for (y=0; y<psrc->height; y++) {
|
||||
|
||||
for (x=0; x<psrc->width; x++)
|
||||
{
|
||||
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
|
||||
53
src/funcs/equalize.c
Normal file
53
src/funcs/equalize.c
Normal file
@@ -0,0 +1,53 @@
|
||||
/*
|
||||
* FLOATIMG
|
||||
* egalisation dynamique approximative
|
||||
* #coronamaison Thu 09 Apr 2020 03:37:10 PM CEST
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
extern int verbosity;
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
int fimg_equalize_compute(FloatImg *src, void *vptr, float vmax)
|
||||
{
|
||||
float minmax[6];
|
||||
int foo;
|
||||
float dr, dg, db;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p %p %f )\n", __func__, src, vptr, vmax);
|
||||
#endif
|
||||
|
||||
memset(minmax, 0, 6*sizeof(float));
|
||||
|
||||
foo = fimg_get_minmax_rgb(src, minmax);
|
||||
if (foo) {
|
||||
fprintf(stderr, "err %d get minmax in %s\n", foo, __func__);
|
||||
return foo;
|
||||
}
|
||||
|
||||
dr = minmax[1] - minmax[0];
|
||||
dg = minmax[3] - minmax[2];
|
||||
db = minmax[5] - minmax[4];
|
||||
|
||||
printf("Rmin %12.4g max %12.4g delta %12.4g\n", minmax[0], minmax[1], dr);
|
||||
printf("Gmin %12.4g max %12.4g delta %12.4g\n", minmax[2], minmax[3], dg);
|
||||
printf("Bmin %12.4g max %12.4g delta %12.4g\n", minmax[4], minmax[5], db);
|
||||
|
||||
if ( (minmax[0]<0.0) || (minmax[2]<0.0) || (minmax[4]<0.0) ) {
|
||||
fprintf(stderr, "%s: negative value ?\n", __func__);
|
||||
return -4;
|
||||
}
|
||||
|
||||
// printf("deltas %12.4g %12.4g %12.4g\n", dr, dg, db);
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
/* --------------------------------------------------------------------- */
|
||||
/* --------------------------------------------------------------------- */
|
||||
|
||||
73
src/funcs/exporter.c
Normal file
73
src/funcs/exporter.c
Normal file
@@ -0,0 +1,73 @@
|
||||
/*
|
||||
* exporter.c
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
extern int verbosity;
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
/*
|
||||
* multi-magic 'save file' function.
|
||||
*/
|
||||
int fimg_export_picture(FloatImg *pic, char *fname, int flags)
|
||||
{
|
||||
int filetype;
|
||||
int foo;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p '%s' 0x%X )\n", __func__,
|
||||
pic, fname, flags);
|
||||
#endif
|
||||
|
||||
filetype = format_from_extension(fname);
|
||||
if (verbosity > 1) {
|
||||
fprintf(stderr, "file %s have type %d\n", fname, filetype);
|
||||
}
|
||||
|
||||
switch(filetype) {
|
||||
case FILE_TYPE_FIMG:
|
||||
foo = fimg_dump_to_file(pic, fname, 0);
|
||||
break;
|
||||
case FILE_TYPE_PNM:
|
||||
foo = fimg_save_as_pnm(pic, fname, 0);
|
||||
break;
|
||||
case FILE_TYPE_PNG:
|
||||
foo = fimg_save_as_png(pic, fname, 0);
|
||||
break;
|
||||
case FILE_TYPE_TGA:
|
||||
fprintf(stderr, "%s: FILE_TYPE_TGA not implemented\n",
|
||||
__func__);
|
||||
foo = -666;
|
||||
break;
|
||||
case FILE_TYPE_TIFF:
|
||||
foo = fimg_write_as_tiff(pic, fname, 0);
|
||||
break;
|
||||
case FILE_TYPE_FITS:
|
||||
foo = fimg_save_R_as_fits(pic, fname, 0);
|
||||
break;
|
||||
case FILE_TYPE_BMP:
|
||||
fprintf(stderr, "%s: file type BMP not implemented\n", __func__);
|
||||
foo = -666;
|
||||
case FILE_TYPE_EXR:
|
||||
fprintf(stderr, "%s: file type EXR experimental\n", __func__);
|
||||
foo = fimg_save_as_exr(pic, fname, 0);
|
||||
default:
|
||||
foo = -1789;
|
||||
break;
|
||||
}
|
||||
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: exporting '%s' -> %d\n", __func__,
|
||||
fname, foo);
|
||||
/* que faire maintenant ? */
|
||||
}
|
||||
|
||||
return foo;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
|
||||
200
src/funcs/filtrage.c
Normal file
200
src/funcs/filtrage.c
Normal file
@@ -0,0 +1,200 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <fcntl.h>
|
||||
#include <float.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
/* -------------------------------------------------------------------- */
|
||||
int fimg_filter_3x3(FloatImg *src, FloatImg *dst, FimgFilter3x3 *filtr)
|
||||
{
|
||||
int x, y, w, h, of;
|
||||
float *pr, *pg, *pb; /* alias for src pix filds */
|
||||
float *M; /* alias of filter matrix */
|
||||
double dval;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p %p %p )\n", __func__, src, dst, filtr);
|
||||
#endif
|
||||
|
||||
if (src->type != FIMG_TYPE_RGB) {
|
||||
fprintf(stderr, "%s: src type %d invalid\n", __func__, src->type);
|
||||
return -99;
|
||||
}
|
||||
if (dst->type != FIMG_TYPE_RGB) {
|
||||
fprintf(stderr, "%s: dst type %d invalid\n", __func__, dst->type);
|
||||
return -99;
|
||||
}
|
||||
if (fimg_images_not_compatible(src, dst)) {
|
||||
fprintf(stderr, "%s: src & dst not comatibles\n", __func__);
|
||||
return -98;
|
||||
}
|
||||
|
||||
/* aliasing some vars for cleaner code */
|
||||
pr = src->R; pg = src->G; pb = src->B;
|
||||
w = src->width; h = src->height;
|
||||
M = filtr->matrix;
|
||||
|
||||
for (y=1; y < h-1; y++) {
|
||||
|
||||
for (x=1; x < w-1; x++) {
|
||||
|
||||
of = x + (y * w);
|
||||
|
||||
dval = M[0] * pr[of-(w+1)] +
|
||||
M[1] * pr[of-w] +
|
||||
M[2] * pr[of-(w-1)] +
|
||||
M[3] * pr[of-1] +
|
||||
M[4] * pr[of] +
|
||||
M[5] * pr[of+1] +
|
||||
M[6] * pr[of+(w+1)] +
|
||||
M[7] * pr[of+w] +
|
||||
M[8] * pr[of+(w-1)] ;
|
||||
|
||||
dst->R[of] = dval + filtr->offset;
|
||||
|
||||
dval = M[0] * pg[of-(w+1)] +
|
||||
M[1] * pg[of-w] +
|
||||
M[2] * pg[of-(w-1)] +
|
||||
M[3] * pg[of-1] +
|
||||
M[4] * pg[of] +
|
||||
M[5] * pg[of+1] +
|
||||
M[6] * pg[of+(w+1)] +
|
||||
M[7] * pg[of+w] +
|
||||
M[8] * pg[of+(w-1)] ;
|
||||
|
||||
dst->G[of] = dval + filtr->offset;
|
||||
|
||||
dval = M[0] * pb[of-(w+1)] +
|
||||
M[1] * pb[of-w] +
|
||||
M[2] * pb[of-(w-1)] +
|
||||
M[3] * pb[of-1] +
|
||||
M[4] * pb[of] +
|
||||
M[5] * pb[of+1] +
|
||||
M[6] * pb[of+(w+1)] +
|
||||
M[7] * pb[of+w] +
|
||||
M[8] * pb[of+(w-1)] ;
|
||||
|
||||
dst->B[of] = dval + filtr->offset;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* -------------------------------------------------------------------- */
|
||||
/*
|
||||
* this is the more shifting hack on the block.
|
||||
*/
|
||||
static int fimg_lissage_2x2_a(FloatImg *img)
|
||||
{
|
||||
int x, y, offset;
|
||||
float cr, cg, cb;
|
||||
float *pr, *pg, *pb;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p )\n", __func__, img);
|
||||
fprintf(stderr," type %d size %dx%d\n", img->type,
|
||||
img->width, img->height);
|
||||
#endif
|
||||
|
||||
if (img->type != FIMG_TYPE_RGB) {
|
||||
fprintf(stderr, "%s : type %d invalide\n", __func__, img->type);
|
||||
return -99;
|
||||
}
|
||||
|
||||
pr = img->R; pg = img->G; pb = img->B;
|
||||
|
||||
for (y=1; y < img->height-1; y++) {
|
||||
|
||||
for (x=1; x < img->width-1; x++) {
|
||||
|
||||
offset = x + (y * img->width);
|
||||
|
||||
cr = pr[offset] + pr[offset+1] +
|
||||
pr[offset+img->width] + pr[offset+img->width+1];
|
||||
|
||||
cg = pg[offset] + pg[offset+1] +
|
||||
pg[offset+img->width] + pg[offset+img->width+1];
|
||||
|
||||
cb = pb[offset] + pb[offset+1] +
|
||||
pb[offset+img->width] + pb[offset+img->width+1];
|
||||
|
||||
pr[offset] = cr / 4.0;
|
||||
pg[offset] = cg / 4.0;
|
||||
pb[offset] = cb / 4.0;
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* -------------------------------------------------------------------- */
|
||||
int fimg_killborders(FloatImg *img)
|
||||
{
|
||||
int idx, h, w, o;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p )\n", __func__, img);
|
||||
fprintf(stderr," type %d size %dx%d\n", img->type,
|
||||
img->width, img->height);
|
||||
#endif
|
||||
|
||||
if (img->type != FIMG_TYPE_RGB) {
|
||||
fprintf(stderr, "%s : type %d invalide\n", __func__, img->type);
|
||||
return -99;
|
||||
}
|
||||
|
||||
h = img->height; w = img->width;
|
||||
|
||||
for (idx=0; idx<h; idx++) {
|
||||
|
||||
#define FAST 1
|
||||
#if FAST
|
||||
img->R[idx*w] = 0.0;
|
||||
img->G[idx*w] = 0.0;
|
||||
img->B[idx*w] = 0.0;
|
||||
img->R[(idx*w)+w-1] = 0.0;
|
||||
img->G[(idx*w)+w-1] = 0.0;
|
||||
img->B[(idx*w)+w-1] = 0.0;
|
||||
#else
|
||||
fimg_plot_rgb(img, 0, idx, 0.0, 0.0, 0.0);
|
||||
fimg_plot_rgb(img, w-1, idx, 0.0, 0.0, 0.0);
|
||||
#endif
|
||||
}
|
||||
|
||||
o = w * (h - 1);
|
||||
|
||||
for (idx=0; idx<w; idx++) {
|
||||
#if FAST
|
||||
img->R[idx] = 0.0;
|
||||
img->G[idx] = 0.0;
|
||||
img->B[idx] = 0.0;
|
||||
img->R[idx+o] = 0.0;
|
||||
img->G[idx+o] = 0.0;
|
||||
img->B[idx+o] = 0.0;
|
||||
#else
|
||||
fimg_plot_rgb(img, idx, 0, 0.0, 0.0, 0.0);
|
||||
fimg_plot_rgb(img, idx, h-1, 0.0, 0.0, 0.0);
|
||||
#endif
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* -------------------------------------------------------------------- */
|
||||
int fimg_lissage_2x2(FloatImg *img)
|
||||
{
|
||||
int foo;
|
||||
|
||||
foo = fimg_lissage_2x2_a(img);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: fail %d\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
fimg_killborders(img);
|
||||
|
||||
return foo;
|
||||
}
|
||||
/* -------------------------------------------------------------------- */
|
||||
|
||||
21
src/funcs/fimg-bmp.c
Normal file
21
src/funcs/fimg-bmp.c
Normal file
@@ -0,0 +1,21 @@
|
||||
/*
|
||||
* Lecture/ecriture des images BMP
|
||||
* -------------------------------
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
extern int verbosity;
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
int fimg_save_as_bmp(FloatImg *src, char *outname, int flags)
|
||||
{
|
||||
|
||||
|
||||
return -2;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
114
src/funcs/fimg-fits.c
Normal file
114
src/funcs/fimg-fits.c
Normal file
@@ -0,0 +1,114 @@
|
||||
/*
|
||||
* FLOATIMG
|
||||
* import/export to/from FITS files
|
||||
|
||||
https://heasarc.gsfc.nasa.gov/docs/software/fitsio/c/c_user/node1.html
|
||||
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include <fitsio.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
extern int verbosity;
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
int fimg_save_plane_as_fits(FloatImg *src, char *outname,
|
||||
char plane, int flags)
|
||||
{
|
||||
fitsfile *fptr; /* pointer to the FITS file */
|
||||
int status, sz;
|
||||
int bitpix = FLOAT_IMG;
|
||||
float *pplane;
|
||||
long naxis = 2;
|
||||
long naxes[2];
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p '%s' %d )\n", __func__, src, outname, flags);
|
||||
#endif
|
||||
|
||||
status = 0;
|
||||
|
||||
switch (plane) {
|
||||
case 'r': case 'R':
|
||||
pplane = src->R; break;
|
||||
case 'g': case 'G':
|
||||
pplane = src->G; break;
|
||||
case 'b': case 'B':
|
||||
pplane = src->B; break;
|
||||
default:
|
||||
return -66;
|
||||
}
|
||||
|
||||
remove(outname); /* Delete old file if it already exists */
|
||||
if (fits_create_file(&fptr, outname, &status)) {
|
||||
fits_report_error(stderr, status);
|
||||
return -9;
|
||||
}
|
||||
|
||||
naxes[0] = src->width; naxes[1] = src->height;
|
||||
if (verbosity) fimg_describe(src, "to be saved as FITS");
|
||||
|
||||
if ( fits_create_img(fptr, bitpix, naxis, naxes, &status) ) {
|
||||
fits_report_error(stderr, status);
|
||||
return -10;
|
||||
}
|
||||
|
||||
sz = naxes[0]*naxes[1];
|
||||
if ( fits_write_img(fptr, TFLOAT, 1, sz, pplane, &status) ) {
|
||||
fits_report_error(stderr, status);
|
||||
return -10;
|
||||
}
|
||||
|
||||
if ( fits_close_file(fptr, &status) ) {
|
||||
fits_report_error(stderr, status);
|
||||
return -9;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
int fimg_save_R_as_fits(FloatImg *src, char *outname, int flags)
|
||||
{
|
||||
int retv;
|
||||
retv = fimg_save_plane_as_fits(src, outname, 'r', flags);
|
||||
return retv;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
int fimg_save_G_as_fits(FloatImg *src, char *outname, int flags)
|
||||
{
|
||||
int retv;
|
||||
retv = fimg_save_plane_as_fits(src, outname, 'g', flags);
|
||||
return retv;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
int fimg_save_B_as_fits(FloatImg *src, char *outname, int flags)
|
||||
{
|
||||
int retv;
|
||||
retv = fimg_save_plane_as_fits(src, outname, 'b', flags);
|
||||
return retv;
|
||||
}
|
||||
|
||||
/************************************************************
|
||||
***** MAGIC CODE FROM OUTERSPACE ?
|
||||
|
||||
function 'writeimage' from :
|
||||
https://heasarc.gsfc.nasa.gov/docs/software/fitsio/cexamples/cookbook.c
|
||||
|
||||
float **array;
|
||||
array = calloc(src->height, sizeof(float *));
|
||||
array[0] = src->R;
|
||||
#define REVERSE 1
|
||||
for( idx=0; idx<naxes[1]; idx++ ) {
|
||||
#if REVERSE
|
||||
k = naxes[1] - idx - 1;
|
||||
#else
|
||||
k = idx;
|
||||
#endif
|
||||
array[idx] = src->R + (k*naxes[0]);
|
||||
fprintf(stderr, " %6d %6d %p\n", idx, k, array[idx]);
|
||||
}
|
||||
**************************************************************/
|
||||
52
src/funcs/fimg-libpnm.c
Normal file
52
src/funcs/fimg-libpnm.c
Normal file
@@ -0,0 +1,52 @@
|
||||
/*
|
||||
* interface FloatImg <-> libpnm(3)
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include <pam.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
extern int verbosity;
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
static void print_struct_pam(struct pam *ppam, char *txt)
|
||||
{
|
||||
|
||||
printf(" size %d\n", ppam->size);
|
||||
|
||||
printf(" format %d\n", ppam->format);
|
||||
printf(" plainformat %d\n", ppam->plainformat);
|
||||
printf(" width & height %d %d\n", ppam->width, ppam->height);
|
||||
printf(" depth %d\n", ppam->depth);
|
||||
printf(" maxval %lu\n", ppam->maxval);
|
||||
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
|
||||
int fimg_pnm_infos(char *fname)
|
||||
{
|
||||
struct pam inpam;
|
||||
FILE *fp;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( '%s' )\n", __func__, fname);
|
||||
#endif
|
||||
|
||||
if (NULL==(fp=fopen(fname, "r"))) {
|
||||
perror(fname);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
pnm_readpaminit(fp, &inpam, sizeof(inpam));
|
||||
|
||||
print_struct_pam(&inpam, fname);
|
||||
|
||||
fclose(fp);
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
30
src/funcs/fimg-openexr.c
Normal file
30
src/funcs/fimg-openexr.c
Normal file
@@ -0,0 +1,30 @@
|
||||
/*
|
||||
* Lecture/ecriture des images EXR
|
||||
* -------------------------------
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
extern int verbosity;
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
int fimg_save_as_exr(FloatImg *src, char *outname, int flags)
|
||||
{
|
||||
// #if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p '%s' 0x%X )\n", __func__, src, outname, flags);
|
||||
// #endif
|
||||
|
||||
if (FIMG_TYPE_RGB != src->type) {
|
||||
fprintf(stderr, "%s: src bad type %d\n", __func__, src->type);
|
||||
return -2;
|
||||
}
|
||||
|
||||
|
||||
|
||||
return -2;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
220
src/funcs/fimg-png.c
Normal file
220
src/funcs/fimg-png.c
Normal file
@@ -0,0 +1,220 @@
|
||||
/*
|
||||
* Lecture des images PNG
|
||||
* ----------------------
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include <pnglite.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
extern int verbosity;
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
/*
|
||||
* warning : this func has been tested only with
|
||||
* RGB (3x8bits) PNG files
|
||||
*
|
||||
* Attention : certains fichiers, tels que ceux
|
||||
* produits par ImageMagick ne sont pas lisibles
|
||||
* par cette fonction :(
|
||||
*/
|
||||
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
|
||||
|
||||
/* We MUST clear the fimg destination header first */
|
||||
memset(fimg, 0, sizeof(FloatImg));
|
||||
|
||||
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 :\n\topen_file '%s' = %d %s\n", __func__,
|
||||
filename, foo, png_error_string(foo));
|
||||
png_close_file(&png);
|
||||
return foo;
|
||||
}
|
||||
#if DEBUG_LEVEL > 1
|
||||
fprintf(stderr, "%s opened\n", filename);
|
||||
#endif
|
||||
|
||||
if (verbosity) {
|
||||
printf("----------- %s ---------\n", filename);
|
||||
png_print_info(&png); puts("");
|
||||
fflush(stdout);
|
||||
}
|
||||
|
||||
if ( 3 != png.bpp ) {
|
||||
fprintf(stderr, "bpp format %d of '%s' not supported\n",
|
||||
png.color_type, filename);
|
||||
return -21;
|
||||
}
|
||||
|
||||
datasize = png.width * png.height * png.bpp;
|
||||
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);
|
||||
}
|
||||
|
||||
/* I GET AN 'Unknown file error' HERE, WHY ???*/
|
||||
foo = png_get_data(&png, datas);
|
||||
if (PNG_NO_ERROR != foo) {
|
||||
fprintf(stderr, "err in '%s:%s' :\n\tpng_get_data -> %d = %s\n\n",
|
||||
__FILE__, __func__, foo, png_error_string(foo));
|
||||
png_close_file(&png);
|
||||
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;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
/* nouveau 13 decembre 2019 */
|
||||
int fimg_save_as_png(FloatImg *src, char *outname, int flags)
|
||||
{
|
||||
png_t png;
|
||||
int foo, sz, idx;
|
||||
unsigned char *bytes, *bptr;
|
||||
double maximum, fk;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %-25s ( %p '%s' 0x%x )\n", __func__, src, outname, flags);
|
||||
#endif
|
||||
|
||||
/* convert ou floating datas to a byte/rgb array */
|
||||
/* first, alloc a buffer */
|
||||
sz = src->width * src->height;
|
||||
bytes = calloc(sz, 3);
|
||||
if (NULL==bytes) {
|
||||
fprintf(stderr, "%s : no mem ?\n", __func__);
|
||||
exit(3);
|
||||
}
|
||||
/* compute max value */
|
||||
maximum = (double)fimg_get_maxvalue(src);
|
||||
fk = maximum / 255.0;
|
||||
if (verbosity > 1)
|
||||
fprintf(stderr, "%s: max val %g fk %g\n", __func__, maximum, fk);
|
||||
/* massage des pixels */
|
||||
bptr = bytes;
|
||||
for (idx=0; idx<sz; idx++) {
|
||||
*bptr++ = (unsigned char) (src->R[idx] / fk);
|
||||
*bptr++ = (unsigned char) (src->G[idx] / fk);
|
||||
*bptr++ = (unsigned char) (src->B[idx] / fk);
|
||||
}
|
||||
|
||||
memset(&png, 0, sizeof(png_t));
|
||||
png_init(NULL, NULL); /* this is VITAL ! */
|
||||
|
||||
foo = png_open_file_write(&png, outname);
|
||||
if (PNG_NO_ERROR != foo) {
|
||||
fprintf(stderr, "error in '%s' : open_file_write -> %d\n",
|
||||
__func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
foo = png_set_data(&png, src->width, src->height, 8, PNG_TRUECOLOR, bytes);
|
||||
if (PNG_NO_ERROR != foo) {
|
||||
fprintf(stderr, "error in '%s' : set_data -> %d\n",
|
||||
__func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
png_close_file(&png);
|
||||
|
||||
free(bytes); /* yolo ? */
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
89
src/funcs/fimg-tiff.c
Normal file
89
src/funcs/fimg-tiff.c
Normal file
@@ -0,0 +1,89 @@
|
||||
/*
|
||||
* FLOATIMG
|
||||
* import/export to/from TIFF files
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include <tiffio.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
|
||||
extern int verbosity;
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
int fimg_write_as_tiff(FloatImg *src, char *fname, int flags)
|
||||
{
|
||||
TIFF *tiff;
|
||||
unsigned short *linebuff, *ptr;
|
||||
int x, y, idx, foo;
|
||||
char ligne[100];
|
||||
double maximum, fk;
|
||||
|
||||
/* bon, tout cela semble bien tortueux ! */
|
||||
|
||||
if (FIMG_TYPE_RGB != src->type) {
|
||||
fprintf(stderr, "%s: src bad type %d\n", __func__, src->type);
|
||||
return -2;
|
||||
}
|
||||
|
||||
linebuff = calloc(src->width, 3*sizeof(unsigned short));
|
||||
if (NULL==linebuff) {
|
||||
fprintf(stderr, "%s: fatal memory error\n", __func__);
|
||||
return -7;
|
||||
}
|
||||
|
||||
maximum = (double)fimg_get_maxvalue(src);
|
||||
fk = maximum / 65535.0;
|
||||
if (verbosity) {
|
||||
fprintf(stderr, "%s : maxv %f fk %f\n", __func__, maximum, fk);
|
||||
}
|
||||
|
||||
tiff = TIFFOpen(fname, "w");
|
||||
if (NULL==tiff) {
|
||||
return -6;
|
||||
}
|
||||
|
||||
TIFFSetField(tiff, TIFFTAG_IMAGEWIDTH, src->width);
|
||||
TIFFSetField(tiff, TIFFTAG_IMAGELENGTH, src->height);
|
||||
|
||||
TIFFSetField(tiff, TIFFTAG_SAMPLESPERPIXEL, 3); // RGB
|
||||
TIFFSetField(tiff, TIFFTAG_BITSPERSAMPLE, 16); // 0->65535
|
||||
|
||||
TIFFSetField(tiff, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
|
||||
TIFFSetField(tiff, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
|
||||
|
||||
sprintf(ligne, "lib FloatImg v %d by tTh", FIMG_VERSION);
|
||||
TIFFSetField(tiff, TIFFTAG_SOFTWARE, ligne);
|
||||
|
||||
foo = src->width * 3;
|
||||
foo = TIFFDefaultStripSize(tiff, foo);
|
||||
if (verbosity) fprintf(stderr, "default strip size %d\n", foo);
|
||||
|
||||
TIFFSetField(tiff, TIFFTAG_ROWSPERSTRIP, foo);
|
||||
|
||||
for (y=0; y<src->height; y++) {
|
||||
ptr = linebuff;
|
||||
idx = y * src->width;
|
||||
|
||||
for (x=0; x<src->width; x++) {
|
||||
*ptr++ = (unsigned short) (src->R[idx] / fk);
|
||||
*ptr++ = (unsigned short) (src->G[idx] / fk);
|
||||
*ptr++ = (unsigned short) (src->B[idx] / fk);
|
||||
idx++;
|
||||
}
|
||||
|
||||
TIFFWriteScanline(tiff, linebuff, y, 0);
|
||||
idx += src->width;
|
||||
}
|
||||
|
||||
TIFFClose(tiff);
|
||||
|
||||
free(linebuff);
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
180
src/funcs/geometry.c
Normal file
180
src/funcs/geometry.c
Normal file
@@ -0,0 +1,180 @@
|
||||
/*
|
||||
* FLOATIMG
|
||||
* distorsions géométriques - coredumping ?
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
extern int verbosity;
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
/*
|
||||
* really crude function, need more work...
|
||||
*/
|
||||
int fimg_halfsize_0(FloatImg *src, FloatImg *dst, int notused)
|
||||
{
|
||||
int wd, hd;
|
||||
int foo, x, y;
|
||||
float pixel[3];
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p %p %d )\n", __func__,
|
||||
src, dst, notused);
|
||||
#endif
|
||||
|
||||
/* no magic check here ? */
|
||||
if (dst->width || dst->height) {
|
||||
fprintf(stderr, "*** %s: image at %p not empty\n", __func__, dst);
|
||||
fimg_describe(dst, "destination halfsize 0");
|
||||
return -2;
|
||||
}
|
||||
|
||||
wd = src->width / 2; hd = src->height / 2;
|
||||
foo = fimg_create(dst, wd, hd, FIMG_TYPE_RGB);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: err create %d\n", __func__, foo);
|
||||
return -3;
|
||||
}
|
||||
|
||||
for (y=0; y<hd; y++) {
|
||||
for (x=0; x<wd; x++) {
|
||||
foo = fimg_get_rgb(src, x*2, y*2, pixel);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: err get %d\n", __func__, foo);
|
||||
abort();
|
||||
}
|
||||
foo = fimg_plot_rgb(dst, x, y, pixel[0], pixel[1], pixel[2]);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: err plot %d\n", __func__, foo);
|
||||
abort();
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
int fimg_halfsize_1(FloatImg *src, FloatImg *dst, int notused)
|
||||
{
|
||||
int wd, hd;
|
||||
int foo, x, y, x2, y2;
|
||||
float ac;
|
||||
|
||||
if (dst->width || dst->height) {
|
||||
fprintf(stderr, "*** %s: image at %p not empty\n", __func__, dst);
|
||||
fimg_describe(dst, "destination halfsize 1");
|
||||
return -2;
|
||||
}
|
||||
|
||||
wd = src->width / 2; hd = src->height / 2;
|
||||
if ( (foo = fimg_create(dst, wd, hd, FIMG_TYPE_RGB)) ) {
|
||||
fprintf(stderr, "%s: err create %d\n", __func__, foo);
|
||||
return -3;
|
||||
}
|
||||
|
||||
#define WS (src->width)
|
||||
#define WD (dst->width)
|
||||
|
||||
for (y=0; y<hd; y++) {
|
||||
y2 = y * 2;
|
||||
for (x=0; x<wd; x++) {
|
||||
x2 = x * 2;
|
||||
|
||||
ac = src->R[(y2*WS)+x2] + src->R[(y2*WS)+x2+1] +
|
||||
src->R[((1+y2)*WS)+x2] + src->R[((1+y2)*WS)+x2+1];
|
||||
dst->R[y*WD +x] = ac / 4.0;
|
||||
|
||||
ac = src->G[(y2*WS)+x2] + src->G[(y2*WS)+x2+1] +
|
||||
src->G[((1+y2)*WS)+x2] + src->G[((1+y2)*WS)+x2+1];
|
||||
dst->G[y*WD +x] = ac / 4.0;
|
||||
|
||||
ac = src->B[(y2*WS)+x2] + src->B[(y2*WS)+x2+1] +
|
||||
src->B[((1+y2)*WS)+x2] + src->B[((1+y2)*WS)+x2+1];
|
||||
dst->B[y*WD +x] = ac / 4.0;
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
#undef WS
|
||||
#undef WD
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
int fimg_extractor(FloatImg *in, FloatImg *out, FimgArea51 *rect)
|
||||
{
|
||||
int foo;
|
||||
int xs, ys, xd, yd;
|
||||
int count;
|
||||
float rgb[3];
|
||||
|
||||
if (verbosity > 1) {
|
||||
fimg_describe(in, "extractor: source");
|
||||
fimg_describe(out, "extractor: destination");
|
||||
// print_rectangle(rect);
|
||||
}
|
||||
|
||||
count = 0;
|
||||
for (yd=0; yd<rect->h; yd++) {
|
||||
ys = yd + rect->y;
|
||||
if ((ys<0) || (ys>=in->height)) continue;
|
||||
for (xd=0; xd<rect->w; xd++) {
|
||||
xs = xd + rect->x;
|
||||
if ((xs<0) || (xs>=in->width)) continue;
|
||||
fimg_get_rgb(in, xs, ys, rgb);
|
||||
fimg_put_rgb(out, xd, yd, rgb);
|
||||
count++;
|
||||
}
|
||||
}
|
||||
|
||||
// fprintf(stderr, "%s: %d pix moved\n", __func__, count);
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
/* ho, btw, you can have a locck at 'incrustator.c' :) */
|
||||
/* --------------------------------------------------------------------- */
|
||||
int fimg_mirror(FloatImg *src, FloatImg *dst, int notused)
|
||||
{
|
||||
float *fptr;
|
||||
int line, col, offl;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p %p 0x%04x )\n", __func__,
|
||||
src, dst, notused);
|
||||
#endif
|
||||
|
||||
if (fimg_images_not_compatible(src, dst)) {
|
||||
fprintf(stderr, "bad karma in %s\n", __func__);
|
||||
return -9;
|
||||
}
|
||||
|
||||
if (NULL == (fptr=alloca(src->width*sizeof(float)))) {
|
||||
fprintf(stderr, "%s: no mem available\n", __func__);
|
||||
#if MUST_ABORT
|
||||
abort();
|
||||
#endif
|
||||
return -11;
|
||||
}
|
||||
|
||||
for (line=0; line<src->height; line++) {
|
||||
offl = line * src->width;
|
||||
for (col=0; col<src->width; col++)
|
||||
fptr[(src->width-1) - col] = src->R[offl+col];
|
||||
memcpy(dst->R+offl, fptr, src->width*sizeof(float));
|
||||
for (col=0; col<src->width; col++)
|
||||
fptr[(src->width-1) - col] = src->G[offl+col];
|
||||
memcpy(dst->G+offl, fptr, src->width*sizeof(float));
|
||||
for (col=0; col<src->width; col++)
|
||||
fptr[(src->width-1) - col] = src->B[offl+col];
|
||||
memcpy(dst->B+offl, fptr, src->width*sizeof(float));
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
|
||||
95
src/funcs/histogram.c
Normal file
95
src/funcs/histogram.c
Normal file
@@ -0,0 +1,95 @@
|
||||
/*
|
||||
* FLOATIMG
|
||||
* calculer un histogramme et l'afficher
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
extern int verbosity;
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
int fimg_calcul_histo(FloatImg *src, long *ghist, int sz)
|
||||
{
|
||||
float maxval;
|
||||
int x, y, idx;
|
||||
float rgb[3], moy;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p %p %d )\n", __func__, src, ghist, sz);
|
||||
#endif
|
||||
|
||||
if (FIMG_TYPE_RGB != src->type) {
|
||||
fprintf(stderr, "%s: bad type %d of image\n", __func__, src->type);
|
||||
return -97;
|
||||
}
|
||||
|
||||
maxval = fimg_get_maxvalue(src);
|
||||
|
||||
fprintf(stderr, "maximum is %f\n", maxval);
|
||||
|
||||
for (y=0; y<src->height; y++) {
|
||||
for(x=0; x<src->width; x++) {
|
||||
fimg_get_rgb(src, x, y, rgb);
|
||||
moy = (rgb[0]+rgb[1]+rgb[2]) / 3.0;
|
||||
|
||||
/* ok, here the had math part ... */
|
||||
idx = (int)( (moy*sz) / maxval);
|
||||
|
||||
/* sanity check */
|
||||
if (idx<0 || idx>=sz) {
|
||||
fprintf(stderr, "idx = %d, error\n", idx);
|
||||
abort();
|
||||
}
|
||||
|
||||
ghist[idx]++;
|
||||
}
|
||||
}
|
||||
|
||||
return -66;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
|
||||
int fimg_essai_histo(FloatImg *src, char *outpic, int nbslices)
|
||||
{
|
||||
long *histo;
|
||||
int foo;
|
||||
FILE *pipe;
|
||||
|
||||
fprintf(stderr, ">>> %s ( %p '%s' %d )\n", __func__, src, outpic, nbslices);
|
||||
|
||||
if (NULL==(histo=calloc(nbslices, sizeof(long)))) {
|
||||
fprintf(stderr, "OUT OF MEMORY\n");
|
||||
abort();
|
||||
}
|
||||
|
||||
foo = fimg_calcul_histo(src, histo, nbslices);
|
||||
|
||||
// for (foo=0; foo<NSLICES; foo++) {
|
||||
// printf("%7d %ld\n", foo, histo[foo]);
|
||||
// }
|
||||
|
||||
pipe = popen("gnuplot", "w");
|
||||
if (NULL==pipe) {
|
||||
fprintf(stderr, "%s: error running gnuplot\n", __func__);
|
||||
return -17;
|
||||
}
|
||||
fprintf(pipe, "set term png size 1024,512\n");
|
||||
fprintf(pipe, "set grid\n");
|
||||
fprintf(pipe, "set output \"%s\"\n", outpic);
|
||||
fprintf(pipe, "plot '/dev/stdin' with lines\n");
|
||||
|
||||
for (foo=0; foo<nbslices; foo++) {
|
||||
fprintf(pipe, "%d %ld\n", foo, histo[foo]);
|
||||
}
|
||||
|
||||
pclose(pipe); // and not fclose (see man page)
|
||||
|
||||
free(histo);
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
161
src/funcs/hsv.c
Normal file
161
src/funcs/hsv.c
Normal file
@@ -0,0 +1,161 @@
|
||||
/*
|
||||
* FloatImg library
|
||||
* HUE - SATURATION - VALUE
|
||||
|
||||
+---------------------------------------------+
|
||||
| ce code ne fonctionne vraiment PAS ! |
|
||||
+---------------------------------------------+
|
||||
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <math.h>
|
||||
#include "../floatimg.h"
|
||||
|
||||
extern int verbosity;
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
/* helper functions */
|
||||
static float maxi3f(float a, float b, float c)
|
||||
{
|
||||
return ((a > b)? (a > c ? a : c) : (b > c ? b : c));
|
||||
}
|
||||
static float mini3f(float a, float b, float c)
|
||||
{
|
||||
return ((a < b)? (a < c ? a : c) : (b < c ? b : c));
|
||||
}
|
||||
static int pseudoeq(float a, float b)
|
||||
{
|
||||
return (fabsf(a-b)<0.00000000000001); // UGLY HACK ???
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
/*
|
||||
* WARNING : ALL THIS CODE IS STRANGE
|
||||
*
|
||||
|
||||
www.tutorialspoint.com/c-program-to-change-rgb-color-model-to-hsv-color-model
|
||||
|
||||
*/
|
||||
int fimg_rgb2hsv(float rgb[3], float hsv[3], float scale)
|
||||
{
|
||||
// float h, s, v;
|
||||
float cmin, cmax, diff;
|
||||
|
||||
// scale input value to [0..1]
|
||||
rgb[0] /= scale; rgb[1] /= scale; rgb[2] /= scale;
|
||||
|
||||
hsv[0] = hsv[1] = hsv[2] = -12345.6789;
|
||||
|
||||
cmin = mini3f(rgb[0], rgb[1], rgb[2]);
|
||||
cmax = maxi3f(rgb[0], rgb[1], rgb[2]);
|
||||
diff = cmax - cmin;
|
||||
|
||||
if (pseudoeq(cmax, cmin)) hsv[0] = 0.0;
|
||||
else if (pseudoeq(cmax, rgb[0]))
|
||||
hsv[0] = fmod((60 * ((rgb[1] - rgb[2]) / diff) + 360), 360.0);
|
||||
else if (pseudoeq(cmax, rgb[1]))
|
||||
hsv[0] = fmod((60 * ((rgb[2] - rgb[0]) / diff) + 120), 360.0);
|
||||
else if (pseudoeq(cmax, rgb[2]))
|
||||
hsv[0] = fmod((60 * ((rgb[0] - rgb[1]) / diff) + 240), 360.0);
|
||||
|
||||
if (pseudoeq(cmax, 0.0)) hsv[1] = 0.0;
|
||||
else hsv[1] = (diff / cmax) / 100.0;
|
||||
|
||||
hsv[2] = cmax * 100.0; /* WHAT THE FUCK ? */
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, "cmin/cmax %f %f\n", cmin, cmax);
|
||||
#endif
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
int fimg_hsv2rgb(float hsv[3], float rgb[3], float scale)
|
||||
{
|
||||
float hh, ff, p, q, t;
|
||||
long i;
|
||||
|
||||
if(hsv[1] <= 0.0) { // < is bogus, just shuts up warnings
|
||||
rgb[0] = rgb[1] = rgb[2] = hsv[2];
|
||||
return 0;
|
||||
}
|
||||
|
||||
hh = hsv[0];
|
||||
if(hh >= 360.0) hh = 0.0;
|
||||
hh /= 60.0;
|
||||
i = (long)hh;
|
||||
ff = hh - i;
|
||||
p = hsv[2] * (1.0 - hsv[1]);
|
||||
q = hsv[2] * (1.0 - (hsv[1] * ff));
|
||||
t = hsv[2] * (1.0 - (hsv[1] * (1.0 - ff)));
|
||||
|
||||
switch(i) {
|
||||
case 0:
|
||||
rgb[0] = hsv[2]; rgb[1] = t; rgb[2] = p;
|
||||
break;
|
||||
case 1:
|
||||
rgb[0] = q; rgb[1] = hsv[2]; rgb[2] = p;
|
||||
break;
|
||||
case 2:
|
||||
rgb[0] = p; rgb[1] = hsv[2]; rgb[2] = t;
|
||||
break;
|
||||
case 3:
|
||||
rgb[0] = p; rgb[1] = q; rgb[2] = hsv[2];
|
||||
break;
|
||||
case 4:
|
||||
rgb[0] = t; rgb[1] = p; rgb[2] = hsv[2];
|
||||
break;
|
||||
case 5:
|
||||
default:
|
||||
rgb[0] = hsv[2]; rgb[1] = p; rgb[2] = q;
|
||||
break;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
/*
|
||||
* expect garbage !
|
||||
*/
|
||||
int fimg_essai_hsv(char *fname)
|
||||
{
|
||||
float colors[3], values[3], newcols[3];
|
||||
int foo, r, g, b;
|
||||
|
||||
#define INC 16
|
||||
for (r=0; r<255; r+=INC) {
|
||||
for (g=0; g<255; g+=INC) {
|
||||
for (b=0; b<255; b+=INC) {
|
||||
|
||||
printf("%4d %4d %4d ", r, g, b);
|
||||
|
||||
colors[0] = (float)r;
|
||||
colors[1] = (float)g;
|
||||
colors[2] = (float)b;
|
||||
foo = fimg_rgb2hsv(colors, values, 255.0);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: err %d in rgv->hsv\n", __func__, foo);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
printf(" %8.4f %8.4f %8.4f ",
|
||||
values[0], values[1], values[2]);
|
||||
|
||||
foo = fimg_hsv2rgb(values, newcols, 255.0);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: err %d in hsv->rgb\n", __func__, foo);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
printf(" %8.4f %8.4f %8.4f\n",
|
||||
newcols[0], newcols[1], newcols[2]);
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
93
src/funcs/incrustator.c
Normal file
93
src/funcs/incrustator.c
Normal file
@@ -0,0 +1,93 @@
|
||||
/*
|
||||
* incrustator VERY experimental
|
||||
* KRKRK
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
// XXX #include "incrustator.h"
|
||||
|
||||
extern int verbosity;
|
||||
|
||||
/* ---------------------------------------------------------------- */
|
||||
static int check_boundaries(FloatImg *from, FloatImg *to, FimgArea51 *a51)
|
||||
{
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p %p %p )\n", __func__, from, to, a51);
|
||||
fimg_printdims("from", from);
|
||||
fimg_printdims("to ", to);
|
||||
#endif
|
||||
|
||||
/* just a small molly-guard */
|
||||
if ( (a51->w < 0) || (a51->h < 0) ) {
|
||||
fprintf(stderr, "%s: fubar on %p\n", __func__, a51);
|
||||
abort(); /* FY Bro ! */
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
/* ---------------------------------------------------------------- */
|
||||
static int move_pixels(FloatImg *from, FloatImg *to,
|
||||
FimgArea51 *a51, int flags)
|
||||
{
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p %p %p 0x%04x )\n", __func__,
|
||||
from, to, a51, flags);
|
||||
#endif
|
||||
|
||||
return -1;
|
||||
}
|
||||
/* ---------------------------------------------------------------- */
|
||||
int fimg_incrustator_0(FloatImg *psrc, FloatImg *pdst,
|
||||
int xpos, int ypos, int flags)
|
||||
{
|
||||
int y, srcpos, dstpos, szl;
|
||||
int foo;
|
||||
|
||||
FimgArea51 area;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p %p %d %d 0x%04X\n", __func__, psrc, pdst,
|
||||
xpos, ypos, flags);
|
||||
#endif
|
||||
|
||||
if (verbosity > 1) {
|
||||
fimg_describe(psrc, "source");
|
||||
fimg_describe(pdst, "destination");
|
||||
}
|
||||
|
||||
/* check boudaries */
|
||||
area.x = xpos; area.y = ypos;
|
||||
area.w = psrc->width; area.h = psrc->height;
|
||||
foo = check_boundaries(psrc, pdst, &area);
|
||||
|
||||
if ( (xpos < 0) || (xpos > pdst->width - psrc->width) ||
|
||||
(ypos < 0) || (ypos > pdst->height - psrc->height) ) {
|
||||
fprintf(stderr, "%s: boudary error\n", __func__);
|
||||
return -2;
|
||||
}
|
||||
|
||||
/* move all the data by looping over lines */
|
||||
srcpos = 0;
|
||||
dstpos = (ypos * pdst->width) + xpos;
|
||||
szl = psrc->width * sizeof(float);
|
||||
for (y=0; y<psrc->height; y++) {
|
||||
// fprintf(stderr, " %7d %7d %7d\n", y, srcpos, dstpos);
|
||||
|
||||
memcpy(pdst->R + dstpos, psrc->R + srcpos, szl);
|
||||
memcpy(pdst->G + dstpos, psrc->G + srcpos, szl);
|
||||
memcpy(pdst->B + dstpos, psrc->B + srcpos, szl);
|
||||
|
||||
srcpos += psrc->width;
|
||||
dstpos += pdst->width;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* ---------------------------------------------------------------- */
|
||||
104
src/funcs/misc-plots.c
Normal file
104
src/funcs/misc-plots.c
Normal file
@@ -0,0 +1,104 @@
|
||||
/*
|
||||
* This is an eternal WIP, sorry...
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <math.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
|
||||
int fimg_test_pattern(FloatImg *fimg, int type, double dval)
|
||||
{
|
||||
int nio;
|
||||
int x, y, k;
|
||||
float fr, fg, fb, val;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p %d %g )\n", __func__, fimg, type, dval);
|
||||
#endif
|
||||
|
||||
if (fimg->type != FIMG_TYPE_RGB) {
|
||||
fprintf(stderr, "%s need an rgb pic\n", __func__);
|
||||
return -6;
|
||||
}
|
||||
|
||||
/* rampe de primaires dans le quart du haut */
|
||||
val = (float)dval;
|
||||
for (x=0; x<fimg->width; x++) {
|
||||
nio = x / (fimg->width / 8);
|
||||
switch(nio) {
|
||||
case 0: fr = 0.0, fg = 0.0, fb = 0.0; break;
|
||||
case 1: fr = val, fg = 0.0, fb = 0.0; break;
|
||||
case 2: fr = 0.0, fg = val, fb = 0.0; break;
|
||||
case 3: fr = val, fg = val, fb = 0.0; break;
|
||||
case 4: fr = 0.0, fg = 0.0, fb = val; break;
|
||||
case 5: fr = val, fg = 0.0, fb = val; break;
|
||||
case 6: fr = 0.0, fg = val, fb = val; break;
|
||||
case 7: fr = val, fg = val, fb = val; break;
|
||||
default:
|
||||
abort(); break;
|
||||
}
|
||||
for (y=0; y<fimg->height/4; y++)
|
||||
fimg_plot_rgb(fimg, x, y, fr, fg, fb);
|
||||
}
|
||||
|
||||
k = fimg->height / 4;
|
||||
for (x=0; x<fimg->width; x++) {
|
||||
val = ((double)x / (double)fimg->width) * dval;
|
||||
for (y=0; y<20; y++) {
|
||||
fimg_plot_rgb(fimg, x, k+y, val, val, val);
|
||||
fimg_plot_rgb(fimg, x, k+y+20, dval-val, dval-val, dval-val);
|
||||
}
|
||||
// fprintf(stderr, " %6d %f\n", x, val);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
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*(sin(fy*K)+1.4),
|
||||
M*(cos(fx*fy)+1.6));
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
int fimg_multirandom(FloatImg *fimg, long nbpass)
|
||||
{
|
||||
int foo, x, y;
|
||||
|
||||
#define RI ( (rand()/7) + (rand()/9) )
|
||||
#define RD ( (drand48()/7) + (drand48()/7) )
|
||||
|
||||
for (foo=0; foo<nbpass; foo++)
|
||||
{
|
||||
x = RI % fimg->width;
|
||||
y = RI % fimg->height;
|
||||
fimg_add_rgb(fimg, x, y, RD, RD, RD);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
43
src/funcs/plasmas.c
Normal file
43
src/funcs/plasmas.c
Normal file
@@ -0,0 +1,43 @@
|
||||
/*
|
||||
PLASMAS
|
||||
|
||||
Inspiration Reep : https://blog.314r.net/2021/01/10/plasma/
|
||||
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <math.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
extern int verbosity;
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
/* --------------------------------------------------------------------- */
|
||||
int fimg_prototype_plasma(FloatImg *img, double time, int type)
|
||||
{
|
||||
int x, y;
|
||||
float rgb[3];
|
||||
double dx, dy;
|
||||
|
||||
fprintf(stderr, ">>> %s ( %p %.3f %d )\n", __func__,
|
||||
img, time, type);
|
||||
|
||||
for (y=0; y<img->height; y++) {
|
||||
dy = ((double)y/(double)img->height) - 0.5000;
|
||||
|
||||
for (x=0; x<img->width; x++) {
|
||||
dx = ((double)x/(double)img->width) - 0.5000;
|
||||
|
||||
rgb[0] = sin(dx*10 + time) + 1.0;
|
||||
rgb[1] = sin(dx*12 + time) + 1.0;
|
||||
rgb[2] = sin(dx*14 + time) + 1.0;
|
||||
fimg_put_rgb(img, x, y, rgb);
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
128
src/funcs/qsortrgb.c
Normal file
128
src/funcs/qsortrgb.c
Normal file
@@ -0,0 +1,128 @@
|
||||
/*
|
||||
* qsort_rgb.c
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <math.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
extern int verbosity;
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
/* nouveau 7 octobre 2020, juste avant sonoptic de la pluie craignos */
|
||||
|
||||
static int compare_a(const void *p1, const void *p2)
|
||||
{
|
||||
return ( *(float *)p1 < *(float *)p2 );
|
||||
}
|
||||
|
||||
int fimg_qsort_rgb_a(FloatImg *psrc, FloatImg *pdst, int notused)
|
||||
{
|
||||
int foo, szimg;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p %p %d )\n", __func__, psrc, pdst, notused);
|
||||
#endif
|
||||
|
||||
if (FIMG_TYPE_RGB != psrc->type) {
|
||||
fprintf(stderr, "%s: bad src type %d\n", __func__, psrc->type);
|
||||
return -7;
|
||||
}
|
||||
if (fimg_images_not_compatible(psrc, pdst)) {
|
||||
fprintf(stderr, "%s: bad dst type %d\n", __func__, pdst->type);
|
||||
return -8;
|
||||
}
|
||||
|
||||
if (psrc != pdst) { /* optimize or futurbug ? */
|
||||
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;
|
||||
// fprintf(stderr, "%s : %d pixels\n", __func__, szimg);
|
||||
|
||||
qsort(pdst->R, szimg, sizeof(float), compare_a);
|
||||
qsort(pdst->G, szimg, sizeof(float), compare_a);
|
||||
qsort(pdst->B, szimg, sizeof(float), compare_a);
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
typedef struct {
|
||||
float sum;
|
||||
float r, g, b;
|
||||
} pix;
|
||||
|
||||
static int compare_b(const void *p1, const void *p2)
|
||||
{
|
||||
pix *s1, *s2;
|
||||
s1 = (pix *)p1;
|
||||
s2 = (pix *)p2;
|
||||
return ( s1->sum < s2->sum );
|
||||
}
|
||||
|
||||
int fimg_qsort_rgb_b(FloatImg *psrc, FloatImg *pdst, int notused)
|
||||
{
|
||||
int x, y, szimg;
|
||||
pix *ppix, *ptr;
|
||||
float rgb[3];
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p %p %d )\n", __func__, psrc, pdst, notused);
|
||||
#endif
|
||||
|
||||
if (FIMG_TYPE_RGB != psrc->type) {
|
||||
fprintf(stderr, "%s: bad src type %d\n", __func__, psrc->type);
|
||||
return -7;
|
||||
}
|
||||
if (fimg_images_not_compatible(psrc, pdst)) {
|
||||
fprintf(stderr, "%s: bad dst type %d\n", __func__, pdst->type);
|
||||
return -8;
|
||||
}
|
||||
|
||||
szimg = pdst->width * pdst->height;
|
||||
// fprintf(stderr, "%s : %d pixels\n", __func__, szimg);
|
||||
|
||||
ppix = calloc(szimg, sizeof(pix));
|
||||
|
||||
ptr = ppix; /* mobile pointer */
|
||||
for (y=0; y<psrc->height; y++) {
|
||||
for (x=0; x<psrc->width; x++) {
|
||||
|
||||
fimg_get_rgb(psrc, x, y, rgb);
|
||||
|
||||
ptr->sum = rgb[0] + rgb[1] + rgb[2];
|
||||
ptr->r = rgb[0];
|
||||
ptr->g = rgb[1];
|
||||
ptr->b = rgb[2];
|
||||
|
||||
ptr++; /* next pixel */
|
||||
}
|
||||
}
|
||||
|
||||
qsort(ppix, szimg, sizeof(pix), compare_b);
|
||||
|
||||
ptr = ppix; /* mobile pointer */
|
||||
for (y=0; y<psrc->height; y++) {
|
||||
for (x=0; x<psrc->width; x++) {
|
||||
|
||||
rgb[0] = ptr->r;
|
||||
rgb[1] = ptr->g;
|
||||
rgb[2] = ptr->b;
|
||||
fimg_put_rgb(pdst, x, y, rgb);
|
||||
|
||||
ptr++; /* next pixel */
|
||||
}
|
||||
}
|
||||
|
||||
free(ppix);
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
63
src/funcs/rampes.c
Normal file
63
src/funcs/rampes.c
Normal file
@@ -0,0 +1,63 @@
|
||||
/*
|
||||
* FLOATIMG
|
||||
* rampes diverses, trucs etranges
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
int fimg_hdeg_a(FloatImg *img, double dcoef)
|
||||
{
|
||||
int x, y;
|
||||
float value;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p %f )\n", __func__, img, dcoef);
|
||||
#endif
|
||||
|
||||
if (FIMG_TYPE_RGB != img->type) {
|
||||
fprintf(stderr, "%s bad type\n", __func__);
|
||||
return -6;
|
||||
}
|
||||
for (x=0; x<img->width; x++)
|
||||
{
|
||||
value = (float)x / (float)img->width;
|
||||
value *= dcoef;
|
||||
for (y=0; y<img->height; y++) {
|
||||
fimg_plot_rgb(img, x, y, value, value, value);
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
/*
|
||||
* To have the black at the bottom, use a negative dcoef
|
||||
*/
|
||||
int fimg_vdeg_a(FloatImg *img, double dcoef)
|
||||
{
|
||||
int x, y;
|
||||
float value;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p %f )\n", __func__, img, dcoef);
|
||||
#endif
|
||||
|
||||
if (FIMG_TYPE_RGB != img->type) {
|
||||
fprintf(stderr, "%s bad type\n", __func__);
|
||||
return -6;
|
||||
}
|
||||
for (y=0; y<img->height; y++)
|
||||
{
|
||||
value = (float)y / (float)img->height;
|
||||
value *= dcoef;
|
||||
for (x=0; x<img->width; x++) {
|
||||
fimg_plot_rgb(img, x, y, value, value, value);
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
26
src/funcs/recurse.c
Normal file
26
src/funcs/recurse.c
Normal file
@@ -0,0 +1,26 @@
|
||||
/*
|
||||
RECURSION 'QUADTREE' SUR LES IMAGES
|
||||
-----------------------------------
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <math.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
/* -------------------------------------------------------------------- */
|
||||
/* may be we need some private variables ? */
|
||||
/* -------------------------------------------------------------------- */
|
||||
/* nouveau 29 avril 2021, pendant un autre masque-flamme coronavidique */
|
||||
|
||||
int fimg_recursion_proto(FloatImg *src, FloatImg *dst, int notused)
|
||||
{
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p %p %d )\n", __func__, src, dst, notused);
|
||||
#endif
|
||||
|
||||
return -1;
|
||||
}
|
||||
/* -------------------------------------------------------------------- */
|
||||
/* -------------------------------------------------------------------- */
|
||||
72
src/funcs/rotate.c
Normal file
72
src/funcs/rotate.c
Normal file
@@ -0,0 +1,72 @@
|
||||
/*
|
||||
* FLOATIMG
|
||||
* rotation matricielle des images
|
||||
* #coronamaison Mon 23 Mar 2020 11:45:59 AM CET
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
extern int verbosity;
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
int fimg_rotate_90(FloatImg *src, FloatImg *dst, int notused)
|
||||
{
|
||||
int foo;
|
||||
int x, y, k;
|
||||
float rgb[3];
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p %p %d )\n", __func__,
|
||||
src, dst, notused);
|
||||
#endif
|
||||
|
||||
if (src->type != FIMG_TYPE_RGB) {
|
||||
fprintf(stderr, "%s: src type %d not valid\n", __func__,
|
||||
src->type);
|
||||
return -6;
|
||||
}
|
||||
|
||||
/* check if dst pic is not allocated */
|
||||
if ( 0 == (dst->type | dst->width | dst->height) ) {
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, "in %s, %p is empty\n", __func__, dst);
|
||||
#endif
|
||||
/* OK allocate a new fpic */
|
||||
foo = fimg_create(dst, src->height, src->width, src->type);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: err %d create new pic\n", __func__, foo);
|
||||
return -887;
|
||||
}
|
||||
// if (verbosity>1) fimg_describe(dst, "new pic");
|
||||
}
|
||||
|
||||
/* check if dst and src are conpatibles */
|
||||
if ( (src->type != dst->type) ||
|
||||
(src->width != dst->height) || (src->height != dst->width) ) {
|
||||
fprintf(stderr, "%s: src & dst not compatibles\n", __func__);
|
||||
return -888;
|
||||
}
|
||||
|
||||
/*
|
||||
* THIS IS A CRUDE IMPLEMENTATION
|
||||
*/
|
||||
for (y=0; y<src->height; y++) {
|
||||
for (x=0; x<src->width; x++) {
|
||||
fimg_get_rgb(src, x, y, rgb);
|
||||
// XXX ??? j = (dst->height - x) - 1;
|
||||
k = (dst->width - y) - 1;
|
||||
#if DEBUG_LEVEL > 1
|
||||
fprintf(stderr, "%6d %6d\n", k, j);
|
||||
#endif
|
||||
fimg_put_rgb(dst, k, x, rgb);
|
||||
}
|
||||
}
|
||||
|
||||
/* we don't have any cleanup to make */
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
109
src/funcs/saturation.c
Normal file
109
src/funcs/saturation.c
Normal file
@@ -0,0 +1,109 @@
|
||||
/*
|
||||
* FloatImg library from tTh - really ugly code inside
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
/* -------------------------------------------------------------- */
|
||||
/* global vars exported from main
|
||||
*/
|
||||
extern int verbosity;
|
||||
|
||||
/* -------------------------------------------------------------- */
|
||||
/*
|
||||
* parameter mix is between 0.0 and 1.0 but other
|
||||
* values give sometime good vibrations.
|
||||
*/
|
||||
int fimg_mix_rgb_gray(FloatImg *img, float mix)
|
||||
{
|
||||
int x, y, p;
|
||||
float gr;
|
||||
|
||||
if (FIMG_TYPE_RGB != img->type) {
|
||||
fprintf(stderr, "%s bad type\n", __func__);
|
||||
return -6;
|
||||
}
|
||||
|
||||
for (y=0; y<img->height; y++) {
|
||||
p = y * img->width; /* first pixel of the row */
|
||||
for (x=0; x<img->width; x++) {
|
||||
|
||||
gr = (img->R[p] + img->G[p] + img->R[p]) / 3.0;
|
||||
|
||||
img->R[p] = ((gr * mix) + (img->R[p] * (1.0-mix))) / 2.0;
|
||||
img->G[p] = ((gr * mix) + (img->G[p] * (1.0-mix))) / 2.0;
|
||||
img->B[p] = ((gr * mix) + (img->B[p] * (1.0-mix))) / 2.0;
|
||||
p++; /* next pixel in the row */
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* -------------------------------------------------------------- */
|
||||
/*
|
||||
* The third parameter was a six value array with min and max
|
||||
* values maybe computed by the 'fimg_get_minmax_rgb' function.
|
||||
*/
|
||||
int fimg_shift_to_zero(FloatImg *s, FloatImg *d, float coefs[6])
|
||||
{
|
||||
int sz, idx;
|
||||
|
||||
if (FIMG_TYPE_RGB != s->type) {
|
||||
fprintf(stderr, "%s bad type\n", __func__);
|
||||
return -6;
|
||||
}
|
||||
|
||||
sz = s->width * s->height;
|
||||
for (idx=0; idx<sz; idx++) {
|
||||
d->R[idx] = s->R[idx] - coefs[0];
|
||||
d->G[idx] = s->G[idx] - coefs[2];
|
||||
d->B[idx] = s->B[idx] - coefs[4];
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* -------------------------------------------------------------- */
|
||||
/*
|
||||
* I think that this function is fully buggy, and need
|
||||
* more explanations.
|
||||
*/
|
||||
int fimg_auto_shift_to_zero(FloatImg *src, FloatImg *dst)
|
||||
{
|
||||
float coefs[6];
|
||||
int foo;
|
||||
float minima = 1e7; /* magic value ? */
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p %p )\n", __func__, src, dst);
|
||||
#endif
|
||||
|
||||
if (FIMG_TYPE_RGB != src->type) {
|
||||
fprintf(stderr, "%s: bad image type %d\n", __func__, src->type);
|
||||
return -6;
|
||||
}
|
||||
|
||||
foo = fimg_get_minmax_rgb(src, coefs);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: err %d get minmax\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
/* crude hack for now */
|
||||
if (coefs[0] < minima) minima = coefs[0];
|
||||
if (coefs[2] < minima) minima = coefs[2];
|
||||
if (coefs[4] < minima) minima = coefs[4];
|
||||
|
||||
coefs[0] = coefs[2] = coefs[4] = minima;
|
||||
|
||||
foo = fimg_shift_to_zero(src, dst, coefs);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s WTF?\n", __func__);
|
||||
return foo;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* -------------------------------------------------------------- */
|
||||
|
||||
89
src/funcs/sfx0.c
Normal file
89
src/funcs/sfx0.c
Normal file
@@ -0,0 +1,89 @@
|
||||
/*
|
||||
* FLOATIMG
|
||||
* effets spéciaux àlc sur les couleurs
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
/*
|
||||
* OMG ! a Color Graphic Adaptor emulator :)
|
||||
*/
|
||||
int fimg_killcolors_a(FloatImg *fimg, float fval)
|
||||
{
|
||||
int nbpix, foo;
|
||||
|
||||
if (FIMG_TYPE_RGB != fimg->type) {
|
||||
fprintf(stderr, "%s: bad src type %d on %p\n", __func__,
|
||||
fimg->type, fimg);
|
||||
return -8;
|
||||
}
|
||||
|
||||
nbpix = fimg->width * fimg->height;
|
||||
for (foo=0; foo<nbpix; foo++) {
|
||||
if (fimg->R[foo] > fimg->G[foo])
|
||||
fimg->B[foo] = fimg->R[foo];
|
||||
else
|
||||
fimg->B[foo] = fimg->G[foo];
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
/*
|
||||
* parameter fval is not used, why ?
|
||||
*/
|
||||
int fimg_killcolors_b(FloatImg *fimg, float fval)
|
||||
{
|
||||
int nbpix, foo;
|
||||
|
||||
if (FIMG_TYPE_RGB != fimg->type) {
|
||||
fprintf(stderr, "%s: bad src type %d on %p\n", __func__,
|
||||
fimg->type, fimg);
|
||||
return -8;
|
||||
}
|
||||
|
||||
nbpix = fimg->width * fimg->height;
|
||||
for (foo=0; foo<nbpix; foo++) {
|
||||
if (fimg->R[foo] > fimg->B[foo])
|
||||
fimg->G[foo] = fimg->R[foo];
|
||||
else
|
||||
fimg->G[foo] = fimg->B[foo];
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
int fimg_colors_mixer_a(FloatImg *fimg, float fval)
|
||||
{
|
||||
int nbpix, foo;
|
||||
float R, G, B;
|
||||
|
||||
if (FIMG_TYPE_RGB != fimg->type) {
|
||||
fprintf(stderr, "%s: bad src type %d on %p\n", __func__,
|
||||
fimg->type, fimg);
|
||||
#if MUST_ABORT
|
||||
abort();
|
||||
#endif
|
||||
return -8;
|
||||
}
|
||||
|
||||
nbpix = fimg->width * fimg->height;
|
||||
|
||||
for (foo=0; foo<nbpix; foo++) {
|
||||
|
||||
R = (fimg->G[foo] + fimg->B[foo]) / fval;
|
||||
G = (fimg->R[foo] + fimg->B[foo]) / fval;
|
||||
B = (fimg->R[foo] + fimg->G[foo]) / fval;
|
||||
|
||||
fimg->R[foo] = R;
|
||||
fimg->G[foo] = G;
|
||||
fimg->B[foo] = B;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
106
src/funcs/sfx1.c
Normal file
106
src/funcs/sfx1.c
Normal file
@@ -0,0 +1,106 @@
|
||||
/*
|
||||
* FLOATIMG - a kluge from tTh
|
||||
* effets spéciaux bizarres sur les couleurs.
|
||||
* nouveau pour un truc chelou avec Maëva
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
/* WARNING
|
||||
some crapy code cuted & pasted here */
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
static void highlight_red(FloatImg *src, FloatImg *dst, float fval)
|
||||
{
|
||||
int sz, idx;
|
||||
|
||||
sz = src->width * src->height;
|
||||
for (idx=0; idx<sz; idx++) {
|
||||
dst->G[idx] = src->G[idx];
|
||||
dst->B[idx] = src->B[idx];
|
||||
if ( (src->G[idx] < src->R[idx]) &&
|
||||
(src->B[idx] < src->R[idx]) ) {
|
||||
dst->R[idx] = src->R[idx] * fval;
|
||||
}
|
||||
else {
|
||||
dst->R[idx] = src->R[idx];
|
||||
}
|
||||
}
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
static void highlight_green(FloatImg *src, FloatImg *dst, float fval)
|
||||
{
|
||||
int sz, idx;
|
||||
|
||||
sz = src->width * src->height;
|
||||
for (idx=0; idx<sz; idx++) {
|
||||
dst->R[idx] = src->R[idx];
|
||||
dst->B[idx] = src->B[idx];
|
||||
if ( (src->R[idx] < src->R[idx]) &&
|
||||
(src->B[idx] < src->R[idx]) ) {
|
||||
dst->G[idx] = src->G[idx] * fval;
|
||||
}
|
||||
else {
|
||||
dst->G[idx] = src->G[idx];
|
||||
}
|
||||
}
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
static void highlight_blue(FloatImg *src, FloatImg *dst, float fval)
|
||||
{
|
||||
int sz, idx;
|
||||
|
||||
sz = src->width * src->height;
|
||||
for (idx=0; idx<sz; idx++) {
|
||||
dst->G[idx] = src->G[idx];
|
||||
dst->R[idx] = src->R[idx];
|
||||
if ( (src->G[idx] < src->B[idx]) &&
|
||||
(src->R[idx] < src->B[idx]) ) {
|
||||
dst->B[idx] = src->B[idx] * fval;
|
||||
}
|
||||
else {
|
||||
dst->B[idx] = src->B[idx];
|
||||
}
|
||||
}
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
int fimg_highlight_color(FloatImg *src, FloatImg *dst, char color, float fval)
|
||||
{
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p %p [%c] %f )\n", __func__,
|
||||
src, dst, color, fval);
|
||||
#endif
|
||||
|
||||
if (FIMG_TYPE_RGB != src->type) {
|
||||
fprintf(stderr, "%s: bad src type %d on %p\n", __func__,
|
||||
src->type, src);
|
||||
return -8;
|
||||
}
|
||||
if (fimg_images_not_compatible(src, dst)) {
|
||||
fprintf(stderr, "oh fuck in %s\n", __func__);
|
||||
return -9;
|
||||
}
|
||||
|
||||
switch (color) {
|
||||
|
||||
case 'r': case 'R':
|
||||
highlight_red(src, dst, fval); break;
|
||||
case 'g': case 'G':
|
||||
highlight_green(src, dst, fval); break;
|
||||
case 'b': case 'B':
|
||||
highlight_blue(src, dst, fval); break;
|
||||
|
||||
default:
|
||||
fprintf(stderr, "%s: '%c' is invalid\n", __func__, color);
|
||||
return -11;
|
||||
break; /* nottreached */
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
/* --------------------------------------------------------------------- */
|
||||
94
src/funcs/sfx2.c
Normal file
94
src/funcs/sfx2.c
Normal file
@@ -0,0 +1,94 @@
|
||||
/*
|
||||
* FLOATIMG - a kluge from tTh
|
||||
*/
|
||||
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
extern int verbosity;
|
||||
|
||||
/*
|
||||
* a place for moving here Fonderie effects
|
||||
*/
|
||||
/* -------------------------------------------------------------- */
|
||||
int fimg_binarize(FloatImg *pimg, int notused)
|
||||
{
|
||||
float mm[6], mR, mG, mB;
|
||||
int foo, size;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p %d )\n", __func__, pimg, notused);
|
||||
#endif
|
||||
|
||||
foo = fimg_get_minmax_rgb(pimg, mm);
|
||||
mR = (mm[1] - mm[0]) / 2.0;
|
||||
mG = (mm[3] - mm[2]) / 2.0;
|
||||
mB = (mm[5] - mm[4]) / 2.0;
|
||||
|
||||
if (verbosity > 1)
|
||||
fprintf(stderr, "%s: %f %f %f\n", __func__, mR, mG, mB);
|
||||
|
||||
size = pimg->width * pimg->height;
|
||||
|
||||
for (foo=0; foo<size; foo++) {
|
||||
if (pimg->R[foo] < mR) pimg->R[foo] = mm[0];
|
||||
else pimg->R[foo] = mm[1];
|
||||
if (pimg->G[foo] < mG) pimg->G[foo] = mm[2];
|
||||
else pimg->G[foo] = mm[3];
|
||||
if (pimg->B[foo] < mB) pimg->B[foo] = mm[4];
|
||||
else pimg->B[foo] = mm[5];
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* -------------------------------------------------------------- */
|
||||
|
||||
int fimg_trinarize(FloatImg *pimg, int notused)
|
||||
{
|
||||
float mm[6], mRa, mGa, mBa, mRb, mGb, mBb;
|
||||
float *fptr;
|
||||
int foo, size;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p %d )\n", __func__, pimg, notused);
|
||||
#endif
|
||||
|
||||
foo = fimg_get_minmax_rgb(pimg, mm);
|
||||
mRa = (mm[1] - mm[0]) * 0.33333;
|
||||
mGa = (mm[3] - mm[2]) * 0.33333;
|
||||
mBa = (mm[5] - mm[4]) * 0.33333;
|
||||
mRb = (mm[1] - mm[0]) * 0.66666;
|
||||
mGb = (mm[3] - mm[2]) * 0.66666;
|
||||
mBb = (mm[5] - mm[4]) * 0.66666;
|
||||
|
||||
size = pimg->width * pimg->height;
|
||||
|
||||
for (foo=0; foo<size; foo++) {
|
||||
|
||||
fptr = pimg->R;
|
||||
if (fptr[foo] < mRa || fptr[foo] > mRb)
|
||||
fptr[foo] = mm[0];
|
||||
else
|
||||
fptr[foo] = mm[1];
|
||||
|
||||
fptr = pimg->G;
|
||||
if (fptr[foo] < mGa || fptr[foo] > mGb)
|
||||
fptr[foo] = mm[2];
|
||||
else
|
||||
fptr[foo] = mm[3];
|
||||
|
||||
fptr = pimg->B;
|
||||
if (fptr[foo] < mBa || fptr[foo] > mBb)
|
||||
fptr[foo] = mm[4];
|
||||
else
|
||||
fptr[foo] = mm[5];
|
||||
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* -------------------------------------------------------------- */
|
||||
|
||||
231
src/funcs/t.c
Normal file
231
src/funcs/t.c
Normal file
@@ -0,0 +1,231 @@
|
||||
/*
|
||||
* tests des fonctions diverses - main file
|
||||
see also: tests.c
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <pam.h>
|
||||
|
||||
#undef DEBUG_LEVEL
|
||||
#define DEBUG_LEVEL 1
|
||||
|
||||
#include "../floatimg.h"
|
||||
#include "tests.h"
|
||||
|
||||
int verbosity;
|
||||
float global_fvalue;
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
/* --------------------------------------------------------------------- */
|
||||
enum nCmd { Equalize=1, Rotate, Sfx0, F3x3, MIRE, Wfits, Wpng, Wtiff,
|
||||
Histo, Hsv, Classif, Ctr2x2, Qsortrgb,
|
||||
Displace, ReadPNG, Plasmas, Hilight, OpenEXR,
|
||||
Geometrie, FileType, Mirror };
|
||||
typedef struct {
|
||||
char *name;
|
||||
int Cmd;
|
||||
} Command;
|
||||
|
||||
Command commands[] = {
|
||||
{ "equalize", Equalize },
|
||||
{ "rotate", Rotate },
|
||||
{ "sfx0", Sfx0 },
|
||||
{ "f3x3", F3x3 },
|
||||
{ "mire", MIRE },
|
||||
{ "wfits", Wfits },
|
||||
{ "wpng", Wpng },
|
||||
{ "wtiff", Wtiff },
|
||||
{ "histo", Histo },
|
||||
{ "hsv", Hsv },
|
||||
{ "classif", Classif },
|
||||
{ "ctr2x2", Ctr2x2 },
|
||||
{ "qsortrgb", Qsortrgb },
|
||||
{ "displace", Displace },
|
||||
{ "readpng", ReadPNG },
|
||||
{ "plasma", Plasmas },
|
||||
{ "hilight", Hilight },
|
||||
{ "openexr", OpenEXR },
|
||||
{ "geometrie", Geometrie, },
|
||||
{ "filetype", FileType },
|
||||
{ "mirror", Mirror },
|
||||
{ NULL, 0 }
|
||||
} ;
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
int lookup_cmd(char *cmdtxt)
|
||||
{
|
||||
Command *pcmd;
|
||||
|
||||
pcmd = commands;
|
||||
while (pcmd->name) {
|
||||
if (!strcmp(pcmd->name, cmdtxt)) return pcmd->Cmd;
|
||||
pcmd++;
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
void list_tests(void)
|
||||
{
|
||||
Command *pcmd = commands;
|
||||
while (pcmd->name) {
|
||||
printf("%s\n", pcmd->name);
|
||||
pcmd++;
|
||||
}
|
||||
exit(0);
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
void help(int k)
|
||||
{
|
||||
Command *pcmd;
|
||||
|
||||
fprintf(stderr, "usage:\n\t./t [options] command [filename]\n");
|
||||
|
||||
fprintf(stderr, "options:\n");
|
||||
fprintf(stderr, "\t-k 1.414\tset float value\n");
|
||||
fprintf(stderr, "\t-l\t\tlist tests\n");
|
||||
fprintf(stderr, "\t-o \t\toutfile\n");
|
||||
|
||||
fprintf(stderr, "commands:\n");
|
||||
pcmd = commands;
|
||||
while (pcmd->name) {
|
||||
fprintf(stderr, "\t%-15s %d\n", pcmd->name, pcmd->Cmd);
|
||||
pcmd++;
|
||||
}
|
||||
fprintf(stderr, "\ncompiled on "__DATE__" at "__TIME__"\n");
|
||||
|
||||
exit(0);
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
int foo, opt;
|
||||
char *filename, *command, *outfile;
|
||||
|
||||
fprintf(stderr, "++++++++ test des fonctions pid=%d\n", getpid());
|
||||
fprintf(stderr, "++++++++ compiled "__DATE__" at " __TIME__ "\n");
|
||||
|
||||
global_fvalue = 1.0;
|
||||
outfile = "out.pnm";
|
||||
command = "none";
|
||||
filename = "in.fimg";
|
||||
|
||||
while ((opt = getopt(argc, argv, "hk:lo:p:v")) != -1) {
|
||||
// fprintf(stderr, "opt = %c\n", opt);
|
||||
switch(opt) {
|
||||
case 'h': help(0); break;
|
||||
case 'k': global_fvalue = atof(optarg); break;
|
||||
case 'l': list_tests(); break;
|
||||
case 'o': outfile = optarg; break;
|
||||
case 'v': verbosity++; break;
|
||||
}
|
||||
}
|
||||
|
||||
// fprintf(stderr, "argc %d optind %d\n", argc, optind);
|
||||
|
||||
switch (argc-optind) {
|
||||
case 1: /* only command */
|
||||
command = argv[optind];
|
||||
break;
|
||||
case 2:
|
||||
command = argv[optind];
|
||||
filename = argv[optind+1];
|
||||
break;
|
||||
default:
|
||||
fprintf(stderr, "%s: bad command line ?\n", argv[0]);
|
||||
help(1);
|
||||
break;
|
||||
}
|
||||
|
||||
if (verbosity) {
|
||||
fprintf(stderr, "++++++++ %s : running command '%s' on '%s'\n",
|
||||
argv[0], command, filename);
|
||||
fprintf(stderr, "global fvalue : %f\n", global_fvalue);
|
||||
}
|
||||
|
||||
opt = lookup_cmd(command);
|
||||
// fprintf(stderr, "lookup '%s' --> %d\n", command, opt);
|
||||
|
||||
switch(opt) {
|
||||
case Equalize:
|
||||
foo = essai_equalize(filename); break;
|
||||
case Sfx0:
|
||||
foo = essai_sfx0(filename); break;
|
||||
case F3x3:
|
||||
foo = essai_filtrage_3x3(filename); break;
|
||||
case MIRE:
|
||||
foo = essai_mire(filename, 0);
|
||||
break;
|
||||
case Wfits:
|
||||
foo = essai_ecriture_fits("out.fits");
|
||||
break;
|
||||
case Wpng:
|
||||
foo = essai_ecriture_png("out.png");
|
||||
break;
|
||||
case Wtiff:
|
||||
foo = essai_ecriture_tiff("out.tiff");
|
||||
break;
|
||||
case Histo:
|
||||
foo = essai_histogramme(filename, 98765);
|
||||
break;
|
||||
case Hsv:
|
||||
// not ready for primtime
|
||||
// foo = fimg_essai_hsv(filename);
|
||||
foo = 0;
|
||||
break;
|
||||
case Classif:
|
||||
foo = essai_classif(filename, outfile, global_fvalue);
|
||||
break;
|
||||
case Ctr2x2:
|
||||
foo = essai_contour_2x2(filename, outfile);
|
||||
break;
|
||||
case Qsortrgb:
|
||||
foo = essai_qsort_rgb(filename, outfile);
|
||||
break;
|
||||
case Displace:
|
||||
foo = essai_displacement(filename, outfile);
|
||||
break;
|
||||
case ReadPNG:
|
||||
// not ready for primetime
|
||||
// foo = essai_lecture_png("in.png", outfile, 0);
|
||||
foo = 0;
|
||||
break;
|
||||
case Plasmas:
|
||||
foo = essai_plasma(filename, outfile, 1, global_fvalue);
|
||||
fprintf(stderr, "we are all plasmafields\n");
|
||||
break;
|
||||
case Rotate:
|
||||
fprintf(stderr, "rotate not implemented (%d)\n", rand());
|
||||
foo = 0;
|
||||
break;
|
||||
case Hilight:
|
||||
foo = essai_highlights(filename, outfile, 0, global_fvalue);
|
||||
break;
|
||||
case OpenEXR:
|
||||
foo = essai_openexr(filename, outfile, 0x55);
|
||||
break;
|
||||
case Geometrie:
|
||||
foo = essai_geometrie(filename, 0);
|
||||
break;
|
||||
case FileType:
|
||||
foo = essai_detect_type();
|
||||
break;
|
||||
case Mirror:
|
||||
foo = essai_miroir(filename, outfile, 0);
|
||||
break;
|
||||
default:
|
||||
fprintf(stderr, "'%s' is a bad command\n", command);
|
||||
exit(1);
|
||||
|
||||
}
|
||||
|
||||
if (foo) {
|
||||
fprintf(stderr, "******* Essai --> %d\n", foo);
|
||||
}
|
||||
|
||||
fprintf(stderr, "++++++++++++ end of '%s' pid %d\n", command, getpid());
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
830
src/funcs/tests.c
Normal file
830
src/funcs/tests.c
Normal file
@@ -0,0 +1,830 @@
|
||||
/*
|
||||
* tests des fonctions diverses - subroutines
|
||||
see also: t.c
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <pam.h>
|
||||
|
||||
#undef DEBUG_LEVEL
|
||||
#define DEBUG_LEVEL 1
|
||||
|
||||
#include "../floatimg.h"
|
||||
#include "tests.h"
|
||||
|
||||
extern int verbosity;
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
|
||||
int fimg_recursion_proto(FloatImg *src, FloatImg *dst, int notused);
|
||||
|
||||
int essai_recursion(char *inf, char *outf, int flags)
|
||||
{
|
||||
int foo;
|
||||
FloatImg src, dst;
|
||||
|
||||
fprintf(stderr, ">>> %s ( '%s' '%s' 0x%04X )\n", __func__,
|
||||
inf, outf, flags);
|
||||
|
||||
foo = fimg_create_from_dump(inf, &src);
|
||||
if (0 != foo) {
|
||||
fprintf(stderr, "%s: err %d loading image '%s'\n", __func__,
|
||||
foo, inf);
|
||||
return foo;
|
||||
}
|
||||
|
||||
fimg_clone(&src, &dst, 0);
|
||||
|
||||
foo = fimg_recursion_proto(&src, &dst, flags);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: fail %d\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
foo = fimg_export_picture(&dst, outf, 0);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s : err %d saving result\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
int essai_miroir(char *inf, char *outf, int flags)
|
||||
{
|
||||
int foo;
|
||||
FloatImg src, dst;
|
||||
|
||||
fprintf(stderr, ">>> %s ( '%s' '%s' 0x%X )\n", __func__,
|
||||
inf, outf, flags);
|
||||
|
||||
foo = fimg_create_from_dump(inf, &src);
|
||||
if (0 != foo) {
|
||||
fprintf(stderr, "%s: err %d loading image '%s'\n", __func__,
|
||||
foo, inf);
|
||||
return foo;
|
||||
}
|
||||
|
||||
fimg_clone(&src, &dst, 0);
|
||||
|
||||
/* run the crappy code */
|
||||
foo = fimg_mirror(&src, &dst, 0);
|
||||
if (foo) {
|
||||
fprintf(stderr, "err %d in fimg_mirrot\n", foo);
|
||||
return -6;
|
||||
}
|
||||
|
||||
foo = fimg_export_picture(&dst, outf, 0);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s : err %d saving result\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
/* nouveau 21 mars 2021 - rue d'Aragon */
|
||||
int essai_openexr(char *inf, char *outf, int flags)
|
||||
{
|
||||
FloatImg src;
|
||||
int foo;
|
||||
|
||||
fprintf(stderr, ">>> %s ( '%s' '%s' 0x%X )\n", __func__,
|
||||
inf, outf, flags);
|
||||
|
||||
foo = fimg_create_from_dump(inf, &src);
|
||||
if (0 != foo) {
|
||||
fprintf(stderr, "%s: err %d loading image '%s'\n", __func__,
|
||||
foo, inf);
|
||||
return foo;
|
||||
}
|
||||
// fprintf(stderr, "image loaded at %p\n", &src);
|
||||
fimg_describe(&src, "for save EXR test");
|
||||
|
||||
foo = fimg_save_as_exr(&src, outf, flags);
|
||||
|
||||
fimg_destroy(&src);
|
||||
|
||||
return -2;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
/* nouveau 20 mars 2021 - rue d'Aragon */
|
||||
int essai_highlights(char *inf, char *outf, int ikoef, float fkoef)
|
||||
{
|
||||
FloatImg src, dst;
|
||||
int foo;
|
||||
|
||||
fprintf(stderr, ">>> %s ( '%s' '%s' %d %g )\n", __func__,
|
||||
inf, outf, ikoef, fkoef);
|
||||
|
||||
foo = fimg_create_from_dump(inf, &src);
|
||||
if (0 != foo) {
|
||||
fprintf(stderr, "%s: err %d loading image '%s'\n", __func__,
|
||||
foo, inf);
|
||||
return foo;
|
||||
}
|
||||
|
||||
fimg_clone(&src, &dst, 0);
|
||||
|
||||
foo = fimg_highlight_color(&src, &dst, 'R', fkoef);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: err %d ?\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
foo = fimg_export_picture(&dst, outf, 0);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s : err %d saving result\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
|
||||
int essai_plasma(char *infile, char *outfile, int ikoef, float fkoef)
|
||||
{
|
||||
FloatImg src, dst;
|
||||
int foo;
|
||||
|
||||
fprintf(stderr, ">>> %s ( '%s' '%s' %d %g )\n", __func__,
|
||||
infile, outfile, ikoef, fkoef);
|
||||
|
||||
/* if infile is loadable, use it for background */
|
||||
foo = fimg_create_from_dump(infile, &src);
|
||||
if (0 == foo) {
|
||||
fprintf(stderr, "%s: image '%s' loaded\n", __func__, infile);
|
||||
}
|
||||
else {
|
||||
/* make a fancy synthetic picture */
|
||||
foo = fimg_create(&src, 800, 600, FIMG_TYPE_RGB);
|
||||
}
|
||||
|
||||
fimg_printhead(&src);
|
||||
fimg_clone(&src, &dst, 1);
|
||||
|
||||
foo = fimg_prototype_plasma(&dst, fkoef, 0);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: err %d on plasma proto\n", __func__, foo);
|
||||
return -88;
|
||||
}
|
||||
|
||||
fimg_mul_3(&src, &dst, &dst);
|
||||
|
||||
foo = fimg_export_picture(&dst, outfile, 0);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s : err %d saving result\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
/* nouveau 24 octobre 2020, pendant le masque-flamme coronavidique */
|
||||
|
||||
int essai_displacement(char *infile, char *outfile)
|
||||
{
|
||||
int foo;
|
||||
FloatImg src, dst;
|
||||
|
||||
fprintf(stderr, "%s : loading %s\n", __func__, infile);
|
||||
foo = fimg_create_from_dump(infile, &src);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: error loading '%s'\n", __func__, infile);
|
||||
return foo;
|
||||
}
|
||||
|
||||
fimg_clone(&src, &dst, 1);
|
||||
|
||||
foo = fimg_displacement_0(&src, &dst, 0);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: err %d in disp map 0\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
foo = fimg_export_picture(&dst, outfile, 0);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s : err %d saving result\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
/*
|
||||
* nouveau 7 octobre 2020 pendant sonoptic
|
||||
*
|
||||
* inspiration: Olivier Baudu
|
||||
*/
|
||||
|
||||
int essai_qsort_rgb(char *infile, char *outfile)
|
||||
{
|
||||
FloatImg src, dst;
|
||||
int foo;
|
||||
|
||||
if (NULL != infile) {
|
||||
fprintf(stderr, "%s : loading %s\n", __func__, infile);
|
||||
foo = fimg_create_from_dump(infile, &src);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: error loading '%s'\n", __func__, infile);
|
||||
return foo;
|
||||
}
|
||||
}
|
||||
else {
|
||||
fprintf(stderr, "%s : NOT INPUT FILE, FUBAR\n", __func__);
|
||||
abort();
|
||||
}
|
||||
|
||||
fimg_clone(&src, &dst, 1);
|
||||
|
||||
foo = fimg_qsort_rgb_b(&src, &dst, 0);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: err %d in qsort_rgb\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
foo = fimg_export_picture(&dst, outfile, 0);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s : err %d saving result\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
fimg_destroy(&src); fimg_destroy(&dst);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
/*
|
||||
* nouveau 5 octobre 2020 pendant sonoptic
|
||||
*/
|
||||
|
||||
int essai_contour_2x2(char *infile, char *outfile)
|
||||
{
|
||||
FloatImg src, dst;
|
||||
int foo;
|
||||
|
||||
if (NULL != infile) {
|
||||
fprintf(stderr, "%s : loading %s\n", __func__, infile);
|
||||
foo = fimg_create_from_dump(infile, &src);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: error loading '%s'\n", __func__, infile);
|
||||
return foo;
|
||||
}
|
||||
}
|
||||
else {
|
||||
fprintf(stderr, "%s : NOT INPUT FILE, FUBAR\n", __func__);
|
||||
abort();
|
||||
}
|
||||
|
||||
fimg_clone(&src, &dst, 1);
|
||||
|
||||
foo = fimg_contour_2x2(&src, &dst, 0);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: err %d in contour_2x2\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
foo = fimg_export_picture(&dst, outfile, 0);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s : err %d saving result\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
fimg_destroy(&src); fimg_destroy(&dst);
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
/*
|
||||
* nouveau 5 octobre 2020 pendant sonoptic
|
||||
*/
|
||||
int essai_classif(char *infile, char *outfile, float fvalue)
|
||||
{
|
||||
FloatImg src, dst;
|
||||
int foo;
|
||||
|
||||
if (NULL != infile) {
|
||||
fprintf(stderr, "%s : loading %s\n", __func__, infile);
|
||||
foo = fimg_create_from_dump(infile, &src);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: error loading '%s'\n", __func__, infile);
|
||||
return foo;
|
||||
}
|
||||
}
|
||||
else {
|
||||
fprintf(stderr, "%s : NOT INPUT FILE, FUBAR\n", __func__);
|
||||
abort();
|
||||
}
|
||||
|
||||
fimg_clone(&src, &dst, 1);
|
||||
|
||||
fprintf(stderr, "%s : fvalue is %f\n", __func__, fvalue);
|
||||
|
||||
foo = fimg_classif_trial(&src, &dst, fvalue, 0);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: err %d in classif_trial\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
foo = fimg_export_picture(&dst, outfile, 0);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s : err %d saving result\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
fimg_destroy(&src); fimg_destroy(&dst);
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
/* nouveau 19 aout 2020, le matin avant la canicule */
|
||||
|
||||
int essai_ecriture_tiff(char *outname)
|
||||
{
|
||||
int foo;
|
||||
FloatImg picz;
|
||||
|
||||
fimg_create(&picz, 800, 600, FIMG_TYPE_RGB);
|
||||
fimg_test_pattern(&picz, 0, 22222);
|
||||
|
||||
foo = fimg_write_as_tiff(&picz, outname, 0);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s got a %d\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
/* essai de fichiers FITS (astronomie) */
|
||||
int essai_ecriture_fits(char *outname)
|
||||
{
|
||||
FloatImg src;
|
||||
int foo;
|
||||
|
||||
fprintf(stderr, "%s is creating the picz\n", __func__);
|
||||
fimg_create(&src, 512, 512, FIMG_TYPE_RGB);
|
||||
fimg_test_pattern(&src, 0, 255.0);
|
||||
|
||||
foo = fimg_save_R_as_fits(&src, outname, 0);
|
||||
|
||||
fprintf(stderr, "saving '%s' to fits --> %d\n", outname, foo);
|
||||
|
||||
return -1;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
/*
|
||||
* egalisation dynamique approximative
|
||||
* #coronamaison Thu 09 Apr 2020 03:37:10 PM CEST
|
||||
*/
|
||||
int essai_equalize(char *infile)
|
||||
{
|
||||
FloatImg src;
|
||||
int foo;
|
||||
|
||||
if (NULL != infile) {
|
||||
fprintf(stderr, "%s: loading %s\n", __func__, infile);
|
||||
foo = fimg_create_from_dump(infile, &src);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: err load '%s'\n", __func__, infile);
|
||||
return foo;
|
||||
}
|
||||
}
|
||||
else {
|
||||
fprintf(stderr, "%s : NOT INPUT FILE, FUBAR\n", __func__);
|
||||
abort();
|
||||
}
|
||||
|
||||
/*
|
||||
* XXX need more work on this function !
|
||||
*/
|
||||
foo = fimg_equalize_compute(&src, NULL, 666.666);
|
||||
fprintf(stderr, "equalize compute --> %d\n", foo);
|
||||
|
||||
fimg_destroy(&src);
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
int essai_rotate(char *infile)
|
||||
{
|
||||
FloatImg src, dst;
|
||||
int foo;
|
||||
|
||||
if (NULL != infile) {
|
||||
fprintf(stderr, "%s: loading %s\n", __func__, infile);
|
||||
foo = fimg_create_from_dump(infile, &src);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: err load '%s'\n", __func__, infile);
|
||||
return foo;
|
||||
}
|
||||
}
|
||||
else {
|
||||
fprintf(stderr, "%s : NOT INPUT FILE, FUBAR\n", __func__);
|
||||
abort();
|
||||
}
|
||||
|
||||
fimg_save_as_png(&src, "test.png", 0);
|
||||
|
||||
foo = fimg_rotate_90(&src, &dst, 0);
|
||||
fprintf(stderr, "rotate 90 -> %d\n", foo);
|
||||
|
||||
foo = fimg_export_picture(&dst, "rotated90.png", 0);
|
||||
foo = fimg_export_picture(&dst, "rotated90.pnm", 0);
|
||||
|
||||
fimg_destroy(&src);
|
||||
|
||||
return -1;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
int essai_filtrage_3x3(char *infile)
|
||||
{
|
||||
FloatImg src, dst;
|
||||
int foo; /// , idx;
|
||||
// char buffer[100];
|
||||
|
||||
FimgFilter3x3 filter_a = {
|
||||
|
||||
{ 1.0, 1.0, 1.0,
|
||||
1.0, -3.0, 1.0,
|
||||
1.0, 1.0, 1.0 },
|
||||
9.0, 0.0
|
||||
|
||||
};
|
||||
|
||||
FimgFilter3x3 filter_b = {
|
||||
|
||||
{ -2.0, -1.0, 0.0,
|
||||
-1.0, 3.0, 1.0,
|
||||
0.0, 1.0, 2.0 },
|
||||
8.0, 0.0
|
||||
|
||||
};
|
||||
|
||||
FimgFilter3x3 filter_c = {
|
||||
{
|
||||
2.0, 1.0, 0.0,
|
||||
1.0, 0.0, -1.0,
|
||||
0.0, -1.0, -2.0,
|
||||
},
|
||||
1.0, 8.0
|
||||
};
|
||||
|
||||
if (NULL != infile) {
|
||||
fprintf(stderr, "%s: loading %s\n", __func__, infile);
|
||||
foo = fimg_create_from_dump(infile, &src);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: err load '%s'\n", __func__, infile);
|
||||
return foo;
|
||||
}
|
||||
}
|
||||
else {
|
||||
fprintf(stderr, "%s is creating the picz\n", __func__);
|
||||
fimg_create(&src, 640, 480, FIMG_TYPE_RGB);
|
||||
fimg_test_pattern(&src, 0, 255.0);
|
||||
}
|
||||
|
||||
// fimg_save_as_png(&src, "test.png", 0);
|
||||
foo = fimg_count_negativ(&src);
|
||||
fprintf(stderr, "%s: source have %d negs\n", __func__, foo);
|
||||
|
||||
foo = fimg_clone(&src, &dst, 0);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: err clone %p\n", __func__, &src);
|
||||
return -44;
|
||||
}
|
||||
|
||||
fimg_filter_3x3(&src, &dst, &filter_a);
|
||||
foo = fimg_clamp_negativ(&dst);
|
||||
if (foo) {
|
||||
fprintf(stderr, "A clamped %d negative pixels\n", foo);
|
||||
}
|
||||
foo = fimg_save_as_png(&dst, "f3x3a.png", 0);
|
||||
// foo = fimg_save_as_pnm(&dst, "f3x3a.pnm", 0);
|
||||
|
||||
fimg_filter_3x3(&src, &dst, &filter_b);
|
||||
foo = fimg_clamp_negativ(&dst);
|
||||
if (foo) {
|
||||
fprintf(stderr, "B clamped %d negative pixels\n", foo);
|
||||
}
|
||||
foo = fimg_save_as_png(&dst, "f3x3b.png", 0);
|
||||
// foo = fimg_save_as_pnm(&dst, "f3x3a.pnm", 0);
|
||||
|
||||
fimg_filter_3x3(&src, &dst, &filter_c);
|
||||
foo = fimg_clamp_negativ(&dst);
|
||||
if (foo) {
|
||||
fprintf(stderr, "C clamped %d negative pixels\n", foo);
|
||||
}
|
||||
foo = fimg_save_as_png(&dst, "f3x3b.png", 0);
|
||||
// foo = fimg_save_as_pnm(&dst, "f3x3a.pnm", 0);
|
||||
|
||||
fimg_destroy(&src); fimg_destroy(&dst);
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
int essai_filtrage_2x2(char *infile)
|
||||
{
|
||||
FloatImg fimg;
|
||||
int foo, idx;
|
||||
char buffer[100];
|
||||
|
||||
if (NULL != infile) {
|
||||
fprintf(stderr, "%s: loading %s\n", __func__, infile);
|
||||
foo = fimg_create_from_dump(infile, &fimg);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: err load '%s'\n", __func__, infile);
|
||||
return foo;
|
||||
}
|
||||
}
|
||||
else {
|
||||
fprintf(stderr, "%s is creating the picz\n", __func__);
|
||||
fimg_create(&fimg, 512, 512, FIMG_TYPE_RGB);
|
||||
fimg_draw_something(&fimg);
|
||||
}
|
||||
|
||||
foo = fimg_save_as_pnm(&fimg, "source.pnm", 0);
|
||||
|
||||
/*
|
||||
* running multiple filters so you can
|
||||
* watch the up-left shift :)
|
||||
*/
|
||||
for (idx=0; idx<5; idx++) {
|
||||
foo = fimg_lissage_2x2(&fimg);
|
||||
sprintf(buffer, "filter%03d.png", idx);
|
||||
foo = fimg_save_as_png(&fimg, buffer, 0);
|
||||
if (verbosity) {
|
||||
fprintf(stderr, "%s %d\n", buffer, foo);
|
||||
}
|
||||
}
|
||||
|
||||
fimg_destroy(&fimg);
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
int essai_geometrie(char *infile, int notused)
|
||||
{
|
||||
FloatImg fimg, result;
|
||||
int foo;
|
||||
|
||||
if (NULL != infile) {
|
||||
fprintf(stderr, "loading %s\n", infile);
|
||||
foo = fimg_create_from_dump(infile, &fimg);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: err load '%s'\n", __func__, infile);
|
||||
return foo;
|
||||
}
|
||||
}
|
||||
else {
|
||||
fimg_create(&fimg, 512, 512, FIMG_TYPE_RGB);
|
||||
fimg_draw_something(&fimg);
|
||||
}
|
||||
|
||||
// foo = fimg_save_as_pnm(&fimg, "source.pnm", 0);
|
||||
|
||||
memset(&result, 0, sizeof(FloatImg));
|
||||
|
||||
foo = fimg_halfsize_0(&fimg, &result, 0);
|
||||
fprintf(stderr, "retour halfsize 0 -> %d\n", foo);
|
||||
if (foo) {
|
||||
return -2;
|
||||
}
|
||||
if (verbosity) fimg_describe(&result, "result after halfsize 0");
|
||||
foo = fimg_save_as_pnm(&result, "halfsize0.pnm", 0);
|
||||
|
||||
fimg_destroy(&result);
|
||||
foo = fimg_halfsize_1(&fimg, &result, 0);
|
||||
fprintf(stderr, "retour halfsize 1 -> %d\n", foo);
|
||||
if (foo) {
|
||||
return -2;
|
||||
}
|
||||
if (verbosity) fimg_describe(&result, "result after halfsize 1");
|
||||
foo = fimg_save_as_pnm(&result, "halfsize1.pnm", 0);
|
||||
|
||||
/* hop, un peu de nettoyage */
|
||||
fimg_destroy(&result); fimg_destroy(&fimg);
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
int essai_sfx0(char *infile)
|
||||
{
|
||||
FloatImg fimg;
|
||||
int foo;
|
||||
|
||||
if (NULL != infile) {
|
||||
fprintf(stderr, "loading %s\n", infile);
|
||||
foo = fimg_create_from_dump(infile, &fimg);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: err load '%s'\n", __func__, infile);
|
||||
return foo;
|
||||
}
|
||||
}
|
||||
else {
|
||||
fimg_create(&fimg, 512, 512, FIMG_TYPE_RGB);
|
||||
fimg_draw_something(&fimg);
|
||||
}
|
||||
|
||||
foo = fimg_save_as_pnm(&fimg, "something.pnm", 0);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: err save %d\n", __func__, foo);
|
||||
return -6;
|
||||
}
|
||||
foo = fimg_killcolors_a(&fimg, 0.0);
|
||||
foo = fimg_save_as_pnm(&fimg, "colorskilled-a.pnm", 0);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: err save %d\n", __func__, foo);
|
||||
return -6;
|
||||
}
|
||||
|
||||
foo = fimg_killcolors_b(&fimg, 0.0);
|
||||
foo = fimg_save_as_pnm(&fimg, "colorskilled-b.pnm", 0);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: err save %d\n", __func__, foo);
|
||||
return -6;
|
||||
}
|
||||
|
||||
fimg_destroy(&fimg);
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
int essai_parse_double(void)
|
||||
{
|
||||
int foo;
|
||||
double dval;
|
||||
char *str;
|
||||
|
||||
str = "12.34"; dval = 0.0;
|
||||
foo = parse_double(str, &dval);
|
||||
printf("%-10s -> %3d %g\n", str, foo, dval);
|
||||
|
||||
str = "12e4"; dval = 0.0;
|
||||
foo = parse_double(str, &dval);
|
||||
printf("%-10s -> %3d %g\n", str, foo, dval);
|
||||
|
||||
str = "5s"; dval = 0.0;
|
||||
foo = parse_double(str, &dval);
|
||||
printf("%-10s -> %3d %g\n", str, foo, dval);
|
||||
|
||||
str = "PORN"; dval = 0.0;
|
||||
foo = parse_double(str, &dval);
|
||||
printf("%-10s -> %3d %g\n", str, foo, dval);
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
int essai_detect_type(void)
|
||||
{
|
||||
int foo;
|
||||
char *fname;
|
||||
|
||||
foo = format_from_extension(fname="foo.fimg");
|
||||
printf("%-10s %3d\n", fname, foo);
|
||||
|
||||
foo = format_from_extension(fname="foo.pnm");
|
||||
printf("%-10s %3d\n", fname, foo);
|
||||
|
||||
foo = format_from_extension(fname="foo.png");
|
||||
printf("%-10s %3d\n", fname, foo);
|
||||
|
||||
foo = format_from_extension(fname="foo.tiff");
|
||||
printf("%-10s %3d\n", fname, foo);
|
||||
|
||||
foo = format_from_extension(fname="foo.fits");
|
||||
printf("%-10s %3d\n", fname, foo);
|
||||
|
||||
foo = format_from_extension(fname="foo.xyzzy");
|
||||
printf("%-10s %3d\n", fname, foo);
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
int essai_mire(char *outname, int notused)
|
||||
{
|
||||
FloatImg fimg;
|
||||
int re, foo;
|
||||
|
||||
fimg_create(&fimg, 1280, 960, FIMG_TYPE_RGB);
|
||||
|
||||
re = fimg_test_pattern(&fimg, 9, 1.0);
|
||||
if (re) {
|
||||
fprintf(stderr, "fimg_test_pattern -> %d\n", re);
|
||||
}
|
||||
foo = fimg_export_picture(&fimg, "mire.pnm", 0);
|
||||
fprintf(stderr, "in %s, export give a %d value\n", __func__, foo);
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
int essai_rampes(void)
|
||||
{
|
||||
FloatImg fimg;
|
||||
int foo;
|
||||
|
||||
fimg_create(&fimg, 640, 480, FIMG_TYPE_RGB);
|
||||
|
||||
#define V ((double)3.141592654)
|
||||
|
||||
foo = fimg_hdeg_a(&fimg, V);
|
||||
fprintf(stderr, "make h deg -> %d\n", foo);
|
||||
foo = fimg_save_as_pnm(&fimg, "hdeg.pnm", 0);
|
||||
fprintf(stderr, "%s: save as pnm -> %d\n", __func__, foo);
|
||||
|
||||
|
||||
foo = fimg_vdeg_a(&fimg, V);
|
||||
fprintf(stderr, "make h deg -> %d\n", foo);
|
||||
foo = fimg_save_as_pnm(&fimg, "vdeg_a.pnm", 0);
|
||||
fprintf(stderr, "%s: save as pnm -> %d\n", __func__, foo);
|
||||
|
||||
foo = fimg_vdeg_a(&fimg, -V);
|
||||
fprintf(stderr, "make h deg -> %d\n", foo);
|
||||
foo = fimg_save_as_pnm(&fimg, "vdeg_b.pnm", 0);
|
||||
fprintf(stderr, "%s: save as pnm -> %d\n", __func__, foo);
|
||||
|
||||
#undef V
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
int essai_lecture_png(char *fname, char *outfile, int notused)
|
||||
{
|
||||
FloatImg fimg;
|
||||
int foo;
|
||||
|
||||
fprintf(stderr, ">>> %s ( '%s' %d )\n", __func__, fname, notused);
|
||||
|
||||
memset(&fimg, 0, sizeof(FloatImg));
|
||||
foo = fimg_create_from_png(fname, &fimg);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: createfrom -> %d\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
fimg_describe(&fimg, "created from png");
|
||||
|
||||
foo = fimg_export_picture(&fimg, outfile, 0);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s : err %d saving result to %s\n", __func__,
|
||||
foo, outfile);
|
||||
return foo;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
int essai_ecriture_png(char *fname)
|
||||
{
|
||||
FloatImg fimg;
|
||||
int foo;
|
||||
|
||||
fimg_create(&fimg, 800, 600, FIMG_TYPE_RGB);
|
||||
|
||||
fimg_draw_something(&fimg);
|
||||
|
||||
if (verbosity) {
|
||||
foo = fimg_save_as_pnm(&fimg, "quux.pnm", 0);
|
||||
fprintf(stderr, "%s: saved as pnm -> %d\n", __func__, foo);
|
||||
}
|
||||
|
||||
foo = fimg_save_as_png(&fimg, fname, 0);
|
||||
fprintf(stderr, "save as png -> %d\n", foo);
|
||||
|
||||
fimg_destroy(&fimg);
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
|
||||
int fimg_essai_hsv(char *fname); /* hsv.c */
|
||||
|
||||
|
||||
int essai_histogramme(char *fname, int k)
|
||||
{
|
||||
FloatImg fimg;
|
||||
int foo;
|
||||
|
||||
fprintf(stderr, ">>> %s ( '%s' %d )\n", __func__, fname, k);
|
||||
|
||||
foo = fimg_create_from_dump(fname, &fimg);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: err load '%s'\n", __func__, fname);
|
||||
return foo;
|
||||
}
|
||||
|
||||
foo = fimg_essai_histo(&fimg, "out.png", k);
|
||||
if (foo) {
|
||||
fprintf(stderr, "essai_histo -> error %d\n", foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
fimg_destroy(&fimg);
|
||||
|
||||
fprintf(stderr, "\\o/ end of %s\n", __func__);
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
/* --------------------------------------------------------------------- */
|
||||
32
src/funcs/tests.h
Normal file
32
src/funcs/tests.h
Normal file
@@ -0,0 +1,32 @@
|
||||
/*
|
||||
* tests des fonctions diverses - prototypes
|
||||
see also: t.c & tests.c
|
||||
*/
|
||||
|
||||
int essai_plasma(char *infile, char *outfile, int ikoef, float fkoef);
|
||||
int essai_miroir(char *inf, char *outf, int flags);
|
||||
|
||||
int essai_displacement(char *infile, char *outfile);
|
||||
int essai_qsort_rgb(char *infile, char *outfile);
|
||||
int essai_equalize(char *infile);
|
||||
int essai_ecriture_fits(char *outname);
|
||||
int essai_rotate(char *infile);
|
||||
int essai_filtrage_2x2(char *infile);
|
||||
int essai_filtrage_3x3(char *infile);
|
||||
int essai_sfx0(char *infile);
|
||||
int essai_mire(char *infile, int wtf);
|
||||
int essai_ecriture_png(char *infile);
|
||||
int essai_ecriture_tiff(char *infile);
|
||||
int fimg_essai_hsv(char *infile);
|
||||
int essai_classif(char *infile, char *outfile, float fvalue);
|
||||
int essai_contour_2x2(char *filename, char *outfile);
|
||||
int essai_geometrie(char *infile, int notused);
|
||||
int essai_detect_type(void);
|
||||
int fimg_essai_histo(FloatImg *src, char *outpic, int k); /* histogram.c */
|
||||
int essai_histogramme(char *fname, int k);
|
||||
|
||||
int essai_lecture_png(char *fname, char *outfile, int notused);
|
||||
|
||||
int essai_highlights(char *inf, char *outf, int ikoef, float fkoef);
|
||||
int essai_openexr(char *inf, char *outf, int flags);
|
||||
|
||||
28
src/funcs/tpnm.c
Normal file
28
src/funcs/tpnm.c
Normal file
@@ -0,0 +1,28 @@
|
||||
/*
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <pam.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
int fimg_pnm_infos(char *);
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
int foo;
|
||||
char *infile = "foo.pnm";
|
||||
|
||||
pnm_init(&argc, argv);
|
||||
|
||||
if (2 == argc) infile = argv[1];
|
||||
|
||||
foo = fimg_pnm_infos(infile);
|
||||
fprintf(stderr, "got %d\n", foo);
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
140
src/funcs/utils.c
Normal file
140
src/funcs/utils.c
Normal file
@@ -0,0 +1,140 @@
|
||||
/*
|
||||
* FloatImg from tTh - 2021
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
extern int verbosity; /* must be declared around main() */
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
void fimg_print_minmax(float minmax[6], char *titre)
|
||||
{
|
||||
|
||||
fprintf(stderr, "\t\tminmax %s\n", titre);
|
||||
fprintf(stderr, "red\t\t%10f %10f\n", minmax[0], minmax[1]);
|
||||
fprintf(stderr, "green\t\t%10f %10f\n", minmax[2], minmax[3]);
|
||||
fprintf(stderr, "blue\t\t%10f %10f\n", minmax[4], minmax[5]);
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
int parse_WxH(char *str, int *pw, int *ph)
|
||||
{
|
||||
// char *ptr;
|
||||
int foo, w, h;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( '%s' %p %p )\n", __func__,
|
||||
str, pw, ph);
|
||||
#endif
|
||||
|
||||
foo = sscanf(str, "%dx%d", &w, &h);
|
||||
if (2 != foo) {
|
||||
fprintf(stderr, "%s : arg '%s' is invalid\n", __func__, str);
|
||||
return foo;
|
||||
}
|
||||
*pw = w; *ph = h;
|
||||
|
||||
return 2;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
int parse_double(char *str, double *dptr)
|
||||
{
|
||||
double value;
|
||||
int foo;
|
||||
|
||||
foo = sscanf(str, "%lf", &value);
|
||||
if (1 == foo) {
|
||||
*dptr = value;
|
||||
return 1;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
int file_type_from_name(char *name)
|
||||
{
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( '%s' )\n", __func__, name);
|
||||
#endif
|
||||
|
||||
if (!strcasecmp(name, "pnm" )) return FILE_TYPE_PNM;
|
||||
if (!strcasecmp(name, "fimg")) return FILE_TYPE_FIMG;
|
||||
if (!strcasecmp(name, "tga" )) return FILE_TYPE_TGA;
|
||||
if (!strcasecmp(name, "png" )) return FILE_TYPE_PNG;
|
||||
if (!strcasecmp(name, "tiff")) return FILE_TYPE_TIFF;
|
||||
if (!strcasecmp(name, "tif" )) return FILE_TYPE_TIFF;
|
||||
if (!strcasecmp(name, "fits")) return FILE_TYPE_FITS;
|
||||
if (!strcasecmp(name, "exr")) return FILE_TYPE_EXR;
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
int print_rectangle(char *str, FimgArea51 *rect)
|
||||
{
|
||||
printf("rect @ %p '%s':\n\t %dx%d at %d,%d\n", rect, str,
|
||||
rect->w, rect->h, rect->x, rect->y);
|
||||
return 0;
|
||||
}
|
||||
/* ---------------------------------------------- ~~~~~~~~~~~~~~~~ */
|
||||
/*
|
||||
* /!\ return 4 on success
|
||||
*/
|
||||
int parse_rectangle(char *str, FimgArea51 *r, int notused)
|
||||
{
|
||||
int x, y, w, h, foo;
|
||||
|
||||
if (verbosity)
|
||||
fprintf(stderr, "parsing %s\n", str);
|
||||
|
||||
foo = sscanf(str, "%d,%d,%d,%d", &w, &h, &x, &y);
|
||||
if (4 == foo) {
|
||||
r->x = x, r->y = y, r->w = w, r->h = h;
|
||||
return 4;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
int format_from_extension(char *fname)
|
||||
{
|
||||
char *cptr;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( '%s' )\n", __func__, fname);
|
||||
#endif
|
||||
|
||||
cptr = rindex(fname, '.');
|
||||
if (NULL==cptr) {
|
||||
fprintf(stderr, "No dot in %s\n", fname);
|
||||
return -1;
|
||||
}
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, "\t[%s] --> [%s]\n", fname, cptr);
|
||||
#endif
|
||||
|
||||
return file_type_from_name(cptr+1);
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
char * extension_from_format(int fmt)
|
||||
{
|
||||
|
||||
switch (fmt) {
|
||||
case FILE_TYPE_FIMG: return ".fimg"; break;
|
||||
case FILE_TYPE_PNM: return ".pnm"; break;
|
||||
case FILE_TYPE_PNG: return ".png"; break;
|
||||
case FILE_TYPE_TIFF: return ".tiff"; break;
|
||||
case FILE_TYPE_FITS: return ".fits"; break;
|
||||
case FILE_TYPE_TGA: return ".tga"; break;
|
||||
|
||||
default:
|
||||
fprintf(stderr, "%s: bad %d fmt type\n", __func__, fmt);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return "???";
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
43
src/funcs/vroum.sh
Executable file
43
src/funcs/vroum.sh
Executable file
@@ -0,0 +1,43 @@
|
||||
#!/bin/bash
|
||||
|
||||
src=/dev/shm/foo.fimg
|
||||
out=out.fimg
|
||||
device=/dev/video2
|
||||
|
||||
maxi=59
|
||||
W="320"
|
||||
H="240"
|
||||
grabopt=" -s ${W}x${H} -vv -u -d $device -p 0 -n 30
|
||||
0 -c none "
|
||||
|
||||
mkdir /tmp/V
|
||||
rm /tmp/V/*
|
||||
|
||||
G=$(printf "%dx%d+0+0" $W $H)
|
||||
|
||||
for foo in $(seq 0 $maxi)
|
||||
do
|
||||
|
||||
echo ; echo
|
||||
|
||||
grabvidseq -$grabopt -o $src
|
||||
|
||||
fval=$(echo "$foo / $maxi * 13.56636" | bc -l)
|
||||
echo ; echo $foo ' => ' $fval
|
||||
|
||||
./t -vv -k $fval -o $out plasma $src
|
||||
|
||||
# fimgstats $out
|
||||
|
||||
dst=$(printf "/tmp/V/%03d.png" $foo)
|
||||
echo $dst
|
||||
montage $src $out -tile 1x2 -geometry $G $dst
|
||||
|
||||
sleep 55
|
||||
|
||||
done
|
||||
|
||||
convert -delay 10 /tmp/V/*.png foo.gif
|
||||
|
||||
rm /tmp/V/*
|
||||
|
||||
Reference in New Issue
Block a user