PImagePng.cpp

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#include <string.h>
 
#include "PImagePng.h"

PImagePng::PImagePng(){
        initialisationPImagePng();
}


PImagePng::PImagePng(const PImagePng & other){
        initialisationPImagePng();
        copyPImagePng(other);
}

PImagePng::~PImagePng(){
        clear();
}


PImagePng & PImagePng::operator = (const PImagePng & other){
        copyPImagePng(other);
        return *this;
}


bool PImagePng::createImage(size_t width, size_t height, PImagePng::ColorType colorType){
        p_image.width = width;
        p_image.height = height;
        p_colorType = colorType;
        if(colorType == PImagePng::RGB){
                p_image.format = PNG_FORMAT_RGB;
                p_nbBytePerPixel = 3;
        }else if(colorType == PImagePng::RGBA){
                p_image.format = PNG_FORMAT_RGBA;
                p_nbBytePerPixel = 4;
        }
        if(p_buffer != NULL){
                free(p_buffer);
        }
        p_buffer = (png_byte*)malloc(PNG_IMAGE_SIZE(p_image));
        
//      png_structp pngStruct = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
//      if(pngStruct == NULL){return false;}
//      png_infop infoPtr = png_create_info_struct(pngStruct);
//      if(infoPtr == NULL){return false;}
//      png_set_IHDR(pngStruct, infoPtr, width, height,
//              8, PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE,
//              PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
        return true;
}


bool PImagePng::read(const PPath & fileName){
        if(fileName == ""){return false;}
        if(!check_is_png(fileName)){
                std::cerr << "PImagePng::read : file is not a png '"<<fileName<<"'" << std::endl;
                return false;
        }
        if(png_image_begin_read_from_file(&p_image, fileName.c_str()) == 0){
                std::cerr << "PImagePng::read : cannot read png image '"<<fileName<<"'" << std::endl;
                return false;
        }
        /* Set the format in which to read the PNG file; this code chooses a
        * simple sRGB format with a non-associated alpha channel, adequate to
        * store most images.
        */
        if(p_image.format == PNG_FORMAT_RGB){
                p_nbBytePerPixel = 3;
                p_colorType = PImagePng::RGB;
        }else if(p_image.format == PNG_FORMAT_RGBA){
                p_nbBytePerPixel = 4;
                p_colorType = PImagePng::RGBA;
        }
 
        /* Now allocate enough memory to hold the image in this format; the
        * PNG_IMAGE_SIZE macro uses the information about the image (width,
        * height and format) stored in 'image'.
        */
        p_buffer = (png_byte*)malloc(PNG_IMAGE_SIZE(p_image));
        if(p_buffer != NULL &&
                png_image_finish_read(&p_image, NULL/*background*/, p_buffer, 0/*row_stride*/, NULL/*colormap*/) != 0){
                return true;
        }
        return false;
}


bool PImagePng::write(const PPath & fileName){
        if(fileName == "" || p_buffer == NULL){return false;}
        if(png_image_write_to_file(&p_image, fileName.c_str(), 0/*convert_to_8bit*/, p_buffer, 0/*row_stride*/, NULL/*colormap*/) != 0){
                /* The image has been written successfully. */
                return true;
        }
        return false;
}

void PImagePng::clear(){
        if(p_buffer == NULL){
                png_image_free(&p_image);
        }else{
                free(p_buffer);
        }
}


void PImagePng::fill(color_t red, color_t green, color_t blue, color_t alpha){
        for(png_uint_32 j(0u); j < p_image.height; ++j){
                for(png_uint_32 i(0u); i < p_image.width; ++i){
                        setColor(i, j, red, green, blue);
                }
        }
}


void PImagePng::setColor(size_t idxWidth, size_t idxHeight, color_t red, color_t green, color_t blue){
        color_t alpha(255);
        setColor(idxWidth, idxHeight, red, green , blue, alpha);
}


void PImagePng::setColor(size_t idxWidth, size_t idxHeight, color_t red, color_t green, color_t blue, color_t alpha){
        size_t index((idxHeight*p_image.width + idxWidth)*p_nbBytePerPixel);
        p_buffer[index] = red;
        p_buffer[index + 1lu] = green;
        p_buffer[index + 2lu] = blue;
        if(p_nbBytePerPixel >= 4lu){
                p_buffer[index + 3lu] = alpha;
        }
}


void PImagePng::getColor(size_t idxWidth, size_t idxHeight, color_t & red, color_t & green, color_t & blue) const{
        color_t alpha(255);
        getColor(idxWidth, idxHeight, red, green , blue, alpha);
}


void PImagePng::getColor(size_t idxWidth, size_t idxHeight, color_t & red, color_t & green, color_t & blue, color_t & alpha) const{
        size_t index((idxHeight*p_image.width + idxWidth)*p_nbBytePerPixel);
        red = p_buffer[index];
        green = p_buffer[index + 1lu];
        blue = p_buffer[index + 2lu];
        if(p_nbBytePerPixel >= 4lu){
                alpha = p_buffer[index + 3lu];
        }
}


unsigned int PImagePng::getWidth() const{return p_image.width;}


unsigned int PImagePng::getHeight() const{return p_image.height;}


const png_byte* PImagePng::getData() const{return p_buffer;}


png_byte* PImagePng::getData(){return p_buffer;}


NbColorByte PImagePng::getNbBytePerPixel() const{return p_nbBytePerPixel;}


void PImagePng::copyPImagePng(const PImagePng & other){
        createImage(other.getWidth(), other.getHeight(), other.p_colorType);
        memcpy(p_buffer, other.p_buffer, sizeof(char)*other.getWidth()*other.getHeight()*p_nbBytePerPixel);
}

void PImagePng::initialisationPImagePng(){
        memset(&p_image, 0, (sizeof p_image));
        p_image.version = PNG_IMAGE_VERSION;     //We have to set the PNG version for this image
        
        p_buffer = NULL;
        p_nbBytePerPixel = 0;
}