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-2020 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 3 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,
// please, see <https://www.gnu.org/licenses/>.
 
// Started on February 13, 2007. Last revision: February 17, 2013.
 
 
#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];
        for (int i = 0; i < 8; ++ i)
                header [i] = 0;
        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, 0, 0, 0);
        //      (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_GRAY_TO_RGB |
                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);
 
        unsigned rowbytes = png_get_rowbytes (png_ptr, info_ptr);
        bool gray_image = (rowbytes == width);
        if (!gray_image && (rowbytes != 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];
                if (gray_image)
                {
                        for (int i = width; i > 0; -- i)
                        {
                                unsigned char byte = *(rowSource ++);
                                *(rowBuffer ++) = byte;
                                *(rowBuffer ++) = byte;
                                *(rowBuffer ++) = byte;
                        }
                }
                else
                {
                        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, 0, 0, 0);
        //      (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_