---

image.cpp

//FILE:         image.cpp
//AUTHOR:       Nathan Cournia <nathan@cournia.com>

#include <iostream>
#include "image.h"

image::image_t::image_t( unsigned int width, unsigned int height, format fmat, 
        unsigned int depth ): 
        m_width( width ),
        m_height( height ),
        m_format( fmat ),
        m_depth( depth ),
        m_seek_pos( 0 )
{
        //make sure the depth is sane
        if( (depth != BYTE) ) { //XXX || (depth != WORD) || (depth != DWORD) ) {
                std::cerr << "image::image( ): " << depth 
                        //<< " is not a valid depth (BYTE, WORD, DWORD)" << std::endl;
                        << " is not a valid depth (BYTE)" << std::endl;
                abort( ); //annoying
        }

        //compute pixel size
        m_pixel_size = m_format * m_depth / 8;

        //compute row size
        m_row_size = m_pixel_size * m_width;

        //compute image size
        m_image_size = m_width * m_height * m_pixel_size;

        //allocate memory for image
        m_pixels = new unsigned char[ m_image_size ];

        //set seek pointer
        m_seek_ptr = m_pixels;
}

image::image_t::image_t( unsigned int width, unsigned int height, format fmat, 
        unsigned int depth, const void *pixels ): 
        m_width( width ),
        m_height( height ),
        m_format( fmat ),
        m_depth( depth ),
        m_seek_pos( 0 )
{
        //make sure the depth is sane
        if( (depth != BYTE) ) { //XXX || (depth != WORD) || (depth != DWORD) ) {
                std::cerr << "image::image( ): " << depth 
                        //<< " is not a valid depth (BYTE, WORD, DWORD)" << std::endl;
                        << " is not a valid depth (BYTE)" << std::endl;
                abort( ); //annoying
        }
        
        //compute pixel size
        m_pixel_size = m_format * m_depth / 8;

        //compute row size
        m_row_size = m_pixel_size * m_width;

        //compute image size
        m_image_size = m_width * m_height * m_pixel_size;
        
        //allocate memory for image
        m_pixels = new unsigned char[ m_image_size ];

        //copy pixel data
        memcpy( m_pixels, pixels, m_image_size );

        //set seek pointer
        m_seek_ptr = m_pixels;
}

image::image_t::~image_t( void )
{
        delete[] m_pixels;
}

bool
image::image_t::seek( unsigned int x, unsigned int y )
{
        //make sure row and col are sane
        assert( y < m_height );
        assert( x < m_width );
        
        //set pointers
        m_seek_pos = y * m_row_size + x * m_pixel_size; 
        m_seek_ptr = m_pixels;
        
        if( m_seek_pos < m_image_size ) {
                m_seek_ptr += m_seek_pos;
                return true;
        }

        //row and col beyond image boundries
        return false;
}

bool
image::image_t::read( unsigned char& gray )
{
        if( !(m_seek_pos < m_image_size) ) {
                //seek pos is not valid
                return false;
        }

        //setup pointers
        unsigned char *ptr = m_seek_ptr;
        m_seek_pos += m_pixel_size;
        m_seek_ptr += m_pixel_size;

        float sum = 0.0;

        //figure out format
        if( m_format == RGB ) {
                //RGB unsigned char
                sum += (static_cast<float>( *(ptr++) ) / 255.0) * 0.299;
                sum += (static_cast<float>( *(ptr++) ) / 255.0) * 0.587;
                sum += (static_cast<float>( *(ptr++) ) / 255.0) * 0.114;
                gray = static_cast<unsigned char>( sum * 255.0 );
                return true;
        } else if( m_format == RGBA ) {
                //RGBA unsigned char
                sum += (static_cast<float>( *(ptr++) ) / 255.0) * 0.299;
                sum += (static_cast<float>( *(ptr++) ) / 255.0) * 0.587;
                sum += (static_cast<float>( *(ptr++) ) / 255.0) * 0.114;
                gray = static_cast<unsigned char>( sum * static_cast<float>( *ptr ) );
                return true;
        } else {
                //greyscale unsigned char
                gray = *ptr;
                return true;
        }
        
        return false;
}

bool
image::image_t::read( unsigned char &r, unsigned char &g, unsigned char &b )
{
        if( !(m_seek_pos < m_image_size) ) {
                //seek pos is not valid
                return false;
        }

        //setup pointers
        unsigned char *ptr = m_seek_ptr;
        m_seek_pos += m_pixel_size;
        m_seek_ptr += m_pixel_size;
        
        //figure out format
        if( (m_format == RGB) || (m_format == RGBA) ) {
                //RGB(A) unsigned char
                r = *(ptr++);
                g = *(ptr++);
                b = *ptr;
                return true;
        } else {
                //greyscale unsigned char
                r = *ptr;
                g = *ptr;
                b = *ptr;
                return true;
        }

        return false;
}

bool
image::image_t::read( unsigned char &r, unsigned char &g, unsigned char &b,
        unsigned char &a )
{
        if( !(m_seek_pos < m_image_size) ) {
                //seek pos is not valid
                return false;
        }

        //setup pointers
        unsigned char *ptr = m_seek_ptr;
        m_seek_pos += m_pixel_size;
        m_seek_ptr += m_pixel_size;
        
        //figure out format
        if( m_format == RGB ) {
                //RGB unsigned char
                r = *(ptr++);
                g = *(ptr++);
                b = *(ptr++);
                a = 255;
                return true;
        } else if( m_format == RGBA ) {
                //RGB unsigned char
                r = *(ptr++);
                g = *(ptr++);
                b = *(ptr++);
                a = *ptr;
                return true;
        } else {
                //greyscale unsigned char
                r = 255;
                g = 255;
                b = 255;
                a = *ptr;
                return true;
        }

        return false;
}

bool
image::image_t::write( unsigned char gray )
{
        if( !(m_seek_pos < m_image_size) ) {
                //seek pos is not valid
                return false;
        }

        //setup pointers
        unsigned char *ptr = m_seek_ptr;
        m_seek_pos += m_pixel_size;
        m_seek_ptr += m_pixel_size;

        float sum = 0.0;

        //figure out format
        if( m_format == RGB ) {
                //RGB unsigned char
                *(ptr++) = gray;
                *(ptr++) = gray;
                *ptr = gray;
                return true;
        } else if( m_format == RGBA ) {
                //RGBA unsigned char
                *(ptr++) = 255;
                *(ptr++) = 255;
                *(ptr++) = 255;
                *ptr = gray;
                return true;
        } else {
                //greyscale unsigned char
                *ptr = gray;
                return true;
        }
        
        return false;
}

bool
image::image_t::write( unsigned char r, unsigned char g, unsigned char b )
{
        if( !(m_seek_pos < m_image_size) ) {
                //seek pos is not valid
                return false;
        }

        //setup pointers
        unsigned char *ptr = m_seek_ptr;
        m_seek_pos += m_pixel_size;
        m_seek_ptr += m_pixel_size;

        //figure out format
        if( (m_format == RGB) || (m_format == RGBA) ) {
                //RGB(A) unsigned char
                *(ptr++) = r;
                *(ptr++) = g;
                *ptr = b;
                return true;
        } else {
                //greyscale unsigned char
                float sum = 0.0;
                sum += (static_cast<float>( r ) / 255.0) * 0.299;
                sum += (static_cast<float>( g ) / 255.0) * 0.587;
                sum += (static_cast<float>( b ) / 255.0) * 0.114;
                *ptr = static_cast<unsigned char>( sum * 255.0 );
                return true;
        }

        return false;
}

bool
image::image_t::write( unsigned char r, unsigned char g, unsigned char b,
        unsigned char a )
{
        if( !(m_seek_pos < m_image_size) ) {
                //seek pos is not valid
                return false;
        }

        //setup pointers
        unsigned char *ptr = m_seek_ptr;
        m_seek_pos += m_pixel_size;
        m_seek_ptr += m_pixel_size;

        //figure out format
        if( m_format == RGB ) {
                //RGB unsigned char
                *(ptr++) = r;
                *(ptr++) = g;
                *ptr = b;
                return true;
        } else if( m_format == RGBA ) {
                //RGBA unsigned char
                *(ptr++) = r;
                *(ptr++) = g;
                *(ptr++) = b;
                *ptr = a;
                return true;
        } else {
                //greyscale unsigned char
                float sum = 0.0;
                sum += (static_cast<float>( r ) / 255.0) * 0.299;
                sum += (static_cast<float>( g ) / 255.0) * 0.587;
                sum += (static_cast<float>( b ) / 255.0) * 0.114;
                *ptr = static_cast<unsigned char>( sum * static_cast<float>( a ) );
                return true;
        }

        return false;
}

bool
image::image_t::get_pixel( unsigned char &r, unsigned char &g, unsigned char &b, 
        unsigned int x, unsigned int y ) const
{
        //make sure y and xumn values are sane
        if( !(y < m_height) ) return false;
        if( !(x < m_width) ) return false;

        //get pointer to start of pixel
        unsigned char *ptr = m_pixels +  
                (y * m_row_size) + (x * m_pixel_size);

        //figure out format
        if( (m_format == RGB) || (m_format == RGBA) ) {
                //RGB(A) unsigned char
                r = *(ptr++);
                g = *(ptr++);
                b = *ptr;
                return true;
        } else {
                //greyscale unsigned char
                r = *ptr;
                g = *ptr;
                b = *ptr;
                return true;
        }

        return false;
}

bool
image::image_t::get_pixel( unsigned char &r, unsigned char &g, unsigned char &b, 
        unsigned char &a, unsigned int x, unsigned int y ) const
{
        //make sure y and xumn values are sane
        if( !(y < m_height) ) return false;
        if( !(x < m_width) ) return false;

        //get pointer to start of pixel
        unsigned char *ptr = m_pixels +  
                (y * m_row_size) + (x * m_pixel_size);

        //figure out format
        if( m_format == RGB ) {
                //RGB unsigned char
                r = *(ptr++);
                g = *(ptr++);
                b = *(ptr++);
                a = 255;
                return true;
        } else if( m_format == RGBA ) {
                //RGBA unsigned char
                r = *(ptr++);
                g = *(ptr++);
                b = *(ptr++);
                a = *ptr;
                return true;
        } else {
                //greyscale unsigned char
                r = 255;
                g = 255;
                b = 255;
                a = *ptr;
                return true;
        }

        return false;
}

bool
image::image_t::set_pixel( unsigned char r, unsigned char g, unsigned char b, 
        unsigned int x, unsigned int y )
{
        //make sure y and xumn values are sane
        if( !(y < m_height) ) return false;
        if( !(x < m_width) ) return false;

        //get pointer to start of pixel
        unsigned char *ptr = m_pixels +  
                (y * m_row_size) + (x * m_pixel_size);

        //figure out format
        if( (m_format == RGB) || (m_format == RGBA) ) {
                //RGB(A) unsigned char
                *(ptr++) = r;
                *(ptr++) = g;
                *ptr = b;
                return true;
        } else {
                //greyscale unsigned char
                float sum = 0.0;
                sum += (static_cast<float>( r ) / 255.0) * 0.299;
                sum += (static_cast<float>( g ) / 255.0) * 0.587;
                sum += (static_cast<float>( b ) / 255.0) * 0.114;
                *ptr = static_cast<unsigned char>( sum * 255.0 );
                return true;
        }

        return false;
}

bool
image::image_t::set_pixel( unsigned char r, unsigned char g, unsigned char b, 
        unsigned char a, unsigned int x, unsigned int y )
{
        //make sure y and x values are sane
        if( !(y < m_height) ) return false;
        if( !(x < m_width) ) return false;

        //get pointer to start of pixel
        unsigned char *ptr = m_pixels +  
                (y * m_row_size) + (x * m_pixel_size);

        //figure out format
        if( m_format == RGB ) {
                //RGB unsigned char
                *(ptr++) = r;
                *(ptr++) = g;
                *ptr = b;
                return true;
        } else if( m_format = RGBA ) {
                //RGBA unsigned char
                *(ptr++) = r;
                *(ptr++) = g;
                *(ptr++) = b;
                *ptr = a;
                return true;
        } else {
                //greyscale unsigned char
                float sum = 0.0;
                sum += (static_cast<float>( r ) / 255.0) * 0.299;
                sum += (static_cast<float>( g ) / 255.0) * 0.587;
                sum += (static_cast<float>( b ) / 255.0) * 0.114;
                *ptr = static_cast<unsigned char>( sum * static_cast<float>( a ) );
                return true;
        }
        
        return false;
}

//TODO add support for greyscale 
bool
image::image_t::blend_pixel( unsigned char r, unsigned char g, unsigned char b, 
        unsigned char a, unsigned int x, unsigned int y )
{
        //make sure y and x values are sane
        if( !(y < m_height) ) return false;
        if( !(x < m_width) ) return false;

        //get pointer to start of pixel
        unsigned char *pixel = m_pixels +  
                (y * m_row_size) + (x * m_pixel_size);

        float rd, gd, bd, ad;
        rd = ((float)*(pixel))/255.0;
        gd = ((float)*(pixel+1))/255.0;
        bd = ((float)*(pixel+2))/255.0;

        if( m_format == RGBA ) {
                ad = ((float)*(pixel+3))/255.0;
        } 

        float rs, gs, bs, as;
        rs = ((float)(r))/255.0;
        gs = ((float)(g))/255.0;
        bs = ((float)(b))/255.0;
        as = ((float)(a))/255.0;

        *(pixel++) = ((unsigned char)((rs * as + rd * (1.0 - as)) * 255.0));
        *(pixel++) = ((unsigned char)((gs * as + gd * (1.0 - as)) * 255.0));
        *(pixel++) = ((unsigned char)((bs * as + bd * (1.0 - as)) * 255.0));
        if( m_format == RGBA ) {
                *(pixel++) = ((unsigned char)((as * as + ad * (1.0 - as)) * 255.0));
        }

        return true;
}


void
image::image_t::flip_horizontal( void ) 
{
        //TODO add support for WORD and DWORD
        if( m_depth != BYTE ) return;
        
        unsigned int channels;
        if( m_format == RGB ) {
                channels = 3;
        } else if( m_format == RGBA ) {
                channels = 4;
        } else if( m_format == GREYSCALE ) {
                channels = 1;
        } else {
                return;
        }

        //channel size
        unsigned int chan_size = m_depth / 8;
        
        for( unsigned int i = 0; i < m_height / 2; ++i ) {
                for( unsigned int j = 0; j < m_width; ++j ) {
                        for( unsigned int k = 0; k < channels; ++k ) {
                                //TODO there should be a cast here based on BYTE, WORD, or DWORD
                                std::swap( 
                                        m_pixels[ i * m_row_size + j * m_pixel_size + k * chan_size ], 
                                        m_pixels[ (m_height - 1 - i) * m_row_size + j * m_pixel_size + k * chan_size ] 
                                );
                        }
                }
        }
}

//\todo It shouldn't be too hard to optimize this method.
bool
image::image_t::blit( const image_t& img, const recti& region )
{
        unsigned char r, g, b, a;
        unsigned int writes = 0;
        for( unsigned int y = 0; y < img.get_height( ); ++y ) {
                for( unsigned int x = 0; x < img.get_width( ); ++x ) {
                        if( img.get_pixel( r, g, b, a, x, y ) ) {
                                if( set_pixel( r, g, b, a, region.x + x, region.y + y ) ) {
                                        ++writes;
                                }
                        }
                }
        }
        return static_cast<bool>( writes );
}

//\todo It shouldn't be too hard to optimize this method.
bool
image::image_t::blend( const image_t& img, const recti& region )
{
        unsigned char r, g, b, a;
        unsigned int writes = 0;
        for( unsigned int y = 0; y < img.get_height( ); ++y ) {
                for( unsigned int x = 0; x < img.get_width( ); ++x ) {
                        if( img.get_pixel( r, g, b, a, x, y ) ) {
                                if( blend_pixel( r, g, b, a, region.x + x, region.y + y ) ) {
                                        ++writes;
                                }
                        }
                }
        }
        return static_cast<bool>( writes );
}

---