SoDataSet.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-2024 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/fields/SoSFDouble.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/fields/SoSFLDMResourceParameters.h>
#include <LDM/fields/SoSFLDMDataTransform.h>
#include <LDM/nodes/SoLDMResourceParameters.h>
#include <LDM/nodes/SoTransferFunction.h>
#include <LDM/tiles/SoCpuBufferUniform.h>
#include <Inventor/sys/SoGLType.h>
 
// TODO: Should be removed : For compatibility only
#include <Inventor/devices/SoCpuBufferObject.h>
 
class SoGLRenderAction;
class SoCallbackAction;
class SoHandleEventAction;
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;
 
SO_PIMPL_PUBLIC_DECLARATION(SoDataSet)
 
 
 
class  SoDataSet : public SoNode
{
  SO_NODE_ABSTRACT_HEADER( SoDataSet );
 
  SO_PIMPL_PUBLIC_HEADER( SoDataSet );
 
public:
 
  SoSFInt32 dataSetId;
 
  SoSFFilePathString  fileName;
 
  SoSFBool   useCompressedTexture;
 
  SoSFUShort texturePrecision;
 
  SoSFBox3f extent;
 
  SoSFLDMDataTransform dataTransform;
 
  SoSFBool   allocateResourceOnRender;
 
  SoSFDouble undefinedValue;
 
  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 );
 
  bool isInMemory( SoLDMTileID tileID ) const;
 
  bool isDataInMemory( const SoLDMTileID& tileID ) const;
 
  void getTileIDInMemory( std::vector<LDM_TILE_ID_TYPE>& tilesInMemory ) const;
 
  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,
    const std::vector<char*> conversionParameters = std::vector<char*>(), SaveEditingCB* callback = NULL );
 
  SbBool saveEditing();
 
  virtual bool hasEditedTile();
 
  SoLDMReader*   getLDMReader();
 
  void           setLDMReader(SoLDMReader* reader);
 
  inline SoVolumeReader* getReader()
  {
    return const_cast<const SoDataSet*>(this)->getReader();
  }
 
  SoVolumeReader* getReader() const;
 
  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,
    DOUBLE = SbDataType::DOUBLE
  };
 
 
  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() const;
 
  int getDataSize();
 
  void setReader( SoVolumeReader &reader, SbBool takeOwnership = FALSE );
 
  static int getMaxNumDataSets() ;
 
  virtual SbVec3f voxelToXYZ( const SbVec3f& dataPosition ) const;
 
  virtual SbBox3f voxelToXYZ( const SbBox3f& box ) const;
 
  virtual SbVec3f XYZToVoxel( const SbVec3f& dataPosition ) const;
 
  virtual SbBox3f XYZToVoxel( const SbBox3f& xyzBox ) const;
 
#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
  int getOverlapping();
 
#endif 
SoEXTENDER_Documented public:
 
  void resetReader();
 
  const SoLDMTopoOctree* getLDMTopoOctree() const;
 
private:
 
  virtual void callback( SoCallbackAction *action );
  virtual void GLRender( SoGLRenderAction *action );
  virtual void getBoundingBox(SoGetBoundingBoxAction *action);
  virtual void handleEvent(SoHandleEventAction* action);
  virtual void pick(SoPickAction *action) ;
  virtual void write(SoWriteAction *action);
  virtual void doAction( SoAction *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 an 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();
 
  bool isReallyOfType(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);
 
  // return the number of SoDataSet instance created
  // this is usefull to optimize SoLdmValuationAction
  static int getNumInstance();
 
  SB_THREAD_TLS_HEADER();
 
  SoMultiDataSeparator *getMultiDataSeparator() { return m_MultiDataSeparator; }
  void setMultiDataSeparator(SoMultiDataSeparator *mds, SoLDMMediator* mediator = nullptr);
 
  virtual void notify(SoNotList *list);
 
  void sendParametersToLDM(SoLdmValuationAction* action);
 
  //When true data set won't be used for rendering
  void ignoredByMultiDataSeparator(bool state);
  bool isIgnoredByMultiDataSeparator();
 
  // have the properties read ?
  virtual bool getDataCharRead() { return m_dataCharRead;};
 
  /* @return texture precision in Bits */
  int getIndTexPrec() const;
  bool loadInMemory(SoState* s = NULL);
  void setListChange(bool val);
  bool getListChange();
 
    /* 
   * Return internal state of resources. Dirty state means
   * resource field has been changed by application / user.
   * Can be cumulative value defined in 
   * See enum definition made in SoLDMResourceManager::State
   */
   unsigned short getResourcesState() const;
 
  /* 
   * 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 );
 
  //shall we accumulate the node in state?
  bool     isAccumulated();
 
  static SbBool getCurrentMatrixDifference(SoState* state, const SoLDM::DataSetIdPair& idPair, SbMatrix& geomMatrix);
 
  //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 LDMSliceAccessor* getAppropriateSliceAccessor(const SoLDM::DataSetIdPair& p);
  virtual SoLDMReader* getAppropriateLDMReader( const SbString& )
  { return NULL; };
 
  // logical center per id
  bool getCenter(SoLDMTileID tileID, SbVec3f& center)const;
 
  SoLDMMediator* getMediator() const
  {
    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 does not need 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);
 
  SoTexture::InternalFormat getRGBAInternalFormat() const;
 
  SoLDMResourceManager& getResourceManager() { return *m_resourceManager; }
 
  virtual int getTexPrec(SoState*);
 
  void getTextureFormat(SoTransferFunction::GLColorMapType colorMapType,
                        SbEnums::ImageDataFormat& format,
                        SbDataType::DataType& dataType,
                        SoTexture::InternalFormat& internalFormat) const;
 
  //Display loaded tiles
  virtual void drawTilesInMainMemory(SoGLRenderAction* action, const SoLDM::DataSetIdPair& idPair);
 
  //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
  };
 
  unsigned short getId() const 
    { return m_id; }
 
  bool 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);
 
  void setFirstTraversalDone(bool flag);
 
  bool isFirstTraversalDone() const;
 
  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
  // manages its signature list.
  virtual uint64_t getTileSignature(const SoLDMTileID& tileId);
 
  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 invalidateHistogram();
 
  SbVec2f getDataTypeMinMax() const;
 
  SoLDMTileID getTileCharacteristics(const SoLDMTileID& tile, SbBox3i32& tileBox, SbVec3i32& tileDim) const;
 
  bool supportUndefinedVoxel(SoState* state);
 
  SoVolumeReader* getInternalReader() const;
 
  int getTexelSizeBits(SoState* state = nullptr);
 
private:
 
  SoDataSet();
 
  virtual ~SoDataSet();
 
  inline virtual void computeLighting( const SbVec3i32& /* tileSize */, SoBufferObject* /* rgbaBuffer */ ) {};
 
  virtual void setElement(SoState* state);
 
  bool isUsingUserExtent();
 
  /*
  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;
 
  bool load(SoState*);
  virtual void unload();
  virtual void releaseMemory();
 
 
  bool m_multidataEnabled;
 
  SbVec3i32     m_dimension;
  bool          m_initialized;
 
  SbDataType       m_type;
  int              m_numBits;
 
  //True if data header has already been read
  bool m_dataCharRead;
 
  SbString      m_filename;
  virtual void updateFilename();
 
 
  unsigned short m_id;
 
 
  virtual void readerChanged();
 
  void initReader();
 
  virtual SoLDMMediator *createMediator();
  SoLDMMediator* m_mediator;
 
  SoMultiDataSeparator *m_MultiDataSeparator;
 
  SoLDMResourceManager* m_resourceManager;
 
  void getTransferFunction(SoTransferFunction *transferFunction, int alphaUse,
                           int &shift, int &offset, int &nrgba, unsigned int * &rgba);
 
  //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);
 
  SoVolumeHistogram *m_histogram;
 
  virtual void ldmAction(SoLdmValuationAction* action);
 
  virtual SbBool isRGBAData();
 
SoINTERNAL private:
 
  virtual SoLDMGeomElement* getAppropriateElement( SoLDMGeometry* SO_UNUSED_PARAM(v) )
  {
    return NULL;
  }
 
  virtual unsigned short getMaxTexturePrecisionBits() const { return 16; }
 
  SoSFFieldContainer customReader;
  SoSFBool           customReaderOwnerShip;
 
  SoSFLDMDataTransform editingStack;
 
private:
 
  void commonConstructor();
 
  bool computeBestEqualResolution(const std::vector<size_t>& tilesByLvlVec);
 
  struct MTstruct {
    SoBufferObject *tmpTexture;
    SoCpuBufferUniform *tmpTextureUniform;
    SoBufferObject *tmpColormap;
    SoBufferObject *tmpTexturePermute;
  };
 
#ifndef HIDDEN_FROM_DOC
   friend class SoVolumeState;
   friend class SoLDMMediator;
   friend class SoCpuBufferFromVolumeReaderImpl;
   friend class SoObliqueSliceLdm;
#endif
   friend class SoLdmValuationAction;
   friend class SoLDMGeometry;
};
 
#ifdef _MSC_VER
#pragma warning( pop )
#endif
 
#endif  // _SO_DATA_SET_