LdfFile.cxx

Go to the documentation of this file.

#include "FitsFile.h"

#include <cassert>

using std::string;
using std::vector;

FitsFile::FitsFile ( const std::string & filename )
  : FitsFileBase ( filename )
{
}

void
FitsFile::
fillHDUNames ( std::vector < std::string > & names )
{
  names.clear ();
  int number = getNumberOfHDU ( );

  for ( int i = 0; i < number; i++ ) {
    moveToHDU ( i );
    string value = stringValueForKey ( "EXTNAME" );

    if ( value == "" ) {
      if ( i == 0 ) {
        int number = intValueForKey ( "NAXIS" );
        if ( number == 0 ) {
          value = "Empty image";
        }
      }
    }

    if ( value == "" ) value = "<no name>";
    names.push_back ( value );
  }
}

int
FitsFile::
fillColumnNames ( std::vector < std::string > & labels )
{
  labels.clear ();
  int columns = getNumberOfColumns ();

  if ( columns != 0 ) {
    m_status = 0; // must NOT be reset on each fits call, else matchs
                  // same column on each call
    for ( int i = 0; i < columns; i++ ) { // count like Fortran
      char colname [ FLEN_VALUE ];
      int col;
      fits_get_colname ( m_fptr, CASEINSEN, "*",
                         colname, &col, &m_status );
      labels.push_back ( string ( colname ) );
    }
  }
  else { // must be image
    labels.push_back ( string ( "none" ) );
  }

  return m_status;
}

int
FitsFile::
fillDoubleVectorFromColumn ( std::vector < double > & vec, int column )
{
  int retval = 0;

  HduType type = getHduType ();
  if ( type == Btable || type == Atable ) {
    retval = fillFromTableColumn ( vec, column );
  }
  else {
    retval = fillFromImage ( vec );
  }

  return retval;
}

int
FitsFile::
fillFromTableColumn ( std::vector < double > & vec, int column )
{
  int anynul;
  double nulval = 0;
  long nelements = vec.size();
  vector<double>::iterator it = vec.begin();
  double * ptr = &*it;
  // Careful, counting columns like Fortran
  m_status = 0;
  fits_read_col_dbl( m_fptr, column+1, 1, 1, nelements, nulval,
                     ptr, &anynul, &m_status);

  return m_status;
}

int
FitsFile::
fillAxisSizes ( std::vector < long > & vec ) const
{
  vec.clear ();
  int naxis = getImageDimensions ();
  vec.resize ( naxis );

  vector < long > ::iterator first = vec.begin();
  long * ptr = & *first;
  m_status = 0;
  fits_get_img_size ( m_fptr, naxis, ptr, & m_status );
  assert ( m_status == 0 );

  return m_status;
}

void
FitsFile::
fillImageDeltas ( std::vector < double > & deltas ) const
{
  deltas.clear ();
  int naxis = getImageDimensions ();
  deltas.reserve ( naxis );

  char key [ FLEN_KEYWORD];
  char * keyroot = "CDELT";
  for ( int i = 0; i < naxis; i++ ) {
    m_status = 0;
    fits_make_keyn ( keyroot, i+1, key, & m_status );
    bool yes = hasKey ( key );

    if ( yes ) {
      double value = doubleValueForKey ( key );
      deltas.push_back ( value );
    }
    else { // no key, take default
      deltas.push_back ( 1.0 );
    }
  }
}

void
FitsFile::
fillRefPixelIndices ( std::vector < int > & indices ) const
{
  indices.clear ();
  int naxis = getImageDimensions ();
  indices.reserve ( naxis );

  char key [ FLEN_KEYWORD];
  char * keyroot = "CRPIX";
  for ( int i = 0; i < naxis; i++ ) {
    m_status = 0;
    fits_make_keyn ( keyroot, i+1, key, & m_status );
    bool yes = hasKey ( key );

    if ( yes ) {
      int value = intValueForKey ( key );
      indices.push_back ( value );
    }
    else { // no key, take default
      indices.push_back ( 1 );
    }
  }
}

void
FitsFile::
fillRefPixelValues ( std::vector < double > & values ) const
{
  values.clear ();
  int naxis = getImageDimensions ();
  values.reserve ( naxis );

  char key [ FLEN_KEYWORD];
  char * keyroot = "CRVAL";
  for ( int i = 0; i < naxis; i++ ) {
    m_status = 0;
    fits_make_keyn ( keyroot, i+1, key, & m_status );
    bool yes = hasKey ( key );

    if ( yes ) {
      double value = doubleValueForKey ( key );
      values.push_back ( value );
    }
    else { // no key, take default
      values.push_back ( 0. );
    }
  }
}

bool
FitsFile::
isHammerAitoff () const
{
  bool hammer = true;

  char key [FLEN_KEYWORD];
  char * keyroot = "CTYPE";
  for ( int i = 0; i < 2; i++ ) {
    fits_make_keyn ( keyroot, i+1, key, & m_status );
    bool yes = hasKey ( key );

    if ( yes ) {
      string value = stringValueForKey ( key );
      if ( value.find ( "-AIT" ) == string::npos ) {
        hammer = false;
      }
    } else {
      hammer = false;
    }
  }

  return hammer;
}

int
FitsFile::
fillFromImage ( std::vector < double > & vec )
{
  vector < long > naxes;
  fillAxisSizes ( naxes );
  if (  naxes.size () == 3 ) {
    assert ( naxes[2] == 1 );
  }

  int datatype = Double;
  long nelements = naxes[0] * naxes[1];
  double nulval = 0;
  vector < double >::iterator first = vec.begin();
  double * ptr = & *first;
  int anynul;
  m_status = 0;
  if ( naxes.size () == 2 ) {
    long fpixel[2] = { 1, 1 }; // index like Fortran
    fits_read_pix ( m_fptr, datatype, fpixel, nelements,
                    & nulval, ptr, & anynul, & m_status );
  } else {
    long fpixel[] = { 1, 1, 1 }; // index like Fortran
    fits_read_pix ( m_fptr, datatype, fpixel, nelements,
                    & nulval, ptr, & anynul, & m_status );
  }

  return m_status;
}

int
FitsFile::
fillIntVectorFromColumn( std::vector < int > & vec, int column )
{
  int anynul, status = 0;
  int nulval = 0;
  long nelements = vec.size();
  vector<int>::iterator it = vec.begin();
  int * ptr = new int [ nelements ];
  // Careful, counting columns like Fortran
  m_status = 0;
  fits_read_col_int( m_fptr, column+1, 1, 1, nelements, nulval,
                     ptr, &anynul, &status);
  copy ( ptr, ptr+nelements, it );

  return status;
}

---