basic/geometry/IGS/IGS_ImageFloat3.cpp

Go to the documentation of this file.

#include <assert.h>
#include <direct.h>
#include "IGS_ImageFloat1.h" 
#include "IGS_ImageFloat3.h" 

static int gNumberOfChannels = 3;

//=============================================================================
// constructor
//
// Description: constructor
//=============================================================================
IGS_ImageFloat3::IGS_ImageFloat3():
        pixels( NULL )
{
        IGS_Image::SetType( GL_FLOAT );
        IGS_Image::SetFormat( GL_RGB );
}

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

//=============================================================================
// FileLoad
//
// Description: load the file from disk
//=============================================================================
void IGS_ImageFloat3::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 * 3, infile );
}

//=============================================================================
// FileSave
//
// Description: saves the image to disk
//=============================================================================
void IGS_ImageFloat3::FileSave( const char* filename ) const
{
        FILE* outfile = fopen( filename, "wb" );
        char header[] = "IGS_FL3X";
        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 * 3, outfile );
        fclose( outfile );
}

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

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

//=============================================================================
// GetBuffer
//
// Description: gets a pointer to the underlying buffer
//=============================================================================
float& IGS_ImageFloat3::GetChannel( int channelNum, int x, int y )
{
        int index = IGS_Image::ComputeIndex( x, y );
        index *= gNumberOfChannels;
        index += channelNum;
        return this->pixels[ index ];
}

//=============================================================================
// GetBuffer
//
// Description: gets a pointer to the underlying buffer
//=============================================================================
const float& IGS_ImageFloat3::GetChannel( int channelNum, int x, int y ) const
{
        int index = IGS_Image::ComputeIndex( x, y );
        index *= gNumberOfChannels;
        index += channelNum;
        return this->pixels[ index ];
}

//=============================================================================
// GetPixel
//
// Description: initializes the image
//=============================================================================
IGS_Color IGS_ImageFloat3::GetPixel( const int x, const int y ) const
{
        const float& r = this->GetChannel( 0, x, y );
        const float& g = this->GetChannel( 1, x, y );
        const float& b = this->GetChannel( 2, x, y );
        return IGS_Color( r, g, b );
}

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

//=============================================================================
// operator *=
//
// Description: multiplies all the pixel values in the image by the other image
//=============================================================================
IGS_ImageFloat3& IGS_ImageFloat3::operator *=( const IGS_ImageFloat1& right )
{
        int i;
        for( i = 0; i < this->sizeX; i++ )
        {
                int j;
                for( j = 0; j < this->sizeY; j++ )
                {
                        this->GetChannel( 0, i, j ) *= right.GetPixel( i, j );
                        this->GetChannel( 1, i, j ) *= right.GetPixel( i, j );
                        this->GetChannel( 2, i, j ) *= right.GetPixel( i, j );
                }
        }
        return *this;
}

//=============================================================================
// operator =
//
// Description: assignment operator
//=============================================================================
IGS_ImageFloat3& IGS_ImageFloat3::operator =( const IGS_ImageFloat3& 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 ) * 3;
        memcpy( this->pixels, right.pixels, size );
        return *this;
}

//=============================================================================
// operator =
//
// Description: assignment operator for a color - sets all the pixels to this color
//=============================================================================
IGS_ImageFloat3& IGS_ImageFloat3::operator =( const IGS_Color& color )
{
        int i;
        for( i = 0; i < this->GetSizeX(); i++ )
        {
                int j;
                for( j = 0; j < this->GetSizeY(); j++ )
                {
                        this->PutPixel( i, j, color );
                }
        }
        return *this;
}

//=============================================================================
// PutPixel
//
// Description: puts a pixel of a specific color in a specific place in the 
//                              image
//=============================================================================
void IGS_ImageFloat3::PutPixel( const int x, const int y, const IGS_Color& color )
{
        this->GetChannel( 0, x, y ) = static_cast< float >( color.r );
        this->GetChannel( 1, x, y ) = static_cast< float >( color.g );
        this->GetChannel( 2, x, y ) = static_cast< float >( color.b );
}

---