PyDataSource.cxx

Go to the documentation of this file.

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

// For truncation warning
#ifdef _MSC_VER
#include "msdevstudio/MSconfig.h"
#endif

#include "PyDataSource.h"

#include "datasrcs/DataSourceController.h"
#include "datasrcs/DataSourceException.h"
#include "datasrcs/NTuple.h"
#include "python/ListTuple.h"

#ifdef HAVE_NUMARRAY
#include "numarray/NumArrayTuple.h"
#include "numarray/num_util.h"
#endif

#ifdef HAVE_CFITSIO
#include "fits/FitsNTuple.h"
#endif

#ifdef HAVE_ROOT
#include "root/QtRootNTuple.h"
#endif

#include <sstream>

using namespace boost::python;

namespace hippodraw {
namespace Python {

void PyDataSourceExceptionTranslator( const PyDataSource::StopIteration & e ) {
   PyErr_SetString ( PyExc_StopIteration, e.what() );
}

void
export_DataArray()
{
   class_ < PyDataSource >
     ( "DataArray",
       "A DataArray wraps a DataSource object so that numerical Python\n"
       "arrays can be used as both input and output.   The numerical array\n"
       "can be either a numarray.array or Numeric.array depending on\n"
       "how the hippo module was configured.\n"
       "\n"
       "Accees to the array is done like a Python list or dictionary.\n"
       "\tarray = my_data_array [ index ] # list form\n"
       "\tarray = my_data_array [ 'my_label' ] # dict form\n"
       "\n"
       "Storage to the array is also done like a Python list or dictionary.\n"
       "\tmy_data_array [ index ] = ... # list form\n"
       "\tmy_data_array [ 'my_label' ] = ... # dict form\n" )

      .def ( init < const std::string & > (
             "DataArray ( string ) -> DataArray\n"
             "\n"
             "Creates a DataArray.   The string can be one of\n"
             "\tListTuple\n"
             "\tNTuple\n"
             "\tNumArrayTuple" ) )
      
      .add_property ( "columns", 
                      &PyDataSource::columns )
      
      .add_property ( "rows",
                      &PyDataSource::rows )

     .def ( "dataSource",
            &PyDataSource::dataSource,
            return_value_policy < reference_existing_object > (),
            "dataSource () -> DataSource\n"
            "\n"
            "Returns reference to underlying DataSource"  )

      .def ( "getTitle", 
             &PyDataSource::getTitle,
             return_value_policy < copy_const_reference > (),
             "getTitle () -> string\n"
             "\n"
             "Returns title of the DataSource." )

      .def ( "setName",
             &PyDataSource::setName,
             "setName ( string ) -> None\n"
             "\n"
             "Sets the name of the DataSource. The name should be unique\n"
             "with one application and may appear in the Inspector panel." )
      
      .def ( "setTitle",
             &PyDataSource::setTitle,
             "setTitle ( string ) -> None\n"
             "\n"
             "Sets the title of the DataSource.  The title is what appears,\n"
             "by default, at the top of a Display." )
           
      .def ( "getLabels",
             &PyDataSource::getLabels,
             return_value_policy < copy_const_reference > (),
             "getLabels () -> list\n"
             "\n"
             "Returns the list of string objects of column labels." )
      
      .def ( "addColumn", 
             ( int (PyDataSource:: * )
               (const std::string &, const std::vector<double> &) )
             &PyDataSource::addColumn,
             "addColumn ( string, list ) -> value\n"
             "addColumn ( string, array ) -> value\n"
             "\n"
             "Adds a column. The string will be the label of the column.\n"
             "A copy of the list or array values will be the contents.\n"
             "The second form is only avalable if HippoDraw was configured\n"
             "with numerical Python support. Returns the new column's index." )
             
#ifdef HAVE_NUMARRAY      
      .def ( "addColumn", 
             ( int (PyDataSource:: * )
               (const std::string &, boost::python::numeric::array) )
             &PyDataSource::addColumn )
#endif
             
      .def ( "getColumn", 
             ( const std::vector < double > & (PyDataSource:: * ) // fptr
               ( unsigned int ) const) // function signature
             &PyDataSource::getColumn,
             return_value_policy < copy_const_reference> (),
             "getColumn ( value ) -> list\n"
             "\n"
             "Returns a column as list of floats.  'value' maybe either\n"
             "the column label or its index." )

      .def ( "getColumn", 
             ( const std::vector < double > & (PyDataSource:: * ) // fptr
               ( const std::string & ) const) // function signature
             &PyDataSource::getColumn,
             return_value_policy < copy_const_reference> () )
      
      .def ( "replaceColumn", 
             ( void (PyDataSource:: * )
               ( const std::string &, const std::vector<double> & ) )
             &PyDataSource::replaceColumn,
             "replaceColumn ( value, list ) -> None\n"
             "replaceColumn ( value, array ) -> None\n"
             "\n"
             "Replace column by its label or index.  The second form is \n"
             "only available if HippoDraw was configure with numerical\n"
             "arrays." )
      
      .def ( "replaceColumn", 
             ( void (PyDataSource:: * ) // fptr
               ( unsigned int index, const std::vector<double> & ) )
             &PyDataSource::replaceColumn )

#ifdef HAVE_NUMARRAY      
      .def ( "replaceColumn", 
             ( void (PyDataSource:: * ) // fptr
               ( const std::string &, numeric::array ) ) // function signature
             &PyDataSource::replaceColumn )
      
      .def ( "replaceColumn", 
             ( void (PyDataSource:: * ) // fptr
               ( unsigned int index, numeric::array ) ) // function signature
             &PyDataSource::replaceColumn )
#endif

// comment out until implemented for ListTuple and NumArrayTuple
//       .def ( "clear",
//              &PyDataSource::clear,
//              "Clears the data elements of the DataSource" )

      .def ("has_key",
            &PyDataSource::hasColumn,
            "has_key ( string ) -> boolean\n"
            "\n"
            "Returns True if column with label exists.")

      .def ( "keys",
             &PyDataSource::getLabels,
             return_value_policy < copy_const_reference > (),
             "keys () -> list\n"
             "\n"
             "Returns the list of column labels." )
      
      .def ( "register",
             ( void (PyDataSource:: * ) ( const std::string & ) )
             &PyDataSource::registerNTuple,
             "register ( string ) -> None\n"
             "register ( ) -> string\n"
             "\n"
             "Register the underlying DataSource with the\n"
             "DataSourceController. The first form registers it with the\n"
             "given name, while the second from returns a unique name\n"
             "generated by the controller." )

      .def ( "register",
             ( std::string (PyDataSource:: * ) () )
             &PyDataSource::registerNTuple )

#ifdef HAVE_NUMARRAY
      .def ( "__getitem__", 
             ( numeric::array ( PyDataSource:: * )
               ( const std::string & ) const )
             &PyDataSource::columnAsNumArray,
             return_value_policy < return_by_value > (),
             "__getitem__ ( value ) -> array\n"
             "\n"
             "Returns a copy of the column as numerical array.   'value' can\n"
             "be either the column label or its index." )

      .def ( "__getitem__", 
             ( numeric::array ( PyDataSource:: * )
               ( unsigned int ) const )
             &PyDataSource::columnAsNumArray,
             return_value_policy < return_by_value > () )

      .def ( "__setitem__", 
             ( void ( PyDataSource:: * )
               ( const std::string &, numeric::array ) )
             &PyDataSource::saveColumnFromNumArray,
             return_value_policy < return_by_value > (),
             "__setitem__ ( value, array ) -> None\n"
             "\n"
             "Copies the constents of array.  If `'value' is an index, then\n"
             "replaces the contents of the existing column.   If 'value' is\n"
             "a label then either replaces existing column with that label\n"
             "or adds a new column." )

      .def ( "__setitem__", 
             ( void ( PyDataSource:: * )
               ( unsigned int, numeric::array ) )
             &PyDataSource::saveColumnFromNumArray,
             return_value_policy < return_by_value > () )
#endif
      ;
   register_exception_translator<PyDataSource::StopIteration>
      (&PyDataSourceExceptionTranslator);
}
   
} // namespace Python
} // namespace hippodraw

PyDataSource::PyDataSource() {
   m_type = "NTuple";
   m_dataSource = new NTuple();
}

PyDataSource::
PyDataSource ( const std::string & name, DataSource * source )
  : m_type ( name ),
    m_dataSource ( source )
{
}

PyDataSource::
PyDataSource(const std::string & dataSource) : m_type(dataSource) {
   if (dataSource == "ListTuple") {
      m_dataSource = new ListTuple();
   } else if (dataSource == "NTuple") {
      m_dataSource = new NTuple();
#ifdef HAVE_NUMARRAY
   } else if (dataSource == "NumArrayTuple") {
      m_dataSource = new NumArrayTuple();
#endif
   } else {
      throw std::runtime_error("Invalid DataSource: " + dataSource);
   }
}

PyDataSource::~PyDataSource() {
   delete m_dataSource;
}


unsigned int PyDataSource::columns() const {
   return m_dataSource->columns();
}

unsigned int PyDataSource::rows() const {
   return m_dataSource->rows();
}

const std::string & PyDataSource::getTitle() const {
   return m_dataSource->title();
}

void PyDataSource::setTitle(const std::string & title) {
   m_dataSource->setTitle(title);
}

void PyDataSource::setName(const std::string & name) {
   m_dataSource->setName(name);
}

const std::vector<std::string> & PyDataSource::getLabels() const {
   return m_dataSource->getLabels();
}

const std::vector<double> & 
PyDataSource::getColumn(const std::string & name) const {
   return m_dataSource->getColumn(name);
}

const std::vector<double> & 
PyDataSource::getColumn(unsigned int index) const {
   return m_dataSource->getColumn(index);
}

void
PyDataSource::
replaceColumn (const std::string & label,
               const std::vector < double > & col )
{
   if (m_type == "NTuple") {
      NTuple * nt = dynamic_cast<NTuple *>(m_dataSource);
      nt->replaceColumn(label, col);
   } else if (m_type == "ListTuple") {
      ListTuple * nt = dynamic_cast<ListTuple *>(m_dataSource);
      boost::python::list seq(col);
      nt->replaceColumn(label, seq);
   } else {
      std::string what("Cannot replace a column of this type in a " + m_type);
      throw std::runtime_error(what);
   }
}

void
PyDataSource::
replaceColumn ( unsigned int index,
                const std::vector < double > & col)
{
   const std::vector<std::string> & names = m_dataSource->getLabels();
   if ( 0 <= index && index < names.size() ) {
      replaceColumn(names[index], col);
   } else {
      std::ostringstream what;
      what << "Invalid column index: " << index;
      throw std::runtime_error(what.str());
   }
}

#ifdef HAVE_NUMARRAY
void
PyDataSource::
replaceColumn ( const std::string & label,
                boost::python::numeric::array array)
{
   NumArrayTuple * nt = dynamic_cast<NumArrayTuple *>(m_dataSource);
   if (!nt) {
      std::string what("Cannot replace a column of this type in a " + m_type);
      throw std::runtime_error(what);
   }
   nt->replaceColumn(label, array);
}

void
PyDataSource::
replaceColumn ( unsigned int index,
                boost::python::numeric::array array )
{
   NumArrayTuple * nt = dynamic_cast<NumArrayTuple *>(m_dataSource);
   if (!nt) {
      std::string what("Cannot replace a column of this type in a " + m_type);
      throw std::runtime_error(what);
   }
   nt->replaceColumn(index, array);
}
#endif

int PyDataSource::addColumn( const std::string & label,
                             const std::vector<double> & col ) {
   if (m_type == "NTuple") {
      NTuple * nt = dynamic_cast<NTuple *>(m_dataSource);
      return nt->addColumn(label, col);
   } else if (m_type == "ListTuple") {
      ListTuple * nt = dynamic_cast<ListTuple *>(m_dataSource);
      boost::python::list seq(col);
      return nt->addColumn(label, seq);
   } else {
      std::string what("Cannot add a column of this type to a " + m_type);
      throw std::runtime_error(what);
   }
   return m_dataSource->columns();
}

#ifdef HAVE_NUMARRAY
int PyDataSource::addColumn( const std::string & label, 
                             boost::python::numeric::array array ) {
   NumArrayTuple * nt = dynamic_cast<NumArrayTuple *>(m_dataSource);
   if (!nt) {
      std::string what("Cannot add a column of this type to a " + m_type);
      throw std::runtime_error(what);
   }
   return nt->addColumn(label, array);
}
#endif

void PyDataSource::clear() {
   m_dataSource->clear();
}

bool PyDataSource::hasColumn(const std::string & colname) const {
   const std::vector<std::string> & names = getLabels();
   return std::find(names.begin(), names.end(), colname) != names.end();
}

void PyDataSource::registerNTuple( const std::string & name ) {
   m_dataSource->setName(name);
   DataSourceController * controller  = DataSourceController::instance();
   controller->registerNTuple(name, m_dataSource);
}

std::string PyDataSource::registerNTuple() {
   DataSourceController * controller  = DataSourceController::instance();
   return controller->registerNTuple(m_dataSource);
}

#ifdef HAVE_NUMARRAY
boost::python::numeric::array
PyDataSource::
columnAsNumArray( const std::string & colname ) const {
   if (m_type == "NumArrayTuple") {
      NumArrayTuple * nt = dynamic_cast<NumArrayTuple *>(m_dataSource);
      return nt->getNumArray(colname);
   } 
   typedef std::vector<double> vec;
   const vec & array = m_dataSource->getColumn(colname);
   std::vector<int> shape(1);
   shape[0] = array.size();
   numeric::array na = num_util::makeNum(&const_cast<vec &>(array)[0], shape);
   return na;
}
boost::python::numeric::array
PyDataSource::
columnAsNumArray( unsigned int index ) const {
   if ( 0 <= index && index < columns() ) {
      if (m_type == "NumArrayTuple") {
         NumArrayTuple * nt = dynamic_cast<NumArrayTuple *>(m_dataSource);
         return nt->getNumArray(index);
      } 
      typedef std::vector<double> vec;
      const vec & array = m_dataSource->getColumn(index);
      std::vector<int> shape(1);
      shape[0] = array.size();
      numeric::array na = 
         num_util::makeNum(&const_cast<vec &>(array)[0], shape);
      return na;
   } else {
      throw StopIteration("index out-of-range");
   }
}

namespace {
   void extractVector(boost::python::numeric::array array,
                      std::vector<double> & col) {
      const numeric::array & my_array = array;
      int size = num_util::size( my_array );
      col.clear();
      col.reserve(size);
      for (int i = 0; i < size; i++) {
         boost::python::object result = my_array[i];
         col.push_back( boost::python::extract<double>(result) );
      }
   }
}

void PyDataSource::
saveColumnFromNumArray( const std::string & label,
                        boost::python::numeric::array array ) {
   if (m_type == "NumArrayTuple") {
      if (hasColumn(label)) {
         replaceColumn(label, array);
      } else {
         addColumn(label, array);
      }
      return;
   }

   if (m_type == "ListTuple") {
      boost::python::list seq(array);
      ListTuple * nt = dynamic_cast<ListTuple *>(m_dataSource);
      if (hasColumn(label)) {
         nt->replaceColumn(label, seq);
      } else {
         nt->addColumn(label, seq);
      }
      return;
   }

   std::vector<double> col;
   ::extractVector(array, col);

   if (m_type == "NTuple") {
      NTuple * nt = dynamic_cast<NTuple *>(m_dataSource);
      if (hasColumn(label)) {
         nt->replaceColumn(label, col);
      } else {
         nt->addColumn(label, col);
      }
      return;
   }

#ifdef HAVE_CFITSIO
   FitsNTuple * fnt = dynamic_cast < FitsNTuple * > ( m_dataSource );
   if ( fnt != 0 ) {
     if ( hasColumn ( label ) ) {
       fnt -> replaceColumn ( label, col );
     } else {
       fnt -> addColumn ( label, col );
     }
     return;
   }
#endif

#ifdef HAVE_ROOT
   QtRootNTuple * rnt = dynamic_cast < QtRootNTuple * > ( m_dataSource );
   if ( rnt != 0 ) {
     if ( hasColumn ( label ) ) {
       rnt -> replaceColumn ( label, col );
     } else {
       rnt -> addColumn ( label, col );
     }
     return;
   }
#endif

   throw std::runtime_error("__setitem__ not supported for " + m_type);
}

void PyDataSource::
saveColumnFromNumArray( unsigned int index,
                        boost::python::numeric::array array ) {
   if (0 <= index && index < columns()) {
      if (m_type == "NumArrayTuple") {
         replaceColumn(index, array);
      } else if (m_type == "NTuple") {
         std::vector<double> col;
         ::extractVector(array, col);
         NTuple * nt = dynamic_cast<NTuple *>(m_dataSource);
         nt->replaceColumn(index, col);
      } else if (m_type == "ListTuple") {
         boost::python::list seq(array);
         ListTuple * nt = dynamic_cast<ListTuple *>(m_dataSource);
         nt->replaceColumn(index, seq);
      } else {
         throw std::runtime_error
            ("__setitem__ by index is not supported for " + m_type);
      }
   } else {
      std::ostringstream what;
      what << "Invalid column index: " << index;
      throw std::runtime_error(what.str());
   }
}
#endif // HAVE_NUMARRAY

---