PortablePicture.h

Go to the documentation of this file.

#pragma once

#include "standard.h"


#pragma warning (push, 3)
#include <vector>
#include <string>
#include <algorithm>
#include <limits>
#pragma warning (pop)

#include "MatrixTypes.h"

template< typename T >
class typeTest
{ public: enum {isFloat = 0}; enum {isDouble = 0}; };

template<>
class typeTest< float >
{ public: enum {isFloat = 1}; enum {isDouble = 0}; };

template<>
class typeTest< double >
{ public: enum {isFloat = 0}; enum {isDouble = 1}; };


typedef struct
{
    char magicNumber; 

    int width;

    int height;

    bool bAscii;      
    
    double maximum;   

    int numChannels;  

} PictureHeaderInfo;

char *fileErrorString(FILE *fp, const char *filename, const char *function_name);
std::string getNextLine(FILE *fp, const char *filename);
void removeFirstToken(std::string &str);
PictureHeaderInfo readHeader(FILE *fp, const char *filename);    
void readBinaryBytes (FILE *fp, const char *filename, PictureHeaderInfo info, std::vector< RgbByte > &picture);
void readBinaryFloats(FILE *fp, const char *filename, PictureHeaderInfo info, std::vector< RgbFloat > &picture);
void readAscii (FILE *fp, const char *filename, PictureHeaderInfo info, std::vector< RgbByte > &picture);


class File
{
public:

    File() { fp = NULL; }

    void openForWriting(const char *filename)
    {
        fp = fopen(filename, "wb");
        if (!fp) throw DiskError(fp, "File::openForWriting()");
    }
    void openForReading(const char *filename)
    {
        fp = fopen(filename, "rb");
        if (!fp) throw DiskError (fp, "File::openForReading()");
    }

    ~File() { if (fp) fclose(fp); }

    FILE *fp;

}; // class File


#define PBM_ASCII  '1'
#define PGM_ASCII  '2'
#define PPM_ASCII  '3'
#define PBM_BINARY '4'
#define PGM_BINARY '5'
#define PPM_BINARY '6'
#define PFM_BINARY 'F'

 


template< typename T >
class PortablePicture
{
    typedef RgbColor< T > ColorType;

    public:

        PortablePicture()
        {
            width = 0;
            height = 0;
        }

        PortablePicture(int width_in, int height_in)
        {
            width = width_in;
            height = height_in;
            colorBuffer.resize(width*height);        
        }


        void getRange (T &our_min, T &our_max)
        {
            if (typeTest< T >::isFloat || typeTest< T >::isDouble)
            {
                our_min = (T)0.;
                our_max = (T)1.;
            }
            else
            {
                our_min = std::numeric_limits< T >::min();
                our_max = std::numeric_limits< T >::max();
            }            
        }


        void loadFile (const char *filename)
        {
            if (strlen(filename) < 4)
                throw Error("PortableFloatMap::saveAs(): extension not supported.");

            // our file extension
            std::string ext = filename + strlen(filename) - 4;

            if (!(ext == ".pfm" ||
                  ext == ".ppm" ||
                  ext == ".pgm"))
            {
                PortablePicture< unsigned char > pixmap;
                loadBits (filename, pixmap);
                T our_min, our_max;
                getRange (our_min, our_max);

                width = pixmap.getWidth();
                height = pixmap.getHeight();
                colorBuffer.resize (pixmap.getWidth() * pixmap.getHeight());
                copyData(pixmap.colorBuffer, 0, 255, our_min, our_max, colorBuffer);
                return;
            }

            
            assert(filename);
            File f;

            f.openForReading(filename);

            // (1) Read the header in. 
            PictureHeaderInfo header = readHeader(f.fp, filename);
    
            // (2) Read the pixels in.
            std::vector< ColorType > picture;

            readPixels (
                f.fp,     // in 
                filename, // in
                header,   // in
                picture); // out

            // (3) If an exception wasn't thrown, we can now set our pixels
            // and dimensions to the ones we've read in.
            width = header.width;
            height = header.height;
            colorBuffer = picture;
        }

        void setDimensions (int width_in, int height_in)
        {
            if (width_in <= 0 || height_in <= 0)
                throw ArgError("PortablePicture::setDimensions(): the width and height must be >= 0.");

            width = width_in;
            height = height_in;

            colorBuffer.resize(width*height);

            // initialize everything to black
            memset(&colorBuffer[0], 0, sizeof(ColorType) * width * height);
        }


        int getWidth()      const { return width; }

        int getHeight()     const { return height; }



        T getMaxColor() const
        {
            T theMax = 0;
            for (unsigned int i = 0; i < colorBuffer.size(); i++)
            {
                theMax = MAX (theMax, colorBuffer[i].r());
                theMax = MAX (theMax, colorBuffer[i].g());
                theMax = MAX (theMax, colorBuffer[i].b());
            }
            return theMax;
        }

        

        ColorType getInterpolated (float y, float x) const
        {
            assert (y <= getHeight() - 1);
            assert (x <= getWidth() - 1);

            // 1. Make sure we get values inside our array
            int xLower = (int)MAX(floor(x), 0);
            int xUpper = (int)MIN(ceil(x),getWidth()-1);

            int yLower = (int)MAX(floor(y), 0);
            int yUpper = (int)MIN(ceil(y),getHeight()-1);

            double pctX = x - xLower;
            double pctY = y - yLower;

            PortablePicture< T > & pp = const_cast< PortablePicture< T >& >(*this);
            ColorType & aColor = pp[yUpper][xLower];
            ColorType & bColor = pp[yUpper][xUpper];
            ColorType & cColor = pp[yLower][xLower];
            ColorType & dColor = pp[yLower][xUpper];

            ColorType ab;
            ab = aColor*(1-pctX) + bColor*(pctX);
            ColorType cd;
            cd = cColor*(1-pctX) + dColor*(pctX);

            ColorType abcd;
            abcd = ab*(pctY) + cd*(1-pctY);

            return abcd;
        }


        
        ColorType at (unsigned int y, unsigned int x) const
        {
            return colorBuffer[width*y + x];
        }


        ColorType * operator[] (int row) { return &colorBuffer[width*row]; }
        
        
        void saveAs (const char *filename) const
        {
            if (strlen(filename) < 4)
                throw ArgError("PortablePicture::saveAs(): extension not supported.");

            // our file extension
            std::string ext = filename + strlen(filename) - 4;

            if (!(ext == ".pfm" ||
                  ext == ".ppm" ||
                  ext == ".pgm"))
            {
                throw ArgError("PortableFloatMap::saveAs(): unsupported file type. Supported types are .ppm, .pgm, and .pfm.");
            }

            File f; // this will close itself
            f.openForWriting (filename);

            if (ext == ".pfm")
            {
                writeHeader(f.fp, "PF", "-1.0000", getWidth(), getHeight(), filename);

                if (colorBuffer.size() != fwrite(&colorBuffer[0], sizeof(colorBuffer[0]), colorBuffer.size(), f.fp))
                    throw DiskError(f.fp, "PortableFloatMap::saveAs");

                return;
            }

            bool bIsPixmap = (ext == ".ppm");
            char *magicNumber;

            if (bIsPixmap)
                    magicNumber = "P6";
            else // is a greymap
                    magicNumber = "P5";

            writeHeader(f.fp,
                magicNumber,
                "255",
                getWidth(), getHeight(),
                filename);

            T our_min, our_max;

            if (typeTest< T >::isFloat || typeTest< T >::isDouble)
            {
                our_min = (T)0.;
                our_max = (T)1.;
            }
            else
            {
                our_min = std::numeric_limits< T >::min();
                our_max = std::numeric_limits< T >::max();
            }


            for (int row = getHeight()-1; row >= 0; row--)
            {
                for (int col = 0; col < getWidth(); col++)
                {
                    const ColorType & curColor = colorBuffer[row*getWidth()+col];

                    RgbByte newColor;
                    newColor.r() = (unsigned char)RESCALE(curColor.r(), our_min, our_max, 0, 255);
                    newColor.g() = (unsigned char)RESCALE(curColor.g(), our_min, our_max, 0, 255);
                    newColor.b() = (unsigned char)RESCALE(curColor.b(), our_min, our_max, 0, 255);
                    if (bIsPixmap)
                    {
                        fputc(newColor.r(), f.fp);
                        fputc(newColor.g(), f.fp);
                        fputc(newColor.b(), f.fp);
                    }
                    else
                    {
                        fputc((newColor.r()+newColor.g()+newColor.b())/3, f.fp);
                    }
                }
            }
        }
    


        std::vector< ColorType > colorBuffer;

    private:
        int width;
        int height;
        
    
        template< typename N >
        void copyData (std::vector< RgbColor< N > > &data, double their_min, double their_max, T our_min, T our_max, std::vector< ColorType > &picture)
        {
            for (int row = 0; row < height; row++)
            {
                for (int col = 0; col < width; col++)
                {
                    unsigned int index = row*width+col;
                    
                    ColorType color;
                    
                    color[0] = (T)RESCALE(data[index][0], their_min, their_max, our_min, our_max);
                    color[1] = (T)RESCALE(data[index][1], their_min, their_max, our_min, our_max);
                    color[2] = (T)RESCALE(data[index][2], their_min, their_max, our_min, our_max);
                    picture[index] = color;
                }
            }
        }

        
        
        void writeHeader (FILE *f, const char *magicNumber, const char *maxNumber, int width, int height, const char *filename) const
        {
            if (0 >= fprintf(f, "%s\n%d %d\n%s%s", 
                magicNumber, 
                width, height, 
                maxNumber?maxNumber:"",
                maxNumber?"\n":""))
            {
                throw DiskError (f, "PortablePicture::saveAs()");
            }
        }        



        void readPixels (FILE *fp, const char *filename, PictureHeaderInfo info, std::vector< ColorType > & picture)
        {
            picture.resize(info.height * info.width);
            width = info.width;
            height = info.height;

            T our_min, our_max;

            getRange (our_min, our_max);

            if (info.magicNumber == PFM_BINARY)
            {
                // if we're floats, and they're floats, we can read the values directly.
                if (typeTest< T >::isFloat)
                {
                    if (picture.size() != (int)fread(&picture[0], sizeof(ColorType), picture.size(), fp))
                        throw fileErrorString(fp, filename, "readPixels()");    
                    return;
                }

                // okay, we're not a float.
                std::vector< RgbFloat > floatPicture;
                readBinaryFloats (fp, filename, info, floatPicture);

                copyData(floatPicture, 0, info.maximum, our_min, our_max, picture);
                return;
            }
            
            std::vector< RgbByte > bytePicture;
            if (info.bAscii)
                readAscii (fp, filename, info, bytePicture);
            else
                readBinaryBytes (fp, filename, info, bytePicture);

            copyData(bytePicture, 0, info.maximum, our_min, our_max, picture);
        }
};




typedef PortablePicture< float > PortableFloatMap;

typedef PortablePicture< unsigned char > PortablePixMap;

void loadBits (const char *filename, PortablePixMap &p);

---