LDM/converters/SoConverter.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 (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* ) {};
  virtual void  outputTileBefore( int fileTileIndex, int dataSize, void *data, bool 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, int dataSize, void *data, bool i = false );
  void printTime();
  int buildLevelMax();
  void outputTile( int fileTileIndex, int 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, int 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 void
SoConverter::outputTileBefore( int , int , void *, bool )
{
}

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_

---

Open Inventor Toolkit reference manual, generated on 15 Mar 2023
Copyright © Thermo Fisher Scientific All rights reserved. http://www.openinventor.com/