SoVolumeReader.h

/*=======================================================================
 *** 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-2023 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);
 
  virtual void getSubSlice( const SbBox2i32& subSlice, int sliceNumber, SoBufferObject * dataBuffer);
 
   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 void reloadTileMinMax() {};
 
  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;
 
  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 index ) const;
 
  enum ReaderType {
    NO_READER,
    AM,
    AVS,
    DICOM,
    GENERIC,
    LDM,
    MEMORY,
    RASTERSTACK,
    SEGY,
    VOL,
    VOX,
    TIFF,
    MRC
  };
 
  virtual SoVolumeReader::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 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
  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 convert( SoDataSet::DataType typeIn , SoBufferObject* bufferIn,
                SoDataSet::DataType typeOut, SoBufferObject* bufferOut, size_t size, SbBool shiftData = true);
 
  void convertDataRange( bool doRange, double min, double max );
 
  virtual int getNumBytesPerDatum();
 
  // number of bytes in a voxel
  // uses DataType if getNumBytesPerDatum() returns 0
  int getDataSize();
 
  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();
 
#if 1             SoDEPRECATED
  void convert( SoDataSet::DataType typeIn , void* bufferIn,
                SoDataSet::DataType typeOut, void* bufferOut, size_t size, SbBool shiftData = true);
 
#endif 
  virtual SoVolumeReader* getInternalReader() const
  {
    return const_cast<SoVolumeReader*>(this);
  }
 
 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
 
  static int bytesToInt(const unsigned char* ptr, int sizeBytes);
 
  static void swapBytes( int *intPtr, int sizeBytes );
 
  static void swapBytesN( void *buffer, int numElements, int numBytesPerElement );
 
  static 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;
 
SoINTERNAL private:
  // Used to guard the buffer obtained by calling getBuffer()
  SbThreadMutex* m_fmmMutex;
 
private:
  SbBool       m_isRGBA;
  SbBool       m_useFMM;
  void        *m_filehandle;
  int          m_filedesc;
  int64_t      m_filesize;
  void        *m_fmmdata;
  int64_t      m_fmmoffset;
  unsigned int m_fmmsize;
  bool m_hasPerTileMinMaxComputed;
 
  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(size_t 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(size_t size, void* bufferIn,  void* bufferOut, int64_t outMin, int64_t outMax);
 
  // Convert any input type to float output
  template <typename TypeIn>
  void convert_in(size_t 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_