forked from tTh/FloatImg
Merge branch 'master' of ssh://tetalab.org:2213/tTh/FloatImg
something is broken ?
This commit is contained in:
commit
aa42aa99fb
1
.gitignore
vendored
1
.gitignore
vendored
@ -27,6 +27,7 @@ doc/co*.tex
|
||||
funcs/t
|
||||
funcs/*.o
|
||||
funcs/*.png
|
||||
funcs/V/*
|
||||
funcs/*.gif
|
||||
funcs/*.fits
|
||||
funcs/*.tiff
|
||||
|
||||
@ -412,7 +412,7 @@ foo = fimg_create_from_dump("lena.fimg", &head);
|
||||
\end{lstlisting}
|
||||
|
||||
Si la valeur retournée est différente de 0, c'est que quelque
|
||||
chose s'est mal passé.
|
||||
chose s'est probablement mal passé.
|
||||
Certains messages sont parfois explicites.
|
||||
|
||||
% _________
|
||||
@ -884,7 +884,7 @@ pas vraiment compte du contenu de l'image.
|
||||
\begin{verbatim}
|
||||
tth@daubian:~/Devel/FloatImg/tools$ ./fimgfx -v -h
|
||||
--- fimg special effects ---
|
||||
cos01 cos010 pow2 sqrt gray0 xper
|
||||
cos01 cos010 pow2 sqrt gray0 cmixa xper desat
|
||||
\end{verbatim}
|
||||
|
||||
Certaines de ces opérations ont besoin d'un paramètre flottant.
|
||||
@ -898,6 +898,12 @@ sera lisible avec le sélecteur \texttt{-L}.
|
||||
\item [Déformations géométriques:] r90
|
||||
\end{description}
|
||||
|
||||
Et pour les aventureux, la commande \texttt{xper} (abréviation
|
||||
de \textsl{expérimental}) permet de tester la plus récente tentative
|
||||
de friture du moment.
|
||||
|
||||
% ---------------------
|
||||
|
||||
\subsection{fimgops}\index{fimgops}\label{fimgops}
|
||||
|
||||
Quelques opérations diverses entre deux images, qui doivent être
|
||||
@ -955,9 +961,34 @@ avoir plusieurs plans de réalité. Il ne faut en négliger aucun.
|
||||
Il faut quand même deviner que pour passer de l'espace RGB\index{RGB}
|
||||
à une abstraction linéaire mono-dimensionnelle, il existe une foultitude
|
||||
de méthodes, toutes plus légitimes que les autres.
|
||||
\index{procrastination}
|
||||
Et face à l'incertitude du choix, j'ai reporté l'écriture de ce
|
||||
logiciel aux calendes grecques, voire même plus tard.
|
||||
|
||||
\subsection{cumulfimgs}\index{cumulfimgs}\label{cumulfimgs}
|
||||
|
||||
Cet outil accumule\index{cumul} une quantité d'images flottantes
|
||||
(même taille et même type) afin d'obtenir
|
||||
un flou de meilleure qualité. Aucune mise à l'échelle n'etant
|
||||
effctuée, les pixels de sortie peuvent atteindre des valeurs
|
||||
considérables\footnote{Prévoir une gestion des \textsf{overflows} ?}
|
||||
|
||||
\begin{verbatim}
|
||||
tth@delirium:~/Devel/FloatImg/tools$ ./cumulfimgs -h
|
||||
usage :
|
||||
cumulfimgs a.fimg b.fimg c-fimg ...
|
||||
cumulator options :
|
||||
-v increase verbosity
|
||||
-o name of output file
|
||||
-g convert to gray level
|
||||
\end{verbatim}
|
||||
|
||||
Le nom par défaut du fichier résultant est \texttt{out.fimg}.
|
||||
L'exportation "multiformat" est pour bientôt.
|
||||
|
||||
% -------------------------------------------------------------------
|
||||
\section{TODO}\index{TODO}\label{TODO}
|
||||
\section{TODO}\index{TODO}\label{TODO}\
|
||||
\index{XXX}
|
||||
|
||||
Il reste plein de choses à faire pour que ce soit vraiment utilisable,
|
||||
surtout dans un contexte artistique à grande porosité.
|
||||
@ -971,7 +1002,8 @@ choses seront acquises.
|
||||
\item Compléter les traitements mathémathiques (eg le gamma\index{gamma}).
|
||||
\item Formaliser les codes d'erreur. \textbf{Urgent}.
|
||||
\item Faire une passe complète de Valgrind\index{valgrind}.
|
||||
\item Integrer la fonderie et l'interpolator.
|
||||
\item Intégrer la fonderie et l'interpolator.
|
||||
\item Vérifier le gestion des images mono-canal.
|
||||
\end{itemize}
|
||||
|
||||
% -------------------------------------------------------------------
|
||||
|
||||
13
floatimg.h
13
floatimg.h
@ -3,7 +3,7 @@
|
||||
* ugly code from tTh
|
||||
*/
|
||||
|
||||
#define FIMG_VERSION 106
|
||||
#define FIMG_VERSION 109
|
||||
|
||||
/*
|
||||
* in memory descriptor
|
||||
@ -59,7 +59,7 @@ int fimg_type_is_valid(int type);
|
||||
|
||||
|
||||
int fimg_print_version(int k);
|
||||
void fimg_print_sizeof(void);
|
||||
void fimg_print_sizeof(void);
|
||||
void fimg_printhead(FloatImg *h);
|
||||
int fimg_describe(FloatImg *head, char *txt);
|
||||
char *fimg_str_type(int type);
|
||||
@ -97,6 +97,9 @@ int fimg_killborders(FloatImg *img);
|
||||
int fimg_lissage_2x2(FloatImg *img);
|
||||
int fimg_filter_3x3(FloatImg *s, FloatImg *d, FimgFilter3x3 *filtr);
|
||||
|
||||
|
||||
int fimg_contour_2x2(FloatImg *psrc, FloatImg *pdst, int notused);
|
||||
|
||||
/* 'sfx0' module */
|
||||
int fimg_killcolors_a(FloatImg *fimg, float fval);
|
||||
int fimg_killcolors_b(FloatImg *fimg, float fval);
|
||||
@ -124,6 +127,10 @@ int fimg_cos_010(FloatImg *s, FloatImg *d, double maxval);
|
||||
int fimg_mix_rgb_gray(FloatImg *img, float mix);
|
||||
int fimg_shift_to_zero(FloatImg *s, FloatImg *d, float coefs[6]);
|
||||
|
||||
/* * * * experimental ! */
|
||||
int fimg_classif_trial(FloatImg *src, FloatImg*dst, float fval, int notused);
|
||||
int fimg_qsort_rgb_a(FloatImg *psrc, FloatImg *pdst, int notused);
|
||||
int fimg_qsort_rgb_b(FloatImg *psrc, FloatImg *pdst, int notused);
|
||||
|
||||
/* module funcs/geometry.c */
|
||||
int fimg_equalize_compute(FloatImg *src, void *vptr, float vmax);
|
||||
@ -158,7 +165,7 @@ int fimg_meanvalues(FloatImg *head, float means[4]);
|
||||
int fimg_to_gray(FloatImg *head);
|
||||
void fimg_add_cste(FloatImg *fi, float value);
|
||||
void fimg_mul_cste(FloatImg *fi, float value);
|
||||
int fimg_normalize(FloatImg *fi, double maxima, int notused);
|
||||
int fimg_ajust_from_grab(FloatImg *fi, double maxima, int notused);
|
||||
void fimg_drand48(FloatImg *fi, float kmul);
|
||||
int fimg_count_negativ(FloatImg *fi);
|
||||
int fimg_clamp_negativ(FloatImg *fi);
|
||||
|
||||
@ -5,7 +5,7 @@ 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 geometry.o rotate.o \
|
||||
equalize.o fimg-fits.o saturation.o histogram.o \
|
||||
hsv.o
|
||||
hsv.o classif.o contour2x2.o qsortrgb.o
|
||||
|
||||
#---------------------------------------------------------------
|
||||
|
||||
@ -55,9 +55,19 @@ equalize.o: equalize.c $(DEPS)
|
||||
sfx0.o: sfx0.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 $<
|
||||
|
||||
|
||||
hsv.o: hsv.c $(DEPS)
|
||||
gcc $(COPT) -c $<
|
||||
|
||||
|
||||
93
funcs/classif.c
Normal file
93
funcs/classif.c
Normal file
@ -0,0 +1,93 @@
|
||||
/*
|
||||
* classif.c
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <math.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
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
|
||||
|
||||
/* 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 ) 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) 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 !!! */
|
||||
}
|
||||
}
|
||||
|
||||
fprintf(stderr, "on %d off %d\n", on, off);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
|
||||
|
||||
71
funcs/contour2x2.c
Normal file
71
funcs/contour2x2.c
Normal file
@ -0,0 +1,71 @@
|
||||
/*
|
||||
* classif.c
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <math.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
int verbosity;
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
/* nouveau 4 octobre 2020, juste avant sonoptic de la pluie craignos */
|
||||
|
||||
int fimg_contour_2x2(FloatImg *psrc, FloatImg *pdst, int notused)
|
||||
{
|
||||
float avg[4];
|
||||
int foo, x, y, q;
|
||||
|
||||
int tbl[] = /* deep magic inside */
|
||||
{
|
||||
0, 1, 1, 1,
|
||||
1, 1, 0, 1,
|
||||
1, 0, 1, 1,
|
||||
1, 1, 1, 0
|
||||
};
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p %p %d )\n", __func__, psrc, pdst, notused);
|
||||
#endif
|
||||
|
||||
foo = fimg_meanvalues(psrc, avg);
|
||||
if (verbosity) {
|
||||
fprintf(stderr, "mean values : %f %f %f\n", avg[0], avg[1], avg[2]);
|
||||
}
|
||||
|
||||
#define RP(ix, iy) ( psrc->R[((iy)*psrc->width)+(ix)] < avg[0] )
|
||||
#define 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] ? 1.0 : 0.0 ;
|
||||
|
||||
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] ? 1.0 : 0.0 ;
|
||||
|
||||
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] ? 1.0 : 0.0 ;
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
@ -19,7 +19,7 @@ int foo;
|
||||
float dr, dg, db;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p )\n", __func__, src);
|
||||
fprintf(stderr, ">>> %s ( %p %p %f )\n", __func__, src, vptr, vmax);
|
||||
#endif
|
||||
|
||||
memset(minmax, 0, 6*sizeof(float));
|
||||
@ -34,9 +34,9 @@ dr = minmax[1] - minmax[0];
|
||||
dg = minmax[3] - minmax[2];
|
||||
db = minmax[5] - minmax[4];
|
||||
|
||||
printf("Rmin %12.4g Rmax %12.4g delta %12.4g\n", minmax[0], minmax[1], dr);
|
||||
printf("Gmin %12.4g Gmax %12.4g delta %12.4g\n", minmax[2], minmax[3], dg);
|
||||
printf("Bmin %12.4g Bmax %12.4g delta %12.4g\n", minmax[4], minmax[5], db);
|
||||
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__);
|
||||
|
||||
104
funcs/qsortrgb.c
Normal file
104
funcs/qsortrgb.c
Normal file
@ -0,0 +1,104 @@
|
||||
/*
|
||||
* qsort_rgb.c
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <math.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
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
|
||||
|
||||
foo = fimg_copy_data(psrc, pdst);
|
||||
|
||||
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 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
|
||||
|
||||
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;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
139
funcs/t.c
139
funcs/t.c
@ -14,6 +14,126 @@ int verbosity;
|
||||
|
||||
float global_fvalue;
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
/*
|
||||
* nouveau 7 octobre 2020 pendant sonoptic
|
||||
*/
|
||||
|
||||
//
|
||||
|
||||
int essai_qsort_rgb(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: 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_dump_to_file(&dst, "out.fimg", 0);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s : err %d saving result\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
/*
|
||||
* nouveau 5 octobre 2020 pendant sonoptic
|
||||
*/
|
||||
int essai_contour_2x2(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: 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_save_as_pnm(&dst, "out.pnm", 0);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s : err %d saving result\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
/*
|
||||
* nouveau 5 octobre 2020 pendant sonoptic
|
||||
*/
|
||||
int essai_classif(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: 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__, global_fvalue);
|
||||
|
||||
foo = fimg_classif_trial(&src, &dst, global_fvalue, 0);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: err %d in classif_trial\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
foo = fimg_save_as_pnm(&dst, "out.pnm", 0);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s : err %d saving result\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
/* nouveau 19 aout 2020, le matin avant la canicule */
|
||||
|
||||
@ -31,7 +151,6 @@ if (foo) {
|
||||
return foo;
|
||||
}
|
||||
|
||||
|
||||
return -7;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
@ -434,7 +553,7 @@ return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
enum nCmd { Equalize=1, Rotate, Sfx0, F3x3, MIRE, Wfits, Wpng, Wtiff,
|
||||
Histo, Hsv };
|
||||
Histo, Hsv, Classif, Ctr2x2, Qsortrgb };
|
||||
typedef struct {
|
||||
char *name;
|
||||
int Cmd;
|
||||
@ -451,6 +570,9 @@ Command commands[] = {
|
||||
{ "wtiff", Wtiff },
|
||||
{ "histo", Histo },
|
||||
{ "hsv", Hsv },
|
||||
{ "classif", Classif },
|
||||
{ "ctr2x2", Ctr2x2 },
|
||||
{ "qsortrgb", Qsortrgb },
|
||||
{ NULL, 0 }
|
||||
} ;
|
||||
|
||||
@ -514,7 +636,9 @@ command = argv[optind];
|
||||
filename = argv[optind+1];
|
||||
|
||||
if (verbosity) {
|
||||
fprintf(stderr, "running command '%s' on '%s'\n", command, filename);
|
||||
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);
|
||||
@ -547,6 +671,15 @@ switch(opt) {
|
||||
case Hsv:
|
||||
foo = fimg_essai_hsv(filename);
|
||||
break;
|
||||
case Classif:
|
||||
foo = essai_classif(filename);
|
||||
break;
|
||||
case Ctr2x2:
|
||||
foo = essai_contour_2x2(filename);
|
||||
break;
|
||||
case Qsortrgb:
|
||||
foo = essai_qsort_rgb(filename);
|
||||
break;
|
||||
default:
|
||||
fprintf(stderr, "%s : bad command\n", command);
|
||||
exit(1);
|
||||
|
||||
32
funcs/vroum.sh
Executable file
32
funcs/vroum.sh
Executable file
@ -0,0 +1,32 @@
|
||||
#!/bin/bash
|
||||
|
||||
src=/dev/shm/foo.fimg
|
||||
out=out.fimg
|
||||
|
||||
maxi=99
|
||||
W="640"
|
||||
H="480"
|
||||
grabopt=" -s 640x480 -v -p 0 -n 100 -c cos01 "
|
||||
|
||||
mkdir /tmp/V
|
||||
|
||||
G=$(printf "%dx%d+0+0" $W $H)
|
||||
|
||||
for foo in $(seq 0 $maxi)
|
||||
do
|
||||
|
||||
echo
|
||||
|
||||
grabvidseq -$grabopt -o $src
|
||||
|
||||
fval=$(echo "$foo / $maxi" | bc -l)
|
||||
./t -k $fval -v qsortrgb $src
|
||||
echo $foo ' = ' $fval
|
||||
|
||||
dst=$(printf "/tmp/V/%03d.png" $foo)
|
||||
|
||||
montage $src $out -geometry $G $dst
|
||||
|
||||
done
|
||||
|
||||
convert -delay 10 V/*.png foo.gif
|
||||
@ -4,8 +4,9 @@ cp libfloatimg.a /usr/local/lib
|
||||
cp floatimg.h /usr/local/include
|
||||
|
||||
cp tools/mkfimg tools/fimg2pnm tools/fimgops \
|
||||
tools/fimg2png tools/fimg2tiff \
|
||||
tools/fimg2png tools/fimg2tiff tools/fimg2fits \
|
||||
tools/png2fimg tools/fimgstats tools/fimgfx \
|
||||
tools/cumulfimgs \
|
||||
/usr/local/bin
|
||||
|
||||
cp v4l2/grabvidseq v4l2/video-infos \
|
||||
|
||||
@ -70,7 +70,7 @@ for (foo=0; foo<nbb; foo++) {
|
||||
(src->R[foo] + src->G[foo] + src->B[foo]) / 3.0;
|
||||
}
|
||||
|
||||
return -99;
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
|
||||
|
||||
@ -246,7 +246,7 @@ for (idx=0; idx<nbre; idx++) {
|
||||
}
|
||||
}
|
||||
/* ---------------------------------------------------------------- */
|
||||
int fimg_normalize(FloatImg *fi, double maxima, int notused)
|
||||
int fimg_ajust_from_grab(FloatImg *fi, double maxima, int notused)
|
||||
{
|
||||
double coef;
|
||||
|
||||
|
||||
@ -19,12 +19,12 @@ int foo, numbers[3];
|
||||
foo = fimg_fileinfos(path, numbers);
|
||||
if (foo) {
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, "%s -> err %d\n", path, foo);
|
||||
fprintf(stderr, "fileinfo of '%s' -> err %d\n", path, foo);
|
||||
#endif
|
||||
return foo;
|
||||
}
|
||||
|
||||
fprintf(stderr, "%s \t%d x %d\n",path, numbers[0], numbers[1]);
|
||||
if (verbosity) fprintf(stderr, "%-20s %d x %d\n",path, numbers[0], numbers[1]);
|
||||
|
||||
if (FIMG_TYPE_RGB != numbers[2]) {
|
||||
fprintf(stderr, "file %s, %d : bad type\n", path, numbers[2]);
|
||||
@ -36,10 +36,13 @@ return 0;
|
||||
/* --------------------------------------------------------------------- */
|
||||
void help(int v)
|
||||
{
|
||||
puts("");
|
||||
puts("$ cumulfimgs a.fimg b.fimg c-fimg ...");
|
||||
puts("cumulator options :");
|
||||
puts("\t-v\tincrease verbosity");
|
||||
puts("\t-o\tname of output file");
|
||||
|
||||
puts("\t-g\tconvert to gray level");
|
||||
puts("");
|
||||
if (verbosity) { puts(""); fimg_print_version(1); }
|
||||
exit(0);
|
||||
}
|
||||
@ -48,14 +51,17 @@ int main(int argc, char *argv[])
|
||||
{
|
||||
int foo, idx;
|
||||
int opt;
|
||||
|
||||
int to_gray = 0;
|
||||
char *output_file = "out.fimg";
|
||||
FloatImg accu, temp;
|
||||
int src_loaded = 0;
|
||||
|
||||
g_width = g_height = 0;
|
||||
|
||||
while ((opt = getopt(argc, argv, "ho:v")) != -1) {
|
||||
while ((opt = getopt(argc, argv, "gho:v")) != -1) {
|
||||
switch(opt) {
|
||||
case 'g': to_gray = 1; break;
|
||||
case 'h': help(0); break;
|
||||
case 'o': output_file = optarg; break;
|
||||
case 'v': verbosity++; break;
|
||||
@ -67,16 +73,17 @@ if (verbosity) fprintf(stderr, "------ cumulfimgs ------\n");
|
||||
fprintf(stderr, "argc = %d, optind = %d\n", argc, optind);
|
||||
#endif
|
||||
|
||||
// foo = testfile(output_file);
|
||||
// fprintf(stderr, "Output %s -> %d\n", output_file, foo);
|
||||
|
||||
|
||||
for (idx=optind; idx<argc; idx++) {
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, "%5d %s\n", idx, argv[idx]);
|
||||
#endif
|
||||
|
||||
foo = testfile(argv[idx]);
|
||||
fprintf(stderr, "testfile %s -> %d\n", argv[idx],foo);
|
||||
if (foo) {
|
||||
fprintf(stderr, "testfile %s -> %d\n", argv[idx],foo);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
if ( ! src_loaded ) {
|
||||
foo = fimg_create_from_dump(argv[idx], &accu);
|
||||
@ -85,13 +92,29 @@ for (idx=optind; idx<argc; idx++) {
|
||||
}
|
||||
else {
|
||||
foo = fimg_load_from_dump(argv[idx], &temp);
|
||||
if (foo) {
|
||||
fprintf(stderr, "load from dump -> %d\n", foo);
|
||||
exit(1);
|
||||
}
|
||||
fimg_add_2(&temp, &accu);
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
if (to_gray) {
|
||||
|
||||
foo = fimg_desaturate(&accu, &accu, 0);
|
||||
if (foo) {
|
||||
fprintf(stderr, "desaturate: error %d\n", foo);
|
||||
}
|
||||
}
|
||||
|
||||
foo = fimg_dump_to_file(&accu, output_file, 0);
|
||||
if (foo) {
|
||||
fprintf(stderr, "error %d while saving '%s'\n", foo, output_file);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -27,7 +27,6 @@ function essai_cmixa
|
||||
{
|
||||
./mkfimg -vv -t tpat0 $TMPF 800 600
|
||||
./fimgfx -vv cmixa $TMPF bar.fimg
|
||||
|
||||
}
|
||||
# -----------------------------------------------------
|
||||
function essai_cumulator
|
||||
@ -36,11 +35,19 @@ D=" 800 600 "
|
||||
./mkfimg -v -t hdeg hdeg.fimg $D
|
||||
./mkfimg -v -t vdeg vdeg.fimg $D
|
||||
./mkfimg -v -t drand48 rand.fimg $D
|
||||
./mkfimg -v -t tpat0 pat0.fimg $D
|
||||
|
||||
./cumulfimgs -vv -o foo.fimg hdeg.fimg rand.fimg vdeg.fimg
|
||||
./cumulfimgs -v -g -o foo.fimg \
|
||||
hdeg.fimg pat0.fimg rand.fimg vdeg.fimg
|
||||
}
|
||||
# -----------------------------------------------------
|
||||
function essai_contour
|
||||
{
|
||||
./mkfimg -vv -t tpat0 $TMPF 800 600
|
||||
./fimgfx -vv ctr2x2 $TMPF bar.fimg
|
||||
}
|
||||
# -----------------------------------------------------
|
||||
|
||||
essai_cumulator
|
||||
essai_contour
|
||||
|
||||
# -----------------------------------------------------
|
||||
|
||||
@ -21,7 +21,7 @@ typedef struct {
|
||||
} Fx;
|
||||
|
||||
enum fxid { Fx_cos01=5, Fx_cos010, Fx_pow2, Fx_sqrt, Fx_gray0, Fx_halfsz0,
|
||||
Fx_rot90, Fx_cmixa, Fx_Desat,
|
||||
Fx_rot90, Fx_cmixa, Fx_desat, Fx_ctr2x2, Fx_norm,
|
||||
Fx_xper };
|
||||
|
||||
Fx fx_list[] = {
|
||||
@ -34,7 +34,9 @@ Fx fx_list[] = {
|
||||
{ "rot90", Fx_rot90, 0, 0 },
|
||||
{ "cmixa", Fx_cmixa, 0, 1 },
|
||||
{ "xper", Fx_xper, 0, 1 },
|
||||
{ "desat", Fx_Desat, 0, 1 },
|
||||
{ "desat", Fx_desat, 0, 1 },
|
||||
{ "ctr2x2", Fx_ctr2x2, 0, 1 },
|
||||
{ "norm", Fx_norm, 0, 1 },
|
||||
{ NULL, 0, 0 }
|
||||
};
|
||||
|
||||
@ -59,6 +61,9 @@ for (n=0, fx=fx_list; fx->name; fx++, n++) {
|
||||
return -1; /* NOT FOUND */
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
/*
|
||||
* this is the mutant function
|
||||
*/
|
||||
int do_experiment(FloatImg *S, FloatImg *D, float kf)
|
||||
{
|
||||
int foo;
|
||||
@ -74,10 +79,10 @@ if (foo) {
|
||||
return -98;
|
||||
}
|
||||
|
||||
foo = fimg_killcolors_a(D, kf);
|
||||
foo = fimg_classif_trial(S, D, kf, 0);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s err %d killcolors %p %f\n", __func__,
|
||||
foo, S, kf);
|
||||
fprintf(stderr, "%s err %d classif_trial %p\n", __func__,
|
||||
foo, S);
|
||||
return -98;
|
||||
}
|
||||
|
||||
@ -167,11 +172,15 @@ switch (action) {
|
||||
fprintf(stderr, "halfsize was not implemented\n");
|
||||
return -3;
|
||||
|
||||
case Fx_Desat:
|
||||
case Fx_desat:
|
||||
fimg_copy_data(&src, &dest);
|
||||
foo = fimg_mix_rgb_gray(&dest, global_fvalue);
|
||||
break;
|
||||
|
||||
case Fx_ctr2x2:
|
||||
foo = fimg_contour_2x2(&src, &dest, 0);
|
||||
break;
|
||||
|
||||
default:
|
||||
fprintf(stderr, "%s %s : %d is bad action\n",
|
||||
__FILE__, __func__, action);
|
||||
|
||||
Loading…
Reference in New Issue
Block a user