pngimage.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// @file pngimage.h
///
/// Writing PNG images.
/// This file contains the definition of a simple class "PngImage"
/// which allows one to create an RGB bitmap image of a prescribed size,
/// set the color of individual pixels, and save the image to a PNG file.
/// This class also allows to read a PNG image which is automatically
/// converted to an RGB bitmap.
///
/// @author Pawel Pilarczyk
///
/////////////////////////////////////////////////////////////////////////////

// Copyright (C) 1997-2008 by Pawel Pilarczyk.
//
// This file is part of my research software package.  This is free software;
// you can redistribute it and/or modify it under the terms of the GNU
// General Public License as published by the Free Software Foundation;
// either version 2 of the License, or (at your option) any later version.
//
// This software is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this software; see the file "license.txt".  If not, write to the
// Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
// MA 02111-1307, USA.

// Started on February 13, 2007. Last revision: April 9, 2008.


#ifndef _PWP_PNGIMAGE_H_
#define _PWP_PNGIMAGE_H_


#ifndef WITHOUT_PNG
#include <png.h>
#endif
#include <cstdlib>


// --------------------------------------------------
// ------------------- PNG Image --------------------
// --------------------------------------------------

/// An interface to the PNG library. Supports creating a 24-bit image,
/// writing individual pixels, and saving the image to a PNG file.
class PngImage
{
public:
        /// The constructor of an empty 24-bit PNG image.
        /// The default background color is white.
        PngImage (int _width, int _height, int _bgcolor = 0xFFFFFF);

        /// The constructor which reads a PNG image from a file.
        /// Throws an error text message (const char *) in case of failure.
        PngImage (const char *filename);

        /// The destructor.
        ~PngImage ();

        /// Plots a pixel in the image with the given RGB color.
        /// The color is encoded as 0xRRGGBB. Black by default.
        void putPixel (int x, int y, int color = 0x000000);

        /// Returns the 0xRRGGBB color value of the given pixel
        /// or -1 if the pixel is outside the image.
        int getPixel (int x, int y) const;

        /// Returns the width of the image.
        int width () const;

        /// Returns the height of the image.
        int height () const;

        /// Writes the image to a PNG file.
        /// Throws an error text message (const char *) in case of failure.
        void save (const char *filename) const;

private:
        /// The copy constructor is not allowed.
        PngImage (const PngImage &src);

        /// The assignment operator is not allowed.
        PngImage &operator = (const PngImage &src);

        /// The width of the image in pixels.
        int imgWidth;

        /// The height of the image in pixels.
        int imgHeight;

        /// The buffer of the picture in RGB byte sequences.
        unsigned char *buffer;

}; /* PngImage */

// --------------------------------------------------

inline PngImage::PngImage (int _width, int _height, int _bgcolor):
        imgWidth (_width), imgHeight (_height), buffer (0)
{
        if ((imgWidth <= 0) || (imgHeight <= 0))
                throw "Wrong size of a PNG image requested.";

        buffer = new unsigned char [3 * imgWidth * imgHeight];

        unsigned char red =
                static_cast<unsigned char> ((_bgcolor >> 16) & 0xFF);
        unsigned char green =
                static_cast<unsigned char> ((_bgcolor >> 8) & 0xFF);
        unsigned char blue =
                static_cast<unsigned char> (_bgcolor & 0xFF);
        unsigned char *buf = buffer;
        for (int i = imgWidth * imgHeight; i > 0; -- i)
        {
                *(buf ++) = red;
                *(buf ++) = green;
                *(buf ++) = blue;
        }
        return;
} /* PngImage::PngImage */

inline PngImage::~PngImage ()
{
        if (buffer)
                delete [] buffer;
        return;
} /* PngImage::~PngImage */

inline PngImage::PngImage (const PngImage &)
{
        return;
} /* PngImage::PngImage */

inline PngImage &PngImage::operator = (const PngImage &)
{
        return *this;
} /* PngImage::operator = */

inline void PngImage::putPixel (int x, int y, int color)
{
        if ((x < 0) || (x >= imgWidth) || (y < 0) || (y >= imgHeight))
                return;
        unsigned char *buf = buffer + 3 * (imgWidth * y + x);
        *(buf ++) = static_cast<unsigned char> ((color >> 16) & 0xFF); // R
        *(buf ++) = static_cast<unsigned char> ((color >> 8) & 0xFF); // G
        *(buf ++) = static_cast<unsigned char> (color & 0xFF); // B
        return;
} /* PngImage::putPixel */

inline int PngImage::getPixel (int x, int y) const
{
        if ((x < 0) || (x >= imgWidth) || (y < 0) || (y >= imgHeight))
                return -1;
        unsigned char *buf = buffer + 3 * (imgWidth * y + x);
        return (buf [0] << 16) | (buf [1] << 8) | buf [2];
} /* PngImage::getPixel */

inline int PngImage::width () const
{
        return imgWidth;
} /* PngImage::width */

inline int PngImage::height () const
{
        return imgHeight;
} /* PngImage::height */

// --------------------------------------------------

inline PngImage::PngImage (const char *filename):
        imgWidth (0), imgHeight (0), buffer (0)
{
#ifndef WITHOUT_PNG
        using namespace std;

        FILE *fp = fopen (filename, "rb");
        if (!fp)
                throw "Unable to open a PNG file.";

        png_byte header [8];
        fread (header, 1, 8, fp);
        if (png_sig_cmp (header, 0, 8))
                throw "The file does not contain a PNG image.";

        png_structp png_ptr = png_create_read_struct
                (PNG_LIBPNG_VER_STRING, png_voidp_NULL,
                png_error_ptr_NULL, png_error_ptr_NULL);
        if (!png_ptr)
                throw "Unable to create a PNG write struct.";

        png_infop info_ptr = png_create_info_struct (png_ptr);
        if (!info_ptr)
        {
                png_destroy_read_struct (&png_ptr, 0, 0);
                throw "Unable to create a PNG info struct.";
        }

        if (setjmp (png_jmpbuf (png_ptr)))
        {
                png_destroy_read_struct (&png_ptr, &info_ptr, 0);
                fclose (fp);
                throw "An error occurred while reading the PNG file.";
        }

        png_init_io (png_ptr, fp);
        png_set_sig_bytes (png_ptr, 8);

        int png_transforms = PNG_TRANSFORM_STRIP_16 |
                PNG_TRANSFORM_STRIP_ALPHA | PNG_TRANSFORM_PACKING |
                PNG_TRANSFORM_EXPAND | PNG_TRANSFORM_SHIFT;
        png_read_png (png_ptr, info_ptr, png_transforms, 0);

        unsigned width = png_get_image_width (png_ptr, info_ptr);
        unsigned height = png_get_image_height (png_ptr, info_ptr);

        if (png_get_rowbytes (png_ptr, info_ptr) != 3 * width)
                throw "Wrong number of bytes per row in a PNG file.";

        png_bytep *row_pointers = png_get_rows (png_ptr, info_ptr);
        buffer = new unsigned char [3 * width * height];
        for (unsigned row = 0; row < height; ++ row)
        {
                unsigned char *rowBuffer = buffer + 3 * row * width;
                unsigned char *rowSource = row_pointers [row];
                for (int i = 3 * width; i > 0; -- i)
                        *(rowBuffer ++) = *(rowSource ++);
        }

        png_destroy_read_struct (&png_ptr, &info_ptr, 0);
        fclose (fp);

        imgWidth = width;
        imgHeight = height;
#else
        if (!filename)
                return;
#endif
        return;
} /* PngImage::PngImage */

inline void PngImage::save (const char *filename) const
{
#ifndef WITHOUT_PNG
        using namespace std;

        FILE *fp = fopen (filename, "wb");
        if (!fp)
                throw "Unable to create a PNG file.";

        png_structp png_ptr = png_create_write_struct
                (PNG_LIBPNG_VER_STRING, png_voidp_NULL,
                png_error_ptr_NULL, png_error_ptr_NULL);
        if (!png_ptr)
                throw "Unable to create a PNG write struct.";

        png_infop info_ptr = png_create_info_struct (png_ptr);
        if (!info_ptr)
        {
                png_destroy_write_struct (&png_ptr, (png_infopp) 0);
                throw "Unable to create a PNG info struct.";
        }

        png_bytep *row_pointers = new png_bytep [imgHeight];
        for (int i = 0; i < imgHeight; ++ i)
                row_pointers [i] = buffer + 3 * i * imgWidth;

        if (setjmp (png_jmpbuf (png_ptr)))
        {
                png_destroy_write_struct (&png_ptr, &info_ptr);
                delete [] row_pointers;
                fclose (fp);
                throw "An error occurred while writing the PNG file.";
        }

        png_init_io (png_ptr, fp);
        png_set_rows (png_ptr, info_ptr, row_pointers);
        png_set_IHDR (png_ptr, info_ptr, imgWidth, imgHeight,
                8, PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE,
                PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);

        png_write_png (png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY, 0);

        png_destroy_write_struct (&png_ptr, &info_ptr);
        delete [] row_pointers;
        fclose (fp);
#else
        if (!filename)
                return;
#endif
        return;
} /* PngImage::save */


#endif // _PWP_PNGIMAGE_H_

---