00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
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
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
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
00159
00160
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
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
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
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
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
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
00215 if( fp3lt=fopen(nom_3lt,"r") ){
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
00261 else if(strcmp(des->ext, "ras")==0){
00262
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
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
00275 des->header = 32;
00276
00277
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
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
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
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
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
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
00352
00353 int select_imau2_init(select_ima_t *des, imau2 *im){
00354 FILE *fpdim;
00355 char nom_ima[200], nom_dim[200];
00356 int c2, l2, tmpi, erreur, j;
00357
00358
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
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
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
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
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
00413
00414 int select_imau4_init(select_ima_t *des, imau4 *im){
00415 FILE *fpdim;
00416 char nom_ima[200], nom_dim[200];
00417 int c2, l2, tmpi, erreur, j;
00418
00419
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
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
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
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
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
00474
00475 int select_imafl_init(select_ima_t *des, imafl *im){
00476 FILE *fpdim;
00477 char nom_ima[200], nom_dim[200];
00478 int c2, l2, tmpi, erreur, j;
00479
00480
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
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
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
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
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
00535
00536 int select_imacx4_init(select_ima_t *des, imacx4 *im){
00537 FILE *fpdim;
00538 char nom_ima[200], nom_dim[200];
00539 int c2, l2, tmpi, erreur, j;
00540
00541
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
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
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
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
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
00596
00597 int select_imacx8_init(select_ima_t *des, imacx8 *im){
00598 FILE *fpdim;
00599 char nom_ima[200], nom_dim[200];
00600 int c2, l2, tmpi, erreur, j;
00601
00602
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
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
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
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
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
00669
00670
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
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
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
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
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
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
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
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
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