Compare commits
No commits in common. "248061f46b7078ee606ad1f428a931dbe42e7ccc" and "7c378f1f7e7e95206fec2840531753d80d6ed8c5" have entirely different histories.
248061f46b
...
7c378f1f7e
@ -77,7 +77,7 @@ IRC de Freenode.
|
||||
|
||||
\textbf{Attention !} ce document commence par une bonne rafale
|
||||
de technique parfois hardue\footnote{gni?}.
|
||||
Vous avez parfaitement le droit de sauter directement à
|
||||
Vous avez parfaitement le droit de auter directement à
|
||||
la page \pageref{outils} pour quelque chose de plus concret.
|
||||
|
||||
% -------------------------------------------------------------------
|
||||
@ -194,7 +194,7 @@ lesquels sont décrits en page \pageref{outils}.
|
||||
% -------------------------------------------------------------------
|
||||
\section{Installation}
|
||||
|
||||
\textit{Attention, ça devient un peu gore. Myrys, punk, toussa\dots}
|
||||
\textit{Attention, ça devient un peu gore.}
|
||||
|
||||
\subsection{Prérequis}
|
||||
|
||||
@ -209,8 +209,6 @@ comme \textsc{gnu}/make\index{make}.
|
||||
Une connaissance de base de l'utilisation du shell\index{shell}
|
||||
et de l'écriture de Makefile's sera un plus.
|
||||
|
||||
Il faut aussi savoir où trouver le code.
|
||||
|
||||
\subsection{Compilation}
|
||||
|
||||
Un script \texttt{build.sh} permet de construire approximativement
|
||||
@ -476,8 +474,6 @@ de pixel flottant.
|
||||
\subsection{Géométrie}\index{géométrie}\label{geometrie}
|
||||
|
||||
Très prochainement, le retour du blitter\index{blitter}.
|
||||
Et pour attendre, un truc improbable, voire même
|
||||
inutile.
|
||||
|
||||
\begin{lstlisting}
|
||||
/* module funcs/geometry.c */
|
||||
@ -489,15 +485,6 @@ contenir d'image, et doit être effacé avec un bon
|
||||
\texttt{memset(\&result, 0, sizeof(FloatImg));} bien senti.
|
||||
Et le résultat est très moyen : il n'y a pas d'interpolation.
|
||||
|
||||
\begin{lstlisting}
|
||||
/* module funcs/geometry.c */
|
||||
int fimg_extract_0(FloatImg *src, FloatImg *dst, int x, int y);
|
||||
\end{lstlisting}
|
||||
|
||||
Contrairement à la fonction précédente, celle-ci demande absolument une
|
||||
image de destination initialisée aux dimensions (largeur et hauteur)
|
||||
désirées.
|
||||
|
||||
% ----------------------------------
|
||||
|
||||
\subsection{Exportation \& Importation}\index{export}\label{export}
|
||||
@ -545,13 +532,12 @@ Actuellement, on peut enregistrer uniquement en mode RGB, 8 bits par composante,
|
||||
mais on a quand même une bonne compression, ça compense.
|
||||
J'utilise \textsl{libpnglite} avec qui j'ai un peu de mal à suivre.
|
||||
Mais je me soigne. Le mode 16 bits va bientôt arriver.
|
||||
On peut aussi songer à l'export de metadatas.
|
||||
|
||||
\begin{lstlisting}
|
||||
int fimg_save_as_png(FloatImg *src, char *outname, int flags);
|
||||
\end{lstlisting}
|
||||
|
||||
Tous les flags doivent être à zéro. Sinon, ça foire parfois.
|
||||
Tous les flags doivent être à zéro.
|
||||
|
||||
\subsubsection{Vers/depuis TIFF}\index{TIFF}
|
||||
|
||||
@ -563,8 +549,7 @@ To be done\index{XXX}
|
||||
|
||||
\subsubsection{Vers FITS}\index{FITS}
|
||||
|
||||
Ce format est essentiellement utilisé pour stocker des images
|
||||
d'astronomie.
|
||||
Essentiellement des images d'astronomie.
|
||||
|
||||
To be done\index{XXX}
|
||||
|
||||
@ -586,9 +571,9 @@ La fonction \texttt{int format\_from\_extension(char *fname)} examine un
|
||||
nom defichier tel que \texttt{lena.xxx}, et retourne, si la partie
|
||||
\texttt{xxx} un éventuel nombre positif, dont les valeurs sont dans floatimg.h
|
||||
le valeureux.
|
||||
Les extensions actuellement connues sont : fimg, png, pnm et tiff.
|
||||
Les extensions connues sont : fimg, png, pnm et tiff.
|
||||
|
||||
To be continued\index{XXX}\dots
|
||||
To be continued\index{XXX}
|
||||
|
||||
|
||||
\subsection{Effets}\index{sfx}
|
||||
@ -609,45 +594,13 @@ int fimg_killcolors_b(FloatImg *fimg, float fval);
|
||||
|
||||
Pour commencer, il faut que je réfléchisse au traitement
|
||||
des bordures des images.
|
||||
Ensuite que je débuggue\index{bug} ces deux fonctions~:
|
||||
Ensuite que je débuggue\index{bug} cette fonction~:
|
||||
|
||||
\begin{lstlisting}
|
||||
int fimg_lissage_2x2(FloatImg *img);
|
||||
int fimg_killborders(FloatImg *img);
|
||||
\end{lstlisting}
|
||||
|
||||
Bon, oké, ça marche ? Passons à l'tape suivante.
|
||||
La convolution avec une matrice 3x3, c'est possible.
|
||||
Et pas trop compliqué à faire.
|
||||
Bon, il reste le souci avec les bordures, souci qui ne peut
|
||||
être que temporaire, mais ésotérique à fixer.
|
||||
|
||||
Passons maintenant aux choses sérieuses, et définissons la
|
||||
description d'un filtre 3x3.
|
||||
|
||||
\begin{verbatim}
|
||||
typedef struct {
|
||||
float matrix[9];
|
||||
float mult;
|
||||
float offset;
|
||||
} FimgFilter3x3;
|
||||
\end{verbatim}
|
||||
|
||||
L'usage des champs \texttt{mult} et \texttt{offset} n'est pas
|
||||
clairement défini. Le prototype de la fonction de filtrage
|
||||
non plus, mais assez simpe quand même. Source et destination
|
||||
ne peuvent désigner la même image, et le champ \texttt{matrix}
|
||||
du filtre doit contenir des valeurs cohérentes.
|
||||
|
||||
\begin{verbatim}
|
||||
int fimg_filter_3x3(FloatImg *src, FloatImg *dst, FimgFilter3x3 *filtr)
|
||||
\end{verbatim}
|
||||
|
||||
Comme dans la plupart des cas, la gestion des valeurs négatives
|
||||
de pixel est laissé au hasard. Quoique, il doit bien exister
|
||||
quelques solutions de contournement : clamping ou shift ?
|
||||
|
||||
\textsl{To be continued\index{XXX}\dots}
|
||||
To be continued\index{XXX}\dots
|
||||
|
||||
% ----------------------------------
|
||||
|
||||
@ -834,8 +787,6 @@ La véracité mathématique n'est pas garantie. Et n'oubliez pas que
|
||||
les valeurs négatives peuvent être la cause de \textsl{glitches}
|
||||
de qualitay.
|
||||
|
||||
% -------------------------
|
||||
|
||||
\subsection{fimg2png, fimg2pnm, fimg2tiff}
|
||||
\index{fimg2png}\label{fimg2png}
|
||||
\index{fimg2pnm}\label{fimg2pnm}
|
||||
@ -846,7 +797,7 @@ vers des choses plus directement utilisables. À condition que le
|
||||
code soit écrit et documenté.
|
||||
|
||||
D'un autre coté, écrire un greffon d'import/export pour
|
||||
Gimp\index{Gimp} ou ImageMagick\index{ImageMagick} ou Krita\index{krita}
|
||||
Gimp\index{Gimp} ou Imagemagick\index{Imagemagick} ou Krita\index{Krita}
|
||||
ne devrait pas être trop difficile. Des volontaires ?
|
||||
|
||||
\textsl{D'ailleurs, pourquoi $n$ logiciels indépendants alors q'un
|
||||
@ -870,7 +821,7 @@ C'est par ces frottements de techniques ayant du sens que les
|
||||
choses seront acquises.
|
||||
|
||||
\begin{itemize}
|
||||
\item Import/export au format \textsc{tiff}\index{TIFF}.
|
||||
\item Import/export au format \textsc{tiff}\index{tiff}.
|
||||
\item Remplacer le « fait-maison » par \textsc{libnetpnm}\index{pnm}.
|
||||
\textsl{[en cours]}.
|
||||
\item Compléter les traitements mathémathiques (eg le gamma\index{gamma}).
|
||||
@ -1143,39 +1094,6 @@ l'\textsc{api} de \textsc{v4l2}, et donc, que ce que raconte
|
||||
ce logiciel doit être pris avec des pincettes. En particulier
|
||||
la liste des résolutions disponibles.
|
||||
|
||||
% -------------------------------------------------------------------
|
||||
\section{À l'extérieur}
|
||||
|
||||
|
||||
\subsection{ImageMagick}\index{ImageMagick}
|
||||
|
||||
Pour afficher notre format .fimg exotique avec \texttt{display}, vous
|
||||
devez mettre ce bout de XML\index{XML} dans le fichier
|
||||
\texttt{\$HOME/.magick/delegates.xml}~:
|
||||
|
||||
\begin{verbatim}
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<delegatemap>
|
||||
<delegate decode="fimg" command="fimg2png '%i' '%o'"/>
|
||||
</delegatemap>
|
||||
\end{verbatim}
|
||||
|
||||
C'est juste un hack rapide, qui ne fonctionne pas très bien avec
|
||||
d'autres commande de IM, comme identify, qui a tendance à
|
||||
raconter un peu n'importe quoi... Je compte donc sur le bouquin
|
||||
de \textsl{Brunus} pour avancer...
|
||||
|
||||
\subsection{Gimp}\index{Gimp}
|
||||
|
||||
Mmmmm... Ça semble un peu plus compliqué. D'un autre coté, il
|
||||
faut faire ça en \textbf{C}, ce qui ne peut être négatif.
|
||||
|
||||
\subsection{Et encore ?}\index{krita}\index{geeqie}
|
||||
|
||||
Il y a d'autres logiciels pour lesquels écrire une fonction d'importation
|
||||
serait bien~: \textsl{Geeqie}, un visualiseur d'image fort pratique, ou
|
||||
\textsl{Krita} qui semble avoir les faveurs de dessinateurs de talent.
|
||||
|
||||
% -------------------------------------------------------------------
|
||||
\section{Et pour la suite ?}
|
||||
|
||||
|
||||
13
floatimg.h
13
floatimg.h
@ -2,7 +2,7 @@
|
||||
* floatimg.h
|
||||
*/
|
||||
|
||||
#define FIMG_VERSION 95
|
||||
#define FIMG_VERSION 94
|
||||
|
||||
/*
|
||||
* in memory descriptor
|
||||
@ -80,17 +80,8 @@ int fimg_minimum(FloatImg *a, FloatImg *b, FloatImg *d);
|
||||
int fimg_maximum(FloatImg *a, FloatImg *b, FloatImg *d);
|
||||
|
||||
|
||||
/* funcs/filtrage.c */
|
||||
|
||||
typedef struct {
|
||||
float matrix[9];
|
||||
float mult;
|
||||
float offset;
|
||||
} FimgFilter3x3;
|
||||
|
||||
int fimg_killborders(FloatImg *img);
|
||||
int fimg_lissage_2x2(FloatImg *img);
|
||||
int fimg_filter_3x3(FloatImg *s, FloatImg *d, FimgFilter3x3 *filtr);
|
||||
|
||||
/* 'sfx0' module */
|
||||
int fimg_killcolors_a(FloatImg *fimg, float fval);
|
||||
@ -136,14 +127,12 @@ void fimg_mul_cste(FloatImg *fi, float value);
|
||||
int fimg_normalize(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);
|
||||
|
||||
/* various funcs modules */
|
||||
int fimg_load_from_png(char *filename, FloatImg *fimg);
|
||||
int fimg_create_from_png(char *filename, FloatImg *fimg);
|
||||
int fimg_save_as_png(FloatImg *src, char *outname, int flags);
|
||||
|
||||
int fimg_test_pattern(FloatImg *fimg, int type, double dval);
|
||||
int fimg_draw_something(FloatImg *fimg);
|
||||
|
||||
int parse_WxH(char *str, int *pw, int *ph);
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
#---------------------------------------------------------------
|
||||
|
||||
COPT = -Wall -fpic -g -pg -no-pie -DDEBUG_LEVEL=0
|
||||
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 geometry.o
|
||||
|
||||
@ -7,75 +7,7 @@
|
||||
#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__, s, d, filtr);
|
||||
#endif
|
||||
|
||||
/* 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;
|
||||
|
||||
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;
|
||||
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
/* -------------------------------------------------------------------- */
|
||||
/*
|
||||
* this is the more shifting hack on the block.
|
||||
*/
|
||||
static int fimg_lissage_2x2_a(FloatImg *img)
|
||||
int fimg_lissage_2x2(FloatImg *img)
|
||||
{
|
||||
int x, y, offset;
|
||||
float cr, cg, cb;
|
||||
@ -87,11 +19,6 @@ 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++) {
|
||||
@ -129,11 +56,6 @@ 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++) {
|
||||
@ -171,20 +93,4 @@ for (idx=0; idx<w; idx++) {
|
||||
return -1;
|
||||
}
|
||||
/* -------------------------------------------------------------------- */
|
||||
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;
|
||||
}
|
||||
|
||||
/* XXX */
|
||||
fimg_killborders(img);
|
||||
|
||||
return foo;
|
||||
}
|
||||
/* -------------------------------------------------------------------- */
|
||||
|
||||
|
||||
@ -11,44 +11,6 @@
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
|
||||
int fimg_test_pattern(FloatImg *fimg, int type, double dval)
|
||||
{
|
||||
int nio;
|
||||
int x, y;
|
||||
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);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
int fimg_draw_something(FloatImg *fimg)
|
||||
{
|
||||
int x, y;
|
||||
|
||||
96
funcs/t.c
96
funcs/t.c
@ -13,68 +13,14 @@ int verbosity;
|
||||
float global_fvalue;
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
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 },
|
||||
8.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
|
||||
|
||||
};
|
||||
|
||||
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_clone(&src, &dst, 0);
|
||||
|
||||
fimg_filter_3x3(&src, &dst, &filter_b);
|
||||
foo = fimg_clamp_negativ(&dst);
|
||||
if (foo) {
|
||||
fprintf(stderr, "clamped %d negativ pixels\n", foo);
|
||||
}
|
||||
foo = fimg_save_as_png(&dst, "f3x3.png", 0);
|
||||
foo = fimg_save_as_pnm(&dst, "f3x3.pnm", 0);
|
||||
|
||||
fimg_destroy(&src); fimg_destroy(&dst);
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
int essai_filtrage_2x2(char *infile)
|
||||
int essai_filtrage(char *infile)
|
||||
{
|
||||
FloatImg fimg;
|
||||
int foo, idx;
|
||||
char buffer[100];
|
||||
|
||||
if (NULL != infile) {
|
||||
fprintf(stderr, "%s: loading %s\n", __func__, 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);
|
||||
@ -89,17 +35,11 @@ else {
|
||||
|
||||
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++) {
|
||||
for (idx=0; idx<20; 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);
|
||||
}
|
||||
foo = fimg_killborders(&fimg);
|
||||
sprintf(buffer, "filter%03d.pnm", idx);
|
||||
foo = fimg_save_as_pnm(&fimg, buffer, 0);
|
||||
}
|
||||
|
||||
fimg_destroy(&fimg);
|
||||
@ -114,11 +54,7 @@ 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;
|
||||
}
|
||||
fimg_create_from_dump(infile, &fimg);
|
||||
}
|
||||
else {
|
||||
fimg_create(&fimg, 512, 512, FIMG_TYPE_RGB);
|
||||
@ -149,11 +85,7 @@ 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;
|
||||
}
|
||||
fimg_create_from_dump(infile, &fimg);
|
||||
}
|
||||
else {
|
||||
fimg_create(&fimg, 512, 512, FIMG_TYPE_RGB);
|
||||
@ -294,19 +226,11 @@ fprintf(stderr, "argc %d optind %d\n", argc, optind);
|
||||
filename = NULL;
|
||||
if (1 == argc-optind) filename = argv[optind];
|
||||
|
||||
/*
|
||||
foo = essai_filtrage_2x2(filename);
|
||||
foo = essai_filtrage(filename);
|
||||
if (foo) {
|
||||
fprintf(stderr, "Filtre 2x2 ====> %d\n", foo);
|
||||
}
|
||||
*/
|
||||
|
||||
foo = essai_filtrage_3x3(filename);
|
||||
if (foo) {
|
||||
fprintf(stderr, "Filtre 3x3 ====> %d\n", foo);
|
||||
fprintf(stderr, "====> %d\n", foo);
|
||||
}
|
||||
|
||||
fprintf(stderr, "++++++++++++++ end of pid %d\n", getpid());
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
# building the base library
|
||||
#
|
||||
|
||||
COPT = -Wall -fpic -g -pg -no-pie -DDEBUG_LEVEL=0
|
||||
COPT = -Wall -fpic -g -no-pie -DDEBUG_LEVEL=0
|
||||
|
||||
OBJS = fimg-core.o fimg-pnm.o fimg-file.o fimg-math.o \
|
||||
fimg-timers.o operators.o fimg-2gray.o \
|
||||
|
||||
@ -144,31 +144,6 @@ for (idx=0; idx<nbre; idx++) {
|
||||
if (fi->R[idx] < 0.0) count++;
|
||||
}
|
||||
|
||||
return count;
|
||||
}
|
||||
/* ---------------------------------------------------------------- */
|
||||
/* nouveau 29 fevrier 2020 */
|
||||
int fimg_clamp_negativ(FloatImg *fi)
|
||||
{
|
||||
int nbre, idx;
|
||||
int count;
|
||||
|
||||
if (fi->type != FIMG_TYPE_RGB) {
|
||||
fprintf(stderr, "%s : type %d invalide\n",
|
||||
__func__, fi->type);
|
||||
return -1;
|
||||
}
|
||||
|
||||
nbre = fi->width * fi->height * fi->type;
|
||||
|
||||
count = 0;
|
||||
for (idx=0; idx<nbre; idx++) {
|
||||
if (fi->R[idx] < 0.0) {
|
||||
fi->R[idx] = 0.0;
|
||||
count++;
|
||||
}
|
||||
}
|
||||
|
||||
return count;
|
||||
}
|
||||
/* ---------------------------------------------------------------- */
|
||||
|
||||
@ -28,8 +28,7 @@ if (foo) {
|
||||
}
|
||||
|
||||
if (verbosity) {
|
||||
fprintf(stderr, "%s: image '%s' is %d x %d %s\n",
|
||||
__func__,
|
||||
fprintf(stderr, "image '%s' is %d x %d %s\n",
|
||||
srcname, infos[0], infos[1],
|
||||
fimg_str_type(infos[2]));
|
||||
}
|
||||
@ -46,8 +45,7 @@ if (grisaille) {
|
||||
|
||||
foo = fimg_save_as_png(&fimg, dstname, 0);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: saving as png '%s' -> %d\n", __func__,
|
||||
dstname, foo);
|
||||
fprintf(stderr, "saving as png '%s' -> %d\n", dstname, foo);
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
@ -14,7 +14,6 @@ int verbosity;
|
||||
#define T_GRAY 3
|
||||
#define T_HDEG_A 4
|
||||
#define T_VDEG_A 5
|
||||
#define T_TPAT0 6
|
||||
|
||||
typedef struct {
|
||||
int code;
|
||||
@ -28,7 +27,7 @@ Type types[] = {
|
||||
{ T_GRAY, "grey" },
|
||||
{ T_HDEG_A, "hdeg" },
|
||||
{ T_VDEG_A, "vdeg" },
|
||||
{ T_TPAT0, "tpat0" },
|
||||
|
||||
{ 0, NULL }
|
||||
};
|
||||
|
||||
@ -129,7 +128,6 @@ switch(type) {
|
||||
break;
|
||||
case T_HDEG_A: fimg_hdeg_a(&fimg, 1.0); break;
|
||||
case T_VDEG_A: fimg_vdeg_a(&fimg, 1.0); break;
|
||||
case T_TPAT0: fimg_test_pattern(&fimg, 0, fvalue); break;
|
||||
}
|
||||
|
||||
foo = fimg_dump_to_file(&fimg, fname, 0);
|
||||
|
||||
Loading…
Reference in New Issue
Block a user