00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #ifndef _SO_VOLUME_READER_
00024 #define _SO_VOLUME_READER_
00025
00026 #ifdef _MSC_VER
00027 #pragma warning( push )
00028 #pragma warning(disable:4251)
00029 #endif
00030
00031 #include <Inventor/nodes/SoNode.h>
00032 #include <Inventor/SoPreferences.h>
00033 #include <LDM/nodes/SoDataSet.h>
00034
00035 #include <Inventor/STL/vector>
00036 #include <Inventor/STL/map>
00037
00038 class SbThreadMutex;
00039 class SoVolumeWriter;
00242 class SoVolumeReader : public SoFieldContainer
00243 {
00244 SO_FIELDCONTAINER_ABSTRACT_HEADER(SoVolumeReader);
00245
00246 public:
00247
00251 enum ReadError {
00255 RD_NO_ERROR,
00259 RD_FILE_NOT_FOUND_ERROR,
00263 RD_INVALID_DATA_ERROR,
00267 RD_UNSUPPORTED_DATA_TYPE_ERROR,
00272 RD_FILE_FORMAT_NOT_VALID_ERROR,
00276 RD_UNKNOWN_ERROR
00277 } ;
00278
00283 enum Axis {
00284 X,
00285 Y,
00286 Z
00287 };
00288
00293 SoVolumeReader();
00294
00309 virtual ReadError getDataChar( SbBox3f &size, SoDataSet::DataType &type, SbVec3i32 &dim )=0;
00310
00317 virtual SbBool setOutputDataType( SbBool doChange, SoDataSet::DataType outputType );
00318
00327 virtual SbBool setInputDataRange( SbBool doChange, double min, double max );
00328
00338 virtual int getNumSignificantBits() { return 0; };
00339
00353 virtual void getSubSlice( const SbBox2i32& subSlice, int sliceNumber, void * data )=0;
00354
00387 virtual void getSubSlice( const SbBox2i32& subSlice, int sliceNumber, SoBufferObject * bufferObject);
00388
00392 enum CopyPolicy
00393 {
00395 COPY,
00397 NO_COPY,
00399 NO_COPY_AND_DELETE
00400 };
00401
00416 SbVec3i32 getNumVoxels( const SbVec3i32& realSize, const SbVec3i32& subsamplingLevel );
00417
00427 SbVec3i32 getSizeToAllocate( const SbVec3i32& realSize, const SbVec3i32& subsamplingLevel );
00428
00433 virtual int setFilename( const SbString& filename );
00434
00438 SbString getFilename() const;
00439
00440
00449 virtual SbBool isDataConverted() const;
00450
00456 virtual SbBool getTileSize(SbVec3i32& size);
00457
00474 virtual SoBufferObject* readTile(int index, const SbBox3i32& tilePosition);
00475
00486 virtual SbBool readXTraceInTile(int index, unsigned char*& buffer, const SbBox3i32& tilePosition, const SbVec2i32& tracePosition);
00487
00498 virtual SbBool readYSliceInTile(int index, unsigned char*& buffer, const SbBox3i32& tilePosition, const uint32_t& slicePosition );
00499
00510 virtual SbBool readZSliceInTile(int index, unsigned char*& buffer, const SbBox3i32& tilePosition, const uint32_t& slicePosition );
00511
00522 virtual SbBool readXSliceInTile(int index, unsigned char*& buffer, const SbBox3i32& tilePosition, const uint32_t& slicePosition );
00523
00530 virtual SbBool isThreadSafe() const;
00531
00535 inline int getNumSubsampledTiles()
00536 {return m_numSubsampledTiles;};
00537
00542 virtual SbString getOriginalFilename() const
00543 { return SbString(""); }
00544
00549 virtual SbBool getMinMax(int64_t & min, int64_t & max);
00550
00555 virtual SbBool getMinMax(double & min, double & max);
00556
00560 virtual SbBool getHistogram(std::vector<int64_t>& numVox);
00561
00569 virtual SbBool setDirectCoordSysAutoDetection(SbBool autoValue);
00573 virtual SbBool getDirectCoordSysAutoDetection();
00574
00581 virtual SbBool setDirectCoorSys(SbBool directCoord);
00582
00586 virtual SbBool getDirectCoordSys();
00587
00607 virtual SbVec2d getTileMinMax( int fileId ) const;
00608
00612 enum ReaderType {
00614 NO_READER,
00616 AM,
00618 AVS,
00620 DICOM,
00622 GENERIC,
00624 LDM,
00626 MEMORY,
00628 RASTERSTACK,
00630 SEGY,
00632 VOL,
00634 VOX,
00636 TIFF
00637 };
00638
00642 virtual ReaderType getReaderType (){return NO_READER;};
00643
00709 virtual SoVolumeWriter* getConfiguredWriter();
00710
00714 enum CoordinateType {
00718 COORDINATES_UNIFORM = 0,
00722 COORDINATES_RECTILINEAR
00723 };
00724
00728 CoordinateType getCoordinateType();
00729
00733 const float * getRectilinearCoordinates(Axis axis) const;
00734
00738 void setRectilinearCoordinates(const float *x, const float *y, const float *z);
00739
00744 virtual SbBool isRGBA() const
00745 { return m_isRGBA; }
00746
00750 inline void setRGBA(const SbBool flag)
00751 { m_isRGBA = flag; }
00752
00761 virtual void closeAllHandles() {};
00762
00766 virtual void restoreAllHandles() {};
00767
00779 static SoVolumeReader* getAppropriateReader(const SbString& filename);
00780
00781 #if 1 SoDEPRECATED
00784 virtual SbBool getSubVolume( const SbBox3i32& subVolume, void * data );
00785 SoDEPRECATED
00790 virtual SbBool getTileSize(SbVec3s& size)
00791 {
00792 SbVec3i32 sizeI32;
00793 SbBool rc = getTileSize( sizeI32 );
00794 size.setValue( (short)sizeI32[0], (short)sizeI32[1], (short)sizeI32[2] );
00795 return rc;
00796 };
00797 SoDEPRECATED
00799 virtual void getDataChar( SbBox3f &size, SoDataSet::DataType &type, SbVec3s &dim )
00800 {
00801 SbVec3i32 dimI32;
00802 getDataChar( size, type, dimI32 );
00803 dim.setValue( (short)dimI32[0], (short)dimI32[1], (short)dimI32[2] );
00804 };
00805 SoDEPRECATED
00807 SbVec3s getNumVoxels( const SbVec3s& realSize, const SbVec3s& subsamplingLevel )
00808 {
00809 SbVec3i32 realSizeI32( realSize[0], realSize[1], realSize[2] );
00810 SbVec3i32 subsamplingLevelI32( subsamplingLevel[0], subsamplingLevel[1], subsamplingLevel[2] );
00811 SbVec3i32 numVoxels = getNumVoxels( realSizeI32, subsamplingLevelI32 );
00812 return SbVec3s( (short)numVoxels[0], (short)numVoxels[1], (short)numVoxels[2] );
00813 };
00814 SoDEPRECATED
00816 SbVec3s getSizeToAllocate( const SbVec3s& realSize, const SbVec3s& subsamplingLevel )
00817 {
00818 SbVec3i32 realSizeI32( realSize[0], realSize[1], realSize[2] );
00819 SbVec3i32 subsamplingLevelI32( subsamplingLevel[0], subsamplingLevel[1], subsamplingLevel[2] );
00820 SbVec3i32 size = getSizeToAllocate( realSizeI32, subsamplingLevelI32 );
00821 return SbVec3s( (short)size[0], (short)size[1], (short)size[2] );
00822 };
00823 SoDEPRECATED
00825 virtual void getSubSlice( const SbBox2s& subSlice, int sliceNumber, void * data )
00826 {
00827 SbBox2i32 subSliceI32( subSlice.getMin()[0], subSlice.getMin()[1], subSlice.getMax()[0], subSlice.getMax()[1] );
00828 getSubSlice( subSliceI32, sliceNumber, data );
00829 };
00830 SoDEPRECATED
00832 virtual SbBool getSubVolume( const SbBox3s& subVolume, void * data );
00833 SoDEPRECATED
00835 virtual SbBool getSubVolume( const SbBox3s& subVolume, const SbVec3s& aSL, void *& data );
00836 SoDEPRECATED
00838 virtual SbBool getSubVolumeInfo( const SbBox3s& subVolume, const SbVec3s& rSL, SbVec3s& aSL, SoVolumeReader::CopyPolicy& policy);
00839 SoDEPRECATED
00841 virtual SbBool readTile( int index, unsigned char*&buffer, const SbBox3s& tilePosition );
00842
00843 #endif
00845 #if 1 SoDEPRECATED
00848 virtual void getNextSlice( int SO_UNUSED_PARAM(sliceNumber), void * SO_UNUSED_PARAM(data) ) {};
00849 SoDEPRECATED
00851 virtual void skipSlice( int SO_UNUSED_PARAM(numSlices) ) {};
00852 SoDEPRECATED
00854 virtual void end( ) {};
00855
00856 #endif
00858 #if 1 SoDEPRECATED
00888 virtual SbBool readTile(int SO_UNUSED_PARAM(index), unsigned char*& SO_UNUSED_PARAM(buffer), const SbBox3i32& SO_UNUSED_PARAM(tilePosition)) { return FALSE; }
00889 SoDEPRECATED
00896 virtual SbBool readTile(int index, SoBufferObject *buffer, const SbBox3i32& tilePosition);
00897
00898 #endif
00900 #if 1 SoDEPRECATED
00914 inline int getNumTimeSteps()
00915 { return 1; };
00916 SoDEPRECATED
00926 void setCurrentTimeStep( int )
00927 { };
00928 SoDEPRECATED
00936 inline int getCurrentTimeStep() const
00937 { return 0;}
00938 SoDEPRECATED
00943 virtual SbBool getSubVolumeInfo(
00944 const SbBox3i32& subVolume,
00945 const SbVec3i32& requestedSubsampleLevel,
00946 SbVec3i32& actualSubsampleLevel,
00947 SoVolumeReader::CopyPolicy& policy
00948 );
00949 SoDEPRECATED
00951 virtual SbBool getSubVolume(
00952 const SbBox3i32& subVolume,
00953 const SbVec3i32& actualSubsampleLevel,
00954 void *& data
00955 );
00956 SoDEPRECATED
00961 virtual int getBorderFlag()
00962 {return -1;}
00963
00964 #endif
00966 #if 1 SoDEPRECATED
00973 virtual SbBool getMinMax(int& min, int& max);
00974
00975 #endif
00977 private:
00978
00979
00980
00981 virtual ReadError getDataChar( SbBox3f &size, std::vector<SoDataSet::DatumElement>& datum, SbVec3i32 &dim );
00982
00983 void lockFileMutex();
00984 void unlockFileMutex();
00985 void setNumSubsampledTiles(int num){m_numSubsampledTiles = num;};
00995 void convert( SoDataSet::DataType typeIn , SoBufferObject* bufferIn,
00996 SoDataSet::DataType typeOut, SoBufferObject* bufferOut, int size, SbBool shiftData = true);
00997
00998 void convertDataRange( bool doRange, double min, double max );
00999
01000 virtual int getNumBytesPerDatum();
01001
01002 virtual bool isLDMReader() { return false; }
01003 virtual bool isVolumeMaskReader() { return false; }
01004
01005 virtual bool hasDeadCell() { return false; }
01006
01007 virtual bool isDead(int i,int j,int k);
01008
01009 virtual uint8_t* getCellGridState() { return NULL; }
01010
01011 virtual int getNbCell() { return 0; }
01012
01013 virtual uint64_t getTileSizeFromFid(int fileId);
01014
01015
01019 bool hasPerTileMinMaxComputed() const;
01020
01021 #if 1 SoDEPRECATED
01024 void convert( SoDataSet::DataType typeIn , void* bufferIn,
01025 SoDataSet::DataType typeOut, void* bufferOut, int size, SbBool shiftData = true);
01026
01027 #endif
01029 private: protected:
01030
01058 static bool registerVolumeReaderExtension(const SbString& fileExtension, const SoType& readerType);
01059
01069 static bool unregisterVolumeReaderExtensions(const SoType& readerType);
01070
01074 virtual ~SoVolumeReader();
01075
01082 void *getBuffer(int64_t offset, unsigned int size);
01083
01084
01085
01090 int bytesToInt( unsigned char *ptr, int sizeBytes );
01091
01095 void swapBytes( int *intPtr, int sizeBytes );
01096
01101 void swapBytesN( void *buffer, int numElements, int numBytesPerElement );
01102
01106 SbBool isValidFloat( const float val );
01107
01111 int64_t fileSize();
01112
01113 #if 1 SoDEPRECATED
01116 SbBool m_dataConverted;
01117
01118 #endif
01120 //------------------------------------------------------------------------------
01121 #ifndef HIDDEN_FROM_DOC
01122 SbString m_filename;
01123
01124 #endif // HIDDEN_FROM_DOC
01125
01126
01132 static SbBox3f adjustFlatExtent(const SbString& fileName, const SbBox3f& extent, const SbVec3i32& dim);
01133
01134 private:
01135
01136
01137
01138 SbBool m_directCoordSysAutoDetect;
01139
01140
01141 SbBool m_directCoordSys;
01142
01143 std::vector<SoDataSet::DatumElement> m_datum;
01144 int m_bytesPerVoxel;
01145
01146 double m_rangeMin, m_rangeMax;
01147 bool m_doRange;
01148
01149
01150 SbBool m_headerRead;
01151
01152 CoordinateType m_coordinateType;
01153 std::vector<float> m_rectilinearCoordinates[3];
01154
01155 private:
01156 SbBool m_isRGBA;
01157 int m_numSubsampledTiles;
01158 SbBool m_useFMM;
01159 void *m_filehandle;
01160 int m_filedesc;
01161 int64_t m_filesize;
01162 void *m_fmmdata;
01163 int64_t m_fmmoffset;
01164 unsigned int m_fmmsize;
01165
01166 void releasefmm();
01167 void bestmap(int64_t);
01168
01169 SbThreadMutex* m_fileMutex;
01170
01171
01172 typedef std::map<SbString,SoType> SoVolumeReaderExtensionAssociationMap;
01173 static SoVolumeReaderExtensionAssociationMap s_volumeReaderExtensionAssociation;
01174
01175
01176 template <typename TypeInt, typename TypeOut>
01177 void convert_range(int size, void* bufferIn, void* bufferOut, int64_t outMin, int64_t outMax);
01178
01179
01180 template <typename TypeOut>
01181 void convert_out(int size, void* bufferIn, void* bufferOut, int64_t outMin, int64_t outMax);
01182
01183
01184 template <typename TypeIn>
01185 void convert_in(int size, void* bufferIn, void* bufferOut, int64_t outMin, int64_t outMax);
01186
01187 };
01188
01189 inline SbBool
01190 SoVolumeReader::readXTraceInTile(int , unsigned char*& , const SbBox3i32& , const SbVec2i32& )
01191 {
01192 return FALSE;
01193 }
01194
01195 inline SbBool
01196 SoVolumeReader::readXSliceInTile(int , unsigned char*& , const SbBox3i32& , const uint32_t& )
01197 {
01198 return FALSE;
01199 }
01200
01201 inline SbBool
01202 SoVolumeReader::readYSliceInTile(int , unsigned char*& , const SbBox3i32& , const uint32_t& )
01203 {
01204 return FALSE;
01205 }
01206
01207 inline SbBool
01208 SoVolumeReader::getMinMax(int& , int& )
01209 {
01210 return FALSE;
01211 }
01212
01213 inline SbBool
01214 SoVolumeReader::getMinMax(int64_t &, int64_t &)
01215 {
01216 return FALSE;
01217 }
01218
01219 inline SbBool
01220 SoVolumeReader::getMinMax(double & , double & )
01221 {
01222 return FALSE;
01223 }
01224
01225 inline SbBool
01226 SoVolumeReader::getHistogram(std::vector<int64_t>&)
01227 {
01228 return FALSE;
01229 }
01230
01231 inline SbBool
01232 SoVolumeReader::setDirectCoordSysAutoDetection(SbBool)
01233 {
01234 return FALSE;
01235 }
01236
01237 inline SbBool
01238 SoVolumeReader::getDirectCoordSysAutoDetection()
01239 {
01240 return m_directCoordSysAutoDetect;
01241 }
01242
01243 inline SbBool
01244 SoVolumeReader::setDirectCoorSys(SbBool)
01245 {
01246 return FALSE;
01247 }
01248
01249 inline SbBool
01250 SoVolumeReader::getDirectCoordSys()
01251 {
01252 return m_directCoordSys;
01253 }
01254
01255 inline bool
01256 SoVolumeReader::isDead(int, int, int)
01257 {
01258 return false;
01259 }
01260
01261 inline uint64_t
01262 SoVolumeReader::getTileSizeFromFid(int)
01263 {
01264 return 0;
01265 }
01266
01267 #ifdef _MSC_VER
01268 #pragma warning( pop )
01269 #endif
01270
01271 #endif // _SO_VOLUME_READER_
01272
01273
01274