LDM/readers/SoVolumeReader.h

Go to the documentation of this file.

/*=======================================================================
 *** THE CONTENT OF THIS WORK IS PROPRIETARY TO FEI S.A.S, (FEI S.A.S.),            ***
 ***              AND IS DISTRIBUTED UNDER A LICENSE AGREEMENT.                     ***
 ***                                                                                ***
 ***  REPRODUCTION, DISCLOSURE,  OR USE,  IN WHOLE OR IN PART,  OTHER THAN AS       ***
 ***  SPECIFIED  IN THE LICENSE ARE  NOT TO BE  UNDERTAKEN  EXCEPT WITH PRIOR       ***
 ***  WRITTEN AUTHORIZATION OF FEI S.A.S.                                           ***
 ***                                                                                ***
 ***                        RESTRICTED RIGHTS LEGEND                                ***
 ***  USE, DUPLICATION, OR DISCLOSURE BY THE GOVERNMENT OF THE CONTENT OF THIS      ***
 ***  WORK OR RELATED DOCUMENTATION IS SUBJECT TO RESTRICTIONS AS SET FORTH IN      ***
 ***  SUBPARAGRAPH (C)(1) OF THE COMMERCIAL COMPUTER SOFTWARE RESTRICTED RIGHT      ***
 ***  CLAUSE  AT FAR 52.227-19  OR SUBPARAGRAPH  (C)(1)(II)  OF  THE RIGHTS IN      ***
 ***  TECHNICAL DATA AND COMPUTER SOFTWARE CLAUSE AT DFARS 52.227-7013.             ***
 ***                                                                                ***
 ***                   COPYRIGHT (C) 1996-2020 BY FEI S.A.S,                        ***
 ***                        BORDEAUX, FRANCE                                        ***
 ***                      ALL RIGHTS RESERVED                                       ***
**=======================================================================*/
/*=======================================================================
** Author      : P. ESTRADE (Mar 2000)
**=======================================================================*/
#ifndef  _SO_VOLUME_READER_
#define  _SO_VOLUME_READER_

#ifdef _MSC_VER
#pragma warning( push )
#pragma warning(disable:4251)
#endif

#include <Inventor/nodes/SoNode.h>
#include <Inventor/SoPreferences.h>
#include <LDM/nodes/SoDataSet.h>

#include <Inventor/STL/vector>
#include <Inventor/STL/map>

class SbThreadMutex;
class SoVolumeWriter;
class  SoVolumeReader : public SoFieldContainer
{
  SO_FIELDCONTAINER_ABSTRACT_HEADER(SoVolumeReader);

 public:

   enum ReadError {
    RD_NO_ERROR,
    RD_FILE_NOT_FOUND_ERROR,
    RD_INVALID_DATA_ERROR,
    RD_UNSUPPORTED_DATA_TYPE_ERROR,
    RD_FILE_FORMAT_NOT_VALID_ERROR,
    RD_UNKNOWN_ERROR
   } ;

  enum Axis {
    X,
    Y,
    Z
  };

   SoVolumeReader();

  virtual ReadError getDataChar( SbBox3f &size, SoDataSet::DataType &type, SbVec3i32 &dim )=0;

  virtual SbBool setOutputDataType( SbBool doChange, SoDataSet::DataType outputType );

  virtual SbBool setInputDataRange( SbBool doChange, double min, double max );

  virtual int getNumSignificantBits() { return 0; };

  virtual void getSubSlice( const SbBox2i32& subSlice, int sliceNumber, void * data )=0;

  virtual void getSubSlice( const SbBox2i32& subSlice, int sliceNumber, SoBufferObject * dataBuffer);

  enum CopyPolicy
  {
    COPY,
    NO_COPY,
    NO_COPY_AND_DELETE
  };

   SbVec3i32 getNumVoxels( const SbVec3i32& realSize, const SbVec3i32& subsamplingLevel );

   SbVec3i32 getSizeToAllocate( const SbVec3i32& realSize, const SbVec3i32& subsamplingLevel );

  virtual int setFilename( const SbString& filename );

  SbString getFilename() const;

  //------------ for LDM -----------------//
  virtual SbBool isDataConverted() const;

  virtual SbBool getTileSize(SbVec3i32& size);

  virtual SoBufferObject* readTile(int index, const SbBox3i32& tilePosition);

  virtual SbBool readXTraceInTile(int index, unsigned char*& buffer, const SbBox3i32& tilePosition, const SbVec2i32& tracePosition);

  virtual SbBool readYSliceInTile(int index, unsigned char*& buffer, const SbBox3i32& tilePosition, const uint32_t& slicePosition );

  virtual SbBool readZSliceInTile(int index, unsigned char*& buffer, const SbBox3i32& tilePosition, const uint32_t& slicePosition );

  virtual SbBool readXSliceInTile(int index, unsigned char*& buffer, const SbBox3i32& tilePosition, const uint32_t& slicePosition );

  virtual SbBool isThreadSafe() const;

  virtual SbBool isIgnoredFile() const;

  inline int getNumSubsampledTiles()
  {return m_numSubsampledTiles;};

  virtual SbString getOriginalFilename() const
  { return SbString(""); }

  virtual SbBool getMinMax(int64_t & min, int64_t & max);

  virtual SbBool getMinMax(double & min, double & max);

  virtual SbBool getHistogram(std::vector<int64_t>& numVox);

  virtual SbBool setDirectCoordSysAutoDetection(SbBool autoValue);
  virtual SbBool getDirectCoordSysAutoDetection();

  virtual SbBool setDirectCoorSys(SbBool directCoord);

  virtual SbBool getDirectCoordSys();

  virtual SbVec2d getTileMinMax( int fileId ) const;

  enum ReaderType {
    NO_READER,
    AM,
    AVS,
    DICOM,
    GENERIC,
    LDM,
    MEMORY,
    RASTERSTACK,
    SEGY,
    VOL,
    VOX,
    TIFF
  };

  virtual ReaderType getReaderType (){return NO_READER;};

  virtual SoVolumeWriter* getConfiguredWriter();

  enum CoordinateType {
    COORDINATES_UNIFORM = 0,
    COORDINATES_RECTILINEAR
  };

  CoordinateType getCoordinateType();

  const float * getRectilinearCoordinates(Axis axis) const;

  void setRectilinearCoordinates(const float *x, const float *y, const float *z);

  virtual SbBool isRGBA() const 
  { return m_isRGBA; }

  inline void setRGBA(const SbBool flag)
  { m_isRGBA = flag; }

  virtual void closeAllHandles() {}; 

  virtual void restoreAllHandles() {}; 

  static SoVolumeReader* getAppropriateReader(const SbString& filename);

#if 1             SoDEPRECATED
  virtual SbBool getSubVolume( const SbBox3i32& subVolume, void * data );
SoDEPRECATED
  virtual SbBool getTileSize(SbVec3s& size)
  {
    SbVec3i32 sizeI32;
    SbBool rc = getTileSize( sizeI32 );
    size.setValue( (short)sizeI32[0], (short)sizeI32[1], (short)sizeI32[2] );
    return rc;
  };
SoDEPRECATED
  virtual void getDataChar( SbBox3f &size, SoDataSet::DataType &type, SbVec3s &dim )
  {
    SbVec3i32 dimI32;
    getDataChar( size, type, dimI32 );
    dim.setValue( (short)dimI32[0], (short)dimI32[1], (short)dimI32[2] );
  };
SoDEPRECATED
  SbVec3s getNumVoxels( const SbVec3s& realSize, const SbVec3s& subsamplingLevel )
  {
    SbVec3i32 realSizeI32( realSize[0], realSize[1], realSize[2] );
    SbVec3i32 subsamplingLevelI32( subsamplingLevel[0], subsamplingLevel[1], subsamplingLevel[2] );
    SbVec3i32 numVoxels = getNumVoxels( realSizeI32, subsamplingLevelI32 );
    return SbVec3s( (short)numVoxels[0], (short)numVoxels[1], (short)numVoxels[2] );
  };
SoDEPRECATED
  SbVec3s getSizeToAllocate( const SbVec3s& realSize, const SbVec3s& subsamplingLevel )
  {
    SbVec3i32 realSizeI32( realSize[0], realSize[1], realSize[2] );
    SbVec3i32 subsamplingLevelI32( subsamplingLevel[0], subsamplingLevel[1], subsamplingLevel[2] );
    SbVec3i32 size = getSizeToAllocate( realSizeI32, subsamplingLevelI32 );
    return SbVec3s( (short)size[0], (short)size[1], (short)size[2] );
  };
SoDEPRECATED
  virtual void getSubSlice( const SbBox2s& subSlice, int sliceNumber, void * data )
  {
    SbBox2i32 subSliceI32( subSlice.getMin()[0], subSlice.getMin()[1], subSlice.getMax()[0], subSlice.getMax()[1] );
    getSubSlice( subSliceI32, sliceNumber, data );
  };
SoDEPRECATED
  virtual SbBool getSubVolume( const SbBox3s& subVolume, void * data );
SoDEPRECATED
  virtual SbBool getSubVolume( const SbBox3s& subVolume, const SbVec3s& aSL, void *& data );
SoDEPRECATED
  virtual SbBool getSubVolumeInfo( const SbBox3s& subVolume, const SbVec3s& rSL, SbVec3s& aSL, SoVolumeReader::CopyPolicy& policy);
SoDEPRECATED
  virtual SbBool readTile( int index, unsigned char*&buffer, const SbBox3s& tilePosition );

#endif 
#if 1             SoDEPRECATED
  virtual void getNextSlice( int SO_UNUSED_PARAM(sliceNumber), void * SO_UNUSED_PARAM(data) ) {};
SoDEPRECATED
  virtual void skipSlice( int SO_UNUSED_PARAM(numSlices) ) {};
SoDEPRECATED
  virtual void end( ) {};

#endif 
#if 1             SoDEPRECATED
  virtual SbBool readTile(int SO_UNUSED_PARAM(index), unsigned char*& SO_UNUSED_PARAM(buffer), const SbBox3i32& SO_UNUSED_PARAM(tilePosition)) { return FALSE; }
SoDEPRECATED
  virtual SbBool readTile(int index, SoBufferObject *buffer, const SbBox3i32& tilePosition);

#endif 
#if 1             SoDEPRECATED
  inline int getNumTimeSteps()
  { return 1; };
SoDEPRECATED
  void setCurrentTimeStep( int  )
  { };
SoDEPRECATED
  inline int getCurrentTimeStep() const
  { return 0;}
SoDEPRECATED
  virtual SbBool getSubVolumeInfo(
    const SbBox3i32& subVolume,                 // in: bounds of subvolume (brick)
    const SbVec3i32& requestedSubsampleLevel,   // in: subsample level VolViz needs
    SbVec3i32& actualSubsampleLevel,            // out : subsample level reader returns.
    SoVolumeReader::CopyPolicy& policy          // out : copyPolicy
    );
SoDEPRECATED
  virtual SbBool getSubVolume(
    const SbBox3i32& subVolume,               // in: bounds of subvolume (brick)
    const SbVec3i32& actualSubsampleLevel,    // in: reader subsample
    void *& data
    );
SoDEPRECATED
  virtual int getBorderFlag()
  {return -1;}

#endif 
#if 1             SoDEPRECATED
  virtual SbBool getMinMax(int& min, int& max);

#endif 
private:
  //for volume having a series of data per datum
  //used by ReservoirViz. The converter asks the eclipse reader for the datum.
  //not used in vviz which uses getDataChar(...type...). (must keep for compatibility reasons).
  virtual ReadError getDataChar( SbBox3f &size, std::vector<SoDataSet::DatumElement>& datum, SbVec3i32 &dim );

  void lockFileMutex();
  void unlockFileMutex();
  void setNumSubsampledTiles(int num){m_numSubsampledTiles = num;};
  void convert( SoDataSet::DataType typeIn , SoBufferObject* bufferIn,
                SoDataSet::DataType typeOut, SoBufferObject* bufferOut, int size, SbBool shiftData = true);

  void convertDataRange( bool doRange, double min, double max );

  virtual int getNumBytesPerDatum();

  virtual bool isLDMReader() { return false; }
  virtual bool isVolumeMaskReader() { return false; }

  virtual bool hasDeadCell() { return false; }

  virtual bool isDead(int i,int j,int k);

  virtual uint8_t* getCellGridState() { return NULL; }

  virtual int getNbCell() { return 0; }

  virtual uint64_t getTileSizeFromFid(int fileId);// Virtual method, only used
                                                  // by resviz for now

  bool hasPerTileMinMaxComputed() const;

#if 1             SoDEPRECATED
  void convert( SoDataSet::DataType typeIn , void* bufferIn,
                SoDataSet::DataType typeOut, void* bufferOut, int size, SbBool shiftData = true);

#endif 
 private: protected:

  static bool registerVolumeReaderExtension(const SbString& fileExtension, const SoType& readerType);

  static bool unregisterVolumeReaderExtensions(const SoType& readerType);

  virtual ~SoVolumeReader();

  void *getBuffer(int64_t offset, unsigned int size);

  // Convenient methods

  int bytesToInt( unsigned char *ptr, int sizeBytes );

  void swapBytes( int *intPtr, int sizeBytes );

  void swapBytesN( void *buffer, int numElements, int numBytesPerElement );

  SbBool isValidFloat( const float val );

  int64_t fileSize();

#if 1             SoDEPRECATED
  SbBool m_dataConverted;

#endif 
  //------------------------------------------------------------------------------
#ifndef HIDDEN_FROM_DOC
  SbString m_filename;

#endif // HIDDEN_FROM_DOC


  static SbBox3f adjustFlatExtent(const SbString& fileName, const SbBox3f& extent, const SbVec3i32& dim);

private:

  //if true, try to detect automatically whether the coord sys is diret or not.
  //default is true
  SbBool m_directCoordSysAutoDetect;
  //has the data been stored using a direct coordinate system?
  //default is true
  SbBool m_directCoordSys;

  std::vector<SoDataSet::DatumElement> m_datum;
  int m_bytesPerVoxel;

  double m_rangeMin, m_rangeMax;
  bool   m_doRange;

  //True if header has already been read
  SbBool m_headerRead;

  CoordinateType m_coordinateType;
  std::vector<float> m_rectilinearCoordinates[3];

  SbBool       m_ignoredFile;

private:
  SbBool       m_isRGBA;
  int          m_numSubsampledTiles;
  SbBool       m_useFMM;
  void        *m_filehandle;
  int          m_filedesc;
  int64_t      m_filesize;
  void        *m_fmmdata;
  int64_t      m_fmmoffset;
  unsigned int m_fmmsize;

  void releasefmm();
  void bestmap(int64_t);

  SbThreadMutex* m_fileMutex;

  // keep a map of readerType <-> extension association
  typedef std::map<SbString,SoType> SoVolumeReaderExtensionAssociationMap;
  static SoVolumeReaderExtensionAssociationMap s_volumeReaderExtensionAssociation;
  
  // Convert range from input type to given TypeOut type.
  template <typename TypeInt, typename TypeOut>
  void convert_range(int size, void* bufferIn,  void* bufferOut, int64_t outMin, int64_t outMax);

  // Convert float input type to any supported type
  template <typename TypeOut>
  void convert_out(int size, void* bufferIn,  void* bufferOut, int64_t outMin, int64_t outMax);

  // Convert any input type to float output
  template <typename TypeIn>
  void convert_in(int size, void* bufferIn,  void* bufferOut, int64_t outMin, int64_t outMax);

};

inline SbBool
SoVolumeReader::readXTraceInTile(int , unsigned char*& , const SbBox3i32& , const SbVec2i32& )
{
  return FALSE;
}

inline SbBool
SoVolumeReader::readXSliceInTile(int , unsigned char*& , const SbBox3i32& , const uint32_t& )
{
  return FALSE;
}

inline SbBool
SoVolumeReader::readYSliceInTile(int , unsigned char*& , const SbBox3i32& , const uint32_t& )
{
  return FALSE;
}

inline SbBool
SoVolumeReader::getMinMax(int& , int& )
{
  return FALSE;
}

inline SbBool
SoVolumeReader::getMinMax(int64_t &, int64_t &)
{
  return FALSE;
}

inline SbBool
SoVolumeReader::isIgnoredFile() const
{
  return m_ignoredFile;
}

inline SbBool
SoVolumeReader::getMinMax(double & , double & )
{
  return FALSE;
}

inline SbBool
SoVolumeReader::getHistogram(std::vector<int64_t>&)
{
  return FALSE;
}

inline SbBool
SoVolumeReader::setDirectCoordSysAutoDetection(SbBool)
{
  return FALSE;
}

inline SbBool
SoVolumeReader::getDirectCoordSysAutoDetection()
{
  return m_directCoordSysAutoDetect;
}

inline SbBool
SoVolumeReader::setDirectCoorSys(SbBool)
{
  return FALSE;
}

inline SbBool
SoVolumeReader::getDirectCoordSys()
{
  return m_directCoordSys;
}

inline bool
SoVolumeReader::isDead(int, int, int)
{
  return false;
}

inline uint64_t
SoVolumeReader::getTileSizeFromFid(int)
{
  return 0;
}

#ifdef _MSC_VER
#pragma warning( pop )
#endif

#endif // _SO_VOLUME_READER_

---

Open Inventor Toolkit reference manual, generated on 12 Feb 2024
Copyright © Thermo Fisher Scientific All rights reserved. http://www.openinventor.com/