Image.cc

Go to the documentation of this file.

#include "Image.h"
#include <fstream>
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <png.h>

using namespace std;

static void error(const std::string& filename, const std::string& errtext)
{
    cerr << "Error reading image: " << filename << ": " << errtext << '\n';
    exit(1);
}

Image::Image(const std::string& filename)
{
    cerr << "Reading " << filename << "...";

    size_t found = filename.rfind(".png");
    if (found != string::npos) {
        // read a png file

        read_png_file(filename.c_str(), xres, yres);

        return;
    }

    // Assume reading ppm
    ifstream in(filename.c_str(), ios::in | ios::binary);
    if(!in)
        error(filename, "Error opening file");
    if(in.get() != 'P' || !in)
        error(filename, "Error reading magic number (1st digit)");
    if(in.get() != '6' || !in)
        error(filename, "Error reading magic number (2nd digit)");
    int maxValue;
    in >> xres >> yres >> maxValue;
    in.get();
    cerr << " " << xres << "x" << yres << "...";
    if(!in)
        error(filename, "Error reading metadaa");
    data = new Pixel*[yres];
    Pixel* p = new Pixel[xres*yres];
    for(int i=0;i<yres;i++)
        data[i] = p + i*xres;
    for(int i=yres-1;i>=0;i--)
        in.read(reinterpret_cast<char*>(data[i]), sizeof(Pixel)*xres);
    if(!in)
        error(filename, "Error reading pixels");
    cerr << " done\n";
}


Image::Image(int xres, int yres)
    : xres(xres), yres(yres)
{
    data = new Pixel*[yres];
    Pixel* p = new Pixel[xres*yres];
    for(int i=0;i<yres;i++)
        data[i] = p + i*xres;
}

Image::~Image()
{
    delete[] data[0];
    delete[] data;
}


void abort_(const char * s, ...)
{
    va_list args;
    va_start(args, s);
    vfprintf(stderr, s, args);
    fprintf(stderr, "\n");
    va_end(args);
    abort();
}


void Image::write_png_file(const char* file_name, int width, int height) const
{
    png_structp png_ptr;
    png_infop info_ptr;
    png_byte color_type = PNG_COLOR_TYPE_RGB;
    png_byte bit_depth = 8;


    /* create file */
    FILE *fp = fopen(file_name, "wb");
    if (!fp)
        abort_("[write_png_file] File %s could not be opened for writing", file_name);


    /* initialize stuff */
    png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
        
    if (!png_ptr)
        abort_("[write_png_file] png_create_write_struct failed");

    info_ptr = png_create_info_struct(png_ptr);
    if (!info_ptr)
        abort_("[write_png_file] png_create_info_struct failed");

    if (setjmp(png_jmpbuf(png_ptr)))
        abort_("[write_png_file] Error during init_io");

    png_init_io(png_ptr, fp);


    /* write header */
    if (setjmp(png_jmpbuf(png_ptr)))
        abort_("[write_png_file] Error during writing header");

    png_set_IHDR(png_ptr, info_ptr, width, height,
                 bit_depth, color_type, PNG_INTERLACE_NONE,
                 PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);

    png_write_info(png_ptr, info_ptr);


    /* write bytes */
    if (setjmp(png_jmpbuf(png_ptr)))
        abort_("[write_png_file] Error during writing bytes");


    png_bytep *row_pointers = (png_bytep *)malloc(sizeof(png_bytep) * height);
    for (int y=0 ; y < height ; y++)
        row_pointers[(height-1)-y] = (png_bytep) &data[y][0];

    png_write_image(png_ptr, row_pointers);


    /* end write */
    if (setjmp(png_jmpbuf(png_ptr)))
        abort_("[write_png_file] Error during end of write");

    png_write_end(png_ptr, NULL);

    /* cleanup heap allocation */
    //  for (int y=0; y<height; y++)
    //          free(row_pointers[y]);
    free(row_pointers);

    fclose(fp);
}

void Image::write(const std::string& filename) const
{
#if 0
    std::ofstream out(filename.c_str(), std::ios::out | std::ios::binary);
    out << "P6 " << xres << " " << yres << " 255\n";
    for(int i=yres-1;i>=0;i--)
        out.write(reinterpret_cast<char*>(data[i]), sizeof(Pixel)*xres);
#else
    write_png_file(filename.c_str(), xres, yres);
#endif

}

void Image::read_png_file(const char* file_name, int &width, int &height)
{
    png_structp png_ptr;
    png_infop info_ptr;
    png_byte color_type = PNG_COLOR_TYPE_RGB;
    png_byte bit_depth = 8;

    char header[8];     // 8 is the maximum size that can be checked

    /* open file and test for it being a png */
    FILE *fp = fopen(file_name, "rb");
    if (!fp)
        abort_("[read_png_file] File %s could not be opened for reading", file_name);
    fread(header, 1, 8, fp);
    if (png_sig_cmp((png_byte *)header, 0, 8))
        abort_("[read_png_file] File %s is not recognized as a PNG file", file_name);


    /* initialize stuff */
    png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
        
    if (!png_ptr)
        abort_("[read_png_file] png_create_read_struct failed");

    info_ptr = png_create_info_struct(png_ptr);
    if (!info_ptr)
        abort_("[read_png_file] png_create_info_struct failed");

    if (setjmp(png_jmpbuf(png_ptr)))
        abort_("[read_png_file] Error during init_io");

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

    png_read_info(png_ptr, info_ptr);

    width = info_ptr->width;
    height = info_ptr->height;
    color_type = info_ptr->color_type;
    bit_depth = info_ptr->bit_depth;

    png_set_interlace_handling(png_ptr);
    png_read_update_info(png_ptr, info_ptr);


    /* read file */
    if (setjmp(png_jmpbuf(png_ptr)))
        abort_("[read_png_file] Error during read_image");

    png_bytep *row_pointers = (png_bytep*) malloc(sizeof(png_bytep) * height);
    for (int y=0; y<height; y++)
        row_pointers[y] = (png_byte*) malloc(info_ptr->rowbytes);

    png_read_image(png_ptr, row_pointers);

    fclose(fp);

    // stash the data
}

---