Main Page | Modules | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages
osg::SGIImageFileType

osg::SGIImageFileType Class Reference
[Image]

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

#include <OSGSGIImageFileType.h>

Inheritance diagram for osg::SGIImageFileType:

osg::ImageFileType 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 Member Functions

Destructor
*virtual ~SGIImageFileType (void)
Read/Write
*virtual bool read (ImagePtr &image, const char *fileName)
virtual bool write (const ImagePtr &image, const char *fileName)
virtual bool validateHeader (const Char8 *fileName, bool &implemented)

Static Public Member Functions

Get Method
*static SGIImageFileType & the (void)

Protected Member Functions

Default Constructor
* SGIImageFileType (const Char8 *mimeType, const Char8 *suffixArray[], UInt16 suffixByteCount)
Copy Constructor
* SGIImageFileType (const SGIImageFileType &obj)

Private Types

typedef ImageFileType Inherited

Static Private Attributes

static SGIImageFileType _the

Detailed Description

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

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

Definition at line 55 of file OSGSGIImageFileType.h.

Member Typedef Documentation

typedef ImageFileType osg::SGIImageFileType::Inherited [private]
 

Definition at line 108 of file OSGSGIImageFileType.h.

Member Enumeration Documentation

anonymous enum [inherited]
 

Enumerator:
OSG_READ_SUPPORTED 
OSG_WRITE_SUPPORTED 

Definition at line 65 of file OSGImageFileType.h.

00066     {
00067         OSG_READ_SUPPORTED = 1,
00068         OSG_WRITE_SUPPORTED = 2
00069     };

Constructor & Destructor Documentation

SGIImageFileType::~SGIImageFileType (  void   )  [virtual]
 

Destructor

Definition at line 532 of file OSGSGIImageFileType.cpp.

00533 {
00534     return;
00535 }

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

Constructor used for the singleton object

Definition at line 510 of file OSGSGIImageFileType.cpp.

00513     : ImageFileType ( mimeType, suffixArray, suffixByteCount )
00514 {
00515     return;
00516 }

SGIImageFileType::SGIImageFileType (  const SGIImageFileType &  obj  )  [protected]
 

Dummy Copy Constructor

Definition at line 522 of file OSGSGIImageFileType.cpp.

00523     : ImageFileType(obj)
00524 {
00525     return;
00526 }

Member Function Documentation

SGIImageFileType & SGIImageFileType::the (  void   )  [static]
 

Class method to get the singleton Object

Definition at line 352 of file OSGSGIImageFileType.cpp.

References _the.

00353 {
00354   return _the;
00355 }

bool SGIImageFileType::read (  ImagePtr &  image,
const char *  fileName
)  [virtual]
 

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

Implements osg::ImageFileType.

Definition at line 366 of file OSGSGIImageFileType.cpp.

References bwtobw(), FWARNING, ImageClose(), ImageGetRow(), ImageOpen(), latola(), osg::Image::OSG_L_PF, osg::Image::OSG_LA_PF, osg::Image::OSG_RGB_PF, osg::Image::OSG_RGBA_PF, rgbatorgba(), rgbtorgb(), ImageRec::xsize, ImageRec::ysize, and ImageRec::zsize.

00367 {
00368  
00369     ImageRec *img = ImageOpen(fileName);
00370     
00371     if(!img)
00372     return false;
00373 
00374     unsigned char *rbuf = (unsigned char *)malloc(img->xsize*
00375                                                     sizeof(unsigned char));
00376     unsigned char *gbuf = (unsigned char *)malloc(img->xsize*
00377                                                     sizeof(unsigned char));
00378     unsigned char *bbuf = (unsigned char *)malloc(img->xsize*
00379                                                     sizeof(unsigned char));
00380     unsigned char *abuf = (unsigned char *)malloc(img->xsize*
00381                                                     sizeof(unsigned char));
00382  
00383     unsigned char *lptr; // pointer to beginning of line in image data
00384     int y;
00385     
00386     switch ( img->zsize )
00387     {
00388     case 1: image->set( Image::OSG_L_PF, img->xsize, img->ysize );
00389             lptr = image->getData();
00390         for(y=0; y<img->ysize; y++) 
00391         {
00392             ImageGetRow(img,rbuf,y,0);
00393             bwtobw(rbuf,lptr,img->xsize);
00394             lptr += img->xsize;
00395         }
00396         break;
00397     case 2: image->set( Image::OSG_LA_PF, img->xsize, img->ysize );
00398             lptr = image->getData();
00399         for(y=0; y<img->ysize; y++) 
00400         {
00401             ImageGetRow(img,rbuf,y,0);
00402             ImageGetRow(img,abuf,y,1);
00403             latola(rbuf,abuf,lptr,img->xsize);
00404             lptr += img->xsize*img->zsize;
00405         }
00406         break;
00407     case 3: image->set( Image::OSG_RGB_PF, img->xsize, img->ysize );
00408             lptr = image->getData();
00409         for(y=0; y<img->ysize; y++) 
00410         {
00411             ImageGetRow(img,rbuf,y,0);
00412             ImageGetRow(img,gbuf,y,1);
00413             ImageGetRow(img,bbuf,y,2);
00414             rgbtorgb(rbuf,gbuf,bbuf,lptr,img->xsize);
00415             lptr += img->xsize*img->zsize;
00416         }
00417         break;
00418     case 4: image->set( Image::OSG_RGBA_PF, img->xsize, img->ysize );
00419             lptr = image->getData();
00420         for(y=0; y<img->ysize; y++) 
00421         {
00422             ImageGetRow(img,rbuf,y,0);
00423             ImageGetRow(img,gbuf,y,1);
00424             ImageGetRow(img,bbuf,y,2);
00425             ImageGetRow(img,abuf,y,3);
00426             rgbatorgba(rbuf,gbuf,bbuf,abuf,lptr,img->xsize);
00427             lptr += img->xsize*img->zsize;
00428         }
00429         break;
00430     default:FWARNING(( "SGIImageFileType::read: unknown zsize %d!", 
00431                 img->zsize));
00432         return false;
00433     }
00434 
00435     ImageClose(img);
00436     free(rbuf);
00437     free(gbuf);
00438     free(bbuf);
00439     free(abuf);
00440 
00441     return true;
00442 }

bool SGIImageFileType::write (  const ImagePtr &  image,
const char *  fileName
)  [virtual]
 

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

Implements osg::ImageFileType.

Definition at line 449 of file OSGSGIImageFileType.cpp.

References FWARNING.

00451 { 
00452     FWARNING(("SGIImageFileType::write: not implemented yet!\n"));
00453     return false;
00454 }

bool SGIImageFileType::validateHeader (  const Char8 *  fileName,
bool &  implemented
)  [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 456 of file OSGSGIImageFileType.cpp.

00457 {
00458     implemented = true;
00459 
00460     if(fileName == NULL)
00461         return false;
00462 
00463     FILE *file = fopen(fileName, "rb");
00464     if(file == NULL)
00465         return false;
00466 
00467     UInt16 magic = 0;
00468     fread((void *) &magic, sizeof(magic), 1, file);
00469     fclose(file);
00470 
00471 #if BYTE_ORDER == LITTLE_ENDIAN
00472     if(magic == 0xda01) // the magic header is big endian need to swap it.
00473 #else
00474     if(magic == 0x01da)
00475 #endif
00476     {
00477         return true;
00478     }
00479 
00480     return false;
00481 }

const Char8 * ImageFileType::getMimeType (  void   )  const [inherited]
 

Get method for the mime type

Definition at line 106 of file OSGImageFileType.cpp.

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

Referenced by osg::ImageFileType::dump(), osg::TIFImageFileType::read(), osg::PNGImageFileType::read(), osg::MNGImageFileType::read(), osg::JPGImageFileType::read(), osg::ImageFileHandler::read(), osg::PNGImageFileType::restoreData(), osg::JPGImageFileType::restoreData(), osg::ImageFileType::restoreData(), osg::ImageFileType::store(), osg::ImageFileHandler::store(), osg::PNGImageFileType::storeData(), osg::JPGImageFileType::storeData(), osg::ImageFileType::storeData(), osg::TIFImageFileType::write(), osg::TGAImageFileType::write(), osg::PNGImageFileType::write(), osg::MNGImageFileType::write(), osg::JPGImageFileType::write(), osg::ImageFileHandler::write(), osg::GIFImageFileType::write(), and osg::DDSImageFileType::write().

00107 {
00108     return _mimeType.str();
00109 }

const std::list< IDString > & ImageFileType::getSuffixList (  void   )  const [inherited]
 

Get method for the suffix list container

Definition at line 125 of file OSGImageFileType.cpp.

References osg::ImageFileType::_suffixList.

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

00126 {
00127     return _suffixList; 
00128 }

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 116 of file OSGImageFileType.cpp.

References osg::ImageFileType::_flags.

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

00117 {
00118     return _flags;
00119 }

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 223 of file OSGImageFileType.cpp.

References FDEBUG, FWARNING, osg::ImageFileHandler::getFileType(), osg::NullFC, osg::Image::OSG_UINT8_IMAGEDATA, osg::ImageFileType::restoreData(), and osg::ImageFileHandler::the().

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

00225 {
00226     unsigned long   imageSize, headSize = sizeof(Head);
00227     unsigned long   size = 0, attachmentSize;
00228     Head            head;
00229     const UChar8    *data = buffer ? (buffer + headSize) : 0;
00230     ImageFileType   *type;
00231     const char      *mimeType;
00232     Image::Type     dataType;
00233 
00234     if ((image != osg::NullFC) && buffer && (memSize >= headSize)) {
00235 
00236         // Copy header. Otherwise netToHost would change the original
00237         // data structur.
00238         memcpy(&head,buffer,sizeof(Head));
00239         head.netToHost();
00240         mimeType = head.mimeType;
00241         
00242         if((type = ImageFileHandler::the().getFileType(mimeType, 0)))
00243         {
00244             if (head.dataType)
00245               dataType = Image::Type(head.dataType);
00246             else
00247               dataType = Image::OSG_UINT8_IMAGEDATA;
00248 
00249             image->set(Image::PixelFormat(head.pixelFormat), head.width,
00250                        head.height, head.depth, head.mipmapCount,
00251                        head.frameCount, float(head.frameDelay) / 1000.0, 0,
00252                        dataType,true,head.sideCount );
00253             imageSize = static_cast<unsigned long>(
00254                 type->restoreData(image, data, memSize - headSize));
00255             attachmentSize = 0; // head->attachmentSize;
00256 
00257             /*
00258             if ((attachmentSize = head->attachmentSize))
00259             {
00260                 attData = (char*)(buffer + headSize + imageSize);
00261                 attKey = attData;
00262                 attValue = 0;
00263                 for (i = 0; i < (attachmentSize-1); i++) {
00264                     if (attData[i] == 0) 
00265                         if (attKey) {
00266                             attValue = &(attData[i+1]);
00267                             image->setAttachmentField (attKey,attValue);
00268                             attKey = attValue = 0;
00269                         }
00270                         else
00271                             attKey = &(attData[i+1]);
00272                 }
00273                 if (attKey || attValue) {
00274                     FFATAL (("Attachment restore error\n"));
00275                 }
00276             }
00277             */
00278 
00279             size = headSize + imageSize + attachmentSize;
00280       
00281             FDEBUG (( "Restore image data: %lu (%lu/%lu/%lu)\n",
00282                       size, headSize, imageSize, attachmentSize ));
00283 
00284         }
00285         else
00286         {
00287             imageSize = 0;
00288             FWARNING(("Can not restore image data, invalid mimeType: %s\n",
00289                       mimeType ? mimeType : "Unknown"));
00290         }
00291 
00292       
00293     }
00294 
00295     return size;
00296 }

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 304 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().

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

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 318 of file OSGImageFileType.cpp.

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

00320 {
00321     Head            *head;
00322     unsigned long   dataSize = 0, headSize = sizeof(Head);
00323     unsigned long   attachmentSize;
00324     UChar8          *dest;
00325     const UChar8    *src = image->getData();
00326     std::map<std::string, std::string>::const_iterator aI;
00327     std::string     value;
00328 
00329     attachmentSize = 0;
00330 
00331     // get attachment size
00332     /*
00333     ImageGenericAttPtr att=ImageGenericAttPtr::dcast(
00334         const_cast<Image*>(image.getCPtr())->findAttachment(
00335             ImageGenericAtt::getClassType().getGroupId()));
00336     if(att != NullFC)
00337     {
00338         for(i = 0; i < (att->getType().getNumFieldDescs()-1); ++i)
00339         {
00340             FieldDescription *fieldDesc=att->getType().getFieldDescription(i);
00341             Field *field=att->getField(i);
00342             if (fieldDesc && field) 
00343             {
00344                 field->getValueByStr(value);
00345                 attachmentSize += strlen( fieldDesc->getName().str() ) + 1;
00346                 attachmentSize += value.length() + 1;
00347               
00348                 std::cout << fieldDesc->getName().str() << std::endl; 
00349                 std::cout << value << std::endl; 
00350             }
00351             else 
00352             {
00353                 FFATAL (("Invalid Attachment in ImageFileType::store()\n"));
00354             }
00355         }
00356     }
00357     */
00358 
00359     if (buffer) 
00360     {
00361         head = (Head *)buffer;
00362 
00363         head->pixelFormat    = image->getPixelFormat();
00364         head->width          = image->getWidth();
00365         head->height         = image->getHeight();
00366         head->depth          = image->getDepth();
00367         head->mipmapCount    = image->getMipMapCount();
00368         head->frameCount     = image->getFrameCount();
00369         head->frameDelay     = short(image->getFrameDelay() * 1000.0);
00370         head->sideCount      = image->getSideCount();
00371         head->dataType       = image->getDataType();
00372         head->attachmentSize = static_cast<unsigned short>(attachmentSize);
00373         head->hostToNet();
00374       
00375         strcpy(head->mimeType, getMimeType());
00376       
00377         dest = (UChar8 *) (buffer + headSize);
00378 
00379         if (src) 
00380             dataSize = static_cast<unsigned long>(
00381                 storeData(image, dest, memSize - headSize));
00382 
00383         dest = (UChar8 *) (buffer + headSize + dataSize);
00384 
00385         /*
00386         if(att != NullFC)
00387         {
00388             for(i = 0; i < (att->getType().getNumFieldDescs()-1); ++i)
00389             {
00390                 FieldDescription *fieldDesc=att->getType().getFieldDescription(i);
00391                 Field *field=att->getField(i);
00392                 if (field && fieldDesc) 
00393                 {
00394                     field->getValueByStr(value);
00395 
00396                     l = strlen( fieldDesc->getName().str() );
00397                     for (i = 0; i < l; i++)
00398                       *dest++ = fieldDesc->getName().str()[i];
00399                     *dest++ = 0;
00400                     l = value.length();
00401                     for (i = 0; i < l; i++)
00402                       *dest++ = value[i];
00403                     *dest++ = 0;
00404                 }
00405                 else
00406                 {
00407                     FFATAL (("Invalid Attachment in ImageFileType::store()\n"));
00408                 }
00409             }
00410         }
00411         */
00412 
00413         FDEBUG (( "Store image data: %lu (%lu/%lu/%lu)\n",
00414                   headSize + dataSize + attachmentSize, headSize, dataSize, 
00415                   attachmentSize ));
00416     }
00417     else {
00418         FFATAL (("Invalid buffer in ImageFileType::store()\n"));
00419     }
00420   
00421     return (headSize + dataSize + attachmentSize);
00422 
00423 }

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 430 of file OSGImageFileType.cpp.

References FINFO.

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

00431 {
00432     std::string value;
00433     unsigned long size, attachmentSize;
00434     unsigned long imageSize = image->getSize(), headSize = sizeof(Head);
00435 
00436     std::map<std::string, std::string>::const_iterator aI;
00437 
00438     attachmentSize = 0;
00439 
00440     // get attachment size
00441         /*
00442     ImageGenericAttPtr att=ImageGenericAttPtr::dcast(
00443         const_cast<Image*>(image.getCPtr())->findAttachment(
00444             ImageGenericAtt::getClassType().getGroupId()));
00445     if(att != NullFC)
00446     {
00447         for(i = 0; i < (att->getType().getNumFieldDescs()-1); ++i)
00448         {
00449             FieldDescription *fieldDesc=att->getType().getFieldDescription(i);
00450             Field *field=att->getField(i);
00451             if (field && fieldDesc) 
00452             {
00453                 field->getValueByStr(value);
00454                 attachmentSize += strlen( fieldDesc->getName().str() ) + 1;
00455                 attachmentSize += value.length() + 1;
00456             }
00457             else 
00458             {
00459                 FFATAL (("Invalid Attachment in ImageFileType::maxBufferSize()\n"));
00460             }
00461         }
00462     }
00463         */
00464 
00465     size = headSize + imageSize + attachmentSize;
00466   
00467     FINFO (( "ImageFileType::maxBufferSize(): %lu (%lu/%lu/%lu)\n", 
00468              size, headSize, imageSize, attachmentSize ));
00469   
00470     return size;
00471 }

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

Abstract restore method. Should be overwriten by a concrete derived class. Tries to restore the image data from the given memblock.

Reimplemented in osg::DATImageFileType, osg::JPGImageFileType, osg::MTDImageFileType, and osg::PNGImageFileType.

Definition at line 193 of file OSGImageFileType.cpp.

References FWARNING, and osg::ImageFileType::getMimeType().

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

00196 {
00197   FWARNING(("ImageXFileType::restoreData() not impl. for mimeType %s\n",
00198             getMimeType()));
00199 
00200   return 0;
00201 }

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

Abstract restore method. Should be overwriten by a concrete derived class. Tries to store the given image data to the given memblock

Reimplemented in osg::DATImageFileType, osg::JPGImageFileType, osg::MTDImageFileType, and osg::PNGImageFileType.

Definition at line 208 of file OSGImageFileType.cpp.

References FWARNING, and osg::ImageFileType::getMimeType().

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

00211 {
00212   FWARNING(("ImageXFileType::storeData() not impl. for mimeType %s\n",
00213             getMimeType()));
00214   
00215   return 0;
00216 }

void ImageFileType::dump (  void   )  [inherited]
 

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

Definition at line 477 of file OSGImageFileType.cpp.

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

00478 {
00479     std::list<IDString>::iterator    sI;
00480 
00481     SLOG << getMimeType();
00482 
00483     if(_suffixList.empty())
00484     {
00485         SLOG << ": Suffix: ";
00486         for(sI = _suffixList.begin(); sI != _suffixList.end(); sI++)
00487         {
00488             Log().stream(OSG::LOG_DEBUG) << sI->str() << " ";
00489         }
00490     }
00491 
00492     std::cerr << std::endl;
00493 }

Member Data Documentation

SGIImageFileType SGIImageFileType::_the [static, private]
 

Referenced by the().

The documentation for this class was generated from the following files:
Generated on Thu Aug 25 04:14:24 2005 for OpenSG by  doxygen 1.4.3