Adobe Photoshop file loader template class

• Download source files - 3 Kb

Introduction

Here is a quick way to load color, alpha and selection channel data from an flattened* Adobe Photoshop image file.  

* If Photoshop's save file preference is set to maximize compatibility with older versions the file will contain a pre-composited version of the image will be saved along with the layers. ).

Example Use

typedef BPT::TPSDFileLoader<ExampleSurface> loader_type;

typedef loader_type::channel_collection_type::iterator channel_iterator;

loader_type psdLoader;

loader_type::channel_collection_type * pChannels = psdLoader.Load( pszFilename );

if ( pChannels ){

    int channelCount = pChannels->size();

    std::cout << "There are " << channelCount << "channels.\n" << std::endl;

    int channel = 1;

    for ( channel_iterator it = pChannels->begin(); it != pChannels->end(); it++ ) {

        ExampleSurface * pSurface = *it;

        if ( 1 == channel ) {
            std::cout << "Red ";
        } else if ( 2 == channel ) {
            std:cout << "Green ";
        } else if ( 3 == channel ) {
            std:cout << "Blue ";
        } else {
            std:cout << "Alpha ";
        }

        std::cout << "Channel " << channel << "of " << channelCount;
        std::cout << " Width " << pSurface->Width();
        std::cout << " Height " << pSurface->Height();
        std::cout << endl;

        ++channel;

    }

    psdLoader.Unload( pChannels );

}

The TPSDFileLoader template parameters

template<
    class CHANNEL_SURFACE
    ,class CHANNEL_COLLECTION = std::list<CHANNEL_SURFACE *>
    ,class INPUT_POLICY = TFileIO<>
    ,class SIZE_COLLECTION = std::vector<int>
>
class TPSDFileLoader { 

The default template parameters are reasonable defaults for use in a Win32 environment. However if you want to bring the code to a slightly different platform or you have specific storage needs you can override defaults with your types. If you are fine with the defaults, the CHANNEL_SURFACE is the only type you *must* specify. 

CHANNEL_SURFACE

The loader references only four methods ( Create(), Width(), Height() and Iterator() ) and one exposed type ( pixel_iterator ) from the CHANNEL_SURFACE type.  The interface is relatively small it should be easy to write an adaptor class for most bitmap representations.  Here is an example surface that conforms to the loader's CHANNEL_SURFACE use.

struct ExampleSurface {

    typedef BYTE pixel_type;
    typedef pixel_type * pixel_iterator;

    SIZE m_Size;
    pixel_iterator m_Storage;

    int Width() { return m_Size.cx; }
    int Height() { return m_Size.cy; }

    pixel_iterator Iterator( const int x, const int y ) {
        if ( !m_Storage ) return 0;
        return m_Storage + (y * m_Size.cx) + x;
    }

    void Destroy() {
        if ( m_Storage ) {
            delete [] m_Storage;
            m_Storage = 0;
        }
        m_Size.cx = m_Size.cy = 0;
    }

    bool Create( const int width, const int height ) {

        Destroy();

        m_Storage = new pixel_type [ width * height ];

        m_Size.cx = width; m_Size.cy = height;

        return (0 != m_Storage);
        
    }

    ~ExampleSurface() { Destroy(); }

    ExampleSurface() : m_Storage(0) { m_Size.cx = m_Size.cy = 0; }

};

CHANNEL_COLLECTION

CHANNEL_COLLECTION is the collection type that will be used to return the channel data. 

class CHANNEL_COLLECTION = std::list<CHANNEL_SURFACE *>

INPUT_POLICY

This policy class is used to provide low-level input capabilities; the default class is simply a wrapper around the fopen/fclose and related basic read methods. It has methods for reading 16 bit and 32 bit values stored in endian specific fashion.  In addition to providing the necessary read interface it also hides memory allocation/deallocation details when reading chunks of data into memory. 

struct ExampleInputPolicy {
    bool Open( const char * filename, const char * access );
    void Close();
    void Seek( const int pos, const int mode );
    int Read_Byte();
    int Read_m16();
    int Read_m32();
    BYTE * LoadData( const int nBytes );
    void UnloadData( BYTE * ptr );
};

SIZE_COLLECTION

Internally the size of each channel is temporarily cached to make the loader implementation simpler. 

class SIZECOLLECTION = std::vector<int>

STL

if you want to eliminate the dependency on the STL you can do so by specifying a different collection type for both the SIZE_COLLECTION and CHANNEL_COLLECTION.

Includes

If you plan on using the default implementation you will need to include the list, vector headers. 

#include <list>
#include <vector>

#include "psd_load_src.h"

Public Methods

Unload() destroys the returned channel collection.

void Unload( CHANNEL_COLLECTION * pLoadedData );

LoadFromAbstraction() is the low-level public method, it is used to read from the IO policy object passed.

template< class INPUT > CHANNEL_COLLECTION *
LoadFromAbstraction( INPUT & input, const int nLoadChannelCountMax = 0 );

Load() -- accepts a null terminated string and uses the INPUT_POLICY and LoadFromAbstraction() to load the channel data.

CHANNEL_COLLECTION *
Load( const char * filename, const int nLoadChannelCountMax = 0 );

Usage

It's common to need access to the individual channel data in an Adobe Photoshop file, so this template saves a lot of time and effort.