osg::DATImageFileType Class Reference
[Image]

DAT File Handler. Used to read/write DAT/RAW files. See Image for a detailed description. More...

#include <OSGDATImageFileType.h>

Inheritance diagram for osg::DATImageFileType:

List of all members.

Safe Store/Restore
UInt64	store (const ImagePtr &image, UChar8 *buffer, Int32 memSize=-1)
virtual UInt64	maxBufferSize (const ImagePtr &image)
static UInt64	restore (ImagePtr &image, const UChar8 *buffer, Int32 memSize=-1)
static UInt64	store (const ImagePtr &image, const char *mimeType, UChar8 *buffer, Int32 memSize=-1)
Public Types
Flags
enum	{ OSG_READ_SUPPORTED = 1, OSG_WRITE_SUPPORTED = 2 }
Public Member Functions
Destructor
virtual	~DATImageFileType (void)
Read/Write
virtual bool	read (ImagePtr &image, const Char8 *fileName)
virtual bool	write (const ImagePtr &image, const Char8 *fileName)
Buffer
virtual UInt64	restoreData (ImagePtr &image, const UChar8 *buffer, Int32 memSize=-1)
virtual UInt64	storeData (const ImagePtr &image, UChar8 *buffer, Int32 memSize=-1)
Set
void	setOptions (const Char8 *options)
Get Methods
const Char8 *	getMimeType (void) const
const std::list< IDString > &	getSuffixList (void) const
virtual UInt32	getFlags (void) const
const Char8 *	getOptions (void)
Read/Write
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)
virtual bool	validateHeader (const Char8 *fileName, bool &implemented)
virtual std::string	determineMimetypeFromStream (std::istream &is)
dump
void	dump (void)
Static Public Member Functions
Get Methods
static DATImageFileType &	the (void)
Protected Member Functions
Default Constructor
	DATImageFileType (const Char8 *mimeType, const Char8 *suffixArray[], UInt16 suffixByteCount)
Protected Attributes
MTD Header
std::string	_options
Private Types
enum	KeyType {   UNKNOWN_KT = 0, OBJECT_FILE_NAME_KT, RESOLUTION_KT, SLICE_THICKNESS_KT,   FORMAT_KT, FILE_OFFSET_KT, CHANNEL_KT, ENDIAN_KT }
Private Member Functions
Copy Constructor
	DATImageFileType (const DATImageFileType &obj)
Copy Operator
const DATImageFileType &	operator= (const DATImageFileType &obj)
Static Private Member Functions
static void	initTypeMap (void)
Static Private Attributes
static DATImageFileType	_the
static std::map< std::string, KeyType >	_keyStrMap
static std::map< std::string, FormatDesc >	_formatStrMap
Classes
struct	FormatDesc

---

Detailed Description

Image File Type to read/write and store/restore Image objects as PNM/RAW data.

All the type specific code is included in the class. Does not depend on external libs.

Definition at line 55 of file OSGDATImageFileType.h.

---

Member Enumeration Documentation

enum osg::DATImageFileType::KeyType [private]

Enumerator:

UNKNOWN_KT
OBJECT_FILE_NAME_KT
RESOLUTION_KT
SLICE_THICKNESS_KT
FORMAT_KT
FILE_OFFSET_KT
CHANNEL_KT
ENDIAN_KT

Definition at line 126 of file OSGDATImageFileType.h.

    { 
      UNKNOWN_KT = 0,

      OBJECT_FILE_NAME_KT,
      RESOLUTION_KT,
      SLICE_THICKNESS_KT,
      FORMAT_KT,
      FILE_OFFSET_KT,
      CHANNEL_KT,
      ENDIAN_KT
    };

anonymous enum [inherited]

Enumerator:

OSG_READ_SUPPORTED
OSG_WRITE_SUPPORTED

Definition at line 66 of file OSGImageFileType.h.

    {
        OSG_READ_SUPPORTED = 1,
        OSG_WRITE_SUPPORTED = 2
    };

---

Constructor & Destructor Documentation

DATImageFileType::~DATImageFileType

(

void

)

[virtual]

Destructor

Definition at line 571 of file OSGDATImageFileType.cpp.

{}

DATImageFileType::DATImageFileType	(	const Char8 *	mimeType,
		const Char8 *	suffixArray[],
		UInt16	suffixByteCount
	)			[protected]

Constructor used for the singleton object

Definition at line 561 of file OSGDATImageFileType.cpp.

    : ImageFileType ( mimeType, suffixArray, suffixByteCount )
{}

osg::DATImageFileType::DATImageFileType

(

const DATImageFileType &

obj

)

[private]

---

Member Function Documentation

DATImageFileType & DATImageFileType::the

(

void

)

[static]

Class method to get the singleton Object

Definition at line 104 of file OSGDATImageFileType.cpp.

References _the.

{
  return _the;
}

bool DATImageFileType::read	(	ImagePtr &	image,
		const Char8 *	fileName
	)			[virtual]

Tries to fill the image object with the data read from the given fileName. Returns true on success.

Reimplemented from osg::ImageFileType.

Definition at line 118 of file OSGDATImageFileType.cpp.

References _formatStrMap, _keyStrMap, osg::beginEditCP(), CHANNEL_KT, osg::endEditCP(), ENDIAN_KT, FILE_OFFSET_KT, osg::PathHandler::findFile(), FINFO, FLOG, FNOTICE, FORMAT_KT, FWARNING, osg::ImageFileHandler::getPathHandler(), initTypeMap(), osg::isGZip(), OBJECT_FILE_NAME_KT, osg::Image::OSG_FLOAT32_IMAGEDATA, osg::Image::OSG_INVALID_IMAGEDATATYPE, osg::Image::OSG_L_PF, osg::Image::OSG_LA_PF, osg::Image::OSG_RGB_PF, osg::Image::OSG_RGBA_PF, osg::Image::OSG_UINT16_IMAGEDATA, osg::Image::OSG_UINT32_IMAGEDATA, osg::Image::OSG_UINT8_IMAGEDATA, RESOLUTION_KT, SFATAL, SLICE_THICKNESS_KT, osg::ImageFileHandler::the(), and UNKNOWN_KT.

{
    bool retCode = false;

    std::ifstream inDat(fileName), inVolS;
    std::istream *inVol;
    std::string keyStr, objectFileName;
    const UInt32 lineBufferSize = 1024;
    Char8 *value, *keySepPos, lineBuffer[lineBufferSize];
    const Char8 keySep = ':';
    int fileOffset, keyL, valueL;
    std::map<std::string, KeyType>::iterator keyI;
    std::map<std::string, FormatDesc>::iterator formatI;
    KeyType key;
    Image::Type formatType;
    UInt32 channel = 1;
    UInt32 res[3];
    UInt32 dataSize = 0;
    Image::PixelFormat pixelFormat;
    char *dataBuffer = 0;
    bool needConversion = false;
    // default endian type is big endian
    bool big_endian = true;

    res[0] = res[1] = res[2] = 0;
    fileOffset = 0;
    formatType = Image::OSG_INVALID_IMAGEDATATYPE;
    dataSize = 0;
    dataBuffer = 0;

    initTypeMap();

    beginEditCP(image);

    // read the data file 
    for ( lineBuffer[0] = 0; 
          inDat.getline ( lineBuffer, lineBufferSize);
          lineBuffer[0] = 0 ) 
    {        
        if ((keySepPos = strchr(lineBuffer,keySep))) 
        {
            keyL = keySepPos - lineBuffer;
            keyStr.assign( lineBuffer, keyL );        
            keyI = _keyStrMap.find(keyStr);
            key = ((keyI == _keyStrMap.end()) ? UNKNOWN_KT : keyI->second);
            value = keySepPos + 1;        
            while (value && isspace(*value))
                value++;
            valueL = strlen(value);
            while (isspace(value[valueL-1]))
                value[--valueL] = 0;
            switch (key)
            {
                case OBJECT_FILE_NAME_KT:
                    objectFileName = value;
                    image->setAttachmentField ( keyStr, value );
                    break;
                case CHANNEL_KT:
                    sscanf ( value, "%d", &(channel) );
                    image->setAttachmentField ( keyStr, value );
                    break;
                case RESOLUTION_KT:
                    sscanf ( value, "%d %d %d", 
                             &(res[0]), &(res[1]), &(res[2]));
                    image->setAttachmentField ( keyStr, value );
                    break;
                case FORMAT_KT:
                    formatI = _formatStrMap.find(value);
                    if (formatI != _formatStrMap.end())
                    {
                        formatType = formatI->second.type;
                    }
                    else 
                    {
                        formatType = Image::OSG_INVALID_IMAGEDATATYPE;
                    }
                    image->setAttachmentField ( keyStr, value );
                    break;
                case ENDIAN_KT:
                    if(!strcmp(value, "LITTLE"))
                        big_endian = false;
                    image->setAttachmentField ( keyStr, value );
                    break;
                case FILE_OFFSET_KT:
                    sscanf ( value, "%d", &fileOffset );
                    image->setAttachmentField ( keyStr, value );
                    break;
                case UNKNOWN_KT:
                    FNOTICE (( "Uknown DAT file key: >%s<\n",
                                 keyStr.c_str() ));
                    image->setAttachmentField ( keyStr, value );
                    break;
                case SLICE_THICKNESS_KT:
                default:
                    image->setAttachmentField ( keyStr, value );
                    break;
            }
        }
        else 
        {        
            FINFO (("Skip DAT line\n"));
        }
    }
  
    // set pixelformat
    switch (channel) {
    case 4:
      pixelFormat = osg::Image::OSG_RGBA_PF;
      break;
    case 3:
      pixelFormat = osg::Image::OSG_RGB_PF;
      break;
    case 2:
      pixelFormat = osg::Image::OSG_LA_PF;
      break;
    default:
      pixelFormat = osg::Image::OSG_L_PF;
      break;
    }

    // check the setting and read the raw vol data
    if (objectFileName.empty() == false) 
    {
        if ( (res[0] > 0) && (res[1] > 0) && (res[2] > 0) ) 
        {
            if (formatType != Image::OSG_INVALID_IMAGEDATATYPE) 
            {
                inVolS.open(objectFileName.c_str(), 
                           std::ios::in | std::ios::binary );
                if (inVolS.fail() && ImageFileHandler::the().getPathHandler())
                {
                    // Try to find the file in the search path
                    inVolS.clear(); // reset the error state
                    PathHandler * ph = ImageFileHandler::the().getPathHandler();
                    inVolS.open(ph->findFile(objectFileName.c_str()).c_str(),
                               std::ios::in | std::ios::binary );
                }
                if (inVolS.fail())
                {
                    // Maybe compressed and name not changed?
                    std::string gzname = objectFileName + ".gz";
                    inVolS.clear(); // reset the error state
                    inVolS.open(gzname.c_str(), 
                           std::ios::in | std::ios::binary );
                    if (inVolS.fail() && 
                        ImageFileHandler::the().getPathHandler())
                    {
                        // Try to find the file in the search path
                        inVolS.clear(); // reset the error state
                        PathHandler * ph = ImageFileHandler::the().getPathHandler();
                        inVolS.open(ph->findFile(gzname.c_str()).c_str(),
                                   std::ios::in | std::ios::binary );
                    }
                } 
                if (inVolS.good())
                {                    
#ifdef OSG_ZSTREAM_SUPPORTED
                    zip_istream *unzipper = NULL;
#endif

                    image->set ( pixelFormat, res[0], res[1], res[2], 1, 1, 0.0, 0, formatType);
                    image->clear();
                    
                    dataSize = image->getSize();
                    
                    UInt32 fileDataSize = dataSize;

                    if(isGZip(inVolS))
                    {
#ifdef OSG_ZSTREAM_SUPPORTED
                        unzipper = new zip_istream(inVolS);
                        inVol = unzipper;
#else
                        SFATAL << "Compressed streams are not supported! Configure with --enable-png --with-png=DIR options." << std::endl;
#endif
                    }
                    else
                    {
                        inVol = &inVolS;

                        // get length of the stream.
                        inVol->seekg(0, std::ios::end);
                        UInt64 length = inVol->tellg();
                        inVol->seekg(0, std::ios::beg);

                        if(length < dataSize - fileOffset)
                        {
                            // correct dataSize.
                            fileDataSize = length;
                            FWARNING (( "RAW file length to small!\n" ));
                        }
                        else if(length > dataSize - fileOffset)
                        {
                            FWARNING (( "RAW file length to big!\n" ));
                        }
                    }

                    if (needConversion)
                        dataBuffer = new char [ dataSize ];
                    else
                        dataBuffer = ((char *)(image->getData()));

                    if(fileOffset != 0)
                        inVol->ignore ( fileOffset );
                    inVol->read ( dataBuffer, fileDataSize );

#ifdef OSG_ZSTREAM_SUPPORTED
                    if(unzipper != NULL)
                        delete unzipper;
#endif
                }
                else 
                {
                    FWARNING (( "Can not open %s image data\n", 
                             objectFileName.c_str() ));
                }
            }
            else 
            {
                FWARNING (( "Invalid/Missing DAT Format\n" ));
            }
        }
        else 
        {
            FWARNING (( "Invalid/Missing DAT Resolution\n" ));
        }
    }
    else 
    {
        FWARNING (( "Invalid/Missing DAT ObjectFileName\n" ));
    }

    // check/reformat vol data
    if (dataSize && dataBuffer)
    {
        // check host endian type
        UInt16 word = 0x0001;
        UInt8 *byte = (UInt8 *) &word;
        bool host_big_endian = byte[0] ? false : true;

        if(big_endian != host_big_endian)
            image->swapDataEndian();
    
        if (needConversion) 
        {
            FLOG (("DAT-Data convert not impl. yet !\n"));
            {
                switch (formatType)
                {
                    case Image::OSG_UINT8_IMAGEDATA:
                        break;
                    case Image::OSG_UINT16_IMAGEDATA:
                        break;
                    case Image::OSG_UINT32_IMAGEDATA:
                        break;
                    case Image::OSG_FLOAT32_IMAGEDATA:
                        break;
                    default:
                        ;
                }
            }
        }
        else 
        {
            retCode = true;
        }
    }


    /* TODO
       std::ifstream in(fileName);
       Head head;
       void *headData = (void*)(&head);
       unsigned dataSize, headSize = sizeof(Head);

       if ( in &&        
       in.read(static_cast<char *>(headData), 
       headSize) && head.netToHost() &&
       image.set ( Image::PixelFormat(head.pixelFormat), 
       head.width, head.height, head.depth, head.mipmapCount, 
       head.frameCount, float(head.frameDelay) / 1000.0) &&
       (dataSize = image.getSize()) && 
       in.read((char *)(image.getData()), dataSize ))
       retCode = true;
       else
       retCode = false;
    */

    endEditCP(image);

    return retCode;
}

bool DATImageFileType::write	(	const ImagePtr &	image,
		const Char8 *	fileName
	)			[virtual]

Tries to write the image object to the given fileName. Returns true on success.

Reimplemented from osg::ImageFileType.

Definition at line 417 of file OSGDATImageFileType.cpp.

References _formatStrMap, initTypeMap(), and SWARNING.

{
    initTypeMap();

    // ok we write always in big endian.
#if BYTE_ORDER == LITTLE_ENDIAN
    image->swapDataEndian();
#endif

    std::ofstream dat(fileName, std::ios::binary);
    if(!dat)
    {
        SWARNING << "DATImageFileType::write : Can not open output stream for file '" << fileName << "'!" << std::endl;
        return false;
    }

    Real64 sT[3];
    sT[0] = sT[1] = sT[2] = 1.0;
    const std::string *attr = image->findAttachmentField("SliceThickness");
    if(attr != NULL)
         sscanf(attr->c_str(), "%lf %lf %lf", &sT[0], &sT[1], &sT[2]);
    
    std::string format = "UCHAR";
    for(std::map<std::string, FormatDesc>::iterator it = _formatStrMap.begin();
        it != _formatStrMap.end();++it)
    {
        if((*it).second.type == image->getDataType())
        {
            format = (*it).first;
            break;
        }
    }

    std::string basename = fileName;
    std::string::size_type i = basename.rfind(".");
    if(i != std::string::npos)
        basename = basename.substr(0, i);
    basename += ".raw";
    
    std::string name = basename;
    i = name.rfind("/");
    // on windows also a / is possible!
#if defined(WIN32)
    if(i == std::string::npos)
        i = name.rfind("\\");
#endif
    if(i != std::string::npos)
        name = name.substr(i+1);

    dat << "ObjectFileName: " << name << "\n";
    dat << "TaggedFileName: ---\n";
    dat << "Resolution:     " << image->getWidth() << " " << image->getHeight()
                              << " " << image->getDepth() << "\n";
    dat << "SliceThickness: " << sT[0] << " " << sT[1] << " " << sT[2] << "\n";
    dat << "Format:         " << format << "\n";
    dat << "NbrTags:        0\n";
    dat << "ObjectType:     TEXTURE_VOLUME_OBJECT\n";
    dat << "ObjectModel:    DENSITY\n";
    dat << "GridType:       EQUIDISTANT\n";

    if (image->getBpp() > 1)
      dat << "Channel: " << image->getBpp() << "\n";

    dat.close();
    
    std::ofstream raw(basename.c_str(), std::ios::binary);
    if(!raw)
    {
        SWARNING << "DATImageFileType::write : Can not open output stream for file '" << basename << "'!" << std::endl;
        return false;
    }
    
    raw.write ((const char *) image->getData(), image->getSize());
    raw.close();

    // restore to original endian
#if BYTE_ORDER == LITTLE_ENDIAN
    image->swapDataEndian();
#endif

    /*
    ofstream out(fileName);
    Head head;
    const void *headData = (void*)(&head);
    unsigned dataSize = image.getSize(), headSize = sizeof(Head);

    head.pixelFormat  = image.getPixelFormat();
    head.width        = image.getWidth();
    head.height       = image.getHeight();
    head.depth        = image.getDepth();
    head.mipmapCount  = image.getMipMapCount();
    head.frameCount   = image.getFrameCount();
    head.frameDelay   = short(image.getFrameDelay() * 1000.0);
    head.hostToNet();
  
    if ( out && out.write(static_cast<const char *>(headData), headSize) && 
         dataSize &&
             out.write((char *)(image.getData()), dataSize) )
            retCode = true;
    else
        retCode = false;    
    */

    return true;
}

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

Tries to restore the image data from the given memblock. Returns the amount of data read.

Reimplemented from osg::ImageFileType.

Definition at line 529 of file OSGDATImageFileType.cpp.

{
    image->setData(buffer);

    return image->getSize();
}

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

Tries to store the image data to the given memblock. Returns the amount of data written.

Reimplemented from osg::ImageFileType.

Definition at line 543 of file OSGDATImageFileType.cpp.

{
    UInt32 dataSize = image->getSize();
    const UChar8 *src = image->getData();

    if ( dataSize && src && buffer )
        memcpy( buffer, src, dataSize);
  
    return dataSize;
} 

const DATImageFileType& osg::DATImageFileType::operator=

(

const DATImageFileType &

obj

)

[private]

void DATImageFileType::initTypeMap

(

void

)

[static, private]

Helper to initialize the type map;

Definition at line 577 of file OSGDATImageFileType.cpp.

References _formatStrMap, _keyStrMap, osg::DATImageFileType::FormatDesc::bpv, CHANNEL_KT, ENDIAN_KT, FILE_OFFSET_KT, FORMAT_KT, osg::DATImageFileType::FormatDesc::needConversion, OBJECT_FILE_NAME_KT, osg::Image::OSG_FLOAT32_IMAGEDATA, osg::Image::OSG_L_PF, osg::Image::OSG_UINT16_IMAGEDATA, osg::Image::OSG_UINT32_IMAGEDATA, osg::Image::OSG_UINT8_IMAGEDATA, osg::DATImageFileType::FormatDesc::pixelFormat, RESOLUTION_KT, SLICE_THICKNESS_KT, and osg::DATImageFileType::FormatDesc::type.

Referenced by read(), and write().

{
  FormatDesc *desc;

  if (_keyStrMap.empty())
    {
      _keyStrMap["ObjectFileName"]  = OBJECT_FILE_NAME_KT;
      _keyStrMap["Resolution"]      = RESOLUTION_KT;
      _keyStrMap["Channel"]         = CHANNEL_KT;
      _keyStrMap["SliceThickness"]  = SLICE_THICKNESS_KT;
      _keyStrMap["Format"]          = FORMAT_KT;
      _keyStrMap["Endian"]          = ENDIAN_KT;
      _keyStrMap["FileOffset"]      = FILE_OFFSET_KT;
     }

  if (_formatStrMap.empty())
    {
      desc = &(_formatStrMap["UCHAR"]);
      desc->type = Image::OSG_UINT8_IMAGEDATA;
      desc->bpv  = 1;
      desc->pixelFormat = Image::OSG_L_PF;
      desc->needConversion = false;

      desc = &(_formatStrMap["USHORT"]);
      desc->type = Image::OSG_UINT16_IMAGEDATA;
      desc->bpv  = 2;
      desc->pixelFormat = Image::OSG_L_PF;
      desc->needConversion = false;

      desc = &(_formatStrMap["UINT"]);
      desc->type = Image::OSG_UINT32_IMAGEDATA;
      desc->bpv  = 4; // TODO; is this right ?
      desc->pixelFormat = Image::OSG_L_PF;
      desc->needConversion = false;

      desc = &(_formatStrMap["ULONG"]);
      desc->type = Image::OSG_UINT32_IMAGEDATA;
      desc->bpv  = 4;
      desc->pixelFormat = Image::OSG_L_PF;
      desc->needConversion = false;

      desc = &(_formatStrMap["FLOAT"]);
      desc->type = Image::OSG_FLOAT32_IMAGEDATA;
      desc->bpv  = 4;
      desc->pixelFormat = Image::OSG_L_PF;
      desc->needConversion = false;

      desc = &(_formatStrMap["DOUBLE"]);
      desc->type = Image::OSG_FLOAT32_IMAGEDATA; // we have no OSG_FLOAT64_IMAGEDATA
      desc->bpv  = 8;
      desc->pixelFormat = Image::OSG_L_PF;
      desc->needConversion = false;
    }

}

void ImageFileType::setOptions

(

const Char8 *

options

)

[inherited]

Definition at line 243 of file OSGImageFileType.cpp.

References osg::ImageFileType::_options.

Referenced by osg::ImageFileHandler::setOptions().

{
    _options = options;
}

const Char8 * ImageFileType::getMimeType

(

void

)

const [inherited]

Get method for the mime type

Definition at line 107 of file OSGImageFileType.cpp.

References osg::ImageFileType::_mimeType, and osg::IDString::str().

Referenced by osg::ImageFileHandler::addImageFileType(), osg::TIFImageFileType::determineMimetypeFromStream(), osg::SGIImageFileType::determineMimetypeFromStream(), osg::PSDImageFileType::determineMimetypeFromStream(), osg::PNMImageFileType::determineMimetypeFromStream(), osg::PNGImageFileType::determineMimetypeFromStream(), osg::MNGImageFileType::determineMimetypeFromStream(), osg::JPGImageFileType::determineMimetypeFromStream(), osg::JP2ImageFileType::determineMimetypeFromStream(), osg::GIFImageFileType::determineMimetypeFromStream(), osg::DDSImageFileType::determineMimetypeFromStream(), osg::BMPImageFileType::determineMimetypeFromStream(), osg::ImageFileType::dump(), osg::TIFImageFileType::read(), osg::PNGImageFileType::read(), osg::JPGImageFileType::read(), osg::JP2ImageFileType::read(), osg::ImageFileType::read(), osg::ImageFileHandler::read(), osg::EXRImageFileType::read(), osg::PNGImageFileType::restoreData(), osg::JPGImageFileType::restoreData(), osg::ImageFileType::restoreData(), osg::ImageFileHandler::store(), osg::PNGImageFileType::storeData(), osg::JPGImageFileType::storeData(), osg::ImageFileType::storeData(), osg::TIFImageFileType::write(), osg::PNGImageFileType::write(), osg::JPGImageFileType::write(), osg::ImageFileType::write(), osg::ImageFileHandler::write(), and osg::EXRImageFileType::write().

{
    return _mimeType.str();
}

const std::list< IDString > & ImageFileType::getSuffixList

(

void

)

const [inherited]

Get method for the suffix list container

Definition at line 134 of file OSGImageFileType.cpp.

References osg::ImageFileType::_suffixList.

Referenced by osg::ImageFileHandler::addImageFileType().

{
    return _suffixList; 
}

UInt32 ImageFileType::getFlags

(

void

)

const [virtual, inherited]

Get method for the flags indicating read/write support. Most image types only support reading.

Definition at line 117 of file OSGImageFileType.cpp.

References osg::ImageFileType::_flags.

Referenced by osg::ImageFileHandler::getSuffixList().

{
    return _flags;
}

const Char8 * ImageFileType::getOptions

(

void

)

[inherited]

Get method for the mime type

Definition at line 124 of file OSGImageFileType.cpp.

References osg::ImageFileType::_options.

Referenced by osg::ImageFileHandler::getOptions().

{
    return _options.c_str();
}

bool ImageFileType::read	(	ImagePtr &	image,
		std::istream &	is,
		const std::string &	mimetype
	)			[virtual, inherited]

Tries to fill the image object with the data read from the given input stream. Returns true on success.

Reimplemented in osg::BMPImageFileType, osg::DDSImageFileType, osg::EXRImageFileType, osg::GIFImageFileType, osg::HDRImageFileType, osg::JP2ImageFileType, osg::JPGImageFileType, osg::MTDImageFileType, osg::NRRDImageFileType, osg::PNGImageFileType, osg::PNMImageFileType, osg::PSDImageFileType, osg::SGIImageFileType, osg::TGAImageFileType, and osg::TIFImageFileType.

Definition at line 172 of file OSGImageFileType.cpp.

References osg::endLog(), osg::ImageFileType::getMimeType(), and SWARNING.

{
    SWARNING << getMimeType()
             << " read from stream is not implemented"
             << endLog;
    return false;
}

bool ImageFileType::write	(	const ImagePtr &	image,
		std::ostream &	os,
		const std::string &	mimetype
	)			[virtual, inherited]

Tries to write the image object to the given output stream. Returns true on success.

Reimplemented in osg::BMPImageFileType, osg::EXRImageFileType, osg::HDRImageFileType, osg::JPGImageFileType, osg::MTDImageFileType, osg::PNGImageFileType, osg::PNMImageFileType, and osg::TIFImageFileType.

Definition at line 185 of file OSGImageFileType.cpp.

References osg::endLog(), osg::ImageFileType::getMimeType(), and SWARNING.

{
    SWARNING << getMimeType()
             << " write to stream is not implemented"
             << endLog;
    return false;
}

bool ImageFileType::validateHeader	(	const Char8 *	fileName,
		bool &	implemented
	)			[virtual, inherited]

Reimplemented in osg::GIFImageFileType, osg::JPGImageFileType, osg::PNGImageFileType, osg::SGIImageFileType, and osg::TIFImageFileType.

Definition at line 161 of file OSGImageFileType.cpp.

Referenced by osg::ImageFileHandler::getFileType().

{
    implemented = false;
    return true;
}

std::string ImageFileType::determineMimetypeFromStream

(

std::istream &

is

)

[virtual, inherited]

Tries to determine the mime type of the data provided by an input stream by searching for magic bytes. Returns the mime type or an empty string when the function could not determine the mime type.

Reimplemented in osg::BMPImageFileType, osg::DDSImageFileType, osg::GIFImageFileType, osg::JP2ImageFileType, osg::JPGImageFileType, osg::MNGImageFileType, osg::PNGImageFileType, osg::PNMImageFileType, osg::PSDImageFileType, osg::SGIImageFileType, and osg::TIFImageFileType.

Definition at line 199 of file OSGImageFileType.cpp.

{
    return std::string();
}

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

Tries to restore the Imagedata from the given memblock. The buffer must include a ImageFileType::Head data block.

Definition at line 283 of file OSGImageFileType.cpp.

References osg::ImageFileType::Head::dataType, osg::ImageFileType::Head::depth, osg::ImageFileHandler::determineMimetypeFromSuffix(), FDEBUG, osg::ImageFileType::Head::frameCount, osg::ImageFileType::Head::frameDelay, FWARNING, osg::ImageFileType::Head::height, osg::ImageFileType::Head::mipmapCount, osg::ImageFileType::Head::netToHost(), osg::NullFC, osg::Image::OSG_UINT8_IMAGEDATA, osg::ImageFileType::Head::pixelFormat, osg::ImageFileType::Head::sideCount, osg::ImageFileType::Head::suffix, osg::ImageFileHandler::the(), and osg::ImageFileType::Head::width.

Referenced by osg::ClusterViewBuffer::recv(), osg::ImageFileHandler::restore(), and osg::SimpleSceneManager::useOpenSGLogo().

{
    unsigned long   imageSize, headSize = sizeof(Head);
    unsigned long   size = 0, attachmentSize;
    Head            head;
    const UChar8    *data = buffer ? (buffer + headSize) : 0;
    ImageFileType   *type;
    std::string     mimeType;
    Image::Type     dataType;

    if ((image != osg::NullFC) && buffer && (memSize >= headSize)) {

        // Copy header. Otherwise netToHost would change the original
        // data structur.
        memcpy(&head,buffer,sizeof(Head));
        head.netToHost();
        mimeType = ImageFileHandler::the().determineMimetypeFromSuffix(head.suffix);
        
        if((type = ImageFileHandler::the().getFileType(mimeType.c_str(), 0)))
        {
            if (head.dataType)
              dataType = Image::Type(head.dataType);
            else
              dataType = Image::OSG_UINT8_IMAGEDATA;

            image->set(Image::PixelFormat(head.pixelFormat), head.width,
                       head.height, head.depth, head.mipmapCount,
                       head.frameCount, float(head.frameDelay) / 1000.0, 0,
                       dataType,true,head.sideCount );
            imageSize = static_cast<unsigned long>(
                type->restoreData(image, data, memSize - headSize));
            attachmentSize = 0; // head->attachmentSize;

            /*
            if ((attachmentSize = head->attachmentSize))
            {
                attData = (char*)(buffer + headSize + imageSize);
                attKey = attData;
                attValue = 0;
                for (i = 0; i < (attachmentSize-1); i++) {
                    if (attData[i] == 0) 
                        if (attKey) {
                            attValue = &(attData[i+1]);
                            image->setAttachmentField (attKey,attValue);
                            attKey = attValue = 0;
                        }
                        else
                            attKey = &(attData[i+1]);
                }
                if (attKey || attValue) {
                    FFATAL (("Attachment restore error\n"));
                }
            }
            */

            size = headSize + imageSize + attachmentSize;
      
            FDEBUG (( "Restore image data: %lu (%lu/%lu/%lu)\n",
                      size, headSize, imageSize, attachmentSize ));

        }
        else
        {
            imageSize = 0;
            FWARNING(("Can not restore image data, invalid mimeType: %s\n",
                      mimeType.empty() == false ? mimeType.c_str() : "Unknown"));
        }

      
    }

    return size;
}

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

Tries to store the raster data to the given mem block. Will include a ImageFileType::Head description and the data encoded as 'mimeType'

Definition at line 364 of file OSGImageFileType.cpp.

References osg::ImageFileHandler::getFileType(), osg::ImageFileType::store(), and osg::ImageFileHandler::the().

Referenced by osg::ClusterViewBuffer::send(), osg::ImageFileType::store(), and osg::ImageFileHandler::store().

{
  ImageFileType   *type = ImageFileHandler::the().getFileType(mimeType);
  
  return type ? type->store(image, buffer, memSize) : 0;
}

UInt64 ImageFileType::store	(	const ImagePtr &	image,
		UChar8 *	buffer,
		Int32	memSize = -1
	)			[inherited]

Tries to store the raster data to the given mem block. Will include a ImageFileType::Head description for the derived concreate mimeType.

Definition at line 378 of file OSGImageFileType.cpp.

References osg::ImageFileType::_suffixList, osg::ImageFileType::Head::attachmentSize, osg::ImageFileType::Head::dataType, osg::ImageFileType::Head::depth, FDEBUG, FFATAL, osg::ImageFileType::Head::frameCount, osg::ImageFileType::Head::frameDelay, osg::ImageFileType::Head::height, osg::ImageFileType::Head::hostToNet(), osg::ImageFileType::Head::mipmapCount, osg::ImageFileType::Head::pixelFormat, osg::ImageFileType::Head::sideCount, osg::ImageFileType::storeData(), osg::ImageFileType::Head::suffix, and osg::ImageFileType::Head::width.

{
    Head            *head;
    unsigned long   dataSize = 0, headSize = sizeof(Head);
    unsigned long   attachmentSize;
    UChar8          *dest;
    const UChar8    *src = image->getData();
    std::map<std::string, std::string>::const_iterator aI;
    std::string     value;

    attachmentSize = 0;

    // get attachment size
    /*
    ImageGenericAttPtr att=ImageGenericAttPtr::dcast(
        const_cast<Image*>(image.getCPtr())->findAttachment(
            ImageGenericAtt::getClassType().getGroupId()));
    if(att != NullFC)
    {
        for(i = 0; i < (att->getType().getNumFieldDescs()-1); ++i)
        {
            FieldDescription *fieldDesc=att->getType().getFieldDescription(i);
            Field *field=att->getField(i);
            if (fieldDesc && field) 
            {
                field->getValueByStr(value);
                attachmentSize += strlen( fieldDesc->getName().str() ) + 1;
                attachmentSize += value.length() + 1;
              
                std::cout << fieldDesc->getName().str() << std::endl; 
                std::cout << value << std::endl; 
            }
            else 
            {
                FFATAL (("Invalid Attachment in ImageFileType::store()\n"));
            }
        }
    }
    */

    if (buffer) 
    {
        head = (Head *)buffer;

        head->pixelFormat    = image->getPixelFormat();
        head->width          = image->getWidth();
        head->height         = image->getHeight();
        head->depth          = image->getDepth();
        head->mipmapCount    = image->getMipMapCount();
        head->frameCount     = image->getFrameCount();
        head->frameDelay     = short(image->getFrameDelay() * 1000.0);
        head->sideCount      = image->getSideCount();
        head->dataType       = image->getDataType();
        head->attachmentSize = static_cast<unsigned short>(attachmentSize);
        head->hostToNet();
      
        strcpy(head->suffix, _suffixList.front().str());
      
        dest = (UChar8 *) (buffer + headSize);

        if (src) 
            dataSize = static_cast<unsigned long>(
                storeData(image, dest, memSize - headSize));

        dest = (UChar8 *) (buffer + headSize + dataSize);

        /*
        if(att != NullFC)
        {
            for(i = 0; i < (att->getType().getNumFieldDescs()-1); ++i)
            {
                FieldDescription *fieldDesc=att->getType().getFieldDescription(i);
                Field *field=att->getField(i);
                if (field && fieldDesc) 
                {
                    field->getValueByStr(value);

                    l = strlen( fieldDesc->getName().str() );
                    for (i = 0; i < l; i++)
                      *dest++ = fieldDesc->getName().str()[i];
                    *dest++ = 0;
                    l = value.length();
                    for (i = 0; i < l; i++)
                      *dest++ = value[i];
                    *dest++ = 0;
                }
                else
                {
                    FFATAL (("Invalid Attachment in ImageFileType::store()\n"));
                }
            }
        }
        */

        FDEBUG (( "Store image data: %lu (%lu/%lu/%lu)\n",
                  headSize + dataSize + attachmentSize, headSize, dataSize, 
                  attachmentSize ));
    }
    else {
        FFATAL (("Invalid buffer in ImageFileType::store()\n"));
    }
  
    return (headSize + dataSize + attachmentSize);

}

UInt64 ImageFileType::maxBufferSize

(

const ImagePtr &

image

)

[virtual, inherited]

Returns the max buffer size needed to store the Image (Head + mimeType specific data block)

Definition at line 490 of file OSGImageFileType.cpp.

References FINFO.

Referenced by osg::ClusterViewBuffer::send(), and osg::ImageFileHandler::store().

{
    std::string value;
    unsigned long size, attachmentSize;
    unsigned long imageSize = image->getSize(), headSize = sizeof(Head);

    std::map<std::string, std::string>::const_iterator aI;

    attachmentSize = 0;

    // get attachment size
        /*
    ImageGenericAttPtr att=ImageGenericAttPtr::dcast(
        const_cast<Image*>(image.getCPtr())->findAttachment(
            ImageGenericAtt::getClassType().getGroupId()));
    if(att != NullFC)
    {
        for(i = 0; i < (att->getType().getNumFieldDescs()-1); ++i)
        {
            FieldDescription *fieldDesc=att->getType().getFieldDescription(i);
            Field *field=att->getField(i);
            if (field && fieldDesc) 
            {
                field->getValueByStr(value);
                attachmentSize += strlen( fieldDesc->getName().str() ) + 1;
                attachmentSize += value.length() + 1;
            }
            else 
            {
                FFATAL (("Invalid Attachment in ImageFileType::maxBufferSize()\n"));
            }
        }
    }
        */

    size = headSize + imageSize + attachmentSize;
  
    FINFO (( "ImageFileType::maxBufferSize(): %lu (%lu/%lu/%lu)\n", 
             size, headSize, imageSize, attachmentSize ));
  
    return size;
}

void ImageFileType::dump

(

void

)

[inherited]

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

Definition at line 537 of file OSGImageFileType.cpp.

References osg::ImageFileType::_suffixList, osg::ImageFileType::getMimeType(), osg::LOG_DEBUG, and SLOG.

{
    std::list<IDString>::iterator    sI;

    SLOG << getMimeType();

    if(_suffixList.empty())
    {
        SLOG << ": Suffix: ";
        for(sI = _suffixList.begin(); sI != _suffixList.end(); sI++)
        {
            Log().stream(OSG::LOG_DEBUG) << sI->str() << " ";
        }
    }

    std::cerr << std::endl;
}

---

Member Data Documentation

DATImageFileType DATImageFileType::_the [static, private]

Definition at line 124 of file OSGDATImageFileType.h.

Referenced by the().

std::map< std::string, DATImageFileType::KeyType > DATImageFileType::_keyStrMap [static, private]

Definition at line 154 of file OSGDATImageFileType.h.

Referenced by initTypeMap(), and read().

std::map< std::string, DATImageFileType::FormatDesc > DATImageFileType::_formatStrMap [static, private]

Definition at line 155 of file OSGDATImageFileType.h.

Referenced by initTypeMap(), read(), and write().

std::string osg::ImageFileType::_options [protected, inherited]

Definition at line 182 of file OSGImageFileType.h.

Referenced by osg::ImageFileType::getOptions(), osg::ImageFileType::setOptions(), and osg::TIFImageFileType::write().

---

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

• OSGDATImageFileType.h
• OSGDATImageFileType.cpp