plan2volcal_.c Source File

00001 
00011 #include "interpolation.h"
00012 #include <unistd.h>
00013 
00014 extern void imerror ( int code, char * format, ...);
00015 
00041 void plan2volcal(char * s2D, char * d2D, char * s3D, char * d3D,float x_pas,float y_pas, int x, int y, int z, int x0, int y0,float min2D,float max2D,int taille_cache,int time_flag)
00042 {
00043   struct nf_fmt gfmt_in,gfmt_out;
00044   Fort_int z_max,y_max,x_max;
00045   char resized_s2D[80]="",resized_d2D[80]="",normed_s2D[80]="",normed_d2D[80]="";
00046 
00047   register int i,j,k;
00048   double min_calc,max_calc,min2_calc,max2_calc;
00049   clock_t t0=0,t1=0;
00050 
00051   inricache *imgS2D=NULL,*imgD2D=NULL,*imgS3D=NULL,*imgD3D=NULL;
00052   inricache *imgS2Drs=NULL,*imgD2Drs=NULL,*imgS2Dnr=NULL,*imgD2Dnr=NULL;
00053 
00054   /* chronometrage si on le demande */
00055   if (time_flag)
00056     t0 = clock();
00057 
00058   /* ouverture des images a convertir, et recuperation de ses parametres dans gfmt_in */
00059 
00060   imgS2D=cree_inricache(s2D,"e","",&gfmt_in,taille_cache);
00061   imgD2D=cree_inricache(d2D,"e","a",&gfmt_in,taille_cache);
00062 
00063   /* verification de la concordance du format a l'interieur de l'appel a cree_inricache */
00064 
00065   if (gfmt_in.lfmt[I_NDIMZ]>1)
00066     fprintf(stderr,"plan2volcal: attention, l'image %s est multiplan, seul le premier sera considere\n",s2D);
00067 
00068   /* initialisation de gfmt_out  */
00069 
00070   if (x!=0)
00071     {
00072       gfmt_out.lfmt[I_NDIMX]=x;//local_x_pas=(gfmt_in.lfmt[I_NDIMX]-x0)/(float)x;
00073       /*fprintf(stderr,"pas calcule en x: %f\n",local_x_pas);*/
00074     }
00075   else
00076     gfmt_out.lfmt[I_NDIMX]=(gfmt_in.lfmt[I_NDIMX]-x0)/x_pas;
00077   
00078   if (y!=0)
00079     {
00080       gfmt_out.lfmt[I_NDIMY]=y;//local_y_pas=(gfmt_in.lfmt[I_NDIMY]-y0)/(float)y;
00081       /*fprintf(stderr,"pas calcule en y: %f\n",local_y_pas);*/
00082     }
00083   else
00084     gfmt_out.lfmt[I_NDIMY]=(gfmt_in.lfmt[I_NDIMY]-y0)/y_pas;
00085 
00086   if(z==0)
00087     gfmt_out.lfmt[I_NDIMZ]=255;
00088   else
00089     gfmt_out.lfmt[I_NDIMZ]=z;
00090 
00091   gfmt_out.lfmt[I_NDIMV]=1;
00092   gfmt_out.lfmt[I_DIMX]=gfmt_out.lfmt[I_NDIMX];
00093   gfmt_out.lfmt[I_DIMY]=gfmt_out.lfmt[I_NDIMZ]*gfmt_out.lfmt[I_NDIMY];
00094   gfmt_out.lfmt[I_BSIZE]=1;
00095   gfmt_out.lfmt[I_TYPE]=0;
00096   gfmt_out.lfmt[I_EXP]=0;
00097 
00098   for (i=0;i<3;i++)
00099     gfmt_out.offsets[i]=0;
00100   gfmt_out.maille=gfmt_in.maille;
00101   gfmt_out.bias=0;
00102   gfmt_out.scale=1;
00103 
00104   /* creation des images de sortie */
00105 
00106   imgS3D=cree_inricache(s3D,"c","a",&gfmt_out,taille_cache);
00107   imgD3D=cree_inricache(d3D,"c","a",&gfmt_out,taille_cache);
00108 
00109   z_max=gfmt_out.lfmt[I_NDIMZ];
00110   y_max=gfmt_out.lfmt[I_NDIMY];
00111   x_max=gfmt_out.lfmt[I_NDIMX];
00112 
00113   /* dimensionnement des images a la bonne taille, on peut modifier gfmt_out, les renseignements necessaires sont toujours contenus dans les inricache crees pour la sortie
00114      on part du principe que resize_inricache redimensionne tout type d'image, en x, y, et en z
00115    */
00116   gfmt_out.lfmt[I_BSIZE]=gfmt_in.lfmt[I_BSIZE];
00117   gfmt_out.lfmt[I_NDIMZ]=gfmt_in.lfmt[I_NDIMZ];
00118   gfmt_out.lfmt[I_DIMY]=gfmt_out.lfmt[I_NDIMY]*gfmt_out.lfmt[I_NDIMZ];
00119   gfmt_out.lfmt[I_TYPE]=gfmt_in.lfmt[I_TYPE];
00120 
00121   sprintf(resized_s2D,"resized_S2D.%d",getpid());
00122   sprintf(resized_d2D,"resized_D2D.%d",getpid());
00123   sprintf(normed_s2D,"normed_S2D.%d",getpid());
00124   sprintf(normed_d2D,"normed_D2D.%d",getpid());
00125 
00126   extrema_inricache(imgS2D,&min_calc,&max_calc);
00127   fprintf(stderr,"source: min=%f max=%f\n",min_calc,max_calc);
00128 
00129   extrema_inricache(imgD2D,&min2_calc,&max2_calc);
00130   fprintf(stderr,"dest: min=%f max=%f\n",min2_calc,max2_calc);
00131 
00132   /* on redimensionne l'image */
00133   imgS2Drs=cree_inricache(resized_s2D,"c","a",&gfmt_out,taille_cache);
00134   imgD2Drs=cree_inricache(resized_d2D,"c","a",&gfmt_out,taille_cache);
00135 
00136   resize_inricache(imgS2D,imgS2Drs,x0,y0,0,max(0,time_flag-1));
00137   resize_inricache(imgD2D,imgD2Drs,x0,y0,0,max(0,time_flag-1));
00138 
00139   /* on peut deja liberer le cache des images sources et destination, on travaille sur le sous-echantillonnage */
00140 
00141   libere_inricache(imgS2D);
00142   libere_inricache(imgD2D);
00143 
00144 
00145   extrema_inricache(imgS2Drs,&min_calc,&max_calc);
00146   fprintf(stderr,"resized source: min=%f max=%f\n",min_calc,max_calc);
00147 
00148   extrema_inricache(imgD2Drs,&min2_calc,&max2_calc);
00149   fprintf(stderr,"resized dest: min=%f max=%f\n",min2_calc,max2_calc);
00150   min_calc=min(min_calc,min2_calc);
00151   max_calc=max(max_calc,max2_calc);
00152 
00153   /* verification de la validite des min et max demandes */
00154   if ((min2D<0) || (min2D>min_calc)) /* le minimum n'est pas impose */
00155     {
00156       if (min2D>min_calc)
00157          fprintf(stderr,"plan2volcal: min demande (%f) superieur au min calcule (%f) : [Ignore]\n",min2D,min_calc);
00158     }
00159   else
00160     {min_calc=min2D;}
00161   
00162   if (max2D<0 || max2D<max_calc) /* le maximum n'est pas impose */
00163     {
00164       if (max2D>0)
00165          fprintf(stderr,"plan2volcal: max demande (%f) inferieur au max calcule (%f) : [Ignore]\n",max2D,max_calc);
00166     }
00167   else
00168     {max_calc=max2D;} 
00169 
00170   fprintf(stderr,"min=%f max=%f\n",min_calc,max_calc);
00171 
00172   /* calage des images dans l'intervalle [0;1] */
00173   imgS2Dnr=cree_inricache(normed_s2D,"c","a",&gfmt_out,taille_cache);
00174   imgD2Dnr=cree_inricache(normed_d2D,"c","a",&gfmt_out,taille_cache);
00175   
00176   normalize_inricache(imgS2Drs,imgS2Dnr,min_calc,max_calc,max(time_flag-1,0));
00177   normalize_inricache(imgD2Drs,imgD2Dnr,min_calc,max_calc,max(time_flag-1,0));
00178 
00179   /* on peut liberer les images redimensionnees, on ne travaille que sur les images normalisees */
00180   libere_inricache(imgS2Drs);
00181   libere_inricache(imgD2Drs);
00182   unlink(resized_s2D);
00183   unlink(resized_d2D);
00184 
00185   /* decision pixel BLANC/NOIR */
00186   /* BLANC = 255 , NOIR = 0 */
00187   for (k=0;k<z_max;k++)
00188     for (j=0;j<y_max;j++)
00189       for (i=0;i<x_max;i++)
00190          {
00191            if (k<(getValue(imgS2Dnr,i,j,0)*(z_max-1)))
00192              setValue(imgS3D,i,j,k,0);
00193            else
00194              setValue(imgS3D,i,j,k,255);
00195            if (k<(getValue(imgD2Dnr,i,j,0)*(z_max-1)))
00196              setValue(imgD3D,i,j,k,0);
00197            else
00198              setValue(imgD3D,i,j,k,255);
00199          }
00200   
00201   /* mise a blanc de tous les pixels */
00202   /*  for (k=0;k<z_max;k++)
00203     for (j=0;j<y_max;j++)
00204       for (i=0;i<x_max;i++)
00205          {
00206            setValue(imgS3D,i,j,k,255);
00207            setValue(imgD3D,i,j,k,255);
00208          }
00209 
00210     for (j=0;j<y_max;j++)
00211       for (i=0;i<x_max;i++)
00212          {
00213            setValue(imgS3D,i,j,(int)(getValue(imgS2Dnr,i,j,0)*(z_max-1)),0);
00214            setValue(imgD3D,i,j,(int)(getValue(imgD2Dnr,i,j,0)*(z_max-1)),0);
00215          }
00216   */
00217   /* liberation des nombreux buffers alloues */
00218 
00219   libere_inricache(imgS2Dnr);
00220   libere_inricache(imgD2Dnr);
00221   unlink(normed_s2D);
00222   unlink(normed_s2D);
00223 
00224   libere_inricache(imgS3D);
00225   libere_inricache(imgD3D);
00226 
00227   if (time_flag)
00228     {
00229       t1=clock()-t0;
00230       printf("plan2volcal: temps mis: %f secondes\n",t1/(float)CLOCKS_PER_SEC);
00231     }
00232 }