DataReader.h

Go to the documentation of this file.

/******************************************************************************
 *
 *  Copyright (C) 2008 Max Hermann
 *
 *  This file is part of the "CEDRIC Event Display" application.
 *
 *****************************************************************************/

#ifndef REDUKT_DATAREADER_H
#define REDUKT_DATAREADER_H

#include <boost/numeric/ublas/matrix.hpp>

#include <sstream>
#include <fstream>
#include <iostream>
#include <vector>

template<class C>
class DataReader
{       
public:
        DataReader( C& data ): m_data(data), m_rows(-1),m_columns(-1) {}
        
        bool loadCSV( const char* filename );
                
        int numRows()    const { return m_rows;    }
        int numColumns() const { return m_columns; }

protected:
        inline bool insertValue( int row, int column, double value );   

        void inline remove_commas  ( std::string& s )
                {
                        size_t pos = s.find(',');
                        while( pos != std::string::npos )
                        {
                                // replace found comma with space character
                                s[pos] = ' ';
                                
                                // go and find next comma
                                pos = s.find( ',', pos );
                        }
                }
                        
        void inline remove_comments( std::string& s )
                {
                        size_t pos = s.find('#');
                        if( pos != std::string::npos )
                        {
                                // remove rest of line beginning with '#'
                                s.erase( pos );
                        }
                }
                
        bool inline is_comment_or_empty( const std::string& s )
                {
                        // find first non empty character
                        size_t pos = s.find_first_not_of(' ');
                        
                        // line empty?
                        if( pos == std::string::npos ) return true;
                        
                        // line begins with caret '#'?
                        if( s[pos] == '#' ) return true;
                        
                        return false;
                }               

private:
        C& m_data;
        int m_rows, m_columns;
};


//=====================================================================================================================

//              TEMPLATE IMPLEMENTATION

//=====================================================================================================================

template<class C>
bool DataReader<C>::loadCSV( const char* filename )
{       
        using namespace std;
        
        // open file
        ifstream f;
        f.open( filename, ifstream::in );
        if( !f.good() )
        {
                f.close();
                cout << "ERROR opening file " << filename << endl;
                return false;
        }
        
        int rows=0, columns=-1;
        
        // read line by line
        string line;
        int cur_line=0;  // number of read lines (also counts empty and ignored lines)
        while( !f.eof() )
        {       
                cout << "Read " << cur_line << " lines\r" << std::flush;
                
                getline( f, line );  cur_line++;
                if( line.empty() ) continue;
                        
                // ignore comment lines
                if( is_comment_or_empty( line ) ) continue;
                        
                // we want space-separated data, so we remove any commas
                remove_commas( line );
                
                // remove any trailing comments
                remove_comments( line );
                
                stringstream ss( line );
                
                int cur_col = 0;
                
                double value; 
                bool first_value_in_row=true;
                while( (ss >> value) &&  !ss.fail() )
                {
                        if( columns != -1 )
                                if( cur_col >= columns )
                                {
                                        cout << endl << "WARNING skipped additional column in line " << cur_line << endl;
                                        continue;
                                }
                        
                        insertValue( rows, cur_col, value );
                        cur_col++;
                        
                        first_value_in_row = false;
                }

                // fail bit indicates that input could not be interpreted as double
                //if( ss.fail() )  // also true when bad bit set
                if( ss.rdstate() & ifstream::failbit )
                {
                        if( first_value_in_row )
                        {
                                cout << endl << "WARNING skipped line " << cur_line << " assuming it contains some kind of comment" << endl;
                                // skip whole line (assuming row contains a comment or headers)
                                continue;
                        }
                        
                        //~ // exit with an error
                        //~ f.close();
                        //~ cout << "ERROR parsing error at line " << cur_line << endl;
                        //~ return false;
                }               
                
                // just read the first data column?
                if( columns == -1 )
                {
                        // yes, then store number of columns which all following rows must match
                        columns = cur_col;
                }
                else
                {
                        // cur_col must match columns
                        if( cur_col =! columns )
                        {
                                cout << endl << "ERROR in line " << cur_line << ", too few columns!" << endl;
                                f.close();
                                return false;
                        }
                }
                
                rows++;
        }
        
        f.close();
        
        // set members
        m_rows    = rows;
        m_columns = columns;
        
        return true;    
};


//=====================================================================================================================

//              TEMPLATE SPECIALIZATION

//=====================================================================================================================

template<>
bool DataReader<boost::numeric::ublas::matrix<float> >::insertValue( int row, int column, double value )
{
        //m_data.insert_element( row, col, (float)value );
        //~ unsigned int nrows = (row    >= (int)m_data.size1()) ? row+1    : m_data.size1();
        //~ unsigned int ncols = (column >= (int)m_data.size2()) ? column+1 : m_data.size2();
        //~ m_data.resize( nrows, ncols );
        m_data( row, column ) = (float)value;
        return true;
}

template<>
bool DataReader<boost::numeric::ublas::matrix<double> >::insertValue( int row, int column, double value )
{
        //~ unsigned int nrows = (row    >= (int)m_data.size1()) ? row+1    : m_data.size1();
        //~ unsigned int ncols = (column >= (int)m_data.size2()) ? column+1 : m_data.size2();
        //~ m_data.resize( nrows, ncols );
        m_data( row, column ) = value;
        return true;
}

template<>
bool DataReader<std::vector<float> >::insertValue( int /*row*/, int /*column*/, double value )
{
        // we ignore row and column and assume row wise input
        m_data.push_back( (float)value );
        return true;
}

template<>
bool DataReader<std::vector<double> >::insertValue( int /*row*/, int /*column*/, double value )
{
        // we ignore row and column and assume row wise input
        m_data.push_back( (double)value );
        return true;
}


#endif // REDUKT_DATAREADER_H