PortablePicture.cpp

Go to the documentation of this file.

#include "standard.h"
#include "PortablePicture.h"





char *fileErrorString(FILE *fp, const char *filename, const char *function_name)
{
    if (!fp) return fmtString("%s: file i/o error for file: %s", function_name, filename);
    if (feof(fp))
        return fmtString("%s: Reached end of file for file: %s", function_name, filename);
    else if (ferror(fp))
        return fmtString("%s: Error reading file (%s): %s", function_name, filename, strerror(ferror(fp)));
    else
        return fmtString("%s: Unknown error reading file (%s).", function_name, filename);
}

 


std::string getNextLine(FILE *fp, const char *filename)
{
    using std::string;
    string s;
    char line[71]; // lines should be no longer than 70 chars

    while (fgets (line, sizeof(line), fp) != NULL)
    {
        s = line;
        
        // remove "#" comments
        unsigned int position;
        if ((position = s.find_first_of ('#')) != string::npos)
            s.resize(position);
    
        // replace newlines & tabs with spaces
        std::replace (s.begin(), s.end(), '\n', ' ');
        std::replace (s.begin(), s.end(), '\r', ' ');
        std::replace (s.begin(), s.end(), '\t', ' ');

        // erase trailing spaces
        while (s.size() && isspace(s[s.size()-1]))
            s.resize (s.size() - 1);

        // erase leading spaces
        while (s.size() && isspace(s[0]))
            s.erase (0,1);

        if (s.length())
            return s;
    }

    throw DiskError(fp, "getNextLine()");

    return s; // never gets here
}

// Removes the first set of nonspace characters from "str"
void removeFirstToken(std::string &str)
{
    // remove leading nonspace chars
    while (str.size() && !isspace(str[0]))
        str.erase (0,1);      
    
    // remove leading space characters
    while (str.size() && isspace(str[0]))
        str.erase (0,1);        
}

PictureHeaderInfo readHeader(FILE *fp, const char *filename)
{
    PictureHeaderInfo info;

    std::string line = getNextLine (fp, filename);

    if (1 != sscanf (line.c_str(), "P%c", &info.magicNumber))
        throw RuntimeError ("readHeader(): Unable to get magic number from file: %s", filename);

/*
 * Find the "magic number". This will tell us whether the file is binary or ascii, and 
 * whether the pixel size is a bit, a byte, or a float.
 */

    switch (info.magicNumber)
    {
        case PBM_ASCII:
            info.bAscii = true;
            info.numChannels = 1;
            break;
        case PBM_BINARY:
            info.bAscii = false;
            info.numChannels = 1;
            throw ArgError("readHeader(): Can't read file (%s): Binary PBM's are unsupported at this time.", filename);
            break;
        case PGM_ASCII:
            info.bAscii = true;
            info.numChannels = 1;
            break;
        case PGM_BINARY:
            info.bAscii = false;
            info.numChannels = 1;
            break;
        case PPM_ASCII:
            info.bAscii = true;
            info.numChannels = 3;
            break;
        case PPM_BINARY:
            info.bAscii = false;
            info.numChannels = 3;
            break;
        case PFM_BINARY:
            info.bAscii = false;
            info.numChannels = 3;
            break;
        default:
            throw RuntimeError(
                "PortableFloatMap::loadFile(): bad magic number (P%c) for file (%s). The file should start with P1, P2, P3, P4, P5, P6, or PF.",
                info.magicNumber, filename);
    }

    
    // move on to next token we can find
    removeFirstToken(line);
    if (line.length() == 0)
        line = getNextLine (fp, filename); // throws exception on EOF

/*
 * Read the width. Just in case someone writes the width in floating point,
 * we will grab it as a float and then round.
 */
    double fWidth;
    if (sscanf(line.c_str(), "%lf", &fWidth) != 1)
        throw RuntimeError("readHeader(): bad header characters for file (%s) while trying to read width:\n%s", filename, line.c_str());
    info.width = ROUND (fWidth);

    // move on to next token we can find
    removeFirstToken(line);
    if (line.length() == 0)
        line = getNextLine (fp, filename); // throws exception on EOF

/*
 * Read the height; same deal as above.
 */
    double fHeight;
    if (sscanf(line.c_str(), "%lf", &fHeight) != 1)
        throw RuntimeError ("readHeader(): bad header characters for file (%s) while trying to read height:\n%s", filename, line.c_str());
    info.height = ROUND (fHeight);
   
/*
 * Each pixel will have a maximum possible value. In a PBM, that value
 * is implicitly "1"; otherwise, we have to read it in.
 */
    if (info.magicNumber == PBM_BINARY || info.magicNumber == PBM_ASCII)
        info.maximum = 1;
    else
    {
        removeFirstToken(line);
        if (line.length() == 0)
            line = getNextLine (fp, filename);

        if (sscanf(line.c_str(), "%lf", &info.maximum) != 1)
            throw RuntimeError ("Bad header characters for file (%s) while trying to read maximum:\n%s", filename, line.c_str());

        if (info.magicNumber == PFM_BINARY)
            info.maximum = 1.;
        else if (ROUND(info.maximum) != 255)
        {
            int max = ROUND(info.maximum);
            throw RuntimeError("readHeader(): This picture has a maximum value of %d; but this library can't deal with maximums other than 255.",
                max);
        }
    }

    return info;
}

template< typename T >
void readBinaryNumbers (FILE *fp, const char *filename, PictureHeaderInfo info, std::vector< RgbColor< T > > &picture)
{
    picture.resize (info.height * info.width);

    std::vector< T > scanline;
    scanline.resize (info.width * info.numChannels);

    for (int row = info.height-1; row >=0; row--)
    {
        if (scanline.size() != fread (&scanline[0], sizeof(T), scanline.size(), fp))
            throw DiskError (fp, "readBinaryNumbers()");
        
        for (unsigned int col = 0; col < scanline.size();)
        {
            if (info.numChannels == 1)
            {
                T currentPixelValue = scanline[col];
                                        
                RgbColor< T > pixel(
                    currentPixelValue,
                    currentPixelValue,
                    currentPixelValue);
                
                picture[row*info.width+col] = pixel;
                col+=1;
            }
            else // numChannels == 3
            {
                RgbColor< T > pixel;
                pixel[0] = scanline[col];
                pixel[1] = scanline[col+1];
                pixel[2] = scanline[col+2];
                
                picture[row*info.width+col/3] = pixel;
                col+=3;
            }
        }
    }
    
    assert ((int)picture.size() == info.width * info.height);
}

void readBinaryBytes (FILE *fp, const char *filename, PictureHeaderInfo info, std::vector< RgbByte > &picture)
{
    readBinaryNumbers< unsigned char >(fp, filename, info, picture);
}

void readBinaryFloats (FILE *fp, const char *filename, PictureHeaderInfo info, std::vector< RgbFloat > &picture)
{
    readBinaryNumbers< float >(fp, filename, info, picture);
}

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

    int currentPixelValue;
    if (info.numChannels == 1)
    {
        for (int row = info.height-1; row >=0; row--)
        {
            for (int col = 0; col < info.width; col++)
            {
                if (fscanf (fp, "%d", &currentPixelValue) != 1)
                    throw DiskError(fp, "readPixels()");
                
                RgbByte pixel(
                    (unsigned char)currentPixelValue,
                    (unsigned char)currentPixelValue,
                    (unsigned char)currentPixelValue);
                
                picture[row*info.width + col] = pixel;
            }
        }
    }
    else // numChannels == 3
    {
        for (int row = info.height-1; row >=0; row--)
        {
            for (int col = 0; col < info.width; col++)
            {
                RgbByte pixel;
                
                for (int c = 0; c < 3; c++)
                {
                    if (fscanf (fp, "%d", &currentPixelValue) != 1)
                    {
                        throw fileErrorString (fp, filename, "readPixels()");
                    }
                    pixel[c] = currentPixelValue;
                }
                
                picture[row*info.width+col] = pixel;
            }
        }
    }
}





#include "MemoryMap.h"
#include <windows.h>
#include <atlbase.h>

CComPtr<IPicture> loadIPicture (const char *filename)
{
/*
 * Load the file as a memory map
 */
    MemoryMap map;
    map.load (filename);
    void *data = map.getData();

    if (map.fileSizeHigh)
        throw Error ("loadIPicture(): file too big: %s", filename);

    unsigned int size = map.fileSizeLow;

/*
 * Get a global block of memory, and copy our file data into that block
 */
        HGLOBAL hGlobal = GlobalAlloc(GMEM_MOVEABLE, size);

        if(!hGlobal)
        throw Error("loadIPicture(): failed to allocate enough memory for file %s", filename);

        void* pData = GlobalLock(hGlobal);
        memcpy(pData, map.getData(), size);
        GlobalUnlock(hGlobal);

/*
 *  Make in in-memory stream representation from our global memory
 */
        CComPtr<IStream> pStream;

        HRESULT hr = CreateStreamOnHGlobal(hGlobal, TRUE, &pStream);

    if (FAILED (hr)) //  either hr == E_OUTOFMEMORY, or hr == E_INVALIDARG
    {
        GlobalFree (hGlobal);
        throw Error("loadBits(): Can't allocate memory for file %s", filename);
    }

/*
 * Load a picture, via the stream representation
 */
    CComPtr<IPicture> pIPicture;
    hr = OleLoadPicture (pStream, size, FALSE, IID_IPicture, (LPVOID*)&pIPicture);
    if (E_NOINTERFACE == hr)
        throw "IPicture interface not supported.";

    if (FAILED (hr))
        throw Error ("loadBits(): OleLoadPicture failure for file: %s (Unsupported file format?)", filename);

    return pIPicture;
}




class BitmapDeviceContext
{
public:
    BitmapDeviceContext(int width, int height) 
    { 
        // initialize everything, in case we throw an exception
        hdc = NULL;
        hBitmap = NULL;
        hBitmapOld = NULL;

        // Create our device context
        hdc = CreateCompatibleDC (NULL); 
        if (!hdc) throw Error("SelectedBitmap: couldn't CreateCompatibleDC");

        // Create a BITMAPINFOHEADER structure to describe the DIB
        BITMAPV4HEADER BIH ;
        int iSize = sizeof(BITMAPV4HEADER) ;
        memset(&BIH, 0, iSize);
        
        // Fill in the header info.
        BIH.bV4Size = iSize;
        BIH.bV4Width = width;
        BIH.bV4Height = height;
        BIH.bV4Planes = 1;
        BIH.bV4BitCount = 24;
        
        // Create the DIB section.
        hBitmap = CreateDIBSection( 
            hdc,
            (BITMAPINFO*)&BIH,
            DIB_RGB_COLORS,
            (void**)&bitmapBits,
            NULL,
            0);
        
        if (!hBitmap || !bitmapBits) 
        {
            cleanup();
            throw Error("BitmapDeviceContext::BitmapDeviceContext(): Unable to create bitmap");
        }
        
        hBitmapOld = (HBITMAP)::SelectObject(
            hdc,
            hBitmap);
    }

    void cleanup() 
    {
        if (hBitmapOld) ::SelectObject (hdc, hBitmapOld);
        if (hBitmap) DeleteObject (hBitmap);
        if (hdc) DeleteDC (hdc);
        
        hBitmapOld = NULL;
        hBitmap = NULL;
        hdc = NULL;
    }

    ~BitmapDeviceContext()
    {
        cleanup();
    }

    HDC getDC() { return hdc; }

    unsigned char *getBitmapBits() { return bitmapBits; }

private:
    HDC hdc;
    HBITMAP hBitmap, hBitmapOld;
    unsigned char *bitmapBits;
};

void loadBits (const char *filename, PortablePixMap &p)
{
    CComPtr<IPicture> pIPicture = loadIPicture (filename);
    
    OLE_YSIZE_HIMETRIC ipictHeight;
    OLE_XSIZE_HIMETRIC ipictWidth;
    
    pIPicture->get_Height (&ipictHeight);
    pIPicture->get_Width (&ipictWidth);
    
    #define HIMETRIC_PER_INCH 2540
    // Could use AtlHiMetricToPixel here, instead of doing this...
    unsigned int destHeight = MulDiv(ipictHeight, 96, HIMETRIC_PER_INCH);
    unsigned int destWidth  = MulDiv(ipictWidth,  96, HIMETRIC_PER_INCH);
    
    BitmapDeviceContext pDC (destWidth, destHeight);
    
    RECT r = {0,0,0,0};
    HRESULT hr = pIPicture->Render(
        pDC.getDC(),
        0, 0,
        destWidth, destHeight,
        0, ipictHeight, 
        ipictWidth, -ipictHeight,
        &r);
    
    if (FAILED(hr))
        throw Error("loadBits(): pIPicture->Render failure");
    

    p.setDimensions (destWidth,destHeight);
    
    unsigned char* destData = (unsigned char*)p[0];
    unsigned int destRowWidth = 3*p.getWidth();
    
    unsigned int srcRowWidth = 3*p.getWidth();
    srcRowWidth = (srcRowWidth + 3) & ~3;
    
    unsigned char *srcData = pDC.getBitmapBits();
    for (int row = 0; row < p.getHeight(); row++)
    {
        unsigned int destRow = row;
        memcpy (
            destData+destRow*destRowWidth, 
            srcData+row*srcRowWidth, 
            p.getWidth()*3);
    }
    
    for (row = 0; row < p.getHeight(); row++)
    {
        for (int col = 0; col < p.getWidth(); col++)
        {
            RGBTRIPLE *r = (RGBTRIPLE*)&p[row][col].r();
            std::swap (r->rgbtBlue, r->rgbtRed);
        }
    }
}

---