osg::ImageFileHandler Class Reference
[Image]

Image file Handler. Used to read/write and store/restore image data. See Image for a detailed description. More...

#include <OSGImageFileHandler.h>

List of all members.

Read Callback
typedef ImagePtr(*	readcbfp )(const char *fileName, const char *mimeType)
void	setReadCB (readcbfp fp)
readcbfp	getReadCB (void)
Public Member Functions
Destructor
virtual	~ImageFileHandler (void)
Read/Write
virtual ImagePtr	read (const char *fileName, const char *mimeType=0)
virtual bool	read (ImagePtr &image, const char *fileName, const char *mimeType=0)
virtual bool	write (const ImagePtr &image, const char *fileName, const char *mimeType=0)
virtual ImagePtr	read (std::istream &is, const std::string &mimeType)
virtual bool	read (ImagePtr &image, std::istream &is, const std::string &mimeType)
virtual bool	write (const ImagePtr &image, std::ostream &os, const std::string &mimeType)
PathHandler
virtual PathHandler *	getPathHandler (void)
virtual void	setPathHandler (PathHandler *pPathHandler)
Options
virtual bool	setOptions (const Char8 *suffix, const Char8 *options)
virtual const Char8 *	getOptions (const Char8 *suffix)
Storage
virtual UInt64	restore (ImagePtr &image, const UChar8 *buffer, Int32 memSize=-1)
virtual UInt64	store (const ImagePtr &image, const char *mimeType, UChar8 *buffer, Int32 memSize=-1)
virtual UChar8 *	store (const ImagePtr &image, UInt64 &memSize, const char *mimeType=0)
Get Types
ImageFileType *	getFileType (const char *mimeType, const char *fileName=0, bool validateHeader=false)
ImageFileType *	getDefaultType (void)
virtual int	getSuffixList (std::list< const Char8 * > &suffixList, UInt32 flags=ImageFileType::OSG_READ_SUPPORTED|ImageFileType::OSG_WRITE_SUPPORTED)
std::string	determineMimetypeFromName (const std::string &fileName)
std::string	determineMimetypeFromSuffix (const std::string &suffix)
std::string	determineMimetypeFromStream (std::istream &is)
Print
void	dump (void)
Static Public Member Functions
Get Method
static ImageFileHandler &	the (void)
Private Types
typedef std::map< std::string, ImageFileType * >	TypeMap
Private Member Functions
Constructor
	ImageFileHandler (void)
Copy Constructor
	ImageFileHandler (const ImageFileHandler &obj)
Copy Operator
const ImageFileHandler &	operator= (const ImageFileHandler &obj)
Static Private Member Functions
static bool	addImageFileType (ImageFileType &fileType)
static void	normalizeMimetype (std::string &mimetype)
static void	normalizeSuffix (std::string &suffix)
Private Attributes
std::map< std::string, ImageFileType * >	_suffixTypeMap
TypeMap	_typeMap
PathHandler *	_pPathHandler
readcbfp	_readFP
Static Private Attributes
static ImageFileHandler *	_the = 0
static const std::string	_fileNameKey
static const std::string	_fullFilePathKey
Friends
class	ImageFileType

---

Detailed Description

Singelton Object/Class which holds all known ImageFileTypes. The class is used to write/read Image objects to/from files and to store/restore image data to/from memory blocks. Utilizes the local pathHandler for file path handler and construction. The PathHandler can be set from the application.

See Image for details.

Definition at line 63 of file OSGImageFileHandler.h.

---

Member Typedef Documentation

typedef ImagePtr(* osg::ImageFileHandler::readcbfp)(const char *fileName, const char *mimeType)

typedef std::map<std::string, ImageFileType*> osg::ImageFileHandler::TypeMap [private]

Definition at line 181 of file OSGImageFileHandler.h.

---

Constructor & Destructor Documentation

ImageFileHandler::~ImageFileHandler

(

void

)

[virtual]

Destructor

Definition at line 707 of file OSGImageFileHandler.cpp.

{}

ImageFileHandler::ImageFileHandler

(

void

)

[private]

Default Constructor

Definition at line 696 of file OSGImageFileHandler.cpp.

                                       :
    _suffixTypeMap(),
    _typeMap(),
    _pPathHandler(0),
    _readFP(0)
{}

osg::ImageFileHandler::ImageFileHandler

(

const ImageFileHandler &

obj

)

[private]

---

Member Function Documentation

ImagePtr ImageFileHandler::read	(	const char *	fileName,
		const char *	mimeType = 0
	)			[virtual]

Creates a new image and tries to read the raster data from the given fileName. If the mimeType is not Null the method will try to find the according ImageFileType. Otherwise it will try to use the fileName suffix to determine the mimeType

Definition at line 273 of file OSGImageFileHandler.cpp.

References _readFP, osg::ImageBase::create(), osg::NullFC, and osg::subRefCP().

Referenced by osg::VRMLImageTextureDesc::endNode(), read(), and osg::Image::read().

{
    if(_readFP != NULL)
        return _readFP(fileName, mimeType);

    ImagePtr image = Image::create();

    if(read(image, fileName, mimeType) == false)
    {
        subRefCP(image);
        image = NullFC;
    }
    return image;
}

bool ImageFileHandler::read	(	ImagePtr &	image,
		const char *	fileName,
		const char *	mimeType = 0
	)			[virtual]

Tries to read the raster data from the given fileName into the given Image. If the mimeType is not Null the method will try to find the according ImageFileType. Otherwise it will try to use the fileName suffix to determine the mimeType

Definition at line 296 of file OSGImageFileHandler.cpp.

References _fileNameKey, _fullFilePathKey, _pPathHandler, osg::beginEditCP(), osg::endEditCP(), FDEBUG, osg::PathHandler::findFile(), osg::PathHandler::getBaseFile(), osg::Directory::getCurrent(), getFileType(), osg::ImageFileType::getMimeType(), osg::SceneFileHandler::getPathHandler(), osg::ImageBase::NameFieldMask, osg::ImageFileType::read(), SWARNING, and osg::SceneFileHandler::the().

{
    bool        retCode = false;
    std::string fullFilePath;

    if( _pPathHandler != NULL )
    {
        fullFilePath = _pPathHandler->findFile(fileName);
    }
    else
    {
        fullFilePath = fileName;
    }

    if(fullFilePath.empty())
    {
        SWARNING << "couldn't find image file " << fileName << std::endl;
        return false;
    }

    ImageFileType   *type = getFileType(mimeType, fullFilePath.c_str(), true);

    if(type)
    {
        FDEBUG(("try to image read %s as %s\n",
                fullFilePath.c_str(),
                type->getMimeType()));

        retCode = type->read(image, fullFilePath.c_str());

        if(retCode)
        {
            FDEBUG(("image: %dx%d\n", image->getWidth(), image->getHeight()));
            image->setAttachmentField(_fileNameKey, fileName);
            image->setAttachmentField(_fullFilePathKey, fullFilePath);
            
            // converting the path to a absolute path.
            std::string abspath;
            if(fullFilePath[0] != '/' && fullFilePath[0] != '\\' && fullFilePath[1] != ':')
            {
                std::string base = SceneFileHandler::the().getPathHandler()->getBaseFile();
                if(base.size() < 2 ||
                   (base[0] != '/' && base[0] != '\\' && base[1] != ':'))
                {
                    const char *cdir = Directory::getCurrent();
                    abspath = cdir;
#ifdef WIN32
                    abspath += '\\';
#else
                    abspath += '/';
#endif
                    delete [] cdir;
                }

                abspath += base;
                abspath += fullFilePath;
            }
            else
            {
                abspath = fullFilePath;
            }

            beginEditCP(image, Image::NameFieldMask);
                image->setName(abspath);
            endEditCP(image, Image::NameFieldMask);
        }
        else
        {
            SWARNING << "could not read " << fullFilePath << std::endl;
        }
    }
    else
    {
        SWARNING << "could not read " << fullFilePath
                 << "; unknown image format" << std::endl;
    }

    return retCode;
}

bool ImageFileHandler::write	(	const ImagePtr &	image,
		const char *	fileName,
		const char *	mimeType = 0
	)			[virtual]

Tries to write the raster data (from the given Image) to the given fileName. If the mimeType is not Null the method will try to find the according ImageFileType. Otherwise it will try to use the fileName suffix to determine the mimeType

Definition at line 396 of file OSGImageFileHandler.cpp.

References _fileNameKey, getFileType(), osg::ImageFileType::getMimeType(), SINFO, SWARNING, and osg::ImageFileType::write().

Referenced by osg::Image::write().

{
    bool            retCode = false;
    ImageFileType   *type;
    const std::string     *fNAttachment;

    if (!fileName && (fNAttachment = image->findAttachmentField(_fileNameKey)))
      fileName = fNAttachment->c_str();

    if ((type = getFileType(mimeType, fileName)))
    {
        SINFO << "try to write " << fileName << " as "
              << type->getMimeType() << std::endl;
        retCode = type->write(image, fileName);
    }
    else
    {
        SWARNING << "can't write " << fileName
                 << "; unknown image format" << std::endl;
    }

    return retCode;
}

ImagePtr ImageFileHandler::read	(	std::istream &	is,
		const std::string &	mimeType
	)			[virtual]

Creates a new image and tries to read the raster data from the given fileName. If the mimeType is not Null the method will try to find the according ImageFileType. Otherwise it will try to use the fileName suffix to determine the mimeType

Definition at line 423 of file OSGImageFileHandler.cpp.

References osg::ImageBase::create(), osg::NullFC, read(), and osg::subRefCP().

{
    ImagePtr image = Image::create();

    if (read(image, is, mimeType) == false)
    {
        subRefCP(image);
        image = NullFC;
    }

    return image;
}

bool ImageFileHandler::read	(	ImagePtr &	image,
		std::istream &	is,
		const std::string &	mimeType
	)			[virtual]

Creates a new image and tries to read the raster data from the given fileName. If the mimeType is not Null the method will try to find the according ImageFileType. Otherwise it will try to use the fileName suffix to determine the mimeType

Definition at line 438 of file OSGImageFileHandler.cpp.

References getFileType(), and osg::ImageFileType::read().

{
    ImageFileType *type = getFileType(mimeType.c_str());
    return type == 0 ? false : type->read(image, is, mimeType);
}

bool ImageFileHandler::write	(	const ImagePtr &	image,
		std::ostream &	os,
		const std::string &	mimeType
	)			[virtual]

Creates a new image and tries to read the raster data from the given fileName. If the mimeType is not Null the method will try to find the according ImageFileType. Otherwise it will try to use the fileName suffix to determine the mimeType

Definition at line 447 of file OSGImageFileHandler.cpp.

References getFileType(), and osg::ImageFileType::write().

{
    ImageFileType *type = getFileType(mimeType.c_str());
    return type == 0 ? false : type->write(image, os, mimeType);
}

void ImageFileHandler::setReadCB

(

readcbfp

fp

)

Definition at line 378 of file OSGImageFileHandler.cpp.

References _readFP.

{
    _readFP = fp;
}

ImageFileHandler::readcbfp ImageFileHandler::getReadCB

(

void

)

Definition at line 383 of file OSGImageFileHandler.cpp.

References _readFP.

{
    return _readFP;
}

PathHandler * ImageFileHandler::getPathHandler

(

void

)

[virtual]

Returns the path handler used

Definition at line 458 of file OSGImageFileHandler.cpp.

References _pPathHandler.

Referenced by osg::VRMLInlineDesc::endNode(), osg::HDRImageFileType::read(), and osg::DATImageFileType::read().

{
    return _pPathHandler;
}

void ImageFileHandler::setPathHandler

(

PathHandler *

pPathHandler

)

[virtual]

Method to set the path handler.

Definition at line 467 of file OSGImageFileHandler.cpp.

References _pPathHandler.

Referenced by osg::SceneFileHandler::initPathHandler().

{
    _pPathHandler = pPathHandler;
}

bool ImageFileHandler::setOptions	(	const Char8 *	suffix,
		const Char8 *	options
	)			[virtual]

Definition at line 665 of file OSGImageFileHandler.cpp.

References getFileType(), and osg::ImageFileType::setOptions().

{
    if(suffix == NULL)
        return false;
    
    ImageFileType *type = getFileType(suffix);
    if(type == NULL)
        return false;
    
    type->setOptions(options);
    
    return true;
}

const Char8 * ImageFileHandler::getOptions

(

const Char8 *

suffix

)

[virtual]

Definition at line 679 of file OSGImageFileHandler.cpp.

References getFileType(), and osg::ImageFileType::getOptions().

{
    if(suffix == NULL)
        return NULL;
    
    ImageFileType *type = getFileType(suffix);
    
    if(type == NULL)
        return NULL;
    
    return type->getOptions();
}

UInt64 ImageFileHandler::restore	(	ImagePtr &	image,
		const UChar8 *	buffer,
		Int32	memSize = -1
	)			[virtual]

Tries to restore the raster data from the given memblock into the given Image. If the mimeType is not Null the method will try to find the according ImageFileType. Otherwise it will try to use the fileName suffix to determine the mimeType

Definition at line 480 of file OSGImageFileHandler.cpp.

References osg::ImageFileType::restore().

{
    return ImageFileType::restore(image, buffer, memSize);
}

UInt64 ImageFileHandler::store	(	const ImagePtr &	image,
		const char *	mimeType,
		UChar8 *	buffer,
		Int32	memSize = -1
	)			[virtual]

Tries to store the raster data (from the given Image) to the given memBlock. If the mimeType is not Null the method will try to find the according ImageFileType. Otherwise it will try to use the fileName suffix to determine the mimeType

Definition at line 494 of file OSGImageFileHandler.cpp.

References getDefaultType(), getFileType(), and osg::ImageFileType::store().

{
    ImageFileType   *type;

    type = mimeType ? getFileType(mimeType) : getDefaultType();

    return type->store(image, buffer, memSize);
}

UChar8 * ImageFileHandler::store	(	const ImagePtr &	image,
		UInt64 &	memSize,
		const char *	mimeType = 0
	)			[virtual]

Tries to store the raster data (from the given Image) to a new memBlock. The method will automatically allocate and return a sufficient amount of memory with new. The application has to free the memory with 'delete [] mem' If the mimeType is not Null the method will try to find the according ImageFileType. Otherwise it will try to use the fileName suffix to determine the mimeType

Definition at line 514 of file OSGImageFileHandler.cpp.

References FFATAL, getDefaultType(), getFileType(), osg::ImageFileType::getMimeType(), osg::ImageFileType::maxBufferSize(), and osg::ImageFileType::store().

{
    ImageFileType   *type = 0;
    UChar8          *mem = 0;

    type = mimeType ? getFileType(mimeType) : getDefaultType();
    memSize = type->maxBufferSize(image);

    if(memSize)
    {
        mem = new UChar8[size_t(memSize)];
        memSize = type->store(image, mem, Int32(memSize));
    }
    else
    {
        FFATAL(("Can not store the image as %s\n", type->getMimeType()));
    }

    return mem;
}

ImageFileType * ImageFileHandler::getFileType	(	const char *	mimeType,
		const char *	fileName = 0,
		bool	validateHeader = false
	)

Method to find a ImageFileHandler for the given mimeType for fileName suffix. Returns the ImageFileHandler object or Null.

Definition at line 94 of file OSGImageFileHandler.cpp.

References _suffixTypeMap, _the, _typeMap, FWARNING, normalizeMimetype(), normalizeSuffix(), and osg::ImageFileType::validateHeader().

Referenced by getOptions(), read(), osg::ClusterViewBuffer::setImgTransType(), setOptions(), osg::ImageFileType::store(), store(), and write().

{
    std::string                                    suffix;
    ImageFileType                                 *type = 0;
    std::map<std::string, ImageFileType *>::iterator sI;
    const char                                     separator = '.';
    int                                            i, l;

    if(mimeType && *mimeType)
    {
        std::string mt = mimeType;
        normalizeMimetype(mt);
        if (mt.find('/') == std::string::npos)
            mt.insert(0, "image/");
        TypeMap::iterator tIt = _the->_typeMap.find(mt);
        if (tIt != _the->_typeMap.end())
            type = tIt->second;
        if (!type) {
          FWARNING (("Invalid mimeType %s in getFileType()\n", mimeType));
        }
    }

    if(!type && fileName && *fileName)
    {
        // check file suffix
        if(!type)
        {
            l = strlen(fileName);
            for(i = l - 1; i >= 0; i--)
            {
                if(fileName[i] == separator)
                    break;
            }

            if(i >= 0)
            {
                suffix.assign(&(fileName[i + 1]));
                normalizeSuffix(suffix);
                sI = _suffixTypeMap.find(suffix);
                type = (sI == _suffixTypeMap.end()) ? 0 : sI->second;
            }
        }
    }

    if(validateHeader)
    {
        // now validate the header of the file
        bool implemented = false;
        if(fileName && *fileName &&
           type != NULL && !type->validateHeader(fileName, implemented))
        {
            FWARNING (("Found wrong image header trying to autodetect image type!\n"));
            for(sI = _suffixTypeMap.begin(); sI != _suffixTypeMap.end(); ++sI)
            {
                type = sI->second;
                if(type != NULL && type->validateHeader(fileName, implemented))
                {
                    if(implemented)
                    {
                        FWARNING (("Autodetected '%s' image type!\n", sI->first.c_str()));
                        return type;
                    }
                }
            }
            FWARNING (("Couldn't autodetect image type!\n"));
            return NULL;
        }
    }

    return type;
}

ImageFileType * ImageFileHandler::getDefaultType

(

void

)

Returns the default OpenSG ImageFileType

Definition at line 172 of file OSGImageFileHandler.cpp.

References _suffixTypeMap, and FFATAL.

Referenced by store().

{
  std::string        dSuffix("opensg");

  std::map<std::string,
    ImageFileType *>::iterator sI = _suffixTypeMap.find(dSuffix);


  ImageFileType *type = (sI == _suffixTypeMap.end()) ? 0 : sI->second;

  if(!type)
    {
      FFATAL(("Can not find any default (suffix:%s) image handler\n",
              dSuffix.c_str()));
    }

  return type;
}

Int32 ImageFileHandler::getSuffixList	(	std::list< const Char8 * > &	suffixList,
		UInt32	flags = ImageFileType::OSG_READ_SUPPORTED | ImageFileType::OSG_WRITE_SUPPORTED
	)			[virtual]

Returns the list of supported image suffixes

Definition at line 196 of file OSGImageFileHandler.cpp.

References _suffixTypeMap, and osg::ImageFileType::getFlags().

{
    Int32                                         count = 0;
    std::map<std::string, ImageFileType *>::iterator sI;

    suffixList.clear();

    for ( sI = _suffixTypeMap.begin(); sI != _suffixTypeMap.end(); ++sI)
    {
        ImageFileType *type = sI->second;
        if(type->getFlags() & flags)
        {
            suffixList.push_back(sI->first.c_str());
            count++;
        }
    }

  return count;
}

std::string ImageFileHandler::determineMimetypeFromName

(

const std::string &

fileName

)

Tries to determine the mime type from the file name.

Definition at line 221 of file OSGImageFileHandler.cpp.

References _suffixTypeMap, and normalizeSuffix().

{
    // Determine the suffix of the filename
    std::string::size_type pos = fileName.rfind('.');
    if (pos == std::string::npos)
        return std::string();
    std::string suffix = fileName.substr(pos + 1);
    normalizeSuffix(suffix);

    // Try to find the suffix in the map of extensions
    std::map<std::string, ImageFileType *>::iterator it = _suffixTypeMap.find(suffix);
    return it != _suffixTypeMap.end() ? std::string(it->second->getMimeType()) : std::string();
}

std::string ImageFileHandler::determineMimetypeFromSuffix

(

const std::string &

suffix

)

Tries to determine the mime type from the suffix.

Definition at line 239 of file OSGImageFileHandler.cpp.

References _suffixTypeMap, and normalizeSuffix().

Referenced by osg::ImageFileType::restore().

{
    std::string s = suffix;
    normalizeSuffix(s);

    // Try to find the suffix in the map of extensions
    std::map<std::string, ImageFileType *>::iterator it = _suffixTypeMap.find(s);
    return it != _suffixTypeMap.end() ? std::string(it->second->getMimeType()) : std::string();
}

std::string ImageFileHandler::determineMimetypeFromStream

(

std::istream &

is

)

tries to determine the mimetype of a stream.

Definition at line 253 of file OSGImageFileHandler.cpp.

References _typeMap.

{
    std::string mimetype;
    TypeMap::iterator it;
    for (it = _typeMap.begin(); it != _typeMap.end(); ++it)
    {
        mimetype = it->second->determineMimetypeFromStream(is);
        if (mimetype.empty() == false)
            break;
    }
    return mimetype;
}

void ImageFileHandler::dump

(

void

)

The dump method just writes some object debugging info to the LOG stream

Definition at line 540 of file OSGImageFileHandler.cpp.

References _suffixTypeMap, and FLOG.

{
    std::map<std::string, ImageFileType *>::iterator    sI;

    for(sI = _suffixTypeMap.begin(); sI != _suffixTypeMap.end(); sI++)
    {
      FLOG (( "Image suffix: %s, mimeType: %s\n",
              sI->first.c_str(), sI->second->getMimeType() ));
    }
}

ImageFileHandler & ImageFileHandler::the

(

void

)

[static]

Static method the get the Singleton Object

Definition at line 713 of file OSGImageFileHandler.cpp.

References _the.

Referenced by osg::VRMLInlineDesc::endNode(), osg::VRMLImageTextureDesc::endNode(), osg::SceneFileHandler::initPathHandler(), osg::Image::read(), osg::HDRImageFileType::read(), osg::DATImageFileType::read(), osg::ImageFileType::restore(), osg::ClusterViewBuffer::setImgTransType(), osg::ImageFileType::store(), and osg::Image::write().

{
    if(_the == NULL)
        _the = new ImageFileHandler;
    return *_the;
}

bool ImageFileHandler::addImageFileType

(

ImageFileType &

fileType

)

[static, private]

Internal Method to add a new ImageFileType

Definition at line 555 of file OSGImageFileHandler.cpp.

References _suffixTypeMap, _the, _typeMap, osg::ImageFileType::getMimeType(), osg::ImageFileType::getSuffixList(), normalizeMimetype(), normalizeSuffix(), and SWARNING.

Referenced by osg::ImageFileType::ImageFileType().

{
    bool                                           retCode = false;
    std::list<IDString                 >::const_iterator sI;
    std::map<std::string, ImageFileType *>::iterator smI;
    std::string                                    suffix;

    if(!_the)
        _the = new ImageFileHandler;

    for( sI = fileType.getSuffixList().begin();
         sI != fileType.getSuffixList().end();
        ++sI)
    {
        suffix.assign(sI->str());
        normalizeSuffix(suffix);
        smI = _the->_suffixTypeMap.find(suffix);
        if(smI != _the->_suffixTypeMap.end())
        {
            SWARNING << "Can't add an image file type with suffix "
                     << suffix << " a second time" << std::endl;
        }
        else
        {
            _the->_suffixTypeMap[suffix] = &fileType;
            retCode = true;
        }
    }

    std::string mimetype = fileType.getMimeType();
    normalizeMimetype(mimetype);
    TypeMap::iterator tIt = _the->_typeMap.find(mimetype);
    if (tIt != _the->_typeMap.end())
    {
        SWARNING << "Can't add an image file type with mimetype "
                 << mimetype << " a second time" << std::endl;
    }
    else
        _the->_typeMap[mimetype] = &fileType;

    return retCode;
}

void ImageFileHandler::normalizeMimetype

(

std::string &

mimetype

)

[static, private]

Normalizes a mime type, i.e. removes parameters and whitespaces and transforms it to lowercase

Definition at line 603 of file OSGImageFileHandler.cpp.

Referenced by addImageFileType(), and getFileType().

{
    // Remove any parameters
    std::string::size_type endpos = mimetype.find(';');
    if (endpos == 0)
    {
        mimetype.erase();
        return;
    }
    if (endpos != std::string::npos)
        --endpos;

    // Remove trailing whitespace
    endpos = mimetype.find_last_not_of(" \t\r\n", endpos);
    if (endpos == std::string::npos)
    {
        mimetype.erase();
        return;
    }
    mimetype.erase(endpos + 1);

    // Remove leading whitespace
    std::string::size_type startpos = mimetype.find_first_not_of(" \t\r\n");
    if (startpos == std::string::npos)
    {
        mimetype.erase();
        return;
    }
    mimetype.erase(0, startpos);

    // Transform to lower case
    std::transform(mimetype.begin(), mimetype.end(), mimetype.begin(), ::tolower);
}

void ImageFileHandler::normalizeSuffix

(

std::string &

suffix

)

[static, private]

Normalizes a suffix, i.e. removes whitespaces and transforms it to lowercase

Definition at line 641 of file OSGImageFileHandler.cpp.

Referenced by addImageFileType(), determineMimetypeFromName(), determineMimetypeFromSuffix(), and getFileType().

{
    // Remove trailing whitespace
    std::string::size_type endpos = suffix.find_last_not_of(" \t\r\n");
    if (endpos == std::string::npos)
    {
        suffix.erase();
        return;
    }
    suffix.erase(endpos + 1);

    // Remove leading whitespace
    std::string::size_type startpos = suffix.find_first_not_of(" \t\r\n");
    if (startpos == std::string::npos)
    {
        suffix.erase();
        return;
    }
    suffix.erase(0, startpos);

    // Transform to lower case
    std::transform(suffix.begin(), suffix.end(), suffix.begin(), ::tolower);
}

const ImageFileHandler& osg::ImageFileHandler::operator=

(

const ImageFileHandler &

obj

)

[private]

---

Friends And Related Function Documentation

friend class ImageFileType [friend]

Definition at line 65 of file OSGImageFileHandler.h.

---

Member Data Documentation

ImageFileHandler * ImageFileHandler::_the = 0 [static, private]

Definition at line 177 of file OSGImageFileHandler.h.

Referenced by addImageFileType(), getFileType(), and the().

std::map<std::string, ImageFileType *> osg::ImageFileHandler::_suffixTypeMap [private]

Definition at line 179 of file OSGImageFileHandler.h.

Referenced by addImageFileType(), determineMimetypeFromName(), determineMimetypeFromSuffix(), dump(), getDefaultType(), getFileType(), and getSuffixList().

TypeMap osg::ImageFileHandler::_typeMap [private]

Definition at line 183 of file OSGImageFileHandler.h.

Referenced by addImageFileType(), determineMimetypeFromStream(), and getFileType().

PathHandler* osg::ImageFileHandler::_pPathHandler [private]

Definition at line 191 of file OSGImageFileHandler.h.

Referenced by getPathHandler(), read(), and setPathHandler().

readcbfp osg::ImageFileHandler::_readFP [private]

Definition at line 192 of file OSGImageFileHandler.h.

Referenced by getReadCB(), read(), and setReadCB().

const std::string ImageFileHandler::_fileNameKey [static, private]

Definition at line 194 of file OSGImageFileHandler.h.

Referenced by read(), and write().

const std::string ImageFileHandler::_fullFilePathKey [static, private]

Definition at line 196 of file OSGImageFileHandler.h.

Referenced by read().

---

The documentation for this class was generated from the following files:

• OSGImageFileHandler.h
• OSGImageFileHandler.cpp