---

ImageRGB.cpp

Go to the documentation of this file.

/**************************************************************************
 *
 * Source code for Real Time Image Library (libRTImage)
 *
 * Leeds Vision Group give permission for this code to be copied, modified 
 * and distributed within the University of Leeds subject to the following 
 * conditions:-
 *
 * - The code is not to be used for commercial gain.
 * - The code and use thereof will be attributed to the author where
 *   appropriate (inluding demonstrations which rely on it's use).
 * - All modified, distributions of the source files will retain this header.
 *
 ****************************************************************************/

#include <new>          // bad_alloc exception
#include <string.h>     // memcpy
#include <MicrosoftBMP_RT.h>
#include <MicrosoftRCBMP_RT.h>
#include <MicrosoftMonoBMP_RT.h>
 
#include "ImageRGB.h"


ImageRGB::ImageRGB(ImageRGB& img) : ImageBase(img)
{
        unsigned int array_size = img.width * img.height;
        data = new PixelRGB[array_size];

        *this = img;
}

ImageRGB::ImageRGB(ImageRGB&    img,  
                   unsigned int min_x,
                   unsigned int min_y,
                   unsigned int max_x,
                   unsigned int max_y) : ImageBase(max_x-min_x+1, max_y-min_y+1)
{
        data = new PixelRGB[width*height];
        copy(img, min_x, min_y, max_x, max_y, 0, 0) ;
}

ImageRGB::ImageRGB(unsigned int w, unsigned int h) : ImageBase(w,h)
{
        unsigned int array_size = width * height;
        data = new PixelRGB[array_size];

//      clear();
}

ImageRGB::ImageRGB(char *filename, FileFormat format)
{

    if(format == FORMAT_BMP_24){
        MicrosoftBMP_RT bmp(filename) ;

        if(!bmp.read()) throw("Invalid Bitmap file specified") ;

        width = bmp.ImageWidth ;
        height = bmp.ImageHeight ;

        data = new PixelRGB[width*height] ;

        bmp.extract_data((int *)data) ;
    }
    else if(format == FORMAT_BMP_RC){
        MicrosoftRCBMP_RT bmp(filename) ;

        if(!bmp.read()) throw("Invalid Bitmap file specified") ;

        width = bmp.ImageWidth ;
        height = bmp.ImageHeight ;

        data = new PixelRGB[width*height] ;

        bmp.extract_data((int *)data) ;
    }
    else if(format == FORMAT_BMP_MONO){
        MicrosoftMonoBMP_RT bmp(filename) ;

        if(!bmp.read()) throw("Invalid Bitmap file specified") ;

        width = bmp.ImageWidth ;
        height = bmp.ImageHeight ;

        data = new PixelRGB[width*height] ;

        bmp.extract_data((int *)data) ;
    }
    else if(format == FORMAT_BMP_ANY){
    // Check all formats
         MicrosoftBMP_RT* bmp ;
         MicrosoftRCBMP_RT *bmp_rc;
         MicrosoftMonoBMP_RT *bmp_mono;

         if((bmp = new  MicrosoftBMP_RT(filename)) != NULL &&
            bmp->read()){
         // 24 bit bmp
            width = bmp->ImageWidth ;
            height = bmp->ImageHeight ;

            data = new PixelRGB[width*height] ;

            bmp->extract_data((int *)data) ;
         }
         else if((bmp_rc = new  MicrosoftRCBMP_RT(filename)) != NULL &&
            bmp_rc->read()){
         // Reduced clour (palette) bmp
            width = bmp_rc->ImageWidth ;
            height = bmp_rc->ImageHeight ;

            data = new PixelRGB[width*height] ;

            bmp_rc->extract_data((int *)data) ;

         }
         else if((bmp_mono = new  MicrosoftMonoBMP_RT(filename)) != NULL &&
            bmp_mono->read()){
         // Monochrome (b+w) bmp
            width = bmp_mono->ImageWidth ;
            height = bmp_mono->ImageHeight ;

            data = new PixelRGB[width*height] ;

            bmp_mono->extract_data((int *)data) ;
         }
    }


}

ImageRGB::~ImageRGB()
{
    delete [] data;
}


void ImageRGB::set_pixel(unsigned int x, unsigned int y, PixelRGB p)
{
        // Check that co-ords are valid. 
        if (x > width || y > height)
                throw "Invalid Coordinates in method set_rgb";
        
        data[y * width + x] = p;
}


void ImageRGB::set_rgb(unsigned int x, unsigned int y, 
                    int red, int green, int blue)
{
        // Check that co-ords are valid. 
        if (x > width || y > height)
                throw "Invalid Coordinates in method set_rgb";
        
        unsigned int offset = y * width + x; 

        data[offset][RED]   = red;
        data[offset][GREEN] = green;
        data[offset][BLUE]  = blue;
}


void ImageRGB::set_field(unsigned int x, unsigned int y, 
                      FieldSelector fs, int value)
{
        // Check that co-ords are valid.
        if (x > width || y > height)
                throw "Invalid Coordinates in method set_field";

        unsigned int offset = y * width + x;
        data[offset][fs] = value;   
}


void ImageRGB::get_pixel(unsigned int x, unsigned int y, PixelRGB& p)
{
        unsigned int offset = y * width + x;

        p[ RED ] = data[offset][RED];
        p[GREEN] = data[offset][GREEN];
        p[ BLUE] = data[offset][BLUE];
}


int ImageRGB::get_field(unsigned int x, unsigned int y, FieldSelector fs)
{
        unsigned int offset = y * width + x;
        return data[offset][fs];
}


ImageRGB& ImageRGB::clear(int k)
{
        int *start = data[0];
        int *end   = start + width * height * 3;
                
        for (int *d = start; d < end; d++) *d = k;

        return *this;
}


ImageRGB& ImageRGB::clear(PixelRGB& p)
{
        int *start = data[0];
        int *end   = start + width * height * 3;
                
        for (int *d = start; d < end; d += 3) {
                d[ RED ] = p[ RED ];
                d[GREEN] = p[GREEN];
                d[ BLUE] = p[ BLUE];
        }
        
        return *this;
}


ImageRGB& ImageRGB::clear_field(FieldSelector fs, int k)
{
        int *start = data[0];
        int *end   = start + width * height * 3;
                
        for (int *d = start + fs; d < end; d += 3) *d = k;
        
        return *this;
}
    

ImageRGB& ImageRGB::copy(ImageRGB& img)
{
        /* check we're not trying to copy ourself */
        if (this == &img)
                throw "Source and Destination are same Image";
        
        /* First check images are the same size and valid */
        if (width != img.width || height != img.height) 
                throw "Difference in ImageRGB Dimensions";      
        
        /* Perform copy */
        memcpy(data, img.data, width * height * 3 * sizeof(int));

        return *this;
}

ImageRGB& ImageRGB::copy(ImageRGB&    img,
                         unsigned int min_x,
                         unsigned int min_y,
                         unsigned int max_x, 
                         unsigned int max_y,
                         unsigned int start_x,
                         unsigned int start_y)
{
        unsigned int sx ;
        unsigned int sy ;
        unsigned int cntx ;
        unsigned int cnty ;
        int          *s_ptr ;
        int          *d_ptr ;
        unsigned int s_width ;

        s_width = img.get_width() ;

        /* check we're not trying to copy ourself */
        if (this == &img)
                throw "Source and Destination are same Image";

        /* check sanity */
        if(min_x > max_x || min_y > max_y)
                throw "Invalid arguments to ImageRGB::copy()" ;

        /* Check images are big enough */
        sx = max_x - min_x + 1 ;
        sy = max_y - min_y + 1 ;

        if(sx+start_x > width || 
           sy+start_y > height)
                throw "Dest. image is not big enough" ;

         if(max_x > s_width ||
            max_y > img.get_height() )
                throw "Source images is not big enough" ;

         for(cnty=0 ; cnty<sy ; cnty++){

                 s_ptr = (int*)img.data + (min_x + (min_y+cnty)*s_width)*3 ;
                 d_ptr = (int*)data + (start_x + (start_y+cnty)*width)*3 ;

                 for(cntx=0 ; cntx<sx ; cntx++){ 

                         *(d_ptr++) = *(s_ptr++) ;
                         *(d_ptr++) = *(s_ptr++) ;
                         *(d_ptr++) = *(s_ptr++) ;
                 }
         }

         return *this; 
}

bool ImageRGB::save(char *filename, FileFormat format)
{
 
    bool            ret_val = true ;

    if(format == FORMAT_BMP_24 || format==FORMAT_BMP_ANY){
    // 24 Bit (full colour) bitmap (+default)
        MicrosoftBMP_RT *btmp;
        btmp = new MicrosoftBMP_RT(filename);
        if(btmp==NULL) ret_val = false ;
        else if(!btmp->set_size(width,height)) ret_val = false ;
        else{
            btmp->put_data((int *)data) ;
            ret_val = btmp->write();
        }
        delete btmp ;
    }
    else if(format == FORMAT_BMP_RC){
    // Greyscale bitmap
        MicrosoftRCBMP_RT *btmp;
        btmp = new MicrosoftRCBMP_RT(filename);
        if(btmp==NULL) ret_val = false ;
        else if(!btmp->set_size(width,height)) ret_val = false ;
        else if(!btmp->set_palette_grey256()) ret_val = false ;
        else{
            btmp->put_data((int *)data) ;
            ret_val = btmp->write();
        }
        delete btmp ;
    }
    else if(format == FORMAT_BMP_MONO){
    // Monochrome bitmap
        MicrosoftMonoBMP_RT *btmp;
        btmp = new MicrosoftMonoBMP_RT(filename);
        if(btmp==NULL) ret_val = false ;
        else if(!btmp->set_size(width,height)) ret_val = false ;
        else{
            btmp->put_data((int *)data) ;
            ret_val = btmp->write();
        }
        delete btmp ;
    }

    return ret_val ;
}

bool ImageRGB::enhance_contrast()
{
    unsigned int cnt ;
    int          max_val = 0 ;
    int          *ptr ;
    float        fact ;

    ptr = (int*)data ; 
    for(cnt=0 ; cnt<width*height*3 ; cnt++, ptr++){
        if(*ptr > max_val) max_val = *ptr ;
    }
   
    fact = 255.0 / (float)max_val ;

    ptr = (int*)data ;
    for(cnt=0 ; cnt<width*height*3 ; cnt++, ptr++){
        *ptr = (int)((float)(*ptr) * fact) ;
    }

    return true ;
} 


void ImageRGB::normalise_colourspace(int scale_factor)
{
    unsigned int cnt ;
    int          *ptr ;
    int          tot ;

    ptr = (int*)data ; 
    for(cnt=0 ; cnt<width*height ; cnt++){
        tot = *ptr ;
        tot += *(ptr+1) ;
        tot += *(ptr+2) ;

        if(tot > 0){
            *ptr *= scale_factor ;
            *(ptr++) /= tot ; 
            *ptr *= scale_factor ;
            *(ptr++) /= tot ; 
            *ptr *= scale_factor ;
            *(ptr++) /= tot ; 
        }
    }
} 

void ImageRGB::quick_grey_and_scale_down(unsigned int scale_fact,
                                         ImageGrey&   img)     
{
    unsigned int xcnt, ycnt ;
    PixelRGB*    pix_ptr ;
    int*         op_ptr ;
    int*         val_ptr ;

    op_ptr = img.brightness ;
    for(ycnt=0 ; ycnt<height ; ycnt+=scale_fact){
        pix_ptr = &(data[ycnt*width]) ;
        for(xcnt=0 ; xcnt<width ; 
            xcnt+=scale_fact, op_ptr++, pix_ptr+=scale_fact){
            val_ptr = (int*)pix_ptr ;
            *op_ptr = *(val_ptr++) ; 
            *op_ptr += *(val_ptr++) ; 
            *op_ptr += *val_ptr ; 
            *op_ptr /= 3 ; 
        }
    }
}

void ImageRGB::histogram_segment(Histogram &hist,
                                 float     threshold,
                                 ImageRGB& result)
{
    unsigned int cnt ;
    PixelRGB*    pix_ptr ;
    PixelRGB*    res_ptr ;
    PixelRGB     p_true(255,255,255) ;
    PixelRGB     p_false(0,0,0) ; 
    float        prob ;

    for(cnt=0, pix_ptr=data, res_ptr=result.data ;
        cnt<width*height ; cnt++, pix_ptr++, res_ptr++){
        prob = hist.get_mapped_value((unsigned int*) pix_ptr);
        if(prob > threshold) *res_ptr = p_true ;
        else                 *res_ptr = p_false ;
    }
}

void ImageRGB::histogram_segment(Histogram &hist,
                                 float     threshold,
                                 bool*     result)
{
    unsigned int cnt ;
    PixelRGB*    pix_ptr ;
    bool*        res_ptr ;
    float        prob ;

    for(cnt=0, pix_ptr=data, res_ptr=result ;
        cnt<width*height ; cnt++, pix_ptr++, res_ptr++){
        prob = hist.get_mapped_value((unsigned int*) pix_ptr);
        if(prob > threshold) *res_ptr = true ;
        else                 *res_ptr = false ;
    }
}


/****************************************************************************\
 *       Extra doxygen comments and information relating to this file       *
\****************************************************************************/
 

---