VolumeViz/nodes/SoVolumeRender.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-2022 BY FEI S.A.S,                        ***
 ***                        BORDEAUX, FRANCE                                        ***
 ***                      ALL RIGHTS RESERVED                                       ***
**=======================================================================*/
/*=======================================================================
** Author      : P. ESTRADE (Mar 2000)
**=======================================================================*/
#ifndef  _SO_VOLUME_RENDER_
#define  _SO_VOLUME_RENDER_

#include <Inventor/caches/SoCache.h>
#include <Inventor/nodes/SoShape.h>
#include <Inventor/nodes/SoShaderParameter.h>
#include <Inventor/nodes/SoGroup.h>
#include <Inventor/nodes/SoTextureUnit.h>
#include <Inventor/fields/SoSFBool.h>
#include <Inventor/fields/SoSFBitMask.h>
#include <Inventor/fields/SoSFEnum.h>
#include <Inventor/fields/SoSFFloat.h>
#include <Inventor/fields/SoSFVec3f.h>
#include <Inventor/fields/SoSFInt32.h>
#include <Inventor/SbBox.h>

#include <Inventor/STL/vector>
#include <Inventor/STL/map>

#include <VolumeViz/nodes/SoVolumeShape.h>

#include <VolumeViz/LDM/SoLDMTileID.h>

class SbProjection;
class SoFrameBufferObject;
class SoGLProgramGLSL;
class SoGLTexture;
class SoVRImageSpaceEffects;
class SoLDMTileID;
class SoLdmSubDivisionIsosurfacePolicy;
class SoLdmSubDivisionPolicy;
class SoLdmSubDivisionTransferFunctionPolicy;
class SoShaderProgram;
class SoVolumeGroup;
class SoVolumeIsosurface;
class SoVolumeRenderInterface;
class SoVolumeRenderRaycast;
class SoVolumeRenderLdm;
class SoVolumeRenderLdm;
class SoVolumeRenderPaging;
class SoVolumeRenderingQuality;
class SoVolumeStateVr;
class SoVolumeRenderDetail;
class SoNodeSensor;
class SoVolumeOffscreenImpl;
class SoProgressIndicator;

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

class  SoVolumeRender : public SoVolumeShape {
  SO_NODE_HEADER( SoVolumeRender );

 public:

   enum LowResMode
   {
     DECREASE_NONE = 1,
     DECREASE_SLICES = 1 << 1,
     DECREASE_SCREEN_RESOLUTION = 1 << 2
   } ;


    enum NumSlicesControl {
    ALL,
    MANUAL,
    AUTOMATIC,
    MAIN_AXIS
  };

  SoMFInt32 dataSetIds;

  SoSFEnum  numSlicesControl;

  SoSFInt32 numSlices;

  SoSFBitMask lowResMode;

  SoSFInt32 lowScreenResolutionScale;


  SoSFBool subdivideTile;
  
  SoSFBool fixedNumSlicesInRoi;

  SoSFInt32 projectedTileSubdivision;

  SoSFBool opacityCorrection;

  enum RenderMode
  {
    VOLUME_RENDERING = 0,

    MIN_INTENSITY_PROJECTION,

    MAX_INTENSITY_PROJECTION,

    SUM_INTENSITY_PROJECTION,

    AVERAGE_INTENSITY_PROJECTION,

    MAX_INTENSITY_DIFFERENCE_ACCUMULATION,

    INTENSITY_DIFFERENCE_ACCUMULATION,

    MAX_GRADIENT_DIFFERENCE_ACCUMULATION,

    GRADIENT_DIFFERENCE_ACCUMULATION
  };

  SoSFEnum renderMode;

  enum SamplingAlignment
  {
    VIEW_ALIGNED = 0,
    DATA_ALIGNED,
    BOUNDARY_ALIGNED,
    SMOOTH_BOUNDARY_ALIGNED,
  };

  SoSFEnum samplingAlignment;

  SoSFFloat opacityThreshold;

  SoVolumeRender();

  void setRenderProgress(SoProgressIndicator* ps) { m_renderProgress = ps; }

  enum AbortCode {
    CONTINUE,
    ABORT,
    SKIP
  };

  typedef AbortCode SoVolumeRenderAbortCB(int totalElems, int thisElem, void *userData);

  void setAbortCallback( SoVolumeRenderAbortCB *func, void *userData = NULL);


#if 1             SoDEPRECATED
  SoSFBool  lighting;
SoDEPRECATED
  SoSFVec3f lightDirection;
SoDEPRECATED
  SoSFFloat lightIntensity;

#endif 
#if 1             SoDEPRECATED
  SoSFBool viewAlignedSlices;

#endif 
/*****************************************************************************/
private:
  virtual void computeBBox(SoAction *, SbBox3f &box, SbVec3f &center);

  virtual void rayPick(SoRayPickAction *action);

/*****************************************************************************/
private:

  static void initClass();

  static void exitClass();

  SoVolumeRenderingQuality* getVolumeRenderingQuality( SoState* state ) const;

  SoVolumeOffscreenImpl* getVolumeOffscreenImpl() const;

#if 1             SoDEPRECATED

#endif 
   bool needOivDepth(SoState* state);

   bool needRttColor(SoState* state) const;

   bool needRttEdgeDetect(SoState* state) const;

   bool needRttBoundaryDepth(SoState* state) const;

   bool needRttBoundaryColor(SoState* state) const;

   SamplingAlignment getSamplingAlignment(SoState* state) const;

   void removeDsFromRegList(SoDataSet* pDs);
   
   virtual void notify(SoNotList *list);

   void onUserInteractionChange(SoState*state, bool stopMoving);
   
/*****************************************************************************/
 private:
   // Destructor
   virtual ~SoVolumeRender();

   void createVolumeRender( SoState* state );

   void generatePrimitives(SoAction *action);

   void doRendering(SoGLRenderAction *action);

   void setupVolumeRenderInterface(SoState* state);

   SoDetail *createTriangleDetail(SoRayPickAction *,
                                  const SoPrimitiveVertex *v1,
                                  const SoPrimitiveVertex *,
                                  const SoPrimitiveVertex *,
                                  SoPickedPoint *);

   void beginOffscreenRendering( SoGLRenderAction* action );

   void endOffscreenRendering( SoGLRenderAction* action );

   void setupFrontToBackGlState(SoState* state);

  SbBool shouldGLRender(SoGLRenderAction *renderAction, SbBool isPointsOrLines);

/*****************************************************************************/
SoINTERNAL private:

  virtual void ldmAction(SoLdmValuationAction* action);

/*****************************************************************************/
private:

#if 1             SoDEPRECATED
  SoSFBool useEarlyZ;SoDEPRECATED
  SoSFInt32 numEarlyZPasses;SoDEPRECATED
  SoSFBool gpuVertexGen;
#endif  
   void fillDetail(SoRayPickAction* rpa, SoVolumeRenderDetail* detail, const SoLDM::DataSetIdPair& idPair);

   void genPrimDataSet(SoAction* action, const SoLDM::DataSetIdPair& idPair);

   bool canSubdivideTiles(SoState* state);

   bool isRaycastingEnabled(SoState* state) const;

  SoVolumeRenderAbortCB *m_abortCBfunc;
  void  *m_abortCBuserData;
  void   GLRenderTex2D3D(SoGLRenderAction* action);

   void useOffscreenRendering(SoGLRenderAction* action);

   void initInternalShaders();

  void setupDepthPeelingTextures(SoGLRenderAction *action);

  void rayPickDataSet(SoRayPickAction* action, const SoLDM::DataSetIdPair& idPair);

  SoVRImageSpaceEffects* m_imageSpaceEffects;

  int m_vpScale;

  int m_lowScreenResScale;

  SoShaderParameter1i *m_opacityTex;
  SoGLProgramGLSL* m_binaryOpacityComposeShader;

  SoShaderProgram* m_writeFragShader;

  SoVolumeIsosurface* m_volumeIsosurface;

  void deleteShadersFboTextures();

  void updateLowResScale( SoState* state );

  void registerCtxId(const SoLDM::DsVector &dsVector, int ctxId); 

  void unregisterCtxId(const SoLDM::DsVector &dsVector, int ctxId);

  bool m_useLowResMove;

  bool m_useLowNumSliceMove;

  SoVolumeRenderLdm* m_vriLdm;
  SoVolumeRenderRaycast* m_vriRaycast;
  SoVolumeRenderInterface* m_vri;

  bool m_frontToBackComposition;

  // List of dataset gathered in previous valuation action
  SoLDM::DsVector m_prevDsList;

  // Callback to manage deletion of dataset
  static void volDataDeleteCB(void* data, SoSensor *sensor);

  // ctxId attached to this volumeRender. Set by ValuationAction.
  int m_prevRegisteredCtxId;

  SoVolumeStateVr* m_vs;

  SoProgressIndicator* m_renderProgress;
  SoVolumeOffscreenImpl* m_volumeOffscreenImpl;

  // Associate a Node sensor to each DataSet managed
  std::map<SoDataSet*, SoNodeSensor*> m_mapDsSensor;

  friend class SoVolumeRenderInterface;
  friend class SoVolumeRenderLdm;
  friend class SoVolumeRenderRaycast;

  SoRef<SoGroup> m_depthPeelingSG;
  SoRef<SoGroup> m_depthPeelingColorTexGroup;
  SoRef<SoTextureUnit> m_depthPeelingColorTexUnit;
  SoRef<SoGroup> m_depthPeelingDepthTexGroup;
  SoRef<SoTextureUnit> m_depthPeelingDepthTexUnit;
};

#if defined(_WIN32)
#pragma warning( pop )
#endif

#endif // _SO_VOLUME_RENDER_

---

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