SoLDMReader.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      : VSG (MMM YYYY)
**=======================================================================*/
 
 
#ifndef _LDM_READER_
#define _LDM_READER_
 
#include <LDM/nodes/SoDataSet.h>
#include <Inventor/STL/vector>
#include <Inventor/threads/SbThread.h>
#include <LDM/readers/SoVolumeReader.h>
#include <LDM/xml/SbXmlTag.h>
 
#ifdef _MSC_VER
#pragma warning( push )
#pragma warning(disable:4251)
#endif
 
class TiXmlElement;
class SbThreadMutex;
class SiBitFile;
class SoDataCompressor;
class SoDataCompressInfo;
 
class  SoLDMReader : public SoVolumeReader
{
  SO_FIELDCONTAINER_HEADER(SoLDMReader);
 
public:
  using SoVolumeReader::getDataChar;
  using SoVolumeReader::getSubSlice;
  using SoVolumeReader::readTile;
 
  enum SoLDMError{
    LDM_NO_ERROR,
    LDM_FILE_NOT_FOUND,
    LDM_XML_ROOT_START_TAG_NOT_FOUND,
    LDM_XML_ROOT_END_TAG_NOT_FOUND,
    LDM_ALTERNATE_FILE_NOT_FOUND,
    LDM_XML_PARSING_ERROR,
    LDM_SIZE_TAG_MISSING,
    LDM_COMPLETION_FILE_NOT_FOUND,
    LDM_RD_NO_ERROR,
    LDM_RD_FILE_NOT_FOUND_ERROR,
    LDM_RD_UNSUPPORTED_DATA_TYPE_ERROR,
    LDM_RD_UNKNOWN_ERROR
  } ;
 
  SoLDMReader();
 
  virtual SbBox3f getSize();
  virtual SbVec3i32 getDimension();
  virtual SbBool getTileSize(SbVec3i32& tile);
 
  //not used in vviz. used on resviz because the geom is not implicit anymore.
  virtual SbBool getBbox(int fileId, SbBox3f& box);
 
  //not used in vviz. used on resviz because the geom is not implicit anymore.
  virtual SbBool getCenter(int fileId, SbVec3f& center);
 
  virtual ReadError getDataChar( SbBox3f &size, SoDataSet::DataType &type,  SbVec3i32 &dim ) override;
 
  void getSubSlice( const SbBox2i32& subSlice, int sliceNumber, void * data );
 
  virtual SoBufferObject* readTile(int index, const SbBox3i32& tilePosition);
 
  virtual SbBool readXTraceInTile(int index, unsigned char*& buffer, const SbBox3i32& tilePosition, const SbVec2i32& tracePosition);
 
  virtual SbBool readXSliceInTile(int index, unsigned char*& buffer, const SbBox3i32& tilePosition, const uint32_t& slicePosition );
 
  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 getMinMax(int64_t & min, int64_t & max);
 
  virtual SbBool getMinMax(double & min, double & max);
 
  virtual SbBool getHistogram(std::vector<int64_t>& numVox);
 
  virtual bool isLittleEndian();
 
  virtual SbString getOriginalFilename() const;
 
  virtual SbXmlTag getXmlTag( const char * tagName );
 
  virtual SoVolumeReader::ReaderType getReaderType (){return LDM;};
 
  virtual SoVolumeWriter* getConfiguredWriter();
 
  virtual int handleHeader(TiXmlElement *) {return LDM_NO_ERROR;} ;
 
  virtual SbBool isThreadSafe() const;
 
  virtual SbVec2d getTileMinMax( int index ) const;
 
#if 1             SoDEPRECATED
  virtual int getBorderFlag();
 
#endif 
#if 1             SoDEPRECATED
  virtual SbBool readTile(int index, unsigned char*&buffer, const SbBox3i32& tilePosition);
 
#endif 
#if 1             SoDEPRECATED
  virtual SbBool getMinMax(int & min, int & max);
 
#endif 
 private:
 
  virtual std::vector<SoDataSet::DatumElement> getDatumDescription();
 
  int  getNumBytesPerDatum();
 
  virtual bool isLDMReader() { return true; }
 
  virtual bool isVolumeMaskReader() { return false; }
 
  virtual unsigned char* getHoleData();
 
  SiBitFile* getFileCompletion();
 
  SoLDMError getLastErr() { return m_lastError; };
 
  //Return the default size of a tile (64x64x64)
  static const SbVec3i32 &getDefaultTileDim() { return DEFAULT_TILE_DIM; }
 
  SbBool getCell8to1() {
    return m_cell8to1;
  }
 
#if 1             SoDEPRECATED
  const SbVec2d& getMinMax(int fileId) const;
SoDEPRECATED
  bool hasPerTileMinMax() const;
#endif 
  virtual double getUndefinedValue() const;
 
  virtual double getDefaultValue() const;
 
  virtual void* getSpecificHeader() { return NULL; }
 
  virtual uint64_t getTileSizeFromFid(int fileId);
 
  virtual void closeAllHandles();
 
  virtual void restoreAllHandles();
 
  virtual bool isDataSetBitSet();
 
  virtual void setTileDimPow2Forced( bool flag );
 
  virtual SbBool isDataConverted() const
    { return TRUE; }
 
  virtual void reloadTileMinMax();
 
  virtual bool hasUndefValue();
 
  virtual bool hasDefaultValue();
 
  virtual SoType getCompressionType() const;
 
  virtual size_t getCompressionLevel() const;
 
  virtual bool useCRC32() const;
 
  // Internal use only. Return true if reader has an histogram (check m_entries size).
  virtual SbBool hasHistogram();
 
  virtual void saveCustomsTags(FILE*) {}
 
  void setHeaderDirty( bool headerDirty );
 
  void setTileCachePolicy( SoLDMResourceParameters::TileCachePolicy tileCachePolicy );
 
private:
  virtual ~SoLDMReader();
 
  SoLDMError m_lastError;
  int m_makeFakeData;
  int m_levelMax;
 
  bool readXmlHeader(int& errorCode);
 
  static const SbVec3i32 DEFAULT_TILE_DIM;
  SbVec3i32 m_tileSize;
  int m_border;
  double m_defaultValue;
 
  SbBool m_cell8to1;
  int m_compression;
  SbBox3f   m_size;
  SbVec3i32 m_dim;
 
  unsigned char* m_hole;
 
  //Compression
  bool m_useCrc32;
  SoType m_compressType;
  size_t m_compressLevel;
  size_t m_numTileInfos;
  SoDataCompressInfo* m_compressInfos;
 
  SbString m_alternateFileName;
  SbString m_completionFileName;
  SbString m_originalFile;
 
  bool hasCompletionFile() const { return m_hasCompletionFile; }
 
  size_t m_compressionIndexArraySize;
  unsigned int *m_compressionIndexArray;
 
  struct Descriptor {
    FILE*         file;
    SiBitFile*    completion;
    SbThreadId_t  threadID;
    SoDataCompressor *compressor;
  };
  std::vector<Descriptor*> m_descriptors;
  Descriptor* getDescriptor( SbThreadId_t id, bool forceBuffering = false );
 
  SbThreadMutex* m_ldmFileMutex;
 
  SbBool getFakeData(int index, unsigned char*&buffer, const SbBox3i32& tilePosition);
 
  SbBool getFakeDataGeom(int index, unsigned char*&buffer, const SbBox3i32& tilePosition);
 
  double getFakeValue( const SbBox3i32& tilePosition);
 
  /* These three function have been added to handle specific header
   * managed by specific reader
   */
 
  // Read the specific header from file
  virtual void readSpecificHeader(FILE*) {};   // No name for parameter to avoid compilation warning
                                               // parameter is the name of the file currently read
 
  // Flag to determine if the specific header has already
  // been read
  virtual bool isSpecificHeaderRead() { return true; }
 
  // get the specific offset from the specific header. This offset
  // represent the amount of data added by specific reader at the beginning
  // of the LDM file
  virtual int getSpecificOffset(bool aligned = true) { return !aligned; }
 
  void* m_xmlDoc;
  void* m_xmlRoot;// a son can parse header from m_xmlRoot
 
  bool m_littleEndian;
  bool m_headerDirty;
 
  void oldUncompress(FILE* dataFile, int64_t compressedSize, size_t tileSize, char* buffer);
  void oldGetOffsetAndSize(int index, int64_t& compressedSize, int64_t& offset);
 
  void uncompressTile(Descriptor* desc, int64_t compressedSize, size_t tileSize, char* buffer);
  void getOffsetAndSize(Descriptor* compressor, int index, int64_t& compressedSize, int64_t& offset);
  void checkCrc32(char* buffer, int tileIndex, size_t tileSize);
 
private:
  enum DebugBorderMode
  {
    NORMAL_BORDERS = 0,
    MARK_BORDERS = 1,
    ONLY_BORDERS = 2
  };
 
 
  void internalInit();
 
  template<typename T> void getFakeDataNoise(void* buffer, const SbBox3i32& tilePosition);
 
  void visibleBorder(unsigned char* buffer);
 
  void readBorderOnly(unsigned char* buffer);
 
  void readTileMinMax(TiXmlElement *s);
 
  void extractUndefValue(TiXmlElement* element);
 
  std::vector<SbVec2d> m_tileMinMax;
 
  double m_undefValue;
 
  bool m_hasUndefValue;
 
  bool m_hasDefaultValue;
 
  bool m_fakeDataNoise;
  unsigned int m_fakeDataNumOctaves;
  float m_fakeDataPersistence;
 
  static DebugBorderMode s_debugBorders;
 
  bool m_hasCompletionFile;
  SbBool m_hasAlternateFile;
 
  // Specific flag to handle bitset dataset
  bool m_bIsBitSetDataSet;
 
  bool m_forcePow2TileDim;
 
  // Used only with a fake uniform reader
  // return fake uniform value based on topoOctree and fileId
  // Should return same value as getFakeValue( const SbBox3i32& tilePosition)
  double getFakeValueBasedOnTopoOctree( const int fileId );
 
  // Used only with a fake uniform reader
  // TopoOctree only used by getFakeValueBasedOnTopoOctree
  SoLDMTopoOctree m_topoOctree;
 
  SoLDMResourceParameters::TileCachePolicy m_tileCachePolicy;
 
  // Used to restore internal path after filename has been changed
  // mainly used be edition 
  void resetInternalPath();
};
 
/*******************************************************************************/
inline SbBool
SoLDMReader::getBbox(int , SbBox3f& )
{
  return FALSE;
}
 
inline SbBool
SoLDMReader::getCenter(int , SbVec3f& )
{
  return FALSE;
}
 
inline void
SoLDMReader::getSubSlice( const SbBox2i32& , int , void *)
{
}
 
inline SbBool
SoLDMReader::getMinMax(int & , int & )
{
  return FALSE;
}
 
inline SbBool
SoLDMReader::getMinMax(int64_t & , int64_t & )
{
  return FALSE;
}
 
inline
SbBool SoLDMReader::getMinMax(double & , double & )
{
  return FALSE;
}
 
inline SbBool
SoLDMReader::getHistogram(std::vector<int64_t>& )
{
  return FALSE;
}
 
inline SbBool
SoLDMReader::hasHistogram()
{
  return FALSE;
}
 
inline void
SoLDMReader::setHeaderDirty( bool headerDirty )
{
  m_headerDirty = headerDirty;
}
 
inline uint64_t
SoLDMReader::getTileSizeFromFid(int)
{
  return 0;
}
 
inline void
SoLDMReader::setTileDimPow2Forced( bool flag )
{
  m_forcePow2TileDim = flag;
}
 
#ifdef _MSC_VER
#pragma warning( pop )
#endif
 
#endif