lselect_ima.c

00001 /*
00002 *    Copyright (c) 2007. The BATI team. All right reserved.
00003 *
00004 *    This file is part of BATI library.
00005 *
00006 *    BATI library is free software: you can redistribute it and/or modify
00007 *    it under the terms of the GNU General Public License as published by
00008 *    the Free Software Foundation, either version 3 of the License, or
00009 *    (at your option) any later version.
00010 *
00011 *    BATI library  is distributed in the hope that it will be useful,
00012 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
00013 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014 *    GNU General Public License for more details.
00015 *
00016 *    You should have received a copy of the GNU General Public License
00017 *    along with BATI library.  If not, see <http://www.gnu.org/licenses/>.
00018 */
00019 /* ***************************** lselect_ima.c ****************************/
00020 /*                                                                        */
00021 /* ************************************************************************/
00022 
00064 #include "image.h"
00065 #include "proto2D.h"
00066 #include "permut.h"
00067 #include <stdlib.h>
00068 #include <fcntl.h>
00069 #include <sys/types.h>
00070 #include <sys/stat.h>
00071 #include "rasterfile.h"
00072 #include <string.h>
00073 
00074 #define PERMS   0644
00075 
00076 
00077 /* **********************  LECTURE DE PARAMETRES   ***************************/
00094 param *select_ima_lect(select_ima_t *des, param *ptp, char *debq){
00095   FILE *fpdim;
00096   char nom[200], nom_dim[200], question[500];
00097   int l, c2, l2, nb;
00098 
00099   sprintf(question, "%s nom complet du fichier", debq); 
00100   lec_param(question, ptp);
00101   strcpy(nom, ptp->rep);
00102   ptp = ptp->next;
00103 
00104   l = strlen(nom);
00105   do
00106       l--;
00107   while(nom[l] != '.'  && l>0);
00108   if( l>0 ){
00109       strncpy(des->nom, nom, l);
00110       des->nom[l] = '\0';
00111       strcpy(des->ext, nom+l+1);
00112   }
00113   else{
00114       printf("\n>> ERREUR select_ima_lect : nom image incomplet (extension?)\n");
00115       exit(1);
00116   }
00117 
00118   /* dimensions des blocs de lignes */
00119   sprintf(question, "%s premiere colonne a extraire", debq); 
00120   lec_param(question, ptp);
00121   des->col0 = atoi(ptp->rep);
00122   ptp = ptp->next;
00123 
00124   sprintf(question, "%s nombre de colonnes des blocs", debq); 
00125   lec_param(question, ptp);
00126   des->nb_col = atoi(ptp->rep);
00127   ptp = ptp->next;
00128 
00129   sprintf(question, "%s premiere ligne a extraire", debq); 
00130   lec_param(question, ptp);
00131   des->lig0 = atoi(ptp->rep);
00132   ptp = ptp->next;
00133 
00134   sprintf(question, "%s nombre de lignes des blocs", debq); 
00135   lec_param(question, ptp);
00136   des->nb_lig = atoi(ptp->rep);
00137   ptp = ptp->next;
00138 
00139   sprintf(question, "%s nombre de blocs a lire", debq); 
00140   lec_param(question, ptp);
00141   des->nb_bloc = atoi(ptp->rep);
00142   ptp = ptp->next;
00143 
00144   return(ptp);
00145 }
00146 
00147 
00148 /* **********************  INITIALISATION  *****************************/
00159 /************************************/
00160 /* image 8 bit : .ima+.dim et .ras */
00161 /************************************/
00162 int select_imau1_init(select_ima_t *des, imau1 *im){ 
00163   FILE *fpdim, *fp3lt;
00164   char nom_ima[200], nom_dim[200], nom_3lt[200], nom_ras[200];  
00165   int c2, l2, tmpi, erreur, j;
00166   
00167   int headras[8], fausse_couleur, fima;
00168   register int nb_color, i;
00169   pixu1 cmap[3][256];
00170 
00171   /* allocation du bloc */
00172   sprintf(im->nom, "%s_bloc.%s", des->nom, des->ext);
00173   im->nc = des->nb_col;
00174   im->nr = des->nb_lig;
00175   alloc_imau1(im);  
00176 
00177   /* cas .ima + .dim + [.3lt] */
00178   if(strcmp(des->ext, "ima") == 0){  
00179       des->header = 0;
00180       sprintf(nom_ima, "%s.ima", des->nom); 
00181       sprintf(nom_dim, "%s.dim", des->nom); 
00182       sprintf(nom_3lt, "%s.3lt", des->nom); 
00183 
00184       /* dimension */ 
00185       if( fpdim=fopen(nom_dim,"r") ){
00186           fscanf(fpdim,"%d %d", &des->dimX, &des->dimY );
00187           fclose(fpdim);
00188           printf("\n>> select_imau1_init : image %s, dimX=%d, dimY=%d\n", 
00189                  nom_ima, des->dimX, des->dimY);
00190       }
00191       else{
00192           printf("\n>> ERREUR select_imau1_init : fichier %s introuvable\n",
00193                  nom_dim);
00194           exit(1);
00195       }      
00196 
00197       /* verif coherence des tailles de bloc */
00198       c2 = des->col0 + des->nb_col;
00199       l2 = des->lig0 + des->nb_lig*des->nb_bloc;
00200       if( des->col0 < 0  || des->col0 >= des->dimX ||
00201           c2 < des->col0 || c2 >  des->dimX        || 
00202           des->lig0 < 0  || des->lig0 >= des->dimY ||
00203           l2 < des->lig0 || l2 > des->dimY         ){ 
00204           printf("\n>> ERREUR select_imau1_init : dimensions incoherentes\n");
00205           exit(1); 
00206       }
00207 
00208       /* ouverture donnees  */
00209       if( (des->dfi=open(nom_ima, O_RDONLY, 0)) == -1 ){
00210           printf("\n>> ERREUR select_imau1_init : fichier %s introuvable\n", nom_ima);
00211           exit(1);
00212       }  
00213 
00214       /* lecture de .3lt */
00215       if( fp3lt=fopen(nom_3lt,"r") ){ /* presence de colormap */
00216           if( (im->lutr = (pixu1*)malloc(256)) == NULL ||
00217               (im->lutv = (pixu1*)malloc(256)) == NULL ||
00218               (im->lutb = (pixu1*)malloc(256)) == NULL ){
00219               printf ("\nERREUR select_imau1_init: allocation impossible\n");  
00220               exit(1);      
00221           }
00222           erreur = 0;
00223           for(j = 0; j < 256; j++)
00224               if( fscanf(fp3lt, "%d", &tmpi) == 1 )
00225                   im->lutr[j] = (pixu1)tmpi;
00226               else{
00227                   erreur = 1;
00228                   break;
00229               }
00230           for(j = 0; j < 256; j++)
00231               if( fscanf(fp3lt, "%d", &tmpi) == 1 )
00232                   im->lutv[j] = (pixu1)tmpi;
00233               else{
00234                   erreur = 1;
00235                   break;
00236               }
00237           for(j = 0; j < 256; j++)
00238               if( fscanf(fp3lt, "%d", &tmpi) == 1 )
00239                   im->lutb[j] = (pixu1)tmpi;
00240               else{
00241                   erreur = 1;
00242                   break;
00243               }
00244           fclose(fp3lt);
00245           if( erreur ){  
00246               printf ("\nATT select_imau1_init: lecture %s incomplete, LUT ignoree\n", nom_3lt);  
00247               free(im->lutr); im->lutr = NULL;
00248               free(im->lutv); im->lutv = NULL;
00249               free(im->lutb); im->lutb = NULL;
00250           }
00251           else
00252               printf ("\nselect_imau1_init: LUT %s chargee\n",nom_3lt);  
00253       }
00254       else{
00255           im->lutr = NULL;
00256           im->lutv = NULL;
00257           im->lutb = NULL;
00258       }
00259   }
00260   /* cas RASTER */
00261   else if(strcmp(des->ext, "ras")==0){
00262       /*ouverture du fichier*/
00263       sprintf(nom_ras, "%s.ras", des->nom); 
00264       if( (des->dfi = open(nom_ras, O_RDONLY, 0)) == -1 ){
00265           printf("\n>> ERREUR select_imau1_init : fichier %s introuvable\n", nom_ras);
00266           exit(1);
00267       }
00268       /*lecture entete*/
00269       if( read(des->dfi, (char*)headras, 32) != 32 ){
00270           printf("\n>> ERREUR select_imau1_init : lecture fichier %s \n", nom_ras);  
00271           exit(1); 
00272       } 
00273 
00274       /*conservation de la dimension de l'entete*/
00275       des->header = 32;
00276 
00277       /*verification type raster*/
00278       if( headras[0] != 0x59a66a95 ){
00279           printf("\n>> ERREUR read_imau1_init: magic number incorrect %x!=0x59a66a95\n", 
00280                   headras[0]);
00281           exit(1);
00282       }
00283 
00284       /*verif coherence des tailles*/
00285       des->dimX = headras[1];
00286       des->dimY = headras[2];
00287       c2 = des->col0 + des->nb_col;
00288       l2 = des->lig0 + des->nb_lig*des->nb_bloc;
00289       if( des->col0 < 0  || des->col0 >= des->dimX ||
00290           c2 < des->col0 || c2 >  des->dimX        || 
00291           des->lig0 < 0  || des->lig0 >= des->dimY ||
00292           l2 < des->lig0 || l2 > des->dimY         ){ 
00293           printf("\n>> ERREUR select_imau1_init : dimensions incoherentes\n");
00294           exit(1); 
00295       }
00296       /*test presence colormap*/
00297       nb_color = 0;
00298       des->lut_ng = 0;
00299       if(headras[6]){
00300           des->lut_ng = 1;
00301           des->header = des->header + headras[7];
00302           nb_color = headras[7]/3;
00303           printf("\nATT read_imau1_init : detection d'une LUT de %d niveaux dans %s\n",
00304                  nb_color, nom_ras);
00305           /*lecture de la lut*/
00306           for(i=0; i<3; i++){ 
00307               if( read(des->dfi, cmap[i], nb_color) != nb_color ){
00308                   printf("\n>> ERREUR read_imau1_init: lecture LUT fichier %s \n", nom_ras);  
00309                   exit(1); 
00310               }
00311               for(j=nb_color; j<256; j++) 
00312                   cmap[i][j] = j;
00313           }
00314           /*test si cas fausses couleurs*/
00315           for(j=0; j<nb_color; j++)
00316               if(cmap[0][j] != cmap[1][j] || cmap[1][j] != cmap[2][j]){
00317                   des->lut_ng = 0;
00318                   break;
00319               }  
00320           if((im->lutr = (pixu1*)malloc(256)) == NULL ||
00321              (im->lutv = (pixu1*)malloc(256)) == NULL ||
00322              (im->lutb = (pixu1*)malloc(256)) == NULL ){
00323               printf ("\nERREUR  read_imau1_init: allocation impossible\n");  
00324               exit(1);      
00325           }
00326           for(j = 0; j < 256; j++){
00327               im->lutr[j] = cmap[0][j];
00328               im->lutv[j] = cmap[1][j];
00329               im->lutb[j] = cmap[2][j];
00330           }
00331           printf("\n>> ATT read_imau1_init: LUT chargee\n");
00332       }
00333       else{
00334           im->lutr = NULL;
00335           im->lutv = NULL;
00336           im->lutb = NULL;
00337       }
00338       /*fin du cas rasterfile*/
00339   }
00340   else{
00341       printf("\n>> ERREUR select_imau1_init : extension %s inconnue\n", des->ext);
00342       exit(1);
00343   }
00344 
00345   des->next_lig = des->lig0;  
00346   des->nb_bloc_lu = 0;
00347   return(0);  
00348 }
00349 
00350 /************************************************/
00351 /* image 16 bit */
00352 /************************************************/
00353 int select_imau2_init(select_ima_t *des, imau2 *im){   /* .imw       */
00354   FILE *fpdim;
00355   char nom_ima[200], nom_dim[200];  
00356   int c2, l2, tmpi, erreur, j;
00357 
00358   /* allocation du bloc */
00359   sprintf(im->nom, "%s_bloc.%s", des->nom, des->ext);
00360   im->nc = des->nb_col;
00361   im->nr = des->nb_lig;
00362   alloc_imau2(im);  
00363 
00364   /* cas .imw|.IMW + .dim  */
00365   if(strcmp(des->ext, "imw") == 0 || strcmp(des->ext, "IMW") == 0){  
00366       des->header = 0;
00367       sprintf(nom_ima, "%s.%s", des->nom, des->ext); 
00368       sprintf(nom_dim, "%s.dim", des->nom); 
00369 
00370       /* dimesion */ 
00371       if( fpdim=fopen(nom_dim,"r") ){
00372           fscanf(fpdim,"%d %d", &des->dimX, &des->dimY );
00373           fclose(fpdim);
00374           printf("\n>> select_imau2_init : image %s, dimX=%d, dimY=%d\n", 
00375                  nom_ima, des->dimX, des->dimY);
00376       }
00377       else{
00378           printf("\n>> ERREUR select_imau2_init : fichier %s introuvable\n",
00379                  nom_dim);
00380           exit(1);
00381       }      
00382 
00383       /* verif coherence des tailles de bloc */
00384       c2 = des->col0 + des->nb_col;
00385       l2 = des->lig0 + des->nb_lig*des->nb_bloc;
00386       if( des->col0 < 0  || des->col0 >= des->dimX ||
00387           c2 < des->col0 || c2 >  des->dimX        || 
00388           des->lig0 < 0  || des->lig0 >= des->dimY ||
00389           l2 < des->lig0 || l2 > des->dimY         ){ 
00390           printf("\n>> ERREUR select_imau2_init : dimensions incoherentes\n");
00391           exit(1); 
00392       }
00393 
00394       /* ouverture donnees  */
00395       if( (des->dfi=open(nom_ima, O_RDONLY, 0)) == -1 ){
00396           printf("\n>> ERREUR select_imau2_init : fichier %s introuvable\n", nom_ima);
00397           exit(1);
00398       }  
00399   }
00400   else{
00401       printf("\n>> ERREUR select_imau2_init : extension %s inconnue\n", des->ext);
00402       exit(1);
00403   }
00404 
00405   des->next_lig = des->lig0;  
00406   des->nb_bloc_lu = 0;
00407 
00408   return(0);  
00409 }
00410 
00411 /************************************************/
00412 /* image 32 bit */
00413 /************************************************/
00414 int select_imau4_init(select_ima_t *des, imau4 *im){   /* .iml       */
00415   FILE *fpdim;
00416   char nom_ima[200], nom_dim[200];  
00417   int c2, l2, tmpi, erreur, j;
00418 
00419   /* allocation du bloc */
00420   sprintf(im->nom, "%s_bloc.%s", des->nom, des->ext);
00421   im->nc = des->nb_col;
00422   im->nr = des->nb_lig;
00423   alloc_imau4(im);  
00424 
00425   /* cas .iml|IML + .dim  */
00426   if(strcmp(des->ext, "iml") == 0 || strcmp(des->ext, "IML") == 0){  
00427       des->header = 0;
00428       sprintf(nom_ima, "%s.%s", des->nom, des->ext); 
00429       sprintf(nom_dim, "%s.dim", des->nom); 
00430 
00431       /* dimesion */ 
00432       if( fpdim=fopen(nom_dim,"r") ){
00433           fscanf(fpdim,"%d %d", &des->dimX, &des->dimY );
00434           fclose(fpdim);
00435           printf("\n>> select_imau4_init : image %s, dimX=%d, dimY=%d\n", 
00436                  nom_ima, des->dimX, des->dimY);
00437       }
00438       else{
00439           printf("\n>> ERREUR select_imau4_init : fichier %s introuvable\n",
00440                  nom_dim);
00441           exit(1);
00442       }      
00443 
00444       /* verif coherence des tailles de bloc */
00445       c2 = des->col0 + des->nb_col;
00446       l2 = des->lig0 + des->nb_lig*des->nb_bloc;
00447       if( des->col0 < 0  || des->col0 >= des->dimX ||
00448           c2 < des->col0 || c2 >  des->dimX        || 
00449           des->lig0 < 0  || des->lig0 >= des->dimY ||
00450           l2 < des->lig0 || l2 > des->dimY         ){ 
00451           printf("\n>> ERREUR select_imau4_init : dimensions incoherentes\n");
00452           exit(1); 
00453       }
00454 
00455       /* ouverture donnees  */
00456       if( (des->dfi=open(nom_ima, O_RDONLY, 0)) == -1 ){
00457           printf("\n>> ERREUR select_imau4_init : fichier %s introuvable\n", nom_ima);
00458           exit(1);
00459       }  
00460   }
00461   else{
00462       printf("\n>> ERREUR select_imau4_init : extension %s inconnue\n", des->ext);
00463       exit(1);
00464   }
00465 
00466   des->next_lig = des->lig0;  
00467   des->nb_bloc_lu = 0;
00468 
00469   return(0);  
00470 }
00471 
00472 /************************************************/
00473 /* image float */
00474 /************************************************/
00475 int select_imafl_init(select_ima_t *des, imafl *im){   /* .imf       */
00476   FILE *fpdim;
00477   char nom_ima[200], nom_dim[200];  
00478   int c2, l2, tmpi, erreur, j;
00479 
00480   /* allocation du bloc */
00481   sprintf(im->nom, "%s_bloc.%s", des->nom, des->ext);
00482   im->nc = des->nb_col;
00483   im->nr = des->nb_lig;
00484   alloc_imafl(im);  
00485 
00486   /* cas .imf|IMF + .dim  */
00487   if(strcmp(des->ext, "imf") == 0 || strcmp(des->ext, "IMF") == 0){  
00488       des->header = 0;
00489       sprintf(nom_ima, "%s.%s", des->nom, des->ext);  
00490       sprintf(nom_dim, "%s.dim", des->nom); 
00491 
00492       /* dimesion */ 
00493       if( fpdim=fopen(nom_dim,"r") ){
00494           fscanf(fpdim,"%d %d", &des->dimX, &des->dimY );
00495           fclose(fpdim);
00496           printf("\n>> select_imafl_init : image %s, dimX=%d, dimY=%d\n", 
00497                  nom_ima, des->dimX, des->dimY);
00498       }
00499       else{
00500           printf("\n>> ERREUR select_imafl_init : fichier %s introuvable\n",
00501                  nom_dim);
00502           exit(1);
00503       }      
00504 
00505       /* verif coherence des tailles de bloc */
00506       c2 = des->col0 + des->nb_col;
00507       l2 = des->lig0 + des->nb_lig*des->nb_bloc;
00508       if( des->col0 < 0  || des->col0 >= des->dimX ||
00509           c2 < des->col0 || c2 >  des->dimX        || 
00510           des->lig0 < 0  || des->lig0 >= des->dimY ||
00511           l2 < des->lig0 || l2 > des->dimY         ){ 
00512           printf("\n>> ERREUR select_imafl_init : dimensions incoherentes\n");
00513           exit(1); 
00514       }
00515 
00516       /* ouverture donnees  */
00517       if( (des->dfi=open(nom_ima, O_RDONLY, 0)) == -1 ){
00518           printf("\n>> ERREUR select_imafl_init : fichier %s introuvable\n", nom_ima);
00519           exit(1);
00520       }  
00521   }
00522   else{
00523       printf("\n>> ERREUR select_imafl_init : extension %s inconnue\n", des->ext);
00524       exit(1);
00525   }
00526 
00527   des->next_lig = des->lig0;  
00528   des->nb_bloc_lu = 0;
00529 
00530   return(0);  
00531 }
00532 
00533 /************************************************/
00534 /* image complexe short */
00535 /************************************************/
00536 int select_imacx4_init(select_ima_t *des, imacx4 *im){ /* .cxs       */
00537   FILE *fpdim;
00538   char nom_ima[200], nom_dim[200];  
00539   int c2, l2, tmpi, erreur, j;
00540 
00541   /* allocation du bloc */
00542   sprintf(im->nom, "%s_bloc.%s", des->nom, des->ext);
00543   im->nc = des->nb_col;
00544   im->nr = des->nb_lig;
00545   alloc_imacx4(im);  
00546 
00547   /* cas .cxs|CXS + .dim  */
00548   if(strcmp(des->ext, "cxs") == 0 || strcmp(des->ext, "CXS") == 0){  
00549       des->header = 0;
00550       sprintf(nom_ima, "%s.%s", des->nom, des->ext);  
00551       sprintf(nom_dim, "%s.dim", des->nom); 
00552 
00553       /* dimesion */ 
00554       if( fpdim=fopen(nom_dim,"r") ){
00555           fscanf(fpdim,"%d %d", &des->dimX, &des->dimY );
00556           fclose(fpdim);
00557           printf("\n>> select_imacx4_init : image %s, dimX=%d, dimY=%d\n", 
00558                  nom_ima, des->dimX, des->dimY);
00559       }
00560       else{
00561           printf("\n>> ERREUR select_imacx4_init : fichier %s introuvable\n",
00562                  nom_dim);
00563           exit(1);
00564       }      
00565 
00566       /* verif coherence des tailles de bloc */
00567       c2 = des->col0 + des->nb_col;
00568       l2 = des->lig0 + des->nb_lig*des->nb_bloc;
00569       if( des->col0 < 0  || des->col0 >= des->dimX ||
00570           c2 < des->col0 || c2 >  des->dimX        || 
00571           des->lig0 < 0  || des->lig0 >= des->dimY ||
00572           l2 < des->lig0 || l2 > des->dimY         ){ 
00573           printf("\n>> ERREUR select_imacx4_init : dimensions incoherentes\n");
00574           exit(1); 
00575       }
00576 
00577       /* ouverture donnees  */
00578       if( (des->dfi=open(nom_ima, O_RDONLY, 0)) == -1 ){
00579           printf("\n>> ERREUR select_imacx4_init : fichier %s introuvable\n", nom_ima);
00580           exit(1);
00581       }  
00582   }
00583   else{
00584       printf("\n>> ERREUR select_imacx4_init : extension %s inconnue\n", des->ext);
00585       exit(1);
00586   }
00587 
00588   des->next_lig = des->lig0;  
00589   des->nb_bloc_lu = 0;
00590 
00591   return(0);  
00592 }
00593 
00594 /************************************************/
00595 /* image complexe float */
00596 /************************************************/
00597 int select_imacx8_init(select_ima_t *des, imacx8 *im){ /* .cxf       */
00598   FILE *fpdim;
00599   char nom_ima[200], nom_dim[200];  
00600   int c2, l2, tmpi, erreur, j;
00601 
00602   /* allocation du bloc */
00603   sprintf(im->nom, "%s_bloc.%s", des->nom, des->ext);
00604   im->nc = des->nb_col;
00605   im->nr = des->nb_lig;
00606   alloc_imacx8(im);  
00607 
00608   /* cas .cxf|CXF + .dim  */
00609   if(strcmp(des->ext, "cxf") == 0 || strcmp(des->ext, "CXF") == 0){  
00610       des->header = 0;
00611       sprintf(nom_ima, "%s.%s", des->nom, des->ext); 
00612       sprintf(nom_dim, "%s.dim", des->nom); 
00613 
00614       /* dimesion */ 
00615       if( fpdim=fopen(nom_dim,"r") ){
00616           fscanf(fpdim,"%d %d", &des->dimX, &des->dimY );
00617           fclose(fpdim);
00618           printf("\n>> select_imacx8_init : image %s, dimX=%d, dimY=%d\n", 
00619                  nom_ima, des->dimX, des->dimY);
00620       }
00621       else{
00622           printf("\n>> ERREUR select_imacx8_init : fichier %s introuvable\n",
00623                  nom_dim);
00624           exit(1);
00625       }      
00626 
00627       /* verif coherence des tailles de bloc */
00628       c2 = des->col0 + des->nb_col;
00629       l2 = des->lig0 + des->nb_lig*des->nb_bloc;
00630       if( des->col0 < 0  || des->col0 >= des->dimX ||
00631           c2 < des->col0 || c2 >  des->dimX        || 
00632           des->lig0 < 0  || des->lig0 >= des->dimY ||
00633           l2 < des->lig0 || l2 > des->dimY         ){ 
00634           printf("\n>> ERREUR select_imacx8_init : dimensions incoherentes\n");
00635           exit(1); 
00636       }
00637 
00638       /* ouverture donnees  */
00639       if( (des->dfi=open(nom_ima, O_RDONLY, 0)) == -1 ){
00640           printf("\n>> ERREUR select_imacx8_init : fichier %s introuvable\n", nom_ima);
00641           exit(1);
00642       }  
00643   }
00644   else{
00645       printf("\n>> ERREUR select_imacx8_init : extension %s inconnue\n", des->ext);
00646       exit(1);
00647   }
00648 
00649   des->next_lig = des->lig0;  
00650   des->nb_bloc_lu = 0;
00651 
00652   return(0);  
00653 }
00654 
00655 
00656 /* ************************  CALCUL  ****************************************/
00669 /************************************************/
00670 /* .ima   ou .ras    */
00671 /************************************************/
00672 int select_imau1_calc(select_ima_t *des, imau1 *im){
00673 
00674   int i, j, nb_oct, sp, col_impair;
00675 
00676   sp = sizeof(pixu1);
00677   col_impair = des->dimX%2;
00678   nb_oct = im->nc*sp;
00679   if(des->nb_bloc_lu >= des->nb_bloc){
00680       close(des->dfi);
00681       printf("\n>> select_imau1_calc: lecture %s terminee\n", im->nom);
00682       return(1); 
00683   }
00684   /* cas .ima + .dim  */
00685   if(strcmp(des->ext, "ima") == 0){
00686       for(j=0; j<im->nr; j++){
00687           lseek(des->dfi,(long)(des->header + ((des->next_lig+j)*des->dimX + des->col0)*sp), 0);  
00688           if( read(des->dfi, (char *)im->p[j], nb_oct) != nb_oct ){
00689               printf("\n>> ATT select_imau1_calc: lecture %s incomplete\n", im->nom);
00690               close(des->dfi);
00691               return(2); 
00692           }
00693       }
00694   }
00695   /* cas RASTER */
00696   else if(strcmp(des->ext, "ras")==0){
00697       for(j=0; j<im->nr; j++){
00698           lseek(des->dfi,(long)(des->header + ((des->next_lig+j)*(des->dimX+col_impair) + des->col0)*sp), 0);
00699           if( read(des->dfi, (char *)im->p[j], nb_oct) != nb_oct ){
00700               printf("\n>> ATT select_imau1_calc: lecture %s incomplete\n", im->nom);
00701               close(des->dfi);
00702               return(2); 
00703           }
00704           /*conversion des donnees par la lut si necessaire*/
00705           if(des->lut_ng && im->lutr!=NULL)
00706               for(i=0; i<im->nc; i++)
00707                   im->p[j][i] = im->lutr[im->p[j][i]];
00708                   
00709       }
00710   }
00711   else{
00712       printf("\n>> ERREUR select_imau1_calc : extension %s inconnue\n", des->ext);
00713       exit(1);
00714   }
00715   printf("\n>> select_imau1_calc: lecture %s : bloc %d, lignes [%d %d] OK\n",
00716          im->nom, des->nb_bloc_lu, des->next_lig, des->next_lig+des->nb_lig-1);
00717 
00718   des->next_lig += des->nb_lig;
00719   des->nb_bloc_lu++;
00720   return(0);
00721 }
00722 
00723 
00724 /************************************************/
00725 /* .imw  | IMW     */
00726 /************************************************/
00727 int select_imau2_calc(select_ima_t *des, imau2 *im){
00728 
00729   int j, nb_oct, sp;
00730 
00731   sp = sizeof(pixu2);
00732   nb_oct = im->nc*sp;
00733   if(des->nb_bloc_lu >= des->nb_bloc){
00734       close(des->dfi);
00735       printf("\n>> select_imau2_calc: lecture %s terminee\n", im->nom);
00736       return(1); 
00737   }
00738   printf("\n>> select_imau2_calc: lecture %s : bloc %d, lignes [%d %d]\n",
00739       im->nom, des->nb_bloc_lu, des->next_lig, des->next_lig+des->nb_lig-1);
00740   for(j=0; j<im->nr; j++){
00741       lseek(des->dfi,(long)(des->header + ((des->next_lig+j)*des->dimX + des->col0)*sp), 0);  
00742       if( read(des->dfi, (char *)im->p[j], nb_oct) != nb_oct ){
00743             printf("\n>> ATT select_imau2_calc: lecture %s incomplete\n", im->nom);
00744             close(des->dfi);
00745             return(2); 
00746       }
00747   }
00748 
00749 #ifdef INVERSE_DATA
00750       if(!strcmp(des->ext, "imw")){
00751         printf("Swap des octets des donnees lors de la lecture\n");
00752         for( j=0; j<im->nr; j++)
00753         permuteShortTab( (short *)im->p[j], im->nc);
00754       }
00755       else if(!strcmp(des->ext, "IMW")){
00756           printf("Pas de swap des octets lors de la lecture car fichier .IMW (INTEL)\n");
00757       }
00758       else{
00759           printf("\n extension %s inconnue\n", des->ext);
00760           exit(0);
00761       } 
00762 #endif
00763 
00764   des->next_lig += des->nb_lig;
00765   des->nb_bloc_lu++;
00766   return(0);
00767 }
00768 
00769 /************************************************/
00770 /* .iml | IML      */
00771 /************************************************/
00772 int select_imau4_calc(select_ima_t *des, imau4 *im){
00773 
00774   int j, nb_oct, sp;
00775 
00776   sp = sizeof(pixu4);
00777   nb_oct = im->nc*sp;
00778   if(des->nb_bloc_lu >= des->nb_bloc){
00779       close(des->dfi);
00780       printf("\n>> select_imau4_calc: lecture %s terminee\n", im->nom);
00781       return(1); 
00782   }
00783   printf("\n>> select_imau4_calc: lecture %s : bloc %d, lignes [%d %d]\n",
00784       im->nom, des->nb_bloc_lu, des->next_lig, des->next_lig+des->nb_lig-1);
00785   for(j=0; j<im->nr; j++){
00786       lseek(des->dfi,(long)(des->header + ((des->next_lig+j)*des->dimX + des->col0)*sp), 0);  
00787       if( read(des->dfi, (char *)im->p[j], nb_oct) != nb_oct ){
00788             printf("\n>> ATT select_imau4_calc: lecture %s incomplete\n", im->nom);
00789             close(des->dfi);
00790             return(2); 
00791       }
00792   }
00793 
00794 #ifdef INVERSE_DATA
00795       if(!strcmp(des->ext, "iml")){
00796         printf("Swap des octets des donnees lors de la lecture\n");
00797         for( j=0; j<im->nr; j++)
00798         permuteIntTab( (unsigned int *)im->p[j], im->nc);
00799       }
00800       else if(!strcmp(des->ext, "IML")){
00801           printf("Pas de swap des octets lors de la lecture car fichier .IML (INTEL)\n");
00802       }
00803       else{
00804           printf("\n extension %s inconnue\n", des->ext);
00805           exit(0);
00806       } 
00807 #endif
00808 
00809   des->next_lig += des->nb_lig;
00810   des->nb_bloc_lu++;
00811   return(0);
00812 }
00813 
00814 /************************************************/
00815 /* .imf | IMF       */
00816 /************************************************/
00817 int select_imafl_calc(select_ima_t *des, imafl *im){
00818 
00819   int j, nb_oct, sp;
00820 
00821   sp = sizeof(pixfl);
00822   nb_oct = im->nc*sp;
00823   if(des->nb_bloc_lu >= des->nb_bloc){
00824       close(des->dfi);
00825       printf("\n>> select_imafl_calc: lecture %s terminee\n", im->nom);
00826       return(1); 
00827   }
00828   printf("\n>> select_imafl_calc: lecture %s : bloc %d, lignes [%d %d]\n",
00829           im->nom, des->nb_bloc_lu, des->next_lig, des->next_lig+des->nb_lig-1);
00830   for(j=0; j<im->nr; j++){
00831       lseek(des->dfi,(long)(des->header + ((des->next_lig+j)*des->dimX + des->col0)*sp), 0);  
00832       if( read(des->dfi, (char *)im->p[j], nb_oct) != nb_oct ){
00833             printf("\n>> ATT select_imafl_calc: lecture %s incomplete\n", im->nom);
00834             close(des->dfi);
00835             return(2); 
00836       }
00837   }
00838 
00839 #ifdef INVERSE_DATA
00840 
00841         if(!strcmp(des->ext, "imf")){
00842           printf("Swap des octets des donnees lors de la lecture\n");
00843           for( j=0; j<im->nr; j++)
00844                 permuteFloatTab( im->p[j], im->nc);
00845         }
00846         else if(!strcmp(des->ext, "IMF")){
00847           printf("Pas de swap des octets lors de la lecture car fichier .IMF (INTEL)\n");
00848         }
00849         else{
00850           printf("\n extension %s inconnue\n", des->ext);
00851           exit(0);
00852         } 
00853 #endif
00854   
00855   des->next_lig += des->nb_lig;
00856   des->nb_bloc_lu++;
00857   return(0);
00858 }
00859 
00860 /************************************************/
00861 /* .cxs | CXS      */
00862 /************************************************/
00863 int select_imacx4_calc(select_ima_t *des, imacx4 *im){
00864 
00865   int j, nb_oct, sp;
00866 
00867   sp = sizeof(pixcx4);
00868   nb_oct = im->nc*sp;
00869   if(des->nb_bloc_lu >= des->nb_bloc){
00870       close(des->dfi);
00871       printf("\n>> select_imacx4_calc: lecture %s terminee\n", im->nom);
00872       return(1); 
00873   }
00874   printf("\n>> select_imacx4_calc: lecture %s : bloc %d, lignes [%d %d]\n",
00875           im->nom, des->nb_bloc_lu, des->next_lig, des->next_lig+des->nb_lig-1);
00876   for(j=0; j<im->nr; j++){
00877       lseek(des->dfi,(long)(des->header + ((des->next_lig+j)*des->dimX + des->col0)*sp), 0);  
00878       if( read(des->dfi, (char *)im->p[j], nb_oct) != nb_oct ){
00879             printf("\n>> ATT select_imacx4_calc: lecture %s incomplete\n", im->nom);
00880             close(des->dfi);
00881             return(2); 
00882       }
00883   }
00884 
00885 #ifdef INVERSE_DATA
00886         if(!strcmp(des->ext, "cxs")){
00887           printf("Swap des octets des donnees lors de la lecture\n");
00888           for( j=0; j<im->nr; j++)
00889             permuteShortTab( (short *)&im->p[j][0].re, 2*im->nc);
00890         }
00891         else if(!strcmp(des->ext, "CXS")){
00892           printf("Pas de swap des octets lors de la lecture car fichier .CXS (INTEL)\n");
00893         }
00894         else{
00895           printf("\n extension %s inconnue\n", des->ext);
00896           exit(0);
00897         } 
00898 #endif
00899 
00900   des->next_lig += des->nb_lig;
00901   des->nb_bloc_lu++;
00902   return(0);
00903 }
00904 
00905 /************************************************/
00906 /* .cxf  | CXF     */
00907 /************************************************/
00908 int select_imacx8_calc(select_ima_t *des, imacx8 *im){
00909 
00910   int j, nb_oct, sp;
00911 
00912   sp = sizeof(pixcx8);
00913   nb_oct = im->nc*sp;
00914   if(des->nb_bloc_lu >= des->nb_bloc){
00915       close(des->dfi);
00916       printf("\n>> select_imacx8_calc: lecture %s terminee\n", im->nom);
00917       return(1); 
00918   }
00919   printf("\n>> select_imacx8_calc: lecture %s : bloc %d, lignes [%d %d]\n",
00920           im->nom, des->nb_bloc_lu, des->next_lig, des->next_lig+des->nb_lig-1);
00921   for(j=0; j<im->nr; j++){
00922       lseek(des->dfi,(long)(des->header + ((des->next_lig+j)*des->dimX + des->col0)*sp), 0);  
00923       if( read(des->dfi, (char *)im->p[j], nb_oct) != nb_oct ){
00924             printf("\n>> ATT select_imacx8_calc: lecture %s incomplete\n", im->nom);
00925             close(des->dfi);
00926             return(2); 
00927       }
00928   }
00929 
00930 #ifdef INVERSE_DATA
00931 
00932         if(!strcmp(des->ext, "cxf")){
00933           printf("Swap des octets des donnees lors de la lecture\n");
00934           for( j=0; j<im->nr; j++)
00935             permuteFloatTab( &im->p[j][0].re, 2*im->nc);
00936         }
00937         else if(!strcmp(des->ext, "CXF")){
00938           printf("Pas de swap des octets lors de la lecture car fichier .CXF (INTEL)\n");
00939         }
00940         else{
00941           printf("\n extension %s inconnue\n", des->ext);
00942           exit(0);
00943         } 
00944 #endif 
00945 
00946   des->next_lig += des->nb_lig;
00947   des->nb_bloc_lu++;
00948   return(0);
00949 }
00950 
00951           

Generated on Tue Apr 22 13:31:04 2008 for ima2D by  doxygen 1.5.3