SoConverter.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 (Apr 2003)
**=======================================================================*/
 
#ifndef _SO_BASE_CONVERTER_
#define _SO_BASE_CONVERTER_
 
#ifdef _MSC_VER
#pragma warning( push )
#pragma warning(disable:4251)
#endif
 
 
#include <LDM/nodes/SoDataSet.h>
#include <Inventor/STL/vector>
#include <Inventor/SbBox.h>
#include <Inventor/SbPList.h>
 
#include <Inventor/threads/SbThreadMutex.h>
 
#include <LDM/readers/SoLDMReader.h>
#include <LDM/compressors/SoDataCompressor.h>
 
class SoLDMTopoOctree;
class ScJob;
class SoVolumeHistogram;
class SiBitFile;
class SoDataCompressInfo;
class SoPerfCounterManager;
class SoConverterParameters;
 
class  SoConverter {
 
public:
 
  virtual ~SoConverter();
 
  enum ConverterError{
    CVT_FINISHED_WITH_WARNINGS  = 1,
    CVT_NO_ERROR                =  0,
    CVT_INPUT_PARAMS_PROBLEM    = -1,
    CVT_FILE_EXT_UNKNOWN        = -2,
    CVT_CANT_OPEN_INPUT_FILE    = -3,
    CVT_CANT_CREATE_DATA_FILE   = -4,
    CVT_CANT_CREATE_HEADER_FILE = -5,
    CVT_NOT_ENOUGH_DISK_SPACE   = -6,
    CVT_CANT_READ_INPUT_FILE    = -7,
    CVT_ABORTED                 = -9,
    CVT_NOT_INITIALIZED         = -10,
    CVT_NO_NODE                 = -998,
    CVT_NO_LDM_LICENSE          = -999
  };
 
  int convert( SoConverterParameters* parameters = NULL);
 
  void setXmlCallback( void (*xmlCB)( FILE*, void * userData ), void * userData );
 
#if 1             SoDEPRECATED
  int convert( int argc, char ** argv);
SoDEPRECATED
  int convert( const SbStringList& arguments );
 
#endif 
private:
 
  enum MessageType{
    INIT = 1,
    BUILD_SLAB,
    BUILD_LEVEL,
    CLEAR
  };
 
  char*     m_slabBuffer;
  SbVec3i32 m_slabBufferDim;
  int64_t   m_subSliceSize;
 
  //statistics
  SoVolumeHistogram* m_stat;
  double             m_min, m_max;
  std::vector<int64_t>    m_numValues;
  std::vector<double>     m_values;
 
  int                m_numTilesGenerated;
  float              m_progress;
 
  struct Stat{
    double  value;
    int64_t numValues;
  };
 
  void checkProgress();
 
 
  //data information
  int                    m_dataSize;
 
  //routines
  ConverterError init();
 
  char* allocateSlabBuffer(int& _numTilesOnYAxis, SbVec3i32& _slabBufferDim, int64_t& _subSliceSize);
  int   buildSlab2Level(SbBox3i32& slabBox, char*& slabBufferPtr, void* parentTile, void** octantTile,SbVec3i32& slabBufferDim, int64_t subSliceSize, std::vector<int>& fileIDsBuilt);
  void  buildLevel(std::vector<int>&, int, int fromFileID = -1, int toFileID = -1);
  int   initializeFiles( int argc, char ** argv );
  int   initializeFiles( SoConverterParameters* parameters );
 
  int   writeSubVolume( const SbBox3i32 & subVolume, const void * data, SbBool doLowerResolution = TRUE, SbBool doOverlappingTiles = TRUE );
  int   writeTile( const SoLDMTileID & tileID, void * data );
 
  int   writeSubVolume( const SbBox3i32 & subVolume, SoBufferObject* data, SbBool doLowerResolution = TRUE, SbBool doOverlappingTiles = TRUE );
  int   writeTile( const SoLDMTileID & tileID, SoBufferObject* data );
 
  const SoLDMTopoOctree* getTopo() { return m_LDMTopo; };
  int   finalizeFiles( int retCode = 0 );
  int   buildLevels( int fromLevel, int numLevels );
 
  void * m_fout;
  SoConverterParameters* getParameters();
  void updateFileCompletion(std::vector<int>& fileIDs);
 
  std::vector<SoDataSet::DatumElement> m_datum;
  bool                   m_isDataFloat;
  bool                   m_isDataSigned;
  size_t                  m_tileSize;
  int                    m_numSigBits;
 
private: protected:
  SoVolumeReader* m_reader;
 
  SoConverter();
 
  virtual void getSubSlice( const SbBox2i32& subSlice, int sliceNumber, void * data ) = 0;
 
  //error returned : 0 = ok, 1 = pb = return
  virtual SbBox3f getSize(int& error) = 0;
  virtual std::vector<SoDataSet::DatumElement> getDatum(int& error) = 0;
  virtual SbVec3i32 getDimension(int& error) = 0;
  virtual int getRange( double & rangeMin, double & rangeMax) = 0;
  virtual SoVolumeHistogram* getHistogram();
  virtual std::vector<SbVec2d>& getTileMinMax(int numTiles);
  virtual void closeInputFileHandles();
 
  virtual void  sampleTile ( const SbVec3i32& tileDim, int border, const void* const octantTile[8], const int octantExists[8], void* parentTile ) = 0;
  virtual void  buildTile  ( SbBox3i32& slabBox, SbVec3i32& slabBufferDim, void* slabBuffer, SbVec3i32& tileOrigin, void* tileBuffer );
          void  buildTile  ( const SbBox3i32& subVolume, const void* subVolumeBuffer, const SbBox3i32& tilePos, void* tileData, const SbBox3i32& intersection );
  virtual void  outputHeader( FILE* ) {};
 
#if 1             SoDEPRECATED
  virtual void  outputTileBefore(int SO_UNUSED_PARAM(fileTileIndex), int SO_UNUSED_PARAM(dataSize),
                                 void* SO_UNUSED_PARAM(data), bool SO_UNUSED_PARAM(dataInverted))
  {}
 
#endif 
  virtual void  outputTileBefore(int SO_UNUSED_PARAM(fileTileIndex), size_t SO_UNUSED_PARAM(dataSize),
                                 void* SO_UNUSED_PARAM(data), bool SO_UNUSED_PARAM(dataInverted))
  {}
 
  virtual void  startConversion(){};
  virtual void  endConversion(){};
 
  virtual bool updateDataFile() { return true; }
  virtual int getSpecificOffset(bool aligned = true ) { return !aligned; }      // dummy return to avoid compilation warning
  virtual SbString getOriginalFilename() const;
  virtual void setOriginalFileName(const SbString& originalFileName);
 
 
 
  enum Abort {
    CVT_CONTINUE,
    CVT_ABORT
  };
 
  enum SampleType
  {
    DECIMATION,
    AVERAGE
  };
 
  virtual Abort progress( int numTilesGenerated, int numTilesToGenerate );
 
  ConverterError  buildHeader( const SbString&, bool conversionDone = false);
 
  virtual void outputDataType(FILE* fout);
 
  SbBox3f          m_volumeSize;
 
  void inputTile( int fileTileIndex, size_t dataSize, void *data, bool i = false );
  void printTime();
  int buildLevelMax();
  void outputTile( int fileTileIndex, size_t dataSize, void*, bool i = false );
 
  void printCompressionInfos();
 
  void (*m_xmlCB)( FILE*, void* );
  void  *m_xmlCBUserData;
  SoLDMTopoOctree *m_LDMTopo;
 
  //files info
  int64_t   m_filesize;//final data file size
  int64_t   m_compressedFilesize;//final compressed file size
  SbString  m_fileCompletion; //file completion
  SbString  m_fileCompletionName;
  SbString m_fileExt;
 
  //data info
  int              m_pid;
  int              m_levelMax;
  bool             m_thinDataSet;
  SbVec3i32        m_volumeDimension;
 
 
  // progress
  int              m_numTilesToGenerate;
  bool             m_abort;
  int  getNumTileToGenerate(SbBox3i32& slabBox);
  SiBitFile* m_bitFile;
 
  //Compression
  SoDataCompressor *m_ldmCompressor;
  int64_t m_sizeOfTileIndex;
  char m_compressionType[256];
  SoDataCompressInfo* m_lastWrittenCompressInfo;
 
 
  bool       m_fromInitializeFiles;
 
  //file completion
  void writeTileComplete(int fileID, bool writeHeader = false);
 
  //abort function
  void abortConversion();
 
  void readSlab(SbBox3i32& slabBox, char*& slabBufferPtr,int64_t subSliceSize);
 
  // Define the algorithm used for downsampling
  SampleType m_sampleType;
 
 
  // type dependent vars/macros
  static const char *m_dataTypeStr[];
  static const char *m_dataTypeXml[];
  int              m_currentWordFormat;
 
  // Performance counter manager
  SoPerfCounterManager *m_perfManager;
  SoConverterParameters* m_parameters;
  SbString m_originalFileName;
 
  virtual void adjustParameters() {};
  virtual void handleCustomTags(FILE*) {};
 
  std::vector<SbVec2d> m_tileMinMax;
 
  bool isFastUpdate();
 
  SoConverter::ConverterError m_statusAdjustParameters;
 
private:
  bool m_userDefinedParameters;
  int64_t getCrc32(void* data, size_t dataSize, const SoDataCompressor::TileInfo& ti);
  void usage();
  template <typename T> void fillTile(void* ptrDst, int size, void* value );
 
  template <typename T> void fillTileWithSingleValue(void* ptrDst, int size, T value );
 
  SoConverter::ConverterError outputMinMaxInfos(FILE* fout);
 
  void computeLowResMinMax(const SoLDMTileID& tileId);
 
  bool m_bComplFileAlreadyExists;
 
  void buildTileFast(int fileID, void* tileData, const SbVec3i32& tileOrigin);
 
  static SbThreadMutex s_classMutex;
 
  static bool s_doFastUpdate;
};
 
inline SoConverterParameters*
SoConverter::getParameters()
{
  return m_parameters;
}
 
inline SbString 
SoConverter::getOriginalFilename() const
{
  return m_originalFileName;
}
 
inline void
SoConverter::setOriginalFileName(const SbString& originalFilename) 
{
  m_originalFileName = originalFilename;
}
 
#ifdef _MSC_VER
#pragma warning( pop )
#endif
 
#endif //_SO_BASE_CONVERTER_