---

normalize.c

Aller à la documentation de ce fichier.

#include "utils.h"
#include "inricache.h"
#include <inrimage/image.h>
#include <stdlib.h>

extern void imerror ( int code, char * format, ...);

static char Ucmd[]=
"[s2D] [norm_s2d] [d2D] [norm_d2D] [-min MIN] [-max MAX] [-cache taille_cache] [-time]";

static char Udetail[]=
"genere norm_s2D et norm_d2D les images derivees de s2D et d2D, telles que les valeurs dans s2D et d2D soient reparties entre 0 et 1, tout en conservant l'ecart relatif entre s2D et d2D. La precision de valeurs MIN et MAX permet d'imposer l'intervalle dans lequel on va etaler nos fonctions. MIN et MAX doivent appartenir a [0;1] pour etre prises en compte";

int main(int argc,char ** argv)
{
  struct nf_fmt gfmt;
  char img[80];
  int time_flag,taille_cache;
  float min2D,max2D;
  double min_calc=0,max_calc=0;
  double min_curr=0,max_curr=0;
  int i;
  int nb_inricaches=1;
  inricache ** iCaches, ** normed_iCaches;
  char ** noms_iCaches=(char **)malloc(sizeof(char *));
  char ** noms_Normed_iCaches=(char **)malloc(sizeof(char *));

  for (i=0;i<9;i++)
    gfmt.lfmt[i]=0;
  for (i=0;i<3;i++)
    gfmt.offsets[i]=0;
  gfmt.maille=0;
  gfmt.bias=0;
  gfmt.scale=1;

  inr_init(argc,argv,"1.0",Ucmd,Udetail);
  /* recherche des fichiers d'entree et de sortie. en cas de redirection d'entrees/sortie, infileopt renvoie 0. on est oblige de faire une lecture avant la boucle while */

  noms_iCaches[0]=(char *)malloc(80*sizeof(char));
  infileopt(img);
  strcpy(noms_iCaches[0],img);
  noms_Normed_iCaches[0]=(char *)malloc(80*sizeof(char));
  outfileopt(img);
  strcpy(noms_Normed_iCaches[0],img);

  while(infileopt(img))
    {
      nb_inricaches++;
      noms_iCaches=(char **)realloc(noms_iCaches,nb_inricaches*sizeof(char *));
      noms_Normed_iCaches=(char **)realloc(noms_Normed_iCaches,nb_inricaches*sizeof(char *));

      noms_iCaches[nb_inricaches-1]=(char *)malloc(80*sizeof(char));
      strcpy(noms_iCaches[nb_inricaches-1],img);
      noms_Normed_iCaches[nb_inricaches-1]=(char *)malloc(80*sizeof(char));
      outfileopt(img);
      strcpy(noms_Normed_iCaches[nb_inricaches-1],img);
    }

  /* recuperation des options de format de l'image */
  if(!igetopt1("-min","%f",&min2D))
    min2D=-1;
  if(!igetopt1("-max","%f",&max2D))
    max2D=-1;
  if (!igetopt1("-cache","%d",&taille_cache))
    taille_cache=1;
  time_flag=igetopt0("-time");

  /* verification des options restantes */
  if(tstopts()) /* s'il reste des options : exit avec message */
    iusage_(Ucmd,Udetail);

  /* ouverture des images */

  iCaches = (inricache **)malloc(nb_inricaches*sizeof(inricache *));
  normed_iCaches = (inricache **)malloc(nb_inricaches*sizeof(inricache *));

  /* les premieres options de verification different pour le premier inricache cree */

  iCaches[0]=cree_inricache(noms_iCaches[0],"e","",&gfmt,taille_cache);
  normed_iCaches[0]=cree_inricache(noms_Normed_iCaches[0],"c","a",&gfmt,taille_cache);
  extrema_inricache(iCaches[0],&min_curr,&max_curr);
  min_calc=min_curr;
  max_calc=max_curr;


  for (i=1;i<nb_inricaches;i++)
    {
      iCaches[i]=cree_inricache(noms_iCaches[i],"e","a",&gfmt,taille_cache);
      normed_iCaches[i]=cree_inricache(noms_Normed_iCaches[i],"c","a",&gfmt,taille_cache);
      extrema_inricache(iCaches[i],&min_curr,&max_curr);
      min_calc=min(min_calc,min_curr);
      max_calc=max(max_calc,max_curr);
    }

  /* verification de la validite des min et max demandes */
  if ((min2D<0) || (min2D>min_calc)) /* le minimum n'est pas impose */
    {
      if (min2D>min_calc)
         fprintf(stderr,"normalize: min demande (%f) superieur au min calcule (%f) : [Ignore]\n",min2D,min_calc);
    }
  else
    {min_calc=min2D;}
  
  if (max2D<0 || max2D<max_calc) /* le maximum n'est pas impose */
    {
      if (max2D>0)
         fprintf(stderr,"normalize: max demande (%f) inferieur au max calcule (%f) : [Ignore]\n",max2D,max_calc);
    }
  else
    {max_calc=max2D;} 

  /* normalisation des inricaches */

  fprintf(stderr,"normalize: %d images, min = %f max = %f\n",nb_inricaches,min_calc,max_calc);

  for (i=0;i<nb_inricaches;i++)
    normalize_inricache(iCaches[i],normed_iCaches[i],min_calc,max_calc,time_flag);

  /* fermeture des caches, liberation des variables */

  for (i=0;i<nb_inricaches;i++)
    {
      free(noms_iCaches[i]);
      free(noms_Normed_iCaches[i]);
      libere_inricache(iCaches[i]);
      libere_inricache(normed_iCaches[i]);
    }  
  free(noms_iCaches);
  free(noms_Normed_iCaches);
  free(iCaches);
  free(normed_iCaches);

  return EXIT_SUCCESS;
}

---