FitsController.cxx

Go to the documentation of this file.

#include "FitsController.h"

#include "FitsFile.h"
#include "FitsNTuple.h"

#include "axes/Range.h"
#include "datasrcs/DataSourceException.h"
#include "datasrcs/DataSourceController.h"

#include "plotters/PlotterBase.h"

#include <fstream>

#ifdef SSTREAM_DEFECT
#include <strstream>
using std::ostrstream;
#else
#include <sstream>
using std::ostringstream;
#endif

#include <cassert>

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

typedef std::map < std::string, FitsFile * >::iterator FileMapIterator;

FitsController * FitsController::s_instance = 0;

FitsController *
FitsController::
instance ()
{
  if ( s_instance == 0 ) {
    s_instance = new FitsController ();
  }
  return s_instance;
}

FitsController::
~FitsController()
{
}

const std::string &
FitsController::
version () const
{
#ifdef SSTREAM_DEFECT
  ostrstream strm_text;
#else
  std::ostringstream strm_text;
#endif
  float version = 0.0;
  fits_get_version ( & version );

  strm_text << version << std::ends;
  m_version = strm_text.str();

  return m_version;
}

FitsFile *
FitsController::
openFile ( const std::string & name )
{
  FitsFile * file = 0;
  FileMapIterator first = m_file_map.find ( name );

  if ( first == m_file_map.end() ) {
    ifstream test ( name.c_str (), std::ios::in );
    if ( test.is_open () == false ) {
      string what ( "FitsController: File `" );
      what += name;
      what += "' not found";
      throw DataSourceException ( what );
    }
    file = new FitsFile ( name );
    int status = file -> status();

    if ( status != 0 ) {
      string what ( "cfitsio: Error opening file `" );
      what += name;
      what += "'";
      delete file;
      throw DataSourceException ( what );
    }
    m_file_map [ name ] = file;
  }
  else {
    file = first -> second;
  }

  return file;
}

void
FitsController::
closeFile ( const std::string & name )
{
//   FileMapIterator where = m_file_map.find ( name );
//   if ( where != m_file_map.end () ) {
//     m_file_map.erase ( where );
//     fitsfile * file = where -> second;
//     fits_close_file ( file, & status );
//   }
}

const vector < string > &
FitsController::
getNTupleNames ( const std::string & file_name )
{
  m_ntuple_names.clear ();
  FitsFile * file = openFile ( file_name );
  if ( file != 0 ) {
    file -> fillHDUNames ( m_ntuple_names );
  }

  return m_ntuple_names;
}


DataSource *
FitsController::
createNTuple ( const std::string & filename,
               const std::string & name )
{
  int index = -1;

  const vector < string > & names 
    = getNTupleNames ( filename );
  unsigned int size = names.size ();

  for ( unsigned int i = 0; i < size; i++ ) {
    if ( name == names[i] ) {
      index = i;
      break;
    }
  }

  if ( index == -1 ) {
    string what ( "FitsController: File\n" );
    what += filename + "\n";
    what += "does not have extensison with name ";
    what += name;
    throw DataSourceException ( what );
  }

  return createNTuple ( filename, name, index );
}

DataSource *
FitsController::
createNTuple ( const std::string & filename, 
               const std::string & name,
               int index )
{
  DataSource  * ntuple = 0;

  string ds_name = filename;
  ds_name += ": ";
  ds_name += name;

  DataSourceController * controller = DataSourceController::instance();
  ntuple = controller -> getDataSource ( ds_name );
    
  if ( ntuple == 0 ) {
    FitsFile * file =  openFile ( filename );
    int retval = file -> moveToHDU ( index );

    if ( retval == 0 ) {
      try {
        ntuple = new FitsNTuple ( file );
      }
      catch ( const DataSourceException & e ) {
        throw e;
      }

      ntuple -> setTitle ( name );
      ntuple -> setName ( ds_name );
      controller -> registerNTuple ( ntuple );
    }
  }

  return ntuple;
}

using namespace hippodraw;

void
FitsController::
checkForImage ( PlotterBase * plotter, const DataSource & source,
                const std::vector < std::string > & binding )
{
  const FitsFile * file = 0;
  try {
    const FitsNTuple & ntuple 
      = dynamic_cast < const  FitsNTuple & > ( source );
    file = ntuple.getFile ();
  }
  catch ( ... ) {
    // do nothing
  }
  if ( file == 0 ) return;

  FitsFileBase::HduType type = file -> getHduType ();
  if ( type != FitsFileBase::Image ) return;

  vector < long > sizes;
  file -> fillAxisSizes ( sizes );
  if ( sizes.size () != 2 ) {
    assert ( sizes[2] == 1 );
  }
  plotter -> setNumberOfBins ( Axes::X, sizes[0] );
  plotter -> setNumberOfBins ( Axes::Y, sizes[1] );

  vector < double > deltas;
  file -> fillImageDeltas ( deltas );
  plotter -> setBinWidth ( Axes::X, deltas[0] );
  plotter -> setBinWidth ( Axes::Y, deltas[1] );

  vector < double > ref_values;
  file -> fillRefPixelValues ( ref_values );
  vector < int > ref_indices;
  file -> fillRefPixelIndices ( ref_indices );

  double x_orig = - deltas[0] * ( ref_indices[0] -1 ) + ref_values[0];
  double y_orig = - deltas[1] * ( ref_indices[1] -1 ) + ref_values[1];
  plotter ->setOffset ( Axes::X, x_orig );
  plotter ->setOffset ( Axes::Y, y_orig );

  Range range;
  if ( deltas[0] < 0. ) {
    range.setLow ( x_orig + ( sizes[0] + 1 ) * deltas[0] );
    range.setHigh ( x_orig );
  }
  else {
    range.setLow ( x_orig );
    range.setLength ( ( sizes[0] + 1 ) * deltas[0] ) ;
  }
  plotter -> setRange ( Axes::X, range, false, true );
  range.setLow ( y_orig );
  range.setLength ( ( sizes[1] + 1 ) * deltas[1] );
  plotter -> setRange ( Axes::Y, range, false, true );

  plotter -> matrixTranspose ( true );

  bool yes = file -> isHammerAitoff ();
  if ( yes ) {
    plotter ->setAspectRatio ( 2.0 );
  }
}

---