basic/geometry/IGS/IGS_ImageFloat1.cpp

Go to the documentation of this file.

#include <assert.h>
#include <direct.h>
#include "IGS_ImageFloat1.h"
#include <list>
#include <math.h>

//=============================================================================
// constructor
//
// Description: constructor
//=============================================================================
IGS_ImageFloat1::IGS_ImageFloat1():
        pixels( NULL )
{
        IGS_Image::SetType( GL_FLOAT );
}

//=============================================================================
// Destructor
//
// Description: destructor
//=============================================================================
IGS_ImageFloat1::~IGS_ImageFloat1()
{
        this->Invalidate();
}

//=============================================================================
// AddBorder
//
// Description: adds a border along the top bottom left and right of theimage
//=============================================================================
void IGS_ImageFloat1::AddBorder( const int width, const float value )
{
        int i;
        for( i = 0; i < this->GetSizeX(); i++ )
        {
                int w;
                for( w = 0; w < width; w++ )
                {
                        this->PutPixel( i, w, value );
                        this->PutPixel( i, this->GetSizeY() - 1 - w, value );
                }
        }

        int j;
        for( j = 0; j < this->GetSizeY(); j++ )
        {
                int w;
                for( w = 0; w < width; w++ )
                {
                        this->PutPixel( w, j, value );
                        this->PutPixel( this->GetSizeX() - 1 - w, j,  value );
                }
        }
}

//=============================================================================
// FileSave
//
// Description: save the file to disk
//=============================================================================
void IGS_ImageFloat1::FileSave( const char* filename ) const
{
        FILE* outfile = fopen( filename, "wb" );
        char header[] = "IGS_FL1X";
        fwrite( header, strlen( header ), 1, outfile );
        fwrite( &sizeX, sizeof( int ), 1, outfile );
        fwrite( &sizeY, sizeof( int ), 1, outfile );
        int size = this->ComputeMaxIndex();
        fwrite( pixels, sizeof( float ), size, outfile );
        fclose( outfile );
}

//=============================================================================
// FileLoad
//
// Description: load the file from disk
//=============================================================================
void IGS_ImageFloat1::FileLoad( const char* filename )
{
        char directoryName[ 256 ] = "";
        ::_getcwd( directoryName, 256 );
        FILE* infile = fopen( filename, "rb" );
        assert( infile != NULL );
        char header[ 9 ] = "";
        fread( header, sizeof( char ), 8, infile );
        fread( &sizeX, sizeof( int ), 1, infile );
        fread( &sizeY, sizeof( int ), 1, infile );
        this->Initialize();
        int size = this->ComputeMaxIndex();
        fread( pixels, sizeof( float ), size, infile );
}


//=============================================================================
// FindMax
//
// Description: finds the maximum value of the image
//=============================================================================
void IGS_ImageFloat1::FindMax( int& xMax, int& yMax, float absoluteMax ) const
{
        xMax = yMax = 0;
        float max = this->GetPixel( 0, 0 );
        int i;
        for( i = 0; i < this->sizeX; i++ )
        {
                int j;
                for( j = 0; j < this->sizeY; j++ )
                {
                        float check = this->GetPixel( i, j );
                        if( check > max )
                        {
                                max = check;
                                xMax = i;
                                yMax = j;
                                if( max >= absoluteMax )
                                {
                                        return;
                                }
                        }
                }
        }
}

//=============================================================================
// GetBuffer
//
// Description: gets a pointer to the underlying buffer
//=============================================================================
const void* const IGS_ImageFloat1::GetBuffer() const
{
        return this->pixels;
}


//=============================================================================
// GetBuffer
//
// Description: gets a pointer to the underlying buffer
//=============================================================================
void*& IGS_ImageFloat1::GetBuffer()
{
        return reinterpret_cast< void*& >( this->pixels );
}       

//=============================================================================
// GetPixel
//
// Description: gets a pixel from the image
//=============================================================================
void IGS_ImageFloat1::GetGradient( const int x, const int y, float& xg, float& yg )
{
        xg = yg = 0;
/*      static float horizontalEdge[] = 
        {
                0,              0,              0,              0,              0,
                0,              -1,             0,              1,              0,
                0,              -2,             0,              2,              0,
                0,              -1,             0,              1,              0,
                0,              0,              0,              0,              0,
        };

        static float verticalEdge[] = 
        {
                0,              0,              0,              0,              0,
                0,              1,              2,              1,              0,
                0,              0,              0,              0,              0,
                0,              -1,             -2,             -1,             0,
                0,              0,              0,              0,              0,
        };
*/
        static float horizontalEdge[] = 
        {
                0,              -1,             0,              1,              0,
                -1,             -4,             0,              4,              1,
                -2,             -6,             0,              6,              2,
                -1,             -4,             0,              4,              1,
                0,              -1,             0,              1,              0,
        };

        static float verticalEdge[] = 
        {
                0,              1,              2,              1,              0,
                1,              4,              6,              4,              1,
                0,              0,              0,              0,              0,
                -1,             -4,             -6,             -4,             -1,
                0,              -1,             -2,             -1,             0,
        };

        float hImage[] = 
        {
                this->GetPixel( x - 2, y + 2 ), this->GetPixel( x - 1, y + 2 ), this->GetPixel( x, y + 1 ) ,this->GetPixel( x + 1, y + 2 ), this->GetPixel( x + 1, y + 2 ),
                this->GetPixel( x - 2, y + 1 ), this->GetPixel( x - 1, y + 1 ), this->GetPixel( x, y + 1 ) ,this->GetPixel( x + 1, y + 1 ), this->GetPixel( x + 1, y + 1 ),
                this->GetPixel( x - 2, y + 0 ), this->GetPixel( x - 1, y + 0 ), this->GetPixel( x, y + 0 ) ,this->GetPixel( x + 1, y + 1 ), this->GetPixel( x + 1, y + 0 ),
                this->GetPixel( x - 2, y - 1 ), this->GetPixel( x - 1, y - 1 ), this->GetPixel( x, y - 1 ) ,this->GetPixel( x + 1, y - 1 ), this->GetPixel( x + 1, y - 1 ),
                this->GetPixel( x - 2, y - 2 ), this->GetPixel( x - 1, y - 2 ), this->GetPixel( x, y - 2 ) ,this->GetPixel( x + 1, y - 2 ), this->GetPixel( x + 1, y - 2 ),
        };

        int i;
        for( i = 0; i < 25; i++ )
        {
                xg += horizontalEdge[ i ] * hImage[ i ];
                yg += verticalEdge[ i ] * hImage[ i ];
        }
        float mag = sqrt( xg * xg + yg * yg );
        if( mag == 0 )
        {
                xg = 1;
                yg = 0;
        }
        else
        {
                assert( mag != 0 );
                xg /= mag;
                yg /= mag;
        }
}

//=============================================================================
// GetPixel
//
// Description: gets a pixel from the image
//=============================================================================
float IGS_ImageFloat1::GetPixel( const int x, const int y ) const
{
        int index = this->ComputeIndex( x, y );
        float* fpixels = reinterpret_cast< float* >( pixels );
        float& value = fpixels[ index ];
        return value;
}

//=============================================================================
// GetPixelFloat1
//
// Description: returns a floating point value of that pixel
//=============================================================================
float IGS_ImageFloat1::GetPixelFloat1( const int x ,const int y ) const
{
        assert( false );
        return 0;
}

//=============================================================================
// Initialize
//
// Description: initializes the image
//=============================================================================
void IGS_ImageFloat1::Initialize()
{
        this->semaphore.Lock();
        int sizeOfData = IGS_Image::SizeOfType( this->type );
        if( pixels != NULL )
        {
                delete[] pixels;
        }
        pixels = new float[ this->sizeX * this->sizeY * sizeOfData ];
        this->semaphore.Unlock();
}       

//=============================================================================
// OperationIncrease
//
// Description: adds a constant factor to each pixel
//=============================================================================
void IGS_ImageFloat1::OperationAbs()
{
        int maxIndex = this->ComputeMaxIndex();
        int i;
        for( i = 0; i < maxIndex; i++ )
        {
                pixels[ i ] = static_cast< float >( fabs( pixels[ i ] ) );
        }
}

//=============================================================================
// OperationDilate
//
// Description: dilates the image
//=============================================================================
void IGS_ImageFloat1::OperationBlur()
{
        static float blur[] =   
        {
                0,              1,              0,
                1,              2,              1,
                0,              1,              0,
        };

        IGS_FilterMatrixFloat blurFilter( 3, 3, blur );
        blurFilter.Normalize();
        IGS_ImageFloat1 intermediate;
        this->OperationFilter( blurFilter, intermediate );
        *this = intermediate;
}

//=============================================================================
// OperationDilate
//
// Description: dilates the image
//=============================================================================
struct XYpair
{
        int x;
        int y;
};

void IGS_ImageFloat1::OperationDilate( const float maxRadius )
{
        std::list< XYpair > points;
        points.clear();

        XYpair coords;
        float increment = 1.0f/256;
        float diagonalIncrement = increment * 1.41;

        //go through and find all the initial coords
        for( coords.x = 0; coords.x < this->GetSizeX() - 5; coords.x++ )
        {
                for( coords.y = 0; coords.y < this->GetSizeY() - 5; coords.y++ )
                {
                        if( this->GetPixel( coords.x, coords.y ) == 0 )
                        {
                                assert( coords.x < this->GetSizeX() );
                                assert( coords.y < this->GetSizeY() );
                                points.push_back( coords );
                        }
                }
        }

        std::list< XYpair>::iterator it = points.begin();
        while( it != points.end() )
        {
                XYpair& point = *it;
                float value = this->GetPixel( point.x, point.y );
                if( value < maxRadius )
                {

                        //add adjacent points
                        //do left
                        if( point.x != 0 )
                        {
                                float currentValue = this->GetPixel( point.x - 1, point.y );
                                if( ( currentValue > value + increment ) )
                                {
                                        XYpair left;
                                        left.x = point.x - 1;
                                        left.y = point.y;
                                        this->PutPixel( left.x, left.y, value + increment );
                                        points.push_back( left );
                                }
                        }

                        //do right
                        if( point.x != this->GetSizeX() - 1 )
                        {
                                float currentValue = this->GetPixel( point.x + 1, point.y );
                                if( ( currentValue > value + increment ) )
                                {
                                        XYpair right;
                                        right.x = point.x + 1;
                                        right.y = point.y;
                                        this->PutPixel( right.x, right.y, value + increment );
                                        points.push_back( right );
                                }
                        }

                        //do up
                        if( point.y != this->GetSizeY() - 1 )
                        {
                                float currentValue = this->GetPixel( point.x, point.y + 1 );
                                if( ( currentValue > value + increment ) )
                                {
                                        XYpair right;
                                        right.x = point.x;
                                        right.y = point.y + 1;
                                        this->PutPixel( right.x, right.y, value + increment );
                                        points.push_back( right );
                                }
                        }

                        //do down
                        if( point.y != 0 )
                        {
                                float currentValue = this->GetPixel( point.x, point.y - 1 );
                                if( ( currentValue > value + increment ) )
                                {
                                        XYpair right;
                                        right.x = point.x;
                                        right.y = point.y - 1;
                                        this->PutPixel( right.x, right.y, value + increment );
                                        points.push_back( right );
                                }
                        }

                        //do lower left
                        if( ( point.y != 0 ) && ( point.x != 0 ) )
                        {
                                float currentValue = this->GetPixel( point.x - 1, point.y - 1 );
                                if( ( currentValue > value + diagonalIncrement )  )
                                {
                                        XYpair right;
                                        right.x = point.x - 1;
                                        right.y = point.y - 1;
                                        this->PutPixel( right.x, right.y, value + diagonalIncrement );
                                        points.push_back( right );
                                }
                        }

                        //do upper left
                        if( ( point.y != 0 ) && ( point.x != 0 ) )
                        {
                                float currentValue = this->GetPixel( point.x - 1, point.y + 1 );
                                if( ( currentValue > value + diagonalIncrement )  )
                                {
                                        XYpair right;
                                        right.x = point.x - 1;
                                        right.y = point.y + 1;
                                        this->PutPixel( right.x, right.y, value + diagonalIncrement );
                                        points.push_back( right );
                                }
                        }

                        //do upper right
                        if( ( point.y != 0 ) && ( point.x != 0 ) )
                        {
                                float currentValue = this->GetPixel( point.x + 1, point.y + 1 );
                                if( ( currentValue > value + diagonalIncrement )  )
                                {
                                        XYpair right;
                                        right.x = point.x + 1;
                                        right.y = point.y + 1;
                                        this->PutPixel( right.x, right.y, value + diagonalIncrement );
                                        points.push_back( right );
                                }
                        }

                        //do lower right
                        if( ( point.y != 0 ) && ( point.x != 0 ) )
                        {
                                float currentValue = this->GetPixel( point.x + 1, point.y - 1 );
                                if( ( currentValue > value + diagonalIncrement )  )
                                {
                                        XYpair right;
                                        right.x = point.x + 1;
                                        right.y = point.y - 1;
                                        this->PutPixel( right.x, right.y, value + diagonalIncrement );
                                        points.push_back( right );
                                }
                        }

                }
                points.pop_front();
                it = points.begin();
        }
}

//=============================================================================
// OperationIncrease
//
// Description: adds a constant factor to each pixel
//=============================================================================
void IGS_ImageFloat1::OperationIncrease( const float f )
{
        int maxIndex = this->ComputeMaxIndex();
        int i;
        for( i = 0; i < maxIndex; i++ )
        {
                pixels[ i ] += f;
        }
}

//=============================================================================
// OperationIncrease
//
// Description: adds a constant factor to each pixel
//=============================================================================
void IGS_ImageFloat1::OperationInvert()
{
        int maxIndex = this->ComputeMaxIndex();
        int i;
        for( i = 0; i < maxIndex; i++ )
        {
                pixels[ i ] = 1 - pixels[ i ];
        }
}

//=============================================================================
// OperationScale
//
// Description: scales a floating point image by a constant factor
//=============================================================================
void IGS_ImageFloat1::OperationFilter( const IGS_FilterMatrixFloat f, IGS_ImageFloat1& output )
{
        //setup size of output image
        output.SetResolution( this->sizeX, this->sizeY );
        output.Initialize();

        int i;
        for( i = 0; i < this->sizeX - f.mSizeX; i++ )
        {
                int j;
                for( j = 0; j < this->sizeY - f.mSizeY; j++ )
                {
                        float outputvalue = 0;
                        int u;
                        for( u = 0; u < f.mSizeX; u++ )
                        {
                                int v;
                                for( v = 0; v < f.mSizeY; v++ )
                                {
                                        float filter = f.GetValue( u, v );
                                        float input = this->GetPixel( i + u, j + v );
                                        outputvalue += filter * input;
                                }
                        }
                        output.PutPixel( i, j, outputvalue );
                }
        }
}

//=============================================================================
// OperationRangeStretch
//
// Description: stretches values in a range
//=============================================================================
void IGS_ImageFloat1::OperationRangeStretch( const float low, const float hi )
{
        int maxIndex = this->ComputeMaxIndex();
        float range = hi - low;
        assert( range != 0 );
        int i;
        for( i = 0; i < maxIndex; i++ )
        {
                float& value = pixels[ i ];
                if( value < low )
                {
                        value = 0;
                }
                else if( value > hi )
                {
                        value = 1;
                }
                else
                {
                        pixels[ i ] = ( value - low ) / range;
                }
        }
}


//=============================================================================
// OperationScale
//
// Description: scales a floating point image by a constant factor
//=============================================================================
void IGS_ImageFloat1::OperationScale( const float f )
{
        int maxIndex = this->ComputeMaxIndex();
        int i;
        for( i = 0; i < maxIndex; i++ )
        {
                pixels[ i ] *= f;
        }
}

//=============================================================================
// OperationScale
//
// Description: scales a floating point image by a constant factor
//=============================================================================
void IGS_ImageFloat1::OperationThreshold( const float f )
{
        int maxIndex = this->ComputeMaxIndex();
        int i;
        for( i = 0; i < maxIndex; i++ )
        {
                if( pixels[ i ] > f )
                {
                        pixels[ i ] = 1;
                }
                else
                {
                        pixels[ i ] = 0;
                }
        }
}

//=============================================================================
// operator*=
//
// Description: in place multiplication
//=============================================================================
IGS_ImageFloat1& IGS_ImageFloat1::operator*=( const IGS_ImageFloat1& right )
{
        assert( this->GetSizeX() == right.GetSizeX() );
        assert( this->GetSizeY() == right.GetSizeY() );
        int i;
        int max = this->ComputeMaxIndex();
        for( i = 0; i < max; i++ )
        {
                this->pixels[ i ] *= right.pixels[ i ];
        }
        return *this;
}

//=============================================================================
// operator*=
//
// Description: in place scalar multiplication
//=============================================================================
IGS_ImageFloat1& IGS_ImageFloat1::operator*=( const float f )
{
        this->OperationScale( f );
        return *this;
}

//=============================================================================
// operator+=
//
// Description: in place addition
//=============================================================================
IGS_ImageFloat1& IGS_ImageFloat1::operator+=( const IGS_ImageFloat1& right )
{
        assert( this->GetSizeX() == right.GetSizeX() );
        assert( this->GetSizeY() == right.GetSizeY() );
        int i;
        int max = this->ComputeMaxIndex();
        for( i = 0; i < max; i++ )
        {
                this->pixels[ i ] += right.pixels[ i ];
        }
        return *this;
}

//=============================================================================
// operator=
//
// Description: assignment operator
//=============================================================================
IGS_ImageFloat1& IGS_ImageFloat1::operator=( const IGS_ImageChannel1& right )
{
        if( ( this->GetSizeX() != right.GetSizeX() ) || ( this->GetSizeY() != right.GetSizeY() ) )
        {
                //need to resize this image
                this->SetResolution( right.GetSizeX(), right.GetSizeY() );
                this->Initialize();
        }

        int x;
        for( x = 0; x < this->GetSizeX(); x++ )
        {
                int y;
                for( y = 0; y < this->GetSizeY(); y++ )
                {
                        float value = right.GetPixelFloat1( x, y );
                        this->PutPixel( x, y, value );
                }
        }
        return *this;
}

//=============================================================================
// operator=
//
// Description: assignment operator
//=============================================================================
IGS_ImageFloat1& IGS_ImageFloat1::operator=( const IGS_ImageFloat1& right )
{
        if( ( this->GetSizeX() != right.GetSizeX() ) || ( this->GetSizeY() != right.GetSizeY() ) )
        {
                //need to resize this image
                this->SetResolution( right.GetSizeX(), right.GetSizeY() );
                this->Initialize();
        }
        
        int size = this->ComputeMaxIndex() * sizeof( float );
        memcpy( this->pixels, right.pixels, size );
        return *this;
}

//=============================================================================
// operator=
//
// Description: assignment operator
//=============================================================================
IGS_ImageFloat1& IGS_ImageFloat1::operator=( const float right )
{
        int i;
        int max = this->ComputeMaxIndex();
        for( i = 0; i < max; i++ )
        {
                this->pixels[ i ] = right;
        }
        return *this;
}


//=============================================================================
// GetPixel
//
// Description: gets a pixel from the image
//=============================================================================
void IGS_ImageFloat1::PutPixel( const int x, const int y, float newValue )
{
        int index = this->ComputeIndex( x, y );
        float* fpixels = reinterpret_cast< float* >( pixels );
        float& value = fpixels[ index ];
        value = newValue;
}

//=============================================================================
// PutPixelFloat1
//
// Description: puts a floating point value into the image (1 channel )
//=============================================================================
void IGS_ImageFloat1::PutPixelFloat1( const int x, const int y, const float value )
{
        assert( false );
}

---