Ignore:
Timestamp:
Sep 24, 2002, 4:03:36 PM (23 years ago)
Author:
lemeur
Message:

toilette d'ete : rationalisation de types...

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/SophyaExt/FitsIOServer/fitsfile.cc

    r2129 r2197  
    2626    if (dc >0) ddata_ = vector<double>(dc);
    2727    if (fc >0) fdata_ = vector<float>(fc);
    28     if (ic >0) idata_ = vector<int>(fc);
    29     if (cc >0) cdata_ = vector<string>(fc);
     28    if (ic >0) idata_ = vector<int>(ic);
    3029    if (lc >0) ldata_ = vector<long>(lc);
    3130    if (bc >0) bdata_ = vector<unsigned char>(bc);
     31    if (cc >0) cdata_ = vector<string>(cc);
    3232   }
    3333
    … …  
    6666   }
    6767
    68 
     68FitsFile::BufferLine::BufferLine(const vector<FitsFile::FitsDataType>& types)
     69{
     70
     71
     72  int dc=0;
     73  int fc=0;
     74  int shc=0;
     75  int ic=0;
     76  int lc=0;
     77  int cc=0;
     78  int bc=0;
     79  id_  = vector< pair<FitsFile::FitsDataType, int> >(types.size());
     80  for (int k= 0; k < types.size(); k++)
     81    {
     82      switch( types[k] )
     83        {
     84        case FitsFile::FitsDataType_double :
     85          {
     86            id_[k] = pair<FitsFile::FitsDataType, int>(FitsFile::FitsDataType_double, dc);
     87            dc++;
     88            break;
     89          }
     90        case FitsFile::FitsDataType_float :
     91          {
     92            id_[k] = pair<FitsFile::FitsDataType, int>(FitsFile::FitsDataType_float, fc);
     93            fc++;
     94            break;
     95          }
     96        case  FitsFile::FitsDataType_short :
     97          {
     98            id_[k] = pair<FitsFile::FitsDataType, int>(FitsDataType_short, shc);
     99            shc++;
     100            break;
     101          }
     102        case  FitsFile::FitsDataType_int :
     103          {
     104            id_[k] = pair<FitsFile::FitsDataType, int>(FitsDataType_int, ic);
     105            ic++;
     106            break;
     107          }
     108        case  FitsFile::FitsDataType_long :
     109          {
     110            id_[k] = pair<FitsFile::FitsDataType, int>(FitsFile::FitsDataType_long, lc);
     111            lc++;
     112            break;
     113          }
     114        case  FitsFile::FitsDataType_byte :
     115          {
     116            id_[k] = pair<FitsFile::FitsDataType, int>(FitsFile::FitsDataType_byte, bc);
     117            bc++;
     118            break;
     119          }
     120        case FitsDataType_char :
     121          {
     122            id_[k] = pair<FitsFile::FitsDataType, int>(FitsFile::FitsDataType_char, cc);
     123            cc++;
     124            break;
     125          }
     126        default:
     127          {
     128            throw PException(" FitsFile::getHeaderWithSophyaObject() : unsupported FITS data type");
     129          }
     130        }
     131    }
     132
     133  if (dc >0) ddata_ = vector<r_8>(dc);
     134  if (fc >0) fdata_ = vector<r_4>(fc);
     135  if (shc >0) shdata_ = vector<int_2>(shc);
     136  if (ic >0) idata_ = vector<int_4>(ic);
     137  if (lc >0) ldata_ = vector<int_8>(lc);
     138  if (cc >0) cdata_ = vector<string>(cc);
     139  if (bc >0) bdata_ = vector<unsigned char>(bc);
     140}
     141
     142
     143void FitsFile::BufferLine::Print() const
     144{
     145  cout << " impression de la ligne: " << endl;
     146
     147  cout << " doubles : " << endl;
     148  for (int k=0; k< ddata_.size(); k++)
     149    {
     150      cout << ddata_[k] << " " ;
     151    }
     152  cout << endl;
     153
     154  cout << " floats : " << endl;
     155  for (int k=0; k< fdata_.size(); k++)
     156    {
     157      cout << fdata_[k] << " " ;
     158    }
     159  cout << endl;
     160
     161  cout << " entiers courts: " << endl;
     162  for (int k=0; k< shdata_.size(); k++)
     163    {
     164      cout << shdata_[k] << " " ;
     165    }
     166  cout << endl;
     167  cout << " entiers : " << endl;
     168  for (int k=0; k< idata_.size(); k++)
     169    {
     170      cout << idata_[k] << " " ;
     171    }
     172  cout << endl;
     173
     174  cout << " entiers longs : " << endl;
     175  for (int k=0; k< ldata_.size(); k++)
     176    {
     177      cout << ldata_[k] << " " ;
     178    }
     179  cout << endl;
     180
     181  cout << " chaines carac.  : " << endl;
     182  for (int k=0; k< cdata_.size(); k++)
     183    {
     184      cout << cdata_[k] << " " ;
     185    }
     186  cout << endl;
     187
     188  cout << " bytes : " << endl;
     189  for (int k=0; k< bdata_.size(); k++)
     190    {
     191      cout << (char)bdata_[k] << " " ;
     192    }
     193  cout << endl;
     194
     195
     196}
    69197
    70198/*!
    … …  
    601729          // printerror( status,":FitsInFile::getHeader : erreur movabs");
    602730        }
     731       
     732
    603733      if(hdutype == IMAGE_HDU)
    604734        {
    … …  
    627757          KeywordsIntoDVList(fptr_, dvl_, hdunum_);
    628758        }
     759
     760    }
     761  if (hdutype_ == FitsExtensionType_BINARY_TBL || hdutype_ == FitsExtensionType_ASCII_TBL)
     762    {
     763      bfl_ = BufferLine(types_);
    629764    }
    630765}
    … …  
    736871    }
    737872  return  taille_des_chaines_[index];
     873}
     874
     875const FitsFile::BufferLine&   FitsInFile::GetBufferLine(long NoLine)
     876{
     877  int status= 0;
     878  int    anynul;
     879  double dnull= dnull_;
     880  float fnull= fnull_;
     881  int inull= inull_;
     882  char* cnull=  const_cast<char*>(cnull_.c_str());
     883  int ncol;
     884  long nels=1;
     885  double dval;
     886  float  fval;
     887  int    ival;
     888
     889  // pas d'entier de longueur superieure a 32 bits, pour cfitsio
     890  int    lval;
     891
     892  unsigned char usval;
     893  int rang = 0;
     894  int ccount = 0;
     895  for (ncol=0; ncol<nbcols_; ncol++)
     896    {
     897      rang =  bfl_.identificateur()[ncol].second;
     898      //      cout << " fitsfile : relecture col " << ncol << " type " << bfl_.identificateur()[ncol].first << " rang " << rang << endl;
     899      switch (bfl_.identificateur()[ncol].first)
     900        {
     901        case FitsDataType_double :
     902          fits_read_col(fptr_,TDOUBLE,ncol+1,NoLine+1,1,1,&dnull, &dval,&anynul,&status);
     903          bfl_.r_8Array(rang) = (r_8)dval;
     904          break;
     905        case FitsDataType_float :
     906          fits_read_col(fptr_,TFLOAT,ncol+1,NoLine+1,1,1,&fnull,&fval,&anynul,&status);
     907          bfl_.r_4Array(rang)  = (r_4)fval;
     908          break;
     909        case FitsDataType_short :
     910          fits_read_col(fptr_,TSHORT,ncol+1,NoLine+1,1,1,&inull,&ival, &anynul,&status);
     911          bfl_.int_2Array(rang) = (int_2)ival;
     912          break;
     913        case FitsDataType_int :
     914          fits_read_col(fptr_,TINT,ncol+1,NoLine+1,1,1,&inull,&ival, &anynul,&status);
     915          bfl_.int_4Array(rang) = (int_4)ival;
     916          break;
     917        case FitsDataType_long :
     918          fits_read_col(fptr_,TLONG,ncol+1,NoLine+1,1,1,&inull,&lval, &anynul,&status);
     919          bfl_.int_8Array(rang) = (int_8)lval;
     920          break;
     921        case FitsDataType_byte :
     922          fits_read_col(fptr_,TBYTE,ncol+1,NoLine+1,1,1,&inull, &usval, &anynul,&status);
     923          bfl_.u_charArray(rang) = usval;
     924          break;
     925        case FitsDataType_char :
     926          char* chaine = new char[taille_des_chaines_[ccount++]];
     927          fits_read_col(fptr_,TSTRING,ncol+1,NoLine+1,1,1,cnull,&chaine,&anynul,&status);
     928          bfl_.stringArray(rang) = string(chaine);
     929          break;
     930        }
     931      if (status)
     932        {
     933          ResetStatus(status);
     934          break;
     935        }
     936    }
     937  //  cout << " fitsfile : ligne relue " << endl;
     938  //  bfl_.Print();
     939  return bfl_;
    738940}
    739941
    … …  
    778980            break;
    779981          }
    780         case FitsDataType_float :         
    781           fits_read_col(fptr_,TFLOAT,ncol+1,ligneALire,premierElement,1,&fnull,&fdata[fcount++],&anynul,&status);
    782           break;
     982        case FitsDataType_float :
     983          {       
     984            fits_read_col(fptr_,TFLOAT,ncol+1,ligneALire,premierElement,1,&fnull,&fdata[fcount++],&anynul,&status);
     985            break;
     986          }
    783987        case  FitsDataType_int :
    784           fits_read_col(fptr_,TINT,ncol+1,ligneALire,premierElement,1,&inull,&idata[icount++],
     988          {
     989            fits_read_col(fptr_,TINT,ncol+1,ligneALire,premierElement,1,&inull,&idata[icount++],
    785990                        &anynul,&status);
    786           break;
     991            break;
     992          }
    787993        case  FitsDataType_long :
    788           fits_read_col(fptr_,TLONG,ncol+1,ligneALire,premierElement,1,&inull,&idata[icount++], &anynul,&status);
    789           break;
     994          {
     995            fits_read_col(fptr_,TLONG,ncol+1,ligneALire,premierElement,1,&inull,&idata[icount++], &anynul,&status);
     996            break;
     997          }
    790998        case  FitsDataType_byte :
    791999          {
    … …  
    7931001            fits_read_col(fptr_,TBYTE,ncol+1,ligneALire,premierElement,1,&inull,&uschar, &anynul,&status);
    7941002            idata[icount++] = (int)uschar;
    795           }
    796           break;
     1003            break;
     1004          }
    7971005        case FitsDataType_char :
    798           fits_read_col(fptr_,TSTRING,ncol+1,ligneALire,premierElement,1,cnull,&cdata[ccount++],&anynul,&status);
    799           break;
     1006          {
     1007            fits_read_col(fptr_,TSTRING,ncol+1,ligneALire,premierElement,1,cnull,&cdata[ccount++],&anynul,&status);
     1008            break;
     1009          }
     1010        default:
     1011          {
     1012            throw PException(" FitsInFile::GetBinTabLine : unsupported FITS data type");
     1013          }
    8001014        }
    8011015      if (status)
    … …  
    8291043        {
    8301044        case FitsDataType_double :
    831           fits_read_col(fptr_,TDOUBLE,ncol+1,NoLine+1,1,1,&dnull,&ligne.ddata_[dcount++],&anynul,&status);
    832           break;
     1045          {
     1046            fits_read_col(fptr_,TDOUBLE,ncol+1,NoLine+1,1,1,&dnull,&ligne.ddata_[dcount++],&anynul,&status);
     1047            break;
     1048          }
    8331049        case FitsDataType_float :
    834           fits_read_col(fptr_,TFLOAT,ncol+1,NoLine+1,1,1,&fnull,&ligne.fdata_[fcount++],&anynul,&status);
    835           break;
     1050          {
     1051            fits_read_col(fptr_,TFLOAT,ncol+1,NoLine+1,1,1,&fnull,&ligne.fdata_[fcount++],&anynul,&status);
     1052            break;
     1053          }
    8361054        case FitsDataType_int :
    837           fits_read_col(fptr_,TINT,ncol+1,NoLine+1,1,1,&inull,&ligne.idata_[icount++], &anynul,&status);
    838           break;
     1055          {
     1056            fits_read_col(fptr_,TINT,ncol+1,NoLine+1,1,1,&inull,&ligne.idata_[icount++], &anynul,&status);
     1057            break;
     1058          }
    8391059        case FitsDataType_long :
    840           fits_read_col(fptr_,TLONG,ncol+1,NoLine+1,1,1,&inull,&ligne.ldata_[icount++], &anynul,&status);
    841           break;
     1060          {
     1061            fits_read_col(fptr_,TLONG,ncol+1,NoLine+1,1,1,&inull,&ligne.ldata_[icount++], &anynul,&status);
     1062            break;
     1063          }
    8421064        case FitsDataType_byte :
    843           fits_read_col(fptr_,TBYTE,ncol+1,NoLine+1,1,1,&inull,&ligne.bdata_[icount++], &anynul,&status);
    844           break;
     1065          {
     1066            fits_read_col(fptr_,TBYTE,ncol+1,NoLine+1,1,1,&inull,&ligne.bdata_[icount++], &anynul,&status);
     1067            break;
     1068          }
    8451069        case FitsDataType_char :
    846           char* chaine = new char[taille_des_chaines_[ccount]];
    847           fits_read_col(fptr_,TSTRING,ncol+1,NoLine+1,1,1,cnull,&chaine,&anynul,&status);
    848           ligne.cdata_[ccount++] = string(chaine);
    849           break;
     1070          {
     1071            char* chaine = new char[taille_des_chaines_[ccount]];
     1072            fits_read_col(fptr_,TSTRING,ncol+1,NoLine+1,1,1,cnull,&chaine,&anynul,&status);
     1073            ligne.cdata_[ccount++] = string(chaine);
     1074            break;
     1075          }
     1076        default:
     1077          {
     1078            throw PException(" FitsInFile::GetBinTabLine : unsupported FITS data type");
     1079          }
    8501080        }
    8511081      if (status)
    … …  
    8561086    }
    8571087}
     1088
     1089
    8581090
    8591091/*! \fn void SOPHYA::FitsInFile::GetBinTabLine(int NoLine, float* fdata)
    … …  
    9451177      long repeat,width;
    9461178      fits_get_coltype(fptr_, NoCol+1,&DTYPE,&repeat,&width,&status);
    947       cout << " en lecture fits trouve le type " << DTYPE << endl;
    9481179      if( DTYPE != TLONG &&  DTYPE != TINT)
    9491180        {
    … …  
    11371368  int rept=0;
    11381369  if(hdutype == ASCII_TBL)
    1139     {
    1140       for(ii = 0; ii <  nbcols; ii++)
    1141         {
    1142           int DTYPE;
    1143           long width;
    1144           long repete = 0;
    1145           fits_get_coltype(fileptr,ii+1,&DTYPE,&repete,&width,&status);
    1146           if( status ) printerror( status,"erreur lecture type de colonne");
    1147           rept = repete;
    1148           noms.push_back(string(ttype[ii]));
    1149           switch (DTYPE)
    1150             {
    1151             case TDOUBLE :
    1152               types.push_back(FitsDataType_double);
    1153               break;
    1154             case TFLOAT :
    1155               types.push_back(FitsDataType_float);
    1156               break;
    1157             case TLONG :
    1158               types.push_back(FitsDataType_long);
    1159               break;
    1160             case TSHORT :
    1161               types.push_back(FitsDataType_int);
    1162               break;
    1163             case TSTRING :
    1164               types.push_back(FitsDataType_char);
    1165               taille_des_chaines.push_back(width);
    1166               rept/=width;
    1167               break;
    1168             default :
    1169               cout << " field " << ii+1 << " DTYPE= " << DTYPE << endl;
    1170               throw IOExc("FitsFile::GetBinTabParameters, unsupported data type of field, for ASCII table");
    1171             }
    1172           repeat.push_back(rept);
    1173         }
    1174     }
    1175   else
    11761370    {
    11771371      for(ii = 0; ii <  nbcols; ii++)
    … …  
    11991393              break;
    12001394            case TSHORT :
     1395              types.push_back(FitsDataType_short);
     1396              break;
     1397            case TSTRING :
     1398              types.push_back(FitsDataType_char);
     1399              taille_des_chaines.push_back(width);
     1400              rept/=width;
     1401              break;
     1402            default :
     1403              cout << " field " << ii+1 << " DTYPE= " << DTYPE << endl;
     1404              throw IOExc("FitsFile::GetBinTabParameters, unsupported data type of field, for ASCII table");
     1405            }
     1406          repeat.push_back(rept);
     1407        }
     1408    }
     1409  else
     1410    {
     1411      for(ii = 0; ii <  nbcols; ii++)
     1412        {
     1413          int DTYPE;
     1414          long width;
     1415          long repete = 0;
     1416          fits_get_coltype(fileptr,ii+1,&DTYPE,&repete,&width,&status);
     1417          if( status ) printerror( status,"erreur lecture type de colonne");
     1418          rept = repete;
     1419          noms.push_back(string(ttype[ii]));
     1420          switch (DTYPE)
     1421            {
     1422            case TDOUBLE :
     1423              types.push_back(FitsDataType_double);
     1424              break;
     1425            case TFLOAT :
     1426              types.push_back(FitsDataType_float);
     1427              break;
     1428            case TLONG :
     1429              types.push_back(FitsDataType_long);
     1430              break;
     1431            case TINT :
    12011432              types.push_back(FitsDataType_int);
     1433              break;
     1434            case TSHORT :
     1435              types.push_back(FitsDataType_short);
    12021436              break;
    12031437            case TSTRING :
    … …  
    17181952   
    17191953
    1720 // la logique voudrait qu'on distingue TLONG et TINT. Mais si j'ecris
    1721 // et relis immediatement quelque chose en TLONG l'experience montre
    1722 // que ca foire. Donc, je fais tout en TINT, d'ailleurs cfitsio n'a pas
    1723 // (apparemment) d'entiers de longueur superieure a 32 bits.
    1724 // En fait, je n'y comprend rien. A suivre (GLM).
    1725   if (code == TINT || code == TLONG )
    1726     {
    1727       cout << " j'ecris des TINT" << endl;
     1954 
     1955  if (code == TINT || code == TLONG)
     1956    {
     1957      // cfitsio n'a que des entiers de longueur inferieure a 32 bits.
     1958      // ici, a l'ecriture TLONG impliquerait que le tableau de donnees
     1959      // soit un tableau int_8. Donc c'est toujours TINT qu;il faut mettre
     1960      // De plus, j'ai l'impression que TINT va devenir obsolete dans cfitsio
     1961      // (GLM)
    17281962      fits_write_col(fptr_,TINT,nocol+1,1,1,nentries, donnees ,&status);
    1729     }
    1730   else if (code == TSHORT)
    1731     {
    1732       cout << " j'ecris des TSHORT " << endl;
    1733       fits_write_col(fptr_,TSHORT,nocol+1,1,1,nentries, donnees ,&status);
    17341963    }
    17351964  else
    … …  
    22112440        {
    22122441          cout << "FitsKeyword : complex keyword value not supported" << endl;;
     2442          break;
    22132443        }
    22142444      default :
Note: See TracChangeset for help on using the changeset viewer.