LDM/nodes/SoDataSet.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      : Jerome Hummel (Mar 2006)
** Modified by : Benjamin Grange (MMM yyyy)
** Modified by : Jean-Michel Godinaud. (MMM yyyy)
**=======================================================================*/


#ifndef _SO_DATA_SET_
#define _SO_DATA_SET_

#ifdef _MSC_VER
#pragma warning( push )
#pragma warning(disable:4251)
#endif

//includes
#include <Inventor/SbBox.h>
#include <Inventor/SbLinear.h>
#include <Inventor/fields/SoSFBool.h>
#include <Inventor/fields/SoSFBox3f.h>
#include <Inventor/fields/SoSFEnum.h>
#include <Inventor/fields/SoSFFieldContainer.h>
#include <Inventor/fields/SoSFFilePathString.h>
#include <Inventor/fields/SoSFFloat.h>
#include <Inventor/SbDataType.h>
#include <Inventor/fields/SoSFInt32.h>
#include <Inventor/fields/SoSFNode.h>
#include <Inventor/fields/SoSFString.h>
#include <Inventor/fields/SoSFUShort.h>
#include <Inventor/misc/SoMemoryObject.h>
#include <Inventor/misc/SoRef.h>
#include <Inventor/nodes/SoNode.h>
#include <LDM/SoLDM.h>
#include <LDM/SoLDMMediator.h>
#include <LDM/SoLDMTileID.h>
#include <LDM/SoLDMTileManager.h>
#include <LDM/fields/SoSFLDMResourceParameters.h>
#include <LDM/fields/SoSFLDMDataTransform.h>
#include <LDM/nodes/SoLDMResourceParameters.h>
#include <LDM/nodes/SoTransferFunction.h>
#include <Inventor/sys/SoGLType.h>

// TODO: Should be removed : For compatibility only
#include <Inventor/devices/SoCpuBufferObject.h>


class SoGLRenderAction;
class SoCallbackAction;
class SoWriteAction;
class SoState;
class SoLDMGeomElement;
class SoLDMGeometry;
class SoLDMReader;
class SoTransferFunction;
class SoMultiDataSeparator;
class SoVolumeHistogram;
class SoVolumeReader;
class SoPerfCounterManager;
class SoPerfCounter;
class SoBufferObject;
class SoCpuBufferUniform;
class SoGLTexture;
class SoCache;

class SoDataExtract;
class SoConversion;
class SoAlgorithms;
class SoLDMAlgorithms;
class SoLdmValuationAction;
class SoDataRange;

class SoVolumeWriter;

class  SoDataSet : public SoNode
{
  SO_NODE_ABSTRACT_HEADER( SoDataSet );

public:

  SoSFInt32 dataSetId;

  SoSFFilePathString  fileName;

  SoSFBool   useCompressedTexture;

  SoSFUShort texturePrecision;

  SoSFBox3f extent;

  SoSFLDMDataTransform dataTransform;

  SoSFBool   allocateResourceOnRender;

  const SbVec3i32&    getDimension();

  SbVec3i32    getTileDimension();

  unsigned int getDatumSize();

  virtual size_t readTile( SoBufferObject*& bufferObject, SoLDMTileID tileID, bool transform );

  virtual void readTile(SoLDMTileID tileID, SoBufferObject* buffer, bool transform);

  virtual void writeTile( SoLDMTileID tileID, SoBufferObject* buffer, SoVolumeWriter* writer );

  SoSFLDMResourceParameters ldmResourceParameters;

  SoLDMDataAccess       & getLdmDataAccess();

  virtual SbBool startEditing( int& transactionId );

  virtual SbBool finishEditing( int transactionId );

  virtual int editTile( const SoLDMTileID& tileId, SoBufferObject* userData );

  virtual int editSubVolume( const SbBox3i32& subVolume, SoBufferObject* userData );

  virtual int editTile( const SoLDMTileID& tileId, const double& value );

  virtual int editSubVolume( const SbBox3i32& subVolume, const double& value );

  virtual int editSurfaceShape( const SoNode* surfaceShape, const float& thickness, const double& value );

  virtual int editSolidShape( const SoNode* solidShape, const double& value );

  virtual int editBoxes(
    const std::vector<SbVec3i32>& boxCenters,
    const int& boxSize,
    const double& newValue
  );

  virtual SbBool undoEditing( int transactionId );

  virtual SbBool redoEditing( int transactionId );


  typedef SbBool SaveEditingCB( SoDataSet* dataSet,
                                SoVolumeWriter* writer, 
                                int tilesRemaining, 
                                int totalTiles );
  virtual SbBool saveEditing( bool recomputeLowerResolution = TRUE,
    const std::vector<char*> conversionParameters = std::vector<char*>(), SaveEditingCB* callback = NULL );

  virtual bool hasEditedTile();

  SoLDMTileManager *getTileManager() { return getLdmManagerAccess().getTileManager(); }

  SoLDMTextureManager *getTextureManager() { return getLdmManagerAccess().getTextureManager(); }

#if 1             SoDEPRECATED
  SoLDMTileVisitor* getTileVisitor();
SoDEPRECATED
  void setTileVisitor( SoLDMTileVisitor* tileVisitor );
SoDEPRECATED
  SoLDMGeometry *getVVizGeometry();

#endif /* @DEPRECATED_END */

  SoLDMNodeFrontManager *getNodeFrontManager() { return getLdmManagerAccess().getNodeFrontManager(); }

  SoLDMReader*   getLDMReader();

  void           setLDMReader(SoLDMReader* reader);

  inline SoVolumeReader* getReader()
  {return (SoVolumeReader*)m_reader.ptr();};

  inline SoVolumeReader* getReader() const
  { return (SoVolumeReader*)m_reader.ptr(); };

  enum DataType {
    UNSIGNED_BYTE  = SbDataType::UNSIGNED_BYTE,
    UNSIGNED_SHORT = SbDataType::UNSIGNED_SHORT,
    UNSIGNED_INT32 = SbDataType::UNSIGNED_INT32,
    SIGNED_BYTE  = SbDataType::SIGNED_BYTE,
    SIGNED_SHORT = SbDataType::SIGNED_SHORT,
    SIGNED_INT32 = SbDataType::SIGNED_INT32,
    FLOAT = SbDataType::FLOAT
  };


  static int dataSize( DataType dataType );

  static SbBool isDataSigned( DataType dataType );

  static SbBool isDataFloat( DataType dataType );

  int numSigBits() const;

  virtual SbBool getMinMax( int64_t &min, int64_t &max);

  virtual SbBool getMinMax( double &min, double &max);

  DataType getDataType();

  int getDataSize();

  void setReader( SoVolumeReader &reader, SbBool takeOwnership = FALSE );

  static int getMaxNumDataSets() ;

#if 1             SoDEPRECATED
  SoLDMResourceParameters& getLdmResourceParameter();

#endif 
#if 1             SoDEPRECATED
  virtual void readTile(SoLDMTileID tileID, unsigned char* buffer, bool transform);

  typedef void SoLDMDataTransformFunction(SoDataSet* ds,
                                          const SbVec3i32& bufferDimension, //tile dim
                                          void* bufferToTransform,
                                          const SbBox3i32& dataBox,      //position of tile in data space
                                          int resolutionLevel,    //resolution level of the tile
                                          void* userData);
SoDEPRECATED
  void setLDMDataTransformFunction(SoLDMDataTransformFunction* func, void* userData = NULL);

#endif 
#if 1             SoDEPRECATED
  inline SbBool isTimeDependent()
  { return FALSE; }
  SoDEPRECATED
  inline int getNumTimeSteps()
  { return 1; }
SoDEPRECATED
  int getOverlapping();
SoDEPRECATED
  void setLDM(SbBool state);

#endif 
SoEXTENDER_Documented public:

  SoLDMMediator::LDMManagerAccess &getLdmManagerAccess() { return m_mediator->ldmManagerAccess; }

  void resetReader();

private:

  virtual void callback( SoCallbackAction *action );
  virtual void GLRender( SoGLRenderAction *action );
  virtual void getBoundingBox(SoGetBoundingBoxAction *action);
  virtual void pick(SoPickAction *action) ;
  virtual void write(SoWriteAction *action);

  inline virtual void useFakeData(SoLDMTileID /* tileID */, SoBufferObject* /* buffer */) {};

private:

  // This map is used to maintain signature of each tile in cache
  // It's used to be able to find a uncompressed version of a given tile in the cache
  // when already uncompressed tile are reloaded.
  typedef std::map<SoLDMTileID, uint64_t> tileSigInCacheMap;

  static void initClass();
  static void exitClass();

  static bool isReallyOfType(SoDataSet* ds, const SoType& type, bool derived);

  bool isGPUDataRange( SoState* state );

  SoBufferObject* getEditedTile( SoBufferObject* tileBuffer, const SoLDMTileID& tileId );

  virtual SoBufferObject *getTransformedTile(const SoLDMTileID& tile,
                                             const SoLDM::DataSetIdPair& p,
                                             SoState * state=NULL,
                                             const bool useExtendedData = false);

  SbBool isTileEdited( const SoLDMTileID& tileId );

  // return the number of SoDataSet instance created
  // this is usefull to optimize SoLdmValuationAction
  static int getNumInstance()
  { return s_numInstance; }

  SB_THREAD_TLS_HEADER();

  typedef std::vector<SoGLTexture*> TextureList;

  SoLDM::DataSetIdPair getDataSetIdPair(SoState* state) const;

  SoMultiDataSeparator *getMultiDataSeparator() { return m_MultiDataSeparator; }
  void setMultiDataSeparator(SoMultiDataSeparator *mds);

  virtual void notify(SoNotList *list);

  void sendParametersToLDM(SoLdmValuationAction* action);

  virtual SoLDMGeomElement* getAppropriateElement(SoLDMGeometry* v) = 0;

  //When true data set won't be used for rendering
  void ignoredByMultiDataSeparator(bool state);
  bool isIgnoredByMultiDataSeparator() { return m_ignoredByMultiDataSeparator; }

  // have the properties read ?
  virtual bool getDataCharRead() { return m_dataCharRead;};

  /* @return texture precision in Bits */
  int getIndTexPrec() const;
  virtual void doAction( SoAction *action );
  bool loadInMemory(SoState* s = NULL);
  void setListChange(bool val){m_listChange = val;};
  bool getListChange(){return m_listChange;};

    /* 
   * Return internal state of resources. Dirty state means
   * resource field have been changed by application / user.
   * Can be cumulative value defined in 
   * See enum definition made in SoLDMResourceManager::State
   */
   inline unsigned short getResourcesState() const 
   { return m_resourcesState;};

  /* 
   * Set internal state of resources. State set to true means
   * resource field have been changed by application / user.
   */
   void setResourcesState( const SoLDMResourceManager::State flag, bool value );

  //eye settings to pass to mediator
  SbVec3i32 getEyeDataCoord(SoState* state);

  int getZaxis(SoState *state, const SbBox3f& volBbox) const;

  SbVec3f getVolCenterToEyeVector(SoState *state, const SbBox3f& volBbox) const;

  SbVec3f getObjectSpaceEyeAxis(SoState *state) const;

  //shall we accumulate the node in state?
  void     setAccumulate(bool val){m_toAccumulate = val;};
  bool     isAccumulated(){return m_toAccumulate;};
  bool     m_toAccumulate;
  SbBool   getCurrentMatrixDifference(SoState*, SbMatrix&);

  //multi-data
  void lookForSceneGraphChange(SoAction* action);

  // extract slice data
  virtual SoBufferObject* getDataOneSlice( const SbVec3i32& tileSize, SoBufferObject* tileData, int Zaxis, int slice);
  virtual void releaseDataOneSlice(SoBufferObject *sliceDataBuffer);

  //***** factory methods ****

  virtual SoLDMTileManager::LDMSliceAccessor* getAppropriateSliceAccessor(const SoLDM::DataSetIdPair& p);
  virtual SoLDMReader* getAppropriateLDMReader( const SbString& )
  { return NULL; };


  virtual bool getBbox(SoLDMTileID tileId, SbBox3f& box);

  // logical center per id
  bool getCenter(SoLDMTileID tileID, SbVec3f& center)const;

  SoLDMMediator* getMediator(){return m_mediator;};
  void setMediator(SoLDMMediator* m);

  virtual bool createTex(int Zaxis, SoState *state, const SbVec3i32 &tileSize, SoBufferObject *tileDataBuffer, SoTransferFunction *transferFunction,
                         SoBufferObject*& textureBufferObject, int alphaUse = 0);

  // TODO FIXME : should cleanup this call.
   void* getTexData(const void* tileBuffer,
                    int numElem,
                    SoTransferFunction* transferFunction,
                    int alphaUse,
                    int texPrec,
                    void *textureBuffer,
                    SoDataRange* datarange,
                    SoDataCompositor* dataCompositor);

  // allocate ( if needed ) and initialize the texture buffer, according to the input buffer and the transfer function.
  // The texture buffer can be given with the tex_data argument. In this case no allocation is done and tex_data is returned.
  // Otherwise returns the initialized texture buffer.
  // Returned pointer do not needs to be deleted, but reference to this buffer will be valid only until the next getTexData call.
  SoBufferObject* getTexData(SoBufferObject* tileBufferObject,
                             SoTransferFunction* transferFunction,
                             int alphaUse,
                             int texPrec,
                             SoBufferObject* textureBufferObject,
                             SoDataRange* dataRange,
                             SoDataCompositor* dataCompositor);

  template <typename DataClassIn>
  static SoBufferObject *permuteData(const SbVec3i32& /* tileSize */, SoBufferObject* /* srcRgbaBuffer */, int /* axis */);

  inline virtual void computeLighting( const SbVec3i32& /* tileSize */, SoBufferObject* /* rgbaBuffer */ ) {};
  int getRGBAInternalFormat() const;

  virtual void updateColorTable(SoState *, SoTransferFunction *);

  SoLDMResourceManager& getResourceManager() { return *m_resourceManager; }

  virtual int getTexPrec(SoState*);

  void getTextureFormat(SoTransferFunction::GLColorMapType colorMapType,
                        GLenum& format,
                        GLenum& dataType,
                        GLint& internalFormat) const;

  //Display loaded tiles
  virtual void drawTilesInMainMemory(SoState *state);

  //Copy dataset's fields if needed into the given mediator
  // Notifications are disabled on #ldmResourceParameters during the process
  void copyLDMParameters(SoLDMMediator *mediator);

  virtual bool isMultidataEnabled() const { return m_multidataEnabled; }

  // draw a colored Box
  enum BoxColor {
    GREY,
    RED,
    BLUE,
    GREEN,
    FULL_RES_GREY,
    FULL_RES_GREEN
  };

  enum FieldId {
    MAX_MAIN_MEMORY = 0,
    MAX_TILES_IN_MAIN_MEMORY,
    LOAD_POLICY,
    LOAD_NOTIFICATION_RATE,
    MAX_TEX_MEMORY,
    MAX_TILES_IN_TEX_MEMORY,
    TEX3_LOAD_RATE,
    MAX_2D_TEXTURES,
    TEX2_LOAD_RATE,
    MIN_RESOLUTION_THRESHOLD,
    MAX_RESOLUTION_THRESHOLD,
    TILE_SIZE,
    FIX_PARAMS,
    OVERLAPPING,
    TILE_HALF_LIFE,
    FIXED_RESOLUTION_MODE,
    LAST_ID
  };

  unsigned short getId() const 
    { return m_id; }

  inline bool hasReadError() 
    { return m_hasReadError; };

  inline bool isEmpty()
  {
    const SbVec3i32& dim = getDimension();
    return ( dim[0] == 0 || dim[1] == 0 || dim[2] == 0 );
  };

  struct DatumElement{
    SoDataSet::DataType type;
    int                 num;
  };

  float convertToNormalizedTextureSpace(SoState *state, const float data);

  inline void setFirstTraversalDone(bool flag)
    { m_firstTraversalDone = flag; }

  inline bool isFirstTraversalDone() const
    { return m_firstTraversalDone;}

  virtual bool isPalettedTexture(SoState*);

  // Get a unique signature for a given tile. If tile already loaded, return the
  // previously generated signature. Otherwise, generate a new one. Each dataset
  // manage its signature list.
  virtual uint64_t getTileSignature(const SoLDMTileID& tileId);

  // Uniq Id management
  uint64_t getUniqueId();

  inline void setOwnedReader( SoVolumeReader &reader )
    { setReader( reader, TRUE ); };

  /*
      Ref/unref mechanism on volume render used to manage
      GPU resources. Allow SoDataSet to free GPU resources when
      texture are not needed
      */
  void refVolRender( int contextId );
  void unrefVolRender( int contextId );

  int getBestEqualResolution() const;

  void computeBestEqualResolution();

private:

  SoDataSet();

  virtual ~SoDataSet();

  virtual void setElement(SoState* state);

  inline bool isUsingUserExtent()
    { return m_useUserExtent; };

  /*
  Allows a class inheriting from SoDataSet to decide whether multiple data should be allowed or not.
  If it is the SoDataSet will assign one mediator for all dataset.
  Else one mediator is assigned for all dataset (one LDM core per dataset).
  In vviz this method checks whether a compositor or a shader is present in the state.
  If not then multidata is not allowed.
  */
  virtual bool enableMultidata(SoState* state);

  //Return a reader according to m_filename and m_data
  virtual SoVolumeReader* getAppropriateReader();

  bool m_forcePow2TileDim;

  //LDM reader
  SoRef<SoFieldContainer> m_reader;
  SbBool          m_internalReader;

  //did the list change?
  bool m_listChange;

  bool load(SoState*);
  virtual void unload();
  virtual void releaseMemory();

  bool assignLDMMediator(SoState* state);
  bool m_multidataEnabled;

  SbVec3i32     m_dimension;
  bool          m_initialized;

  SbDataType       m_type;
  int              m_numBits;
  bool             m_isDataFloat;
  bool             m_isDataSigned;
  unsigned int     m_datumSize;

  bool m_deletedFlag;
  //True if data header has already been read
  bool m_dataCharRead;

  SbString      m_filename;
  virtual void updateFilename();

  //Notify mediator or multidataseparator about id change
  void dataIDChanged(int newId);
  unsigned short m_id;

  void ldmResourceParamChanged();

  virtual void readerChanged();

  void extentChanged();

  void initReader();
  void setType(SbDataType);

  //
  void getFilePathName( SbString& pathName, SbString& fileExtension);

  virtual SoLDMMediator *createMediator();
  SoLDMMediator* m_mediator;

  SoMultiDataSeparator *m_MultiDataSeparator;
  bool m_ignoredByMultiDataSeparator;

  SoLDMResourceManager* m_resourceManager;

  virtual int isSharedPalettedTexture() { return FALSE; }

  void getTransferFunction(SoTransferFunction *transferFunction, int alphaUse,
                           int &shift, int &offset, int &nrgba, unsigned int * &rgba);

  SbVec3i32 getPow2(SbVec3i32) const;

  //OpenGL display of tiles given in tileIDs. The line width increase with the level of the tile.
  void drawTiles(SoState *state, const SoLDM::TileIdVector& tileIDs,
                 const SbVec4f &tileColor, const SbVec4f &maxLevelColor,
                 size_t maxLineWidth);
  template<class DataType>
  void buildSlice(SoCpuBufferObject& slice, const SbVec3i32& min, const SbVec3i32& max, const SbVec2i32 sampleStep);

  template<typename _DataType>
  void buildLine(SoCpuBufferObject& line, const SbVec3i32& min, const SbVec3i32& max, const int sampleStep );

  //Build a tile out of the original full resolution data.
  //The data is taken out from disk by the reader (vol, am,..)
  //and subsampled until the desired level.
  virtual void buildTile(SoLDMTileID tileID, SoBufferObject* buffer);

  //Set data characteristic size, extent...
  virtual void readChar();

  //Set if an undefinedValue was defined
  virtual void setUseUserUndefinedValue(bool useUserUndefinedValue);

  bool m_useUserExtent;

  SoVolumeHistogram *m_histogram;

  // Cache element to monitor DataCompositor modification
  SoCache* m_dataCompositorCache;

  struct MTstruct {
    SoBufferObject *tmpTexture;
    SoCpuBufferUniform *tmpTextureUniform;
    SoBufferObject *tmpColormap;
    SoBufferObject *tmpTexturePermute;
  };


SoINTERNAL private:
  SoSFFieldContainer customReader;
  SoSFBool           customReaderOwnerShip;

  SoSFLDMDataTransform editingStack;

  virtual void ldmAction(SoLdmValuationAction* action);

  virtual SbBool isRGBAData();

private:
  void updateDataSetId(SoState* state);

  void enableThinVolume();

  // Take in account modification of DataCompositorElement
  void updateCompositorCache(SoState *state);

  bool isValidDimension(const SbVec3i32& dim) const;

  void displayReadError(int err);

  SbVec3i32 clampTileDimension(const SbVec3i32& tileDim) const;

  static const unsigned int MAX_DATASET_DIMENSION;

  static const int MAX_TILE_DIMENSION;

  bool isIdUsed(int id, std::vector<SoDataSet*>);

#ifndef HIDDEN_FROM_DOC
  friend class SoLDMMediator;
  friend class SoLDMMediator::LDMManagerAccess;
  friend class SoCpuBufferFromVolumeReader;
#endif

  // implementation of buildTile doing one reader's getSubslice() call
  // per tile's line to build. it works well when the reader's getSubslice() call cost is low
  // nb: it is the perfered method for most non-bricked reader (except Raster)
  template<typename _DataType>
  void buildTileByLine(const SbBox3i32& tileBox, SoBufferObject* bufferObject);

  // implementation of buildTile doing one reader's getSubslice() call
  // per tile's slice to build. it works well when the reader's getSubslice() call cost is very high
  // whatever is the size of the data requested
  // Nb: it is currently the case for RasterStackReader which read a complete image on ech call)
  // Then Raster will use this version.
  template<typename _DataType>
  void buildTileBySlice(const SbBox3i32& tileBox, SoBufferObject* bufferObject);


  bool m_filenameChange;

  bool m_hasReadError;

  bool m_accumulate;

  SoPerfCounterManager* m_perf;

  // Perf counter used for data copy timing
  SoPerfCounter* m_nbTexGen;
  SoPerfCounter* m_byteGetTexData;
  SoPerfCounter* m_timeCreateTex;
  SoPerfCounter* m_timeGetTexData;

  static SoAlgorithms* s_algorithms;
  static SoLDMAlgorithms* s_LDMAlgorithms;

  bool m_firstTraversalDone;
  friend class SoLdmValuationAction;
  bool m_ldmUseInMemCompression;

  static int s_numInstance;

  /* 
   * Internal short to store change of state regarding a given resource.
   * See enum definition made in SoLDMResourceManager::State
   */
  unsigned short m_resourcesState;

  static uint64_t s_lasUniqId;

  // Some stuff to manage cache. Static mutex to be sure all dataset won't access
  // at the same time to Id generator
  static SbThreadMutex s_sigCacheMutex;

  // Map to manage internal association between tileId and uniqId
  tileSigInCacheMap m_tileSigInCache;

  // Reference counter on each contextId.
  // Key: the contextId
  // Value: number of reference done on this context
  std::map<int, int> m_mapContextIdRef;

  // Best equal resolution (for the mode resolution = BEST)
  // Equal to -1 until best equal resolution is computed
  int m_bestEqualResolution;

  static bool s_GPUDataRange;
};

#ifdef _MSC_VER
#pragma warning( pop )
#endif

#endif  // _SO_DATA_SET_

---

Open Inventor Toolkit reference manual, generated on 12 Feb 2024
Copyright © Thermo Fisher Scientific All rights reserved. http://www.openinventor.com/