---

inricache.c

Aller à la documentation de ce fichier.

#include "inricache.h"
#include "utils.h"
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
/* on a besoin des valeurs limites pour les differents types supportes, en fonction de la machine. */
#include <limits.h>
#include <float.h>

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

/* dans le cache on a toujours des plans consecutifs */
struct inricache_
{
  int cache_size;
  Fort_int lfmt[9];
  struct image * img; 
  char ** cache; 
  int plan_min; 
  int debut; 
};

void chargePlan(inricache * iCache,int numplan);

/****************************/
/* createur et destructeur  */
/****************************/

inricache * cree_inricache(char * nom_image,char * mode,char * verif,struct nf_fmt * gfmt,int taille_cache)
{
  register int i;
  register int buff_size;
  //register int buff_len;
  char * tmpbuff;
  inricache * retour = (inricache *)malloc(sizeof(inricache));

  retour->cache_size=taille_cache;
  retour->plan_min=0;
  retour->debut=0;
  retour->img=image_(nom_image,mode,verif,gfmt);
  
  if (taille_cache>gfmt->lfmt[I_NDIMZ])
    {
      fprintf(stderr,"cree_inricache: %s sur %i plans, cache demande trop grand (%i),ajuste au nombre de plans de l'image.\n",nom_image,gfmt->lfmt[I_NDIMZ],taille_cache);
      retour->cache_size=gfmt->lfmt[I_NDIMZ];
    }

  for (i=0;i<9;i++)
    {
      retour->lfmt[i]=gfmt->lfmt[i];
    }
  buff_size = buffer_size(retour->lfmt,retour->lfmt[I_NDIMY]);
  //buff_len = buff_size/sizeof(char);
  retour->cache = (char **)malloc(retour->cache_size*sizeof(char *));
  tmpbuff = i_malloc(buff_size);

  if (mode[0]=='c')
    {
      //for (i=0;i<buff_len;i++)
      //tmpbuff[i]=0;
      for (i=0;i<retour->lfmt[I_NDIMZ];i++)
         c_pecr(retour->img,gfmt->lfmt[I_NDIMY],tmpbuff,1+i*gfmt->lfmt[I_NDIMY],0);
    }

  for (i=0;i<retour->cache_size;i++)
    {      
      retour->cache[i] = i_malloc(buff_size);
      c_plect(retour->img,gfmt->lfmt[I_NDIMY],retour->cache[i],1+i*gfmt->lfmt[I_NDIMY],0);
    }
  i_Free(&tmpbuff);
  return retour;
}

void libere_inricache(inricache * iCache)
{
  register int i,n_dimy = iCache->lfmt[I_NDIMY];

  for (i=0;i<iCache->cache_size;i++)
    {
      register int indice = (iCache->debut + i)% iCache->cache_size;
      /* pour chaque plan charge en cache: ecriture + suppression */
      c_pecr(iCache->img,n_dimy,iCache->cache[indice],1+(i + iCache->plan_min)*n_dimy,0);
      i_Free(&(iCache->cache[indice]));
    }
  /* fermeture de l'image utilisee pour le cache */
  fermnf_(&(iCache->img));

  free(iCache->cache);
  free(iCache);
}

double getValue(inricache * iCache,int x,int y,int z)
{
  /* chargement du plan si necessaire --> mise a jour du cache */
  chargePlan(iCache,z);

  /* z - plan_min = numero de la page de cache si le cache partait de l'indice zero */
  /* (z - plan_min + debut) % cache_size = indice de la page du cache correspondant au plan z */

  switch (iCache->lfmt[I_BSIZE])
    {
    case 1: /* on a des char */
      return (double) (iCache->cache[(z-iCache->plan_min + iCache->debut) % iCache->cache_size][y*iCache->lfmt[I_NDIMX] + x]);
      break;
    case 2: /* on a des short int */
      return (double) ( ((short int *)(iCache->cache[(z-iCache->plan_min + iCache->debut) % iCache->cache_size])) [y*iCache->lfmt[I_NDIMX] + x]);
      break;
    case 4:
      if (iCache->lfmt[I_TYPE]==1) /* on a des flottants */
         return (double) (((float *)(iCache->cache[(z-iCache->plan_min + iCache->debut) % iCache->cache_size])) [y*iCache->lfmt[I_NDIMX] + x]);
      else /* on a des int */
         return (double) ( ((int *)(iCache->cache[(z-iCache->plan_min + iCache->debut) % iCache->cache_size])) [y*iCache->lfmt[I_NDIMX] + x]); 
      break;
    case 8:
      return ((double *)(iCache->cache[(z-iCache->plan_min + iCache->debut) % iCache->cache_size])) [y*iCache->lfmt[I_NDIMX] + x];
      break;
    default:
      fprintf(stderr,"%s: (%d,%d,%d) non reconnu\n",iCache->img->nom,x,y,z);
      return 0;
      break;
    }
}

void setValue(inricache * iCache,int x,int y,int z,double valeur)
{
  /* chargement du plan si necessaire --> mise a jour du cache */
  chargePlan(iCache,z);
  switch (iCache->lfmt[I_BSIZE])
    {
    case 1: /* on a des char */
      iCache->cache[(z-iCache->plan_min + iCache->debut) % iCache->cache_size][y*iCache->lfmt[I_NDIMX] + x] = (char)valeur;
      break;
    case 2: /* on a des short int */
      ((short int *)(iCache->cache[(z-iCache->plan_min + iCache->debut) % iCache->cache_size])) [y*iCache->lfmt[I_NDIMX] + x] = (short int)valeur;
      break;
    case 4:
      if (iCache->lfmt[I_TYPE]==1) /* on a des flottants */
         ((float *)(iCache->cache[(z-iCache->plan_min + iCache->debut) % iCache->cache_size])) [y*iCache->lfmt[I_NDIMX] + x] = (float)valeur;
      else /* on a des int */
         ((int *)(iCache->cache[(z-iCache->plan_min + iCache->debut) % iCache->cache_size])) [y*iCache->lfmt[I_NDIMX] + x] = (int) valeur; 
      break;
    case 8:
      ((double *)(iCache->cache[(z-iCache->plan_min + iCache->debut) % iCache->cache_size])) [y*iCache->lfmt[I_NDIMX] + x] = valeur;
      break;
    }
}

void copie_inricache(inricache *src,inricache *dest)
{
  register int x,y,z;
  for (z=0;z<src->lfmt[I_NDIMZ];z++)
    for (y=0;y<src->lfmt[I_NDIMY];y++)
      for (x=0;x<src->lfmt[I_NDIMX];x++)
         setValue(dest,x,y,z,getValue(src,x,y,z));
}

/*********************/
/* fonctions locales */
/*********************/

void chargePlan(inricache * iCache,int numplan)
{
  register int plan_min=iCache->plan_min;
  register int taille_cache=iCache->cache_size;
  register int i=0,n_dimy = iCache->lfmt[I_NDIMY];
  register int indice;
  register int premier_charge;

  if ((numplan<plan_min) || (numplan >= plan_min + taille_cache))
    {
      if (numplan == plan_min + taille_cache)  
         {
           /* charger un plan */
           /* on ecrit le plus vieux, on l'incremente, et on remplace */
           indice = iCache->debut;
           c_pecr(iCache->img,n_dimy,iCache->cache[indice],1+(plan_min)*n_dimy,0);
           (iCache->plan_min)++;
           iCache->debut=(indice+1) % taille_cache;
           c_plect(iCache->img,n_dimy,iCache->cache[indice],1+(numplan)*n_dimy,0);
         }
      else
         {
           if (numplan == plan_min-1)
             {
               /* pour les parcours avant/arriere de l'algorithme de Danielsson, il veut mieux gerer les retours en arriere */
               /* charger un plan */
               /* on ecrit le plus recent , on decremente le plus vieux plan et on remplace */
               indice = (iCache->debut + taille_cache - 1)%taille_cache;
               c_pecr(iCache->img,n_dimy,iCache->cache[indice],1+(plan_min-1)*n_dimy,0);
               iCache->plan_min=numplan;
               iCache->debut=indice;
               c_plect(iCache->img,n_dimy,iCache->cache[indice],1+(numplan)*n_dimy,0);
             }
           else
             {
               /* on choisit ce min afin de ne pas tenter de charger un plan dont le numero est superieur au nombre de plabs dans l'image */
               premier_charge = (int)min(numplan,iCache->lfmt[I_NDIMZ]-taille_cache);
               /* charger complementement le cache depuis 0, on revient en arriere */
               for (i=0;i<taille_cache;i++)
                  {
                    indice = (iCache->debut + i)% taille_cache;
                    /* pour chaque plan charge en cache: ecriture */
                    c_pecr(iCache->img,n_dimy,iCache->cache[indice],1+(i + plan_min)*n_dimy,0);
                  }
               iCache->plan_min=premier_charge;
               iCache->debut=0;
               for (i=0;i<taille_cache;i++)
                  {
                    /* rechargement du cache */
                    c_plect(iCache->img,n_dimy,iCache->cache[i],1+(i + premier_charge)*n_dimy,0);
                  }
             }
         }
    }
}

double max_inricache(inricache *iCache)
{
  switch (iCache->lfmt[I_BSIZE])
    {
    case 1: /* on a des char */
      return ((double) CHAR_MAX);
      break;
    case 2: /* on a des short int */
      return ((double) SHRT_MAX);
      break;
    case 4:
      if (iCache->lfmt[I_TYPE]==1) /* on a des flottants, ceux-ci doivent etre compris entre -1 et 1 */
         //       return ((double) FLT_MAX);
         return 1;
      else /* on a des int */
         return ((double) INT_MAX);
      break;
    case 8: /* on a un double le comportement est le meme que pour un flottant */
      //      return (DBL_MAX);
      return 1;
      break;
    default:
      fprintf(stderr,"%s: format non reconnu\n",iCache->img->nom);
      return 0;
      break;
    }
}

void extrema_inricache(inricache *iCache,double *mini,double *maxi)
{
  register int x,y,z,x_max,y_max,z_max;

  x_max = iCache->lfmt[I_NDIMX];
  y_max = iCache->lfmt[I_NDIMY];
  z_max = iCache->lfmt[I_NDIMZ];
  /* on initialise les extrema au premier pixel des caches, quitte a relire ces derniers */
  *mini=getValue(iCache,0,0,0);
  *maxi=*mini;

  for (z=0;z<z_max;z++)
    for (y=0;y<y_max;y++)
      for (x=0;x<x_max;x++)
         {
           *mini=min(*mini,getValue(iCache,x,y,z));
           *maxi=max(*maxi,getValue(iCache,x,y,z));
         }
}

char * getName(inricache * iCache)
{
  return (iCache->img->nom);
}

void resize_inricache(inricache *iCache,inricache *dest,int x0,int y0,int z0,int time_flag)
{
  clock_t t0=0,t1=0;
  double x_pas,y_pas,z_pas;
  register int i,j,k,x_max,y_max,z_max;

  /* chronometrage si on le demande */
  if (time_flag)
    t0 = clock(); 

  /* initialisation des parametres */

  x_max = dest->lfmt[I_NDIMX];
  y_max = dest->lfmt[I_NDIMY];
  z_max = dest->lfmt[I_NDIMZ];
  x_pas = (double)(iCache->lfmt[I_NDIMX]-x0)/x_max;
  y_pas = (double)(iCache->lfmt[I_NDIMY]-y0)/y_max;
  z_pas = (double)(iCache->lfmt[I_NDIMZ]-z0)/z_max;

  /* sous-echantillonage */

  for (k=0;k<z_max;k++)
    for (j=0;j<y_max;j++)
      for (i=0;i<x_max;i++)
         setValue(dest,i,j,k,getValue(iCache,x0+(int)(i*x_pas),y0+(int)(j*y_pas),z0+(int)(k*z_pas)));

  if (time_flag)
    {
      t1=clock()-t0;
      fprintf(stderr,"resize_inricache: temps mis: %f secondes\n",t1/(float)CLOCKS_PER_SEC);
    }
}

void normalize_inricache(inricache *iCache,inricache *iNormed,double mini,double maxi,int time_flag)
{
  clock_t t0=0,t1=0;
  register int i,j,k,x_max,y_max,z_max;
  double min_calc=0,max_calc=0;
  double delta,coeff;

  /* chronometrage si on le demande */
  if (time_flag)
    t0 = clock();

  /* si jamais les deux inricaches ne sont pas de meme dimension on quitte avec imerror code 6 */
  if ((iCache->lfmt[I_NDIMX]!=iNormed->lfmt[I_NDIMX]) ||
      (iCache->lfmt[I_NDIMY]!=iNormed->lfmt[I_NDIMY]) ||
      (iCache->lfmt[I_NDIMZ]!=iNormed->lfmt[I_NDIMZ]))
    imerror(6,"normalize_inricache: dimensions differentes pour les caches source et destination");

  /* initialisation des parametres */
  x_max = iCache->lfmt[I_NDIMX];
  y_max = iCache->lfmt[I_NDIMY];
  z_max = iCache->lfmt[I_NDIMZ];

  extrema_inricache(iCache,&min_calc,&max_calc);
  if ((mini<0) || (mini>min_calc)) /* le minimum n'est pas impose */
    {
      if (mini>min_calc)
         fprintf(stderr,"min demande (%f) superieur au min calcule (%f) : [Ignore]\n",mini,min_calc);
    }
  else
    {min_calc=mini;}
  
  if (maxi<0 || maxi<max_calc) /* le maximum n'est pas impose */
    {
      if (maxi>0)
         fprintf(stderr,"max demande (%f) inferieur au max calcule (%f) : [Ignore]\n",maxi,max_calc);
    }
  else
    {max_calc=maxi;}
  
  delta=max_calc-min_calc;
  if (delta==0)
    imerror(9,"normalize_inricache: tentative de normalisation d'une image constante\n");

  /* ce coefficient sert a passer d'un element compris entre 0 et src_max, a un element compris entre 0 et dest_max */
  coeff=max_inricache(iNormed)/max_inricache(iCache);

  for (k=0;k<z_max;k++)
    for (j=0;j<y_max;j++)
      for (i=0;i<x_max;i++)
         setValue(iNormed,i,j,k,coeff*(getValue(iCache,i,j,k)-min_calc)/delta);

  if (time_flag)
    {
      t1=clock()-t0;
      fprintf(stderr,"normalize_inricache: temps mis: %f secondes\n",t1/(float)CLOCKS_PER_SEC);
    } 
}

---