image.h

Go to the documentation of this file.

#ifndef IMAGE_H_INCLUDED
#define IMAGE_H_INCLUDED
 
#include <string>
#include <fstream>
#include <bitset>
 
namespace sp
{
 
 
class PNM
{
  private:
    std::ifstream ifs;    
    std::ofstream ofs;    
    arma::uword   cols;   
    arma::uword   rows;   
    int           maxval; 
  public:
    enum imtype
    {
        NOTUSED,
        PBM_A,
        PGM_A,
        PPM_A,
        PBM_B,
        PGM_B,
        PPM_B
    } type; 
 
    PNM()
    {
        type   = NOTUSED;
        cols   = 0;
        rows   = 0;
        maxval = 0;
    }
 
    ~PNM()
    {
    }
 
    void clear( void )
    {
        type   = NOTUSED;
        cols   = 0;
        rows   = 0;
        maxval = 0;
    }
 
    void read_header()
    {
        std::string str;
        while( ifs >> str ) // Read until we have maxval
        {
            // Remove comments
            size_t mark = str.find_first_of( "#" );
            if( mark != std::string::npos )
            {
                ifs.ignore( 256, '\n' );
                str.erase( mark, 1 );
 
                if( str.empty() )
                    continue;
            }
 
            if( type == NOTUSED )
            {
                type = static_cast<imtype>( str.at( 1 ) - 48 ); // Conv char to int
                if( str.at( 0 ) != 'P' || type > PPM_B )
                    err_handler( "Wrong type!" );
            }
            else if( cols == 0 )
            {
                cols = atoi( str.c_str() );
            }
            else if( rows == 0 )
            {
                rows = atoi( str.c_str() );
                if( type == PBM_A || type == PBM_B )
                {
                    maxval = 1; // Set maxval=1 for .PBM types
                    break;
                }
            }
            else if( maxval == 0 )
            {
                maxval = atoi( str.c_str() );
                break;
            }
        }
        ifs.ignore( 1 ); // Skip one char before data
    }
 
    void write_header( const imtype _type, const arma::uword _rows, const arma::uword _cols, const int _maxval, const std::string comments )
    {
        type   = _type;
        rows   = _rows;
        cols   = _cols;
        maxval = _maxval;
        ofs << "P" << type << std::endl;
        ofs << "# " << comments << std::endl;
        ofs << cols << " " << rows << std::endl;
        if( !( ( type == PBM_A ) || ( type == PBM_B ) ) )
            ofs << maxval << std::endl;
    }
 
    bool write( std::string fname, const imtype _type, const arma::cube& img, const std::string info = "" )
    {
        // Open file
        ofs.open( fname.c_str(), std::ofstream::binary );
        if( !ofs.good() )
        {
            std::cout << "Could not open " << fname << std::endl;
            return false;
        }
        else
        {
            write_header( _type, img.n_rows, img.n_cols, (int)img.max(), info );
            //            get_info();
 
            // Write data
            if( type == PPM_A ) // Plain (ASCII )type
            {
                for( arma::uword r = 0; r < rows; r++ )
                {
                    arma::uword i = 0;
                    for( arma::uword c = 0; c < cols; c++ )
                    {
                        ofs << img( r, c, 0 ) << " " << img( r, c, 1 ) << " " << img( r, c, 2 ) << " "; // R G B
                        if( ++i % 5 == 0 )
                            ofs << std::endl; // Max len is 70 chars/line
                    }
                }
            }
            else if( type == PPM_B )
            {
                for( arma::uword r = 0; r < rows; r++ )
                    for( arma::uword c = 0; c < cols; c++ )
                    {
                        unsigned char bb;
                        bb = static_cast<unsigned char>( img( r, c, 0 ) ); // R
                        ofs.write( reinterpret_cast<char*>( &bb ), 1 );
                        bb = static_cast<unsigned char>( img( r, c, 1 ) ); // G
                        ofs.write( reinterpret_cast<char*>( &bb ), 1 );
                        bb = static_cast<unsigned char>( img( r, c, 2 ) ); // B
                        ofs.write( reinterpret_cast<char*>( &bb ), 1 );
                    }
            }
        }
        ofs.close();
        return true;
    }
 
    bool write( std::string fname, const imtype _type, arma::mat& img, const std::string info = "" )
    {
        // Open file
        ofs.open( fname.c_str(), std::ofstream::binary );
        if( !ofs.good() )
        {
            std::cout << "Could not open " << fname << std::endl;
            return false;
        }
        else
        {
            write_header( _type, img.n_rows, img.n_cols, (int)img.max(), info );
            //            get_info();
 
            // Write data
            if( type == PBM_A || type == PGM_A ) // Plain (ASCII )type
            {
                arma::uword i = 0;
                for( arma::mat::iterator ii = img.begin(); ii != img.end(); ++ii )
                {
                    ofs << *ii << " ";
                    if( ++i % 11 == 0 )
                        ofs << std::endl; // Max len is 70 chars/line
                }
            }
            else if( type == PBM_B ) // Raw .pbm
            {
                std::bitset<8> b;
                for( arma::uword r = 0; r < rows; r++ )
                    for( arma::uword c = 0; c < cols; c++ )
                    {
                        arma::uword ix = 7 - ( c % 8 );
                        b[ix]          = ( img( r, c ) > 0 );
                        if( ix == 0 || c == cols - 1 )
                        {
                            ofs.write( reinterpret_cast<char*>( &b ), 1 );
                            b.reset();
                        }
                    }
            }
            else if( type == PGM_B ) // Raw .pgm
            {
                if( maxval <= 255 )
                {
                    for( arma::uword r = 0; r < rows; r++ )
                        for( arma::uword c = 0; c < cols; c++ )
                        {
                            unsigned char bb = static_cast<unsigned char>( img( r, c ) );
                            ofs.write( reinterpret_cast<char*>( &bb ), 1 );
                        }
                }
                else
                {
                    for( arma::uword r = 0; r < rows; r++ )
                        for( arma::uword c = 0; c < cols; c++ )
                        {
                            unsigned int bb;
                            bb = ( ( static_cast<unsigned int>( img( r, c ) ) ) >> 8 ) & 0x00ff; // Write MSB first
                            ofs.write( reinterpret_cast<char*>( &bb ), 1 );
                            bb = static_cast<unsigned int>( img( r, c ) ) & 0x00ff;
                            ofs.write( reinterpret_cast<char*>( &bb ), 1 );
                        }
                }
            }
        }
 
        ofs.close();
        return true;
    }
 
    void get_info()
    {
        std::cout << "Type:  P" << type << std::endl;
        std::cout << "cols:   " << cols << std::endl;
        std::cout << "rows:   " << rows << std::endl;
        if( type == PGM_A || type == PGM_B )
            std::cout << "Maxval: " << maxval << std::endl;
    }
 
    arma::uword get_rows()
    {
        return rows;
    }
 
    arma::uword get_cols()
    {
        return cols;
    }
 
    int get_maxval()
    {
        return maxval;
    }
 
    bool read( std::string fname, arma::cube& img )
    {
        // Open file
        ifs.open( fname.c_str(), std::ifstream::binary );
        if( !ifs.good() )
        {
            std::cout << "Could not open " << fname << std::endl;
            return false;
        }
        else
        {
            read_header();
            //            get_info();
 
            img.set_size( rows, cols, 3 );
            arma::uword r = 0, c = 0;
            // Get the data
            if( type == PPM_A ) // Plain .PPM
            {
                std::string str;
                arma::uword i = 0;
                while( ifs >> str && r < rows ) // Read until eof
                {
                    // Remove comments
                    size_t mark = str.find_first_of( "#" );
                    if( mark != std::string::npos )
                    {
                        ifs.ignore( 256, '\n' );
                        str.erase( mark, 1 );
 
                        if( str.empty() )
                            continue;
                    }
                    int pix = atoi( str.c_str() ); // Convert to int
 
                    img( r, c, i % 3 ) = pix;
                    i++;
                    if( i % 3 == 0 )
                        if( ++c == cols )
                        {
                            c = 0;
                            r++;
                        }
                }
            }
            else if( type == PPM_B ) // Raw .PPM
            {
                for( arma::uword r = 0; r < rows; r++ )
                    for( arma::uword c = 0; c < cols; c++ )
                    {
                        unsigned char bb;
                        ifs.read( reinterpret_cast<char*>( &bb ), 1 ); // R
                        img( r, c, 0 ) = bb;
                        ifs.read( reinterpret_cast<char*>( &bb ), 1 ); // G
                        img( r, c, 1 ) = bb;
                        ifs.read( reinterpret_cast<char*>( &bb ), 1 ); // B
                        img( r, c, 2 ) = bb;
                    }
            }
        }
        ifs.close();
        return true;
    }
 
    bool read( std::string fname, arma::mat& img )
    {
        // Open file
        ifs.open( fname.c_str(), std::ifstream::binary );
        if( !ifs.good() )
        {
            std::cout << "Could not open " << fname << std::endl;
            return false;
        }
        else
        {
            read_header();
            get_info();
 
            img.set_size( rows, cols );
            arma::uword r = 0, c = 0;
            // Get the data
            if( type == PBM_A || type == PGM_A ) // Plain .PGM or .PBM
            {
                std::string str;
                while( ifs >> str && r < rows ) // Read until eof
                {
                    // Remove comments
                    size_t mark = str.find_first_of( "#" );
                    if( mark != std::string::npos )
                    {
                        ifs.ignore( 256, '\n' );
                        str.erase( mark, 1 );
 
                        if( str.empty() )
                            continue;
                    }
                    int pix     = atoi( str.c_str() ); // Convert to int
                    img( r, c ) = pix;
 
                    if( ++c == cols )
                    {
                        c = 0;
                        r++;
                    }
                }
            }
            else if( type == PBM_B ) // Raw PBM
            {
                unsigned char ch;
                while( ifs.read( reinterpret_cast<char*>( &ch ), 1 ) && r < rows ) // Read until eof
                {
                    std::bitset<8> pix( ch );
                    for( int b = 7; b >= 0; b-- )
                    {
                        img( r, c ) = pix[b];
                        if( ++c >= cols )
                        {
                            c = 0;
                            r++;
                            break;
                        }
                    }
                }
            }
            else if( type == PGM_B ) // Raw PGM
            {
                if( maxval <= 255 )
                {
                    for( arma::uword r = 0; r < rows; r++ )
                        for( arma::uword c = 0; c < cols; c++ )
                        {
                            unsigned char bb;
                            ifs.read( reinterpret_cast<char*>( &bb ), 1 );
                            img( r, c ) = bb;
                        }
                }
                else
                {
                    for( arma::uword r = 0; r < rows; r++ )
                        for( arma::uword c = 0; c < cols; c++ )
                        {
                            unsigned char bb[2];
                            ifs.read( reinterpret_cast<char*>( bb ), 2 );
                            img( r, c ) = ( bb[0] << 8 ) + bb[1];
                        }
                }
            }
        }
        ifs.close();
        return true;
    }
};
 
} // namespace sp
#endif