LDM/readers/SoLDMReader.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      : 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;

// abstract class for LDM reader
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 );

  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 ReaderType getReaderType (){return LDM;};

  virtual SoVolumeWriter* getConfiguredWriter();

  virtual int handleHeader(TiXmlElement *) {return LDM_NO_ERROR;} ;

  virtual SbBool isThreadSafe() const;

  virtual SbVec2d getTileMinMax( int fileId ) const;

#if 1             SoDEPRECATED
  virtual SbBool getTileSize(SbVec3s& size);

#endif 
#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 );

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;
  SbBool m_HeaderRead;

  //Compression
  bool m_useCrc32;
  SoType m_compressType;
  size_t m_compressLevel;
  size_t m_numTileInfos;
  SoDataCompressInfo* m_compressInfos;

  // Some preference info
  SbBool m_ldmUseInMemCompression; 

  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 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 *)
{
}

#if 1             
inline SbBool
SoLDMReader::getMinMax(int & , int & )
{
  return FALSE;
}
#endif 
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

---

Open Inventor Toolkit reference manual, generated on 22 Jul 2025
Copyright © Thermo Fisher Scientific All rights reserved. http://www.openinventor.com/