utilities.h

#include <iostream>
#include <fstream>
#include <cstdlib>
#include <cctype>
#include <cmath>

#define EM_GTE (1)
#define EM_DAT (2)

using namespace std ;

/* Routines in this file:

int read_PNM_file( char * file_name, 
                   int &width, 
                   int &height,
                   int &max_color_depth,
                   int &type, 
                   unsigned char ** data ) 

int read_GTE_file( char * file_name, 
                   double & length_x,
                   double & length_y,
                   int &points_x, 
                   int &points_y,
                   int &max_color_depth,
                   unsigned char ** data ) 


int emit_PNM_file( int points_x, 
                   int points_y,
                   unsigned char * data ) 

int emit_data( int no_of_columns, 
               int no_of_rows ,
               double length_x, 
               double length_y,
               int mode,
               unsigned char * image_data   ) 

int scale_data( int scale,
                int points_x,
                int points_y,
                unsigned char * data )

int invert_data( int points_x,
                 int points_y,
                 int relative,
                 unsigned char * data )

int blow_up( int scale,
             double scale_x,
             double scale_y,
             int & points_x,
             int & points_y,
             unsigned char ** data )


*/

/*------------------------------------------------------------------------
            IMPLEMENTATION
------------------------------------------------------------------------*/

/*------------------------------------------------------------------------
            read_PNM_file
------------------------------------------------------------------------*/


int read_PNM_file( char * file_name, 
                   int &width, 
                   int &height,
                   int &max_color_depth,
                   int &type, 
                   unsigned char ** data ) 
{

    /* returned type:
       2 = Grayscale ASCII ( equiv. P2 )
       3 = RGB ASCII ( equiv. P3 )
       5 = Grayscale binary ( equiv. P5 ) 
       6 = RGB binary ( equiv. P6 ) */


    int status ;
    
    ifstream PNM_file ;
    char PNM_descriptor[ 10 ] ;
    char buffer, can_continue, endlin[ 10 ] ;
    unsigned char byte_read ;
    int int_read ;
    long total_number_of_pixels ;
    long index ;
    int image_stats[ 3 ] ;

    status = 0 ;


    if ( file_name != NULL )
        {
            PNM_file.open( file_name ) ;
            if ( !PNM_file )
                {
                    cerr << "ERROR! File " << file_name 
                         << " could not be opened! Exiting.\n" ;
                    exit( 1 ) ;
                }
        }

    /* Trying to get the descriptor */

    while ( 
           ( ( file_name != NULL )?PNM_file.peek():cin.peek() )  
            == (int)'#' )
        {
            ( file_name != NULL )?PNM_file.ignore( 1000, (int)'\n' ):
                cin.ignore( 1000, (int)'\n' ) ;
        }

    /* Recognize PNM descriptor */

    ( file_name != NULL )?PNM_file.getline( PNM_descriptor, 10 ):
        cin.getline( PNM_descriptor, 10 ) ;

    switch( PNM_descriptor[1] )
        {

        case '2': 
            type = 2 ;
            break ;
        case '3':
            type = 3 ;
            break ;
        case '5':
            type = 5 ;
            break ;
        case '6':
            type = 6 ;
            break ;
        default:
            type = 0 ;
            status = -1 ;
            cerr << "\nERROR: "
                 << "Unrecognized PNM format! Exiting\n" ;
            exit( 1 ) ;
            break ;

        }

    /* Establish image width, height, and color depth */

    index = 0 ;
    do
        {

            do
                {
                    can_continue = 1 ;

                    (file_name != NULL)?buffer = PNM_file.peek():
                        buffer = cin.peek() ;
                        
                    if ( buffer == '#')
                        {
                            (file_name != NULL)?
                                PNM_file.ignore( 1000, (int)'\n' ): 
                                cin.ignore( 1000, (int)'\n' ) ;   

                            can_continue = 0 ;
                        }
                    else if ( !isdigit( buffer )  )
                        {
                            ( file_name != NULL )?
                                PNM_file.ignore( 1 ):
                                cin.ignore( 1 ) ;   
                            
                            can_continue = 0 ;
                        }
                }
            while ( !can_continue ) ;
            
            ( file_name != NULL )?
                PNM_file >> image_stats[ index ]:
                cin >> image_stats[ index ] ;
            
            index++ ;
        }
    while ( index < 3 ) ;


    width = image_stats[ 0 ] ;
    height = image_stats[ 1 ] ;
    max_color_depth = image_stats[ 2 ] ;

    /* Now allocate the data array depending on the type of the file */

    total_number_of_pixels = width * height ;

    
    if ( ( type == 3 ) || ( type == 6 ) )
        { 
            total_number_of_pixels *= 3 ;
        } 

    ( *data ) = new unsigned char [ total_number_of_pixels ] ;


    /* Prepare to retrieve image data */
    ( file_name != NULL )?
        PNM_file.ignore( 1000, (int)'\n' ):
        cin.ignore( 1000, (int)'\n' ) ;


    /* Now perform the reading - either in ASCII or in binary */

    can_continue = 1 ;
    if ( type > 4 )
        {
            /* WE ARE BINARY */
            for ( index = 0 ; index < total_number_of_pixels ; index++ )
                {
                    
                    if ( (file_name != NULL)?PNM_file.good():cin.good() )
                        {
                            (*data)[ index ] = 
                                (file_name != NULL)?PNM_file.get():cin.get() ;
                        }
                    else
                        {
                            can_continue = 0 ;
                            break ;
                        }
                }
        }
    else
        {

            /* WE ARE ASCII */
            for ( index = 0 ; index < total_number_of_pixels ; index++ )
                {
                    
                    while( !( isdigit((file_name != NULL)?PNM_file.peek():
                                      cin.peek() ) 
                              || ( (file_name != NULL)?PNM_file.eof():0 )
                              )  
                           )
                        {
                            (file_name != NULL)?
                                PNM_file.ignore( 1 ):
                                cin.ignore( 1 );
                        }
                    if ( (file_name != NULL)?PNM_file.good():cin.good() )
                        {

                            (file_name != NULL)?PNM_file >> int_read: 
                                cin >> int_read ;
                            (*data)[ index ] = (unsigned char)int_read ;

                        }
                    else
                        {
                            can_continue = 0 ;
                            break ;
                        }
                }

            
        }

    if ( !can_continue )
        {
            cerr << "Error! The PNM file appears to be too short! Exiting!\n" ;
            delete [] (*data) ;
            exit( 1 ) ;
        }

    if ( file_name != NULL )
        {
            PNM_file.close() ;
        }
    return( status ) ;

}


/*------------------------------------------------------------------------
                read_GTE_file
------------------------------------------------------------------------*/


int read_GTE_file( char * file_name, 
                   double & length_x,
                   double & length_y,
                   int &points_x, 
                   int &points_y,
                   unsigned char ** data ) 
{

    int status ;
    ifstream GTE_file ;
    char buffer ;
    double numread ;
    long total_number_of_points, position_in_dataset ;
    int index_x, index_y ;
    double delta_x, delta_y ;
    int value ;

    status = 0 ;


    if ( file_name != NULL )
        {
            GTE_file.open( file_name ) ;
            if ( !GTE_file )
                {
                    cerr << "ERROR! File " << file_name 
                         << " could not be opened! Exiting.\n" ;
                    exit( 1 ) ;
                }
        }

    /* Information about the lengths and numbers of points */

    while( !( isdigit((file_name != NULL)?GTE_file.peek():
                      cin.peek() ) 
              || ( (file_name != NULL)?GTE_file.eof():0 )
              )  
           )
        {
            (file_name != NULL)?GTE_file.ignore( 1 ):cin.ignore( 1 );
        }

    ( file_name != NULL)?(GTE_file >> length_x):( cin >> length_x ) ;


    while( !( isdigit((file_name != NULL)?GTE_file.peek():
                      cin.peek() ) 
              || ( (file_name != NULL)?GTE_file.eof():0 )
              )  
           )
        {
            (file_name != NULL)?GTE_file.ignore( 1 ):cin.ignore( 1 );
        }

    ( file_name != NULL)?(GTE_file >> numread):( cin >> numread ) ;
    points_x = (int)numread ;

    while( !( isdigit((file_name != NULL)?GTE_file.peek():
                      cin.peek() ) 
              || ( (file_name != NULL)?GTE_file.eof():0 )
              )  
           )
        {
            (file_name != NULL)?GTE_file.ignore( 1 ):cin.ignore( 1 );
        }

    ( file_name != NULL)?(GTE_file >> length_y):( cin >> length_y ) ;


    while( !( isdigit((file_name != NULL)?GTE_file.peek():
                      cin.peek() ) 
              || ( (file_name != NULL)?GTE_file.eof():0 )
              )  
           )
        {
            (file_name != NULL)?GTE_file.ignore( 1 ):cin.ignore( 1 );
        }

    ( file_name != NULL)?(GTE_file >> numread):( cin >> numread ) ;
    points_y = (int)(numread) ;

    delta_x = length_x / ( (double)( points_x - 1 ) ) ;
    length_x += delta_x ;

    delta_y = length_y / ( (double)( points_y - 1 ) ) ;
    length_y += delta_y ;

    /* Get ready to read the data */

    total_number_of_points = points_x * points_y ;

    (*data) = new unsigned char [ total_number_of_points ] ;

    for ( index_y = 0 ; index_y < points_y ; index_y++ )
        {

            position_in_dataset = ( points_y - 1 - index_y ) * points_x ;

            for ( index_x = 0 ; index_x < points_x ; index_x++ )
                {
                    while( !( isdigit((file_name != NULL)?GTE_file.peek():
                                      cin.peek() ) 
                              || ( (file_name != NULL)?GTE_file.eof():0 )
                              )  
                           )
                        {
                            (file_name != NULL)?
                                GTE_file.ignore( 1 ):cin.ignore( 1 );
                        }

                    if ( (file_name != NULL)?GTE_file.good():cin.good() )
                        {

                            (file_name != NULL)?GTE_file >> value: 
                                cin >> value ;

                            (*data)[ position_in_dataset ] 
                                = (unsigned char)value ;
                            
                            position_in_dataset++ ;

                        }
                    else
                        {
                            status = 1 ;
                            break ;
                        }

                }

            if ( status == 1) break ;
        }


    if ( status == 1 )
        {
            cerr << "Error! The GTE file appears to be too short! Exiting!\n" ;
            delete [] (*data) ;
            exit( 1 ) ;
        }


    return( status ) ;

}


/*------------------------------------------------------------------------
                emit_PNM_file
------------------------------------------------------------------------*/


int emit_PNM_file( int points_x, 
                   int points_y,
                   unsigned char * data ) 
{

    long total_number_of_pixels, index ;

    int status ;

    status = 0 ;

    cout << "P5" << endl ;
    cout << points_x << " " << points_y << endl ;
    cout << "255" << endl ;
    
    total_number_of_pixels = points_x * points_y ;

    /* Now perform the writing - always in binary */

    for ( index = 0 ; index < total_number_of_pixels ; index++ )
        {
            cout << data[ index ] ;
        }

    cout << endl ;

    return( status ) ;

}



/*------------------------------------------------------------------------
           emit_data
------------------------------------------------------------------------*/


int emit_data( int no_of_columns, 
              int no_of_rows ,
              double length_x, 
              double length_y,
              int mode,
              unsigned char * image_data   ) 
{

    int status ;
    double delta_x, delta_y ;
    int index_x, index_y  ;
    int image_pixel_row, image_pixel_column, index_in_image_data ;
    double position_x, position_y ;
    int value ;

    status = 0 ;

    if (length_x == 0.0 ) length_x = (double)no_of_columns ;
    if (length_y == 0.0 ) length_y = (double)no_of_rows ;

    delta_x = length_x / ((double) no_of_columns  ) ;
    delta_y = length_y / ((double) no_of_rows  ) ;


    /* Emission starts with the length and resolution parameters */

    if ( mode == EM_GTE )
        {
            cout << length_x - delta_x << "   " 
                 << no_of_columns << endl ;
            cout << length_y - delta_y << "   " 
                 << no_of_rows << endl ;
        }

    /* Note that image_data contains data in order assuming that
       the origin is the UPPER LEFT-HAND corner, and the Y-axis is
       directed downwards. We have to change this. For us, the origin
       has to be in the LOWER LEFT-HAND corner, and the Y-axis
       is directed UPwards. We have to put image_data on its head then! */

    /* image_data has no_of_columns points in the x direction
       and no_of_rows points in the y direction. Data is stored row-by-row. */

    /* Activity 1. Establish the scaling of the DISTANCEs - i.e.,
       separation of "effective pixels " */


    /* Activity 2. Loop through all new points. Find the pixels
       they fall into. Retrieve the appropriate value. Emit it. */

    for ( index_y = 0 ; index_y < no_of_rows ; index_y++)
        {

            /* We need to switch it around so that the origin is
               actually the LOWER left hand corner */

            position_y = (double)index_y * delta_y ;

            image_pixel_row = no_of_rows - 1 - index_y ;
            
            for ( index_x = 0 ; index_x < no_of_columns ; index_x++  )
                {

                    position_x = (double)index_x * delta_x ;
                    image_pixel_column = index_x ;  

                    index_in_image_data = image_pixel_row * no_of_columns ;
                    index_in_image_data += image_pixel_column ;

                    if ( mode == EM_GTE )
                        {
                            cout << 
                                (int) image_data[index_in_image_data] << " " ;
                        }
                    else if ( mode == EM_DAT )
                        {
                            cout << position_x << "  " 
                                 << position_y << "  "
                                 <<(int) image_data[index_in_image_data] 
                                 << endl ;

                        }
                }
            if ( mode == EM_GTE )
                {
                    cout << endl ;
                }
        }

    return( status ) ;

}

/*------------------------------------------------------------------------
                        scale_data
------------------------------------------------------------------------*/


int scale_data( int scale,
                int points_x,
                int points_y,
                unsigned char * data )
{
    
    int status ;
    long index ;
    long no_of_points ;
    unsigned char saturation_max, saturation_min, value ;

    status = 0 ;

    if ( scale == 0 )
        {
            return( status ) ;
        }

    no_of_points = points_x * points_y ;


    /* Parse the datafile. Find the max and the min saturation */

    saturation_max = 0 ;
    saturation_min = 255 ;

    for ( index = 0 ; index < no_of_points ; index++ )
        {

            value = data[ index ] ;
            if ( value > saturation_max )
                {
                    saturation_max = value ;
                }
            if ( value < saturation_min )
                {
                    saturation_min = value ;
                }
        }


    saturation_max = saturation_max - saturation_min ;

    /* The data have values from saturation_min to saturation_max.
       We want to rescale so they range from 0 to 255. */

    for ( index = 0 ; index < no_of_points ; index++ )
        {
            value = data[ index ] ;
            value = value - saturation_min ;
            value = (unsigned char)( (double)value * 255.0 / 
                                     (double)saturation_max ) ;
            data[ index ] = value ;
        }

    return( status ) ;

}

/*------------------------------------------------------------------------
                        invert_data
------------------------------------------------------------------------*/

int invert_data( int points_x,
                 int points_y,
                 int relative,
                 unsigned char * data )
{
    
    int status ;
    long index ;
    long no_of_points ;
    unsigned char saturation_max, saturation_min, temp ;

    status = 0 ;

    no_of_points = points_x * points_y ;

    if ( relative == 0 )
        {
            for ( index = 0 ; index < no_of_points ; index++ )
                {
                   
                    temp = 255 - data[ index ] ;
                    data[ index ] = temp ;
                }
        }
    else
        {

            /* find max and min saturation */

            saturation_max = 0 ;
            saturation_min = 255 ;
            
            for ( index = 0 ; index < no_of_points ; index++ )
                {
                    temp = data[ index ];
                    if ( temp < saturation_min )
                        {
                            saturation_min = temp ;
                        }
                    if ( temp > saturation_max )
                        {
                            saturation_max = temp ;
                        }
                }

            /* inversion proper */

            for ( index = 0 ; index < no_of_points ; index++ )
                {
                    temp = saturation_max - data[ index ];
                    temp += saturation_min ;

                    data[ index ] = temp ;

                }


        }

    return( status ) ;

}

/*------------------------------------------------------------------------
                        blow_up
------------------------------------------------------------------------*/

int blow_up( int scale,
             double scale_x,
             double scale_y,
             int & points_x,
             int & points_y,
             unsigned char ** data )
{

    int status ;
    long no_of_points_old, no_of_points_new, index ;
    int index_x, index_y, index_x_old, index_y_old ;
    int points_x_new, points_y_new ;
    long position_in_old, position_in_new ;
    unsigned char value ;
    unsigned char * new_data ;

    status = 0 ;

    /* scale = whether to adjust the clolr depth to max
       scale_x = change of resolution along x axis
       scale_y = change of resolution along y axis */

    scale_data( scale, points_x, points_y, (*data) ) ;


    /* Be graceful when the scales happen to be negative */
    scale_x = fabs( scale_x ) ;
    scale_y = fabs( scale_y ) ;

    /* adjust for smallness */
    if ( scale_x == 0.0 ) scale_x = 0.01 ;
    if ( scale_y == 0.0 ) scale_y = 0.01 ;
    
    points_x_new = (int)( (double)points_x * scale_x ) ;
    points_y_new = (int)( (double)points_y * scale_y ) ;
    

    if ( ( scale_x != 1.0 ) || ( scale_y != 1.0 ) )
        {

            no_of_points_old = points_x * points_y ;
            no_of_points_new = points_x_new * points_y_new ;


            new_data = new unsigned char [ no_of_points_new ] ;

            for ( index_y = 0 ; index_y < points_y_new ; index_y++ )
                {

                    position_in_new = index_y * points_x_new ;
                    
                    index_y_old = (int)( (double)index_y / scale_y ) ;

                    for ( index_x = 0 ; index_x < points_x_new ; index_x++ )
                        {

                            index_x_old = (int)( (double)index_x / scale_x ) ;


                            position_in_old = index_y_old * points_x +
                                index_x_old ;

                            new_data[ position_in_new ] =
                                (*data)[ position_in_old ] ;

                            position_in_new++ ;
                        }
                }

            delete[] (*data) ;
            (*data) = new_data ;

        }

    points_x = points_x_new ;
    points_y = points_y_new ;

    return( status ) ;
}

/*----------------------------------------------------------------------*/

/*----------------------------------------------------------------------*/