PNG.cpp

Aller à la documentation de ce fichier.

/// \file 
/// Implémentation des classes permettant de manipuler des fichiers au format PNG
#include "PNG.hpp"
///////////////////////////////////////////////////////////////////////////////
/// PNG
///////////////////////////////////////////////////////////////////////////////
PNG::PNG(string fileName){
        p = new PNG_Reader(fileName);
}
PNG::PNG(int width, int height, EPNG_TYPE type, string fileName){
        p = new PNG_Writer(width, height, type, fileName);
}
PNG::PNG(const PNG& png){
        p = png.p; 
        ++p->use;       
}
PNG& PNG::operator=(const PNG& rhs){
        rhs.p->use++;
        if(--p->use == 0){
                delete p;       
        }
        p = rhs.p;
        return *this;
}
PNG::~PNG(){
        if(--p->use == 0){
                delete p;
        }
}
EPNG_TYPE PNG::getType()const{
        return p->getType();
}
string PNG::toString()const{
        return p->toString();
}
int PNG::getWidth()const{
        return p->getWidth();
}
int PNG::getHeight()const{
        return p->getHeight();
}
/*
void PNG::setFileName(const string fileName){
        p->setFileName(fileName);
}
*/
Color PNG::getColor(int i, int j)const{
        return p->getColor(i, j);
}
void PNG::setColor(int i, int j, Color color){
        p->setColor(i, j, color);
}
void PNG::setColor(int i, int j, float gray){
        p->setColor(i, j , gray);
}
void PNG::setColor(int i, int j, float red, float green, float blue){
        p->setColor(i, j, red, green, blue);
}
void PNG::read(){
        p->read();
}

void PNG::write(){
        p->write();
}
Histogram* PNG::getHistogram()const{
        return p->getHistogram();
}
///////////////////////////////////////////////////////////////////////////////
/// PNG_Base
///////////////////////////////////////////////////////////////////////////////
PNG_Base::PNG_Base():
        use(1),
        fp(NULL),
        png_ptr(NULL),
        info_ptr(NULL)
        {}
int PNG_Base::getWidth()const{
        return width;
};
int PNG_Base::getHeight()const{
        return height;
}
EPNG_TYPE PNG_Base::getType()const{
        switch(color_type){
                case 0 : // GRAY
                {
                        return PNG_GRAY;
                }
                break;
                case 2 : // RGB
                {
                        return PNG_COLOR;
                }
                break;
        }
}
string PNG_Base::toString()const{
        std::ostringstream o;
        o << "width\t\t" << width << endl;
        o << "height\t\t" << height << endl;
        o << "bit_depth\t" << (int)bit_depth << endl;
        o << "color_type\t" << (int)color_type << endl;
        o << "rowbytes\t" << (int)rowbytes << endl;
        return o.str();
}
Histogram* PNG_Base::getHistogram()const{
        Histogram* ret = new Histogram();
        for(int j = 0; j < height; j++){
                for(int i = 0; i < width; i++){
                        Pixel pixel(i, j, getColor(i, j));
                        ret->addPixel(pixel);
                }
        }
        return ret;
}

///////////////////////////////////////////////////////////////////////////////
/// PNGReader
///////////////////////////////////////////////////////////////////////////////
void PNG_Reader::read(){
        const int PNG_BYTES_TO_CHECK = 4;
        png_structp png_ptr;
        png_infop info_ptr;

        FILE *fp = fopen(fileName.c_str(), "rb");
        if(fp == NULL){
                throw std::runtime_error(" IMPOSSIBLE D'OUVRIE LE FICHIER " + fileName);
        }
        unsigned char buf[PNG_BYTES_TO_CHECK];
        if(fread(buf, 1, PNG_BYTES_TO_CHECK, fp) != PNG_BYTES_TO_CHECK){
                throw std::runtime_error(" LE FICHIER " + fileName + " N'EST PAS AU FORMAT PNG ");
        }
        if(png_sig_cmp(&buf[0], (png_size_t)0, PNG_BYTES_TO_CHECK)){
                throw std::runtime_error(" LE FICHIER " + fileName + " N'EST PAS AU FORMAT PNG ");
        }
          png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
        if (png_ptr == NULL) {
                fclose(fp);
                throw std::runtime_error(" ERREUR A LA CREATION DE LA STRUCTURE PNG ");
        }
        info_ptr = png_create_info_struct(png_ptr);
        if (info_ptr == NULL) {
                fclose(fp);
                png_destroy_read_struct(&png_ptr, png_infopp_NULL, png_infopp_NULL);
                throw std::runtime_error(" ERRUUR A LA CREATION D'INFORMATION PNG ");
        }
        if(setjmp(png_jmpbuf(png_ptr))) {
                png_destroy_read_struct(&png_ptr, &info_ptr, png_infopp_NULL);
                fclose(fp);
                throw std::runtime_error(" ERREUR A LA CREATION DE LA STRUCTURE INTERNE PNG ");
        }
        png_init_io(png_ptr, fp);
        png_set_sig_bytes(png_ptr, PNG_BYTES_TO_CHECK);

        // high-level read
        png_read_png(png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY, png_voidp_NULL);
        width = (int)png_get_image_width(png_ptr, info_ptr);
        height = (int)png_get_image_height(png_ptr, info_ptr);
        bit_depth = (int)png_get_bit_depth(png_ptr, info_ptr);
        color_type = (int)png_get_color_type(png_ptr, info_ptr);
        rowbytes = png_get_rowbytes(png_ptr, info_ptr);

        fclose(fp);
        pData = png_get_rows(png_ptr, info_ptr);
}
Color PNG_Reader::getColor(int x, int y)const{
        x = (x < 0 ? 0 : x);
        x = (x >= width ? width - 1 : x);

        y = (y < 0 ? 0 : y);
        y = (y >= height ? height - 1 : y);

        switch(color_type){
                case 0 : // GRAY
                {
                        int gray = pData[y][x];
                        return Color(gray);
                }
                break;
                case 2 : // RGB
                {
                        int r = pData[y][x * 3];
                        int g = pData[y][x * 3 + 1];
                        int b = pData[y][x * 3 + 2];
                        return Color(r, g, b, true);

                }
                break;
        }
}
///////////////////////////////////////////////////////////////////////////////
/// PNG_Writer
/////////////////////////////////////////////////////////////////////////////// 
PNG_Writer::PNG_Writer(int _width, int _height, EPNG_TYPE type, string _fileName){
        width = _width;
        height = _height;
        fileName = _fileName;

        buffer.resize(width * height);
        switch(type){
                case PNG_GRAY:
                        color_type = 0;
                        bit_depth = 8;
                        rowbytes = width;
                break;
                case PNG_COLOR:
                        color_type = 2;
                        bit_depth = 8;
                        rowbytes = width * 3;
                break;
                default:
                        throw std::runtime_error(" TYPE DE FICHIER PNG NON SUPPORTE ");
        }
        pData = make_pixels();
}
void PNG_Writer::write(){
        for(int i = 0; i < height; i++){
                for(int j = 0; j < width; j++){
                        _setColor(j, i, buffer[j + i * width]);
                }
        }
        FILE *fp;
        png_structp png_ptr;
        png_infop info_ptr;

        fp = fopen(fileName.c_str(), "wb");
        if (fp == NULL){
                throw std::runtime_error(" ECRITURE FICHIER PNG " + fileName);
        }
        png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
        if (png_ptr == NULL) {
                fclose(fp);
                throw std::runtime_error(" CREATION STRUCTURE D'ECRITURE PNG ");        
        }
        info_ptr = png_create_info_struct(png_ptr);
        if (info_ptr == NULL) {
                fclose(fp);
                png_destroy_read_struct(&png_ptr, png_infopp_NULL, png_infopp_NULL);
                throw std::runtime_error(" CREATION INFORMATION PNG ");         
        }

        if (setjmp(png_jmpbuf(png_ptr))) {
                png_destroy_read_struct(&png_ptr, &info_ptr, png_infopp_NULL);
                fclose(fp);
                throw std::runtime_error(" CREATION INFORMATION INTERNE PNG ");         
        }
          png_init_io(png_ptr, fp);
        switch(color_type){
                case 0:
                        png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth, PNG_COLOR_TYPE_GRAY,
                                PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
                break;
                case 2:
                        png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth, PNG_COLOR_TYPE_RGB,
                                PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
                break;
        }
        png_set_rows(png_ptr, info_ptr, pData);
        png_write_png(png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY, png_voidp_NULL);

        fclose(fp);
}

png_bytep* PNG_Writer::make_pixels() {
        png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
        if (png_ptr == NULL) {
                throw std::runtime_error(" CREATION INFORMATION PNG ");         
        }
        png_bytep *row_pointers = (unsigned char **)png_malloc(png_ptr, height*sizeof(png_bytep));
        for (int i = 0; i < height; i++)
        row_pointers[i] = (unsigned char *)png_malloc(png_ptr, rowbytes);
        return row_pointers;
}
void PNG_Writer::_setColor(int x, int y, float gray){
        switch(color_type){
                case 0 : // GREY
                {
                        pData[y][x] = (int)gray;
                }
                break;
                case 2 : // TRUE COLOR
                {
                        pData[y][x * 3] = (int)gray;
                        pData[y][x * 3 + 1] = (int)gray;
                        pData[y][x * 3 + 2] = (int)gray;
                }
                break;
        }
}
void PNG_Writer::_setColor(int x, int y, float r, float g, float b){
        Color p = Color(r, g, b, true);
        switch(color_type){
                case 0 : // GREY
                {
                        pData[y][x] = (int)p.getGray();
                }
                break;
                case 2 : // TRUE COLOR
                {
                        pData[y][x * 3] = (int)p.getRed();
                        pData[y][x * 3 + 1] = (int)p.getGreen();
                        pData[y][x * 3 + 2] = (int)p.getBlue();
                }
                break;
        }
}
void PNG_Writer::_setColor(int x, int y, Color c){
        switch(color_type){
                case 0 : // GREY
                {
                        pData[y][x] = (int)c.getGray();
                }
                break;
                case 2 : // TRUE COLOR
                {
                        pData[y][x * 3] = (int)c.getRed();
                        pData[y][x * 3 + 1] = (int)c.getGreen();
                        pData[y][x * 3 + 2] = (int)c.getBlue();
                }
                break;
        }
}
void PNG_Writer::setColor(int x, int y, Color color){
        buffer[y * width + x] = color;
}
void PNG_Writer::setColor(int x, int y, float gray){
        Color c = Color(gray);
        buffer[y * width + x] = c;
}
void PNG_Writer::setColor(int x, int y, float r, float g, float b){
        Color c = Color(r, g, b, true);
        buffer[y * width + x] = c;
}

Color PNG_Writer::getColor(int x, int y) const{
        return buffer[width * y + x];
}

---