SoConverterParameters.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      : VSG3D (Jun 2009)
**=======================================================================*/
 
 
#ifndef _SO_BASE_CONVERTER_PARAMETERS
#define _SO_BASE_CONVERTER_PARAMETERS
 
#ifdef _MSC_VER
#pragma warning( push )
#pragma warning(disable:4251)
#endif
 
#include <Inventor/STL/vector>
#include <Inventor/SbBox.h>
#include <Inventor/SbPList.h>
#include <LDM/compressors/SoDataCompressor.h>
#include <Inventor/helpers/SbFileHelper.h>
 
class  SoConverterParameters {
 
public:
  
  enum SampleType
  {
    DECIMATION,
    AVERAGE
  };
 
  enum ParametersError
  {
    PARAM_NO_ERROR =  0,
    PARAM_ERROR    = -1
  };
 
  
  SoConverterParameters( );
 
  virtual ~SoConverterParameters();
 
  static SoConverterParameters* create( int argc, char** argv );
 
  static SoConverterParameters* create( const SbStringList& arguments );
 
  void setVerbose( const bool isVerbose );
 
  bool isVerbose() const;
 
  void setTileDim( const int tileDim );
 
  void setTileDim(const SbVec3i32& tileDim);
 
  SbVec3i32 getTileDim() const;
 
  void setHeaderFileName( const SbString& headerFileName );
 
  SbString getHeaderFileName() const;
 
  void setDataFileName( const SbString& dataFileName );
 
  SbString getDataSectionFileName() const;
 
  SbString getDataFileName() const;
 
  void setInputFileName( const SbString& inputFileName );
 
  SbString getInputFileName() const ;
 
  void setInputVolume(SoDataSet* inputVolume);
 
  SoDataSet* getInputVolume() const;
 
  bool setMaxMemory( int maxMemory );
 
  int getMaxMemory() const;
 
  void setOutputHeaderOnly( bool headerOnly );
 
  bool getOutputHeaderOnly() const;
 
  bool setOutputDataFormat( const SbString& dataFormat );
 
  bool setOutputDataFormat( const SoDataSet::DataType& dataType);
 
  SoDataSet::DataType getOutputDataFormat() const;
 
  bool setTargetWordFormat(int wordFormat);
 
  int getTargetWordFormat() const;
  
  bool setInputRangeMinMax( double min, double max );
 
  void getInputRangeMinMax( double& min, double& max ) const;
 
  bool setCompressionName( const SbString& compressionName );
 
  void setCompressionLevel (int compressionLevel );
  
  void setCrcCheck (bool addCrcCheck );
 
  SbString getCompressionName() const;
 
  /*
   * Returns compression level.
   */
  int getCompressionLevel() const;
 
  /*
   * Returns CRC check setting.
   */
  bool isCrcCheckDone () const;
 
  /*
   * Returns true if using default compression level.
   */
  bool useDefaultCompLvl() const;
 
  bool setLowResAlgorithm( int lowResAlgorithm );
 
  SampleType getLowResAlgorithm() const;
 
  int getPondCoef() const;
 
  void setUndefinedValue(double undefinedValue);
 
  double getUndefinedValue() const;
 
  int getNbArgs() const;
 
   bool isOutputDataTypeSpecified() const;
 
  bool isInputDataRangeSpecified() const;
 
  void setRGBAMode(const bool flag);
 
  bool isRGBAMode() const;
 
  void enableHistogram(const bool flag);
 
  bool isHistogramEnabled() const;
 
  bool isSavedAsBitSet() const;
 
  void saveAsBitSet( bool flag, double  bitsetThreshold = 0);
 
  double getBitSetThreshold() const;
 
  void setBitSetThreshold( double bitsetThreshold );
 
  void doUpdate ( bool value );
 
  bool isForUpdate() const;
 
  void setVerticalFlip(bool flag);
 
  bool isVerticalFlip() const;
 
private:
 
  SbStringList* getArgListAsSbString() const;
 
  bool isForEditing() const;
  void setIsForEditing(bool flag);
  void setDefaultValue(double value);
  double getDefaultValue() const;
  bool isTileDimDefault();
  bool isRGBAModeDefault() const;
  void setIsFromWriter( bool flag );
  bool isFromWriter() const;
  bool recomputeHistogram() const;
  void enableRecomputeHistogram(bool flag);
 
  void enableTileMinMax(const bool flag);
 
  bool isTileMinMaxEnabled() const;
 
private: protected:
 
  bool      m_verboseMode;
  bool      m_outputDataTypeSpecified;
  bool      m_inputDataRangeSpecified;
  bool      m_headerOnly;
  bool      m_crcCheck;
  bool      m_useDefaultCompLevel;
  double    m_defaultValue;
  bool      m_RGBAMode;
 
  int       m_memSize;
  int       m_targetWordFormat;
  int       m_compressionLevel;
  int       m_pondCoeff;
  int       m_nbArgs;
 
  double    m_undefValue;
  double    m_dataRangeInMin;
  double    m_dataRangeInMax;
 
  SbString  m_headerFileName;
  SbString  m_dataSectionFileName;
  SbString  m_dataFileName;
  SoDataSet* m_inputVolume;
 
  SbString m_inputFileName; //file to convert
  SbString m_compressionName;
  
  SampleType             m_sampleType;
  SoDataSet::DataType    m_dataTypeOut;
  SbVec3i32              m_tileDim;
 
  // type dependent vars/macros
  static const char *m_dataTypeStr[];
  static const char *m_dataTypeXml[];
 
  void buildOutputFileName();
  bool m_isForEditing;
  bool m_isTileDimDefaultValue;
  bool m_savedAsBitSet;
  bool m_isRGBAModeDefault;
  bool m_doHistogram;
  bool m_recomputeHistogram;
  bool m_doTileMinMax;
  double m_bitsetThreshold;
  bool m_doUpdate;
  bool m_bVerticalFlip;
 
  //instanciate the converterParameters
  bool m_bFromWriter;
};
 
#ifdef _MSC_VER
#pragma warning( pop )
#endif
 
inline bool
SoConverterParameters::isVerbose() const
{
  return m_verboseMode;
}
 
inline void
SoConverterParameters::setVerbose(bool flag)
{
   m_verboseMode = flag;
}
 
inline SbVec3i32
SoConverterParameters::getTileDim() const
{
  return m_tileDim;
}
 
inline void
 SoConverterParameters::setHeaderFileName( const SbString& headerFileName )
 {
    m_headerFileName = headerFileName;
    m_dataFileName.makeEmpty();
    m_dataSectionFileName.makeEmpty();
    buildOutputFileName();
 }
 
inline SbString
SoConverterParameters::getHeaderFileName() const
{
  return m_headerFileName;
}
 
inline SbString
SoConverterParameters::getDataSectionFileName() const 
{
  return m_dataSectionFileName;
}
 
inline void
SoConverterParameters::setDataFileName(const SbString& dataFileName)
{
  m_dataFileName = dataFileName;
  m_dataSectionFileName = SbFileHelper::getBaseName( m_dataFileName );
}
 
inline SbString 
SoConverterParameters::getDataFileName() const
{
  return m_dataFileName;
}
 
inline int
SoConverterParameters::getMaxMemory() const 
{
  return m_memSize;
}
 
inline bool
SoConverterParameters::getOutputHeaderOnly() const 
{
  return m_headerOnly;
} 
 
inline void
SoConverterParameters::setOutputHeaderOnly(bool headerOnly)
{
  m_headerOnly = headerOnly;
} 
 
inline SoDataSet::DataType 
SoConverterParameters::getOutputDataFormat() const
{
  return m_dataTypeOut;
}
 
inline int
SoConverterParameters::getTargetWordFormat() const
{
  return m_targetWordFormat;
}
 
inline SbString 
SoConverterParameters::getCompressionName() const
{
  return m_compressionName;
}
 
inline int 
SoConverterParameters::getCompressionLevel() const 
{
  return m_compressionLevel;
}
 
inline bool 
SoConverterParameters::isCrcCheckDone() const 
{
  return m_crcCheck;
}
 
inline void 
SoConverterParameters::setCrcCheck ( bool addCrcCheck )
{
  m_crcCheck = addCrcCheck;
}
 
inline void
SoConverterParameters::getInputRangeMinMax(double& min, double& max) const 
{
  min = m_dataRangeInMin;
  max = m_dataRangeInMax;
}
 
inline SoConverterParameters::SampleType
SoConverterParameters::getLowResAlgorithm() const 
{
  return m_sampleType;
}
 
inline double
SoConverterParameters::getUndefinedValue() const 
{
  return m_undefValue;
}
 
inline int
SoConverterParameters::getNbArgs() const 
{
  return m_nbArgs;
}
 
inline bool
SoConverterParameters::useDefaultCompLvl() const 
{
  return m_useDefaultCompLevel;
}
 
inline void
SoConverterParameters::setUndefinedValue(double undefinedValue)
{
  m_undefValue = undefinedValue;
}
 
inline bool 
SoConverterParameters::isOutputDataTypeSpecified() const 
{
  return m_outputDataTypeSpecified;
}
 
inline void
SoConverterParameters::setInputFileName( const SbString& inputFileName )
{
  m_inputFileName = inputFileName;
 
  buildOutputFileName();
}
 
inline SbString
SoConverterParameters::getInputFileName() const 
{
  return m_inputFileName;
}
 
inline SoDataSet* 
SoConverterParameters::getInputVolume() const
{
  return m_inputVolume;
}
 
inline void
SoConverterParameters::setInputVolume(SoDataSet* inputVolume)
{
  m_inputVolume = inputVolume;
}
 
inline bool
SoConverterParameters::isInputDataRangeSpecified() const 
{
  return m_inputDataRangeSpecified;
}
 
inline int 
SoConverterParameters::getPondCoef() const 
{
  return m_pondCoeff;
}
 
inline bool
SoConverterParameters::isForEditing() const 
{
  return m_isForEditing;
}
 
inline void
SoConverterParameters::setDefaultValue(const double value)
{
    m_defaultValue = value;
}
 
inline double
SoConverterParameters::getDefaultValue() const
{
    return m_defaultValue;
}
 
inline bool
SoConverterParameters::isTileDimDefault()
{
  return m_isTileDimDefaultValue;
}
 
inline bool
SoConverterParameters::isSavedAsBitSet() const
{
  return m_savedAsBitSet;
}
 
inline void 
SoConverterParameters::saveAsBitSet( bool flag, double bitsetThreshold )
{
  m_savedAsBitSet = flag;
 
  if ( flag )
    m_bitsetThreshold = bitsetThreshold;
}
 
inline void 
SoConverterParameters::setRGBAMode(const bool flag)
{
  m_isRGBAModeDefault = false;
  m_RGBAMode = flag;
}
 
inline bool 
SoConverterParameters::isRGBAMode() const
{
  return m_RGBAMode;
}
 
inline void 
SoConverterParameters::enableHistogram(const bool flag)
{
  m_doHistogram = flag;
}
 
inline bool
SoConverterParameters::isHistogramEnabled() const
{
  return m_doHistogram && !isRGBAMode();
}
 
inline void
SoConverterParameters::enableRecomputeHistogram(const bool flag)
{
  m_recomputeHistogram = flag;
}
 
inline bool
SoConverterParameters::recomputeHistogram() const
{
  return m_recomputeHistogram;
}
 
inline void
SoConverterParameters::enableTileMinMax(const bool flag)
{
  m_doTileMinMax = flag;
}
 
inline bool
SoConverterParameters::isTileMinMaxEnabled() const
{
  return m_doTileMinMax;
}
 
inline bool
SoConverterParameters::isRGBAModeDefault() const 
{
  return m_isRGBAModeDefault;
}
 
inline double
SoConverterParameters::getBitSetThreshold() const
{
  return m_bitsetThreshold;
}
 
inline void
SoConverterParameters::setBitSetThreshold( double bitsetThreshold ) 
{
  m_bitsetThreshold = bitsetThreshold;
}
 
inline bool
SoConverterParameters::isFromWriter() const
{
  return m_bFromWriter;
}
 
inline void
SoConverterParameters::setIsFromWriter( bool flag )
{
  m_bFromWriter = flag;
}
 
inline void
SoConverterParameters::doUpdate ( bool flag )
{
  m_doUpdate = flag;
}
 
inline bool 
SoConverterParameters::isForUpdate() const
{
  return m_doUpdate;
}
 
inline bool
SoConverterParameters::isVerticalFlip() const
{
  return m_bVerticalFlip;
}
 
inline void
SoConverterParameters::setVerticalFlip( bool flag )
{
  m_bVerticalFlip = flag;
}
 
#endif //_SO_BASE_CONVERTER_