MeVisLab/Standard/Sources/Inventor/SoCSO/SoView2DCSOEditor/SoView2DCSOExtensibleEditor/SoCSOVisualizationSettings.h

Go to the documentation of this file.

// **InsertLicense** code
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------

#ifndef __SoCSOVisualizationSettings_H
#define __SoCSOVisualizationSettings_H

#include <SoCSODefines.h>


enum CSOPathPointStyle
{
  PATH_POINTS_STYLE_NONE         = 0,
  PATH_POINTS_STYLE_SOLID        = 1,
  PATH_POINTS_STYLE_DASHED       = 2,
  PATH_POINTS_STYLE_DOTTED       = 3,
  PATH_POINTS_STYLE_SHORT_DASHED = 4
};


enum CSOSeedPointStyle
{
  SEED_POINT_STYLE_NONE              = 0,
  SEED_POINT_STYLE_RECTANGLE         = 1,
  SEED_POINT_STYLE_CIRCLE            = 2,
  SEED_POINT_STYLE_FIXED_SIZE_CIRCLE = 3
};


enum CSOHighlightMode
{
  HIGHLIGHT_MODE_RELATIVE = 0, 
  HIGHLIGHT_MODE_ABSOLUTE = 1  
};


struct CSOPathPointsRenderSettings
{
  SbColor color;
  float alpha;
  float lineWidth;
  bool shouldRenderShadow;
  unsigned short stipplePattern;
};


class SoCSOVisualizationSettings;


ML_START_NAMESPACE

#define addMemberAndAccessMethod(type, name) \
  public:\
  type name() const { return _##name; } \
  private: \
  type _##name;

#define addMemberAndAccessMethodWithCSO(type, name) \
  public:\
  type name() const { return _##name; } \
  type name(CSO* cso) const; \
  private: \
  type _##name;


class CSOVisualizationSettings : public Base
{  
public:
  CSOVisualizationSettings();

  // Smart access methods. They regard the various modes and settings in the network.
  void  getPathPointsOnSliceColor(CSO* cso, SbColor& color, float& alpha, bool isMouseOver=false) const;
  unsigned short getPathPointsOnSliceStipplePattern(CSO* cso) const;
  unsigned short getPathPointsOnSliceStipplePattern() const;
  float getPathPointsOnSliceLineWidth(CSO* cso, bool isMouseOver=false) const;  
  void  getSeedPointOnSliceColor(CSO* cso, CSOSeedPoint* seedPoint, SbColor& color, float& alpha, bool isMouseOver=false) const;  
  float getSeedPointOnSliceSize (CSO* cso, CSOSeedPoint* seedPoint, bool isMouseOver=false) const;  
  
  void  getPathPointsBelowSliceColor(CSO* cso, SbColor& color, float& alpha, bool isMouseOver=false) const;
  unsigned short getPathPointsBelowSliceStipplePattern(CSO* cso) const;
  unsigned short getPathPointsBelowSliceStipplePattern() const;
  float getPathPointsBelowSliceLineWidth(CSO* cso, bool isMouseOver=false) const;
  void  getSeedPointBelowSliceColor(CSO* cso, CSOSeedPoint* seedPoint, SbColor& color, float& alpha, bool isMouseOver=false) const;
  float getSeedPointBelowSliceSize (CSO* cso, CSOSeedPoint* seedPoint, bool isMouseOver=false) const;

  void  getPathPointsAboveSliceColor(CSO* cso, SbColor& color, float& alpha, bool isMouseOver=false) const;
  unsigned short getPathPointsAboveSliceStipplePattern(CSO* cso) const;
  unsigned short getPathPointsAboveSliceStipplePattern() const;
  float getPathPointsAboveSliceLineWidth(CSO* cso, bool isMouseOver=false) const;
  void  getSeedPointAboveSliceColor(CSO* cso, CSOSeedPoint* seedPoint, SbColor& color, float& alpha, bool isMouseOver=false) const;
  float getSeedPointAboveSliceSize (CSO* cso, CSOSeedPoint* seedPoint, bool isMouseOver=false) const;

  // global settings
  addMemberAndAccessMethod(bool,    shouldUseAntiAliasing);
  addMemberAndAccessMethod(float,   globalAlphaFactor);

  // time points
  addMemberAndAccessMethod(bool,    showCSOsOnAllTimePoints);
  addMemberAndAccessMethod(bool,    overwriteCurrentTimePoint);
  addMemberAndAccessMethod(int,     newCurrentTimePoint);

  // parallel to slice
  addMemberAndAccessMethod(bool,    showOnlyParallelCSOs);
  addMemberAndAccessMethod(float,   showParallelThickness);

  // ghosting
  addMemberAndAccessMethod(int,     ghostingDepthInVoxel);

  // shadow
  addMemberAndAccessMethod(bool,    shouldRenderShadow);
  addMemberAndAccessMethod(SbColor, shadowColor);  
  addMemberAndAccessMethod(float,   shadowLineWidth);

  addMemberAndAccessMethod(bool,    shouldRenderSeedPoints);
  addMemberAndAccessMethod(bool,    shouldRenderPathPoints);  

  // seed points  
  addMemberAndAccessMethod(bool,    shouldOverwriteSeedPointsSettings);
  addMemberAndAccessMethod(bool,    shouldUsePathPointColorForSeedPoints);
  addMemberAndAccessMethod(bool,    shouldRenderSeedPointsOnlyForSelectedCSOs);

  addMemberAndAccessMethod(bool,    useSeedPointBelowSliceStyle);
  addMemberAndAccessMethod(bool,    useSeedPointBelowSliceSize);
  addMemberAndAccessMethod(bool,    useSeedPointBelowSliceColor);
  addMemberAndAccessMethod(bool,    useSeedPointBelowSliceAlpha);

  addMemberAndAccessMethod(bool,    useSeedPointAboveSliceStyle);
  addMemberAndAccessMethod(bool,    useSeedPointAboveSliceSize);
  addMemberAndAccessMethod(bool,    useSeedPointAboveSliceColor);
  addMemberAndAccessMethod(bool,    useSeedPointAboveSliceAlpha);

  // path points
  addMemberAndAccessMethod(bool,    shouldOverwritePathPointsSettings);   

  addMemberAndAccessMethod(bool,    usePathPointsBelowSliceLineStyle);
  addMemberAndAccessMethod(bool,    usePathPointsBelowSliceLineWidth);
  addMemberAndAccessMethod(bool,    usePathPointsBelowSliceColor);
  addMemberAndAccessMethod(bool,    usePathPointsBelowSliceAlpha);  

  addMemberAndAccessMethod(bool,    usePathPointsAboveSliceLineStyle);  
  addMemberAndAccessMethod(bool,    usePathPointsAboveSliceLineWidth);
  addMemberAndAccessMethod(bool,    usePathPointsAboveSliceColor);
  addMemberAndAccessMethod(bool,    usePathPointsAboveSliceAlpha);  

  addMemberAndAccessMethod(bool,    highlightSelectedGroups);   

  // selection style
  addMemberAndAccessMethod(bool,    shouldOverwriteSelectionSettings);  

  // mouse over style
  addMemberAndAccessMethod(bool,    enableMouseOverHighlighting);

  addMemberAndAccessMethod(int,     mouseOverPathPointsColorMode);
  addMemberAndAccessMethod(int,     mouseOverPathPointsLineWidthMode);  
  addMemberAndAccessMethod(float,   mouseOverPathPointsBrightenValue);
  addMemberAndAccessMethod(SbColor, mouseOverPathPointsFixedColor);  
  addMemberAndAccessMethod(float,   mouseOverPathPointsWidenValue);
  addMemberAndAccessMethod(float,   mouseOverPathPointsFixedLineWidth);

  addMemberAndAccessMethod(int,     mouseOverSeedPointColorMode);
  addMemberAndAccessMethod(int,     mouseOverSeedPointSizeMode);
  addMemberAndAccessMethod(float,   mouseOverSeedPointBrightenValue);  
  addMemberAndAccessMethod(SbColor, mouseOverSeedPointFixedColor);
  addMemberAndAccessMethod(float,   mouseOverSeedPointEnlargeValue);
  addMemberAndAccessMethod(float,   mouseOverSeedPointFixedSize);

private:
  float _mouseOverPathPointsAlpha;
  float _mouseOverSeedPointAlpha;
  float _shadowAlpha;
public:
  float mouseOverPathPointsAlpha() const { return _mouseOverPathPointsAlpha * _globalAlphaFactor; }
  float mouseOverSeedPointAlpha()  const { return _mouseOverSeedPointAlpha  * _globalAlphaFactor; }
  float shadowAlpha() const              { return _shadowAlpha              * _globalAlphaFactor; }


  addMemberAndAccessMethodWithCSO(int,     seedPointOnSliceStyle);
  addMemberAndAccessMethodWithCSO(float,   seedPointOnSliceSize);
  addMemberAndAccessMethodWithCSO(SbColor, seedPointOnSliceColor);
  addMemberAndAccessMethodWithCSO(float,   seedPointOnSliceAlpha);

  addMemberAndAccessMethodWithCSO(int,     seedPointBelowSliceStyle);
  addMemberAndAccessMethodWithCSO(float,   seedPointBelowSliceSize);
  addMemberAndAccessMethodWithCSO(SbColor, seedPointBelowSliceColor);
  addMemberAndAccessMethodWithCSO(float,   seedPointBelowSliceAlpha);

  addMemberAndAccessMethodWithCSO(int,     seedPointAboveSliceStyle);
  addMemberAndAccessMethodWithCSO(float,   seedPointAboveSliceSize);
  addMemberAndAccessMethodWithCSO(SbColor, seedPointAboveSliceColor);
  addMemberAndAccessMethodWithCSO(float,   seedPointAboveSliceAlpha);

  addMemberAndAccessMethodWithCSO(int,     pathPointsOnSliceLineStyle);
  addMemberAndAccessMethodWithCSO(float,   pathPointsOnSliceLineWidth);
  addMemberAndAccessMethodWithCSO(SbColor, pathPointsOnSliceColor);
  addMemberAndAccessMethodWithCSO(float,   pathPointsOnSliceAlpha);

  addMemberAndAccessMethodWithCSO(int,     pathPointsBelowSliceLineStyle);
  addMemberAndAccessMethodWithCSO(float,   pathPointsBelowSliceLineWidth);
  addMemberAndAccessMethodWithCSO(SbColor, pathPointsBelowSliceColor);
  addMemberAndAccessMethodWithCSO(float,   pathPointsBelowSliceAlpha);

  addMemberAndAccessMethodWithCSO(float,   pathPointsAboveSliceLineWidth);
  addMemberAndAccessMethodWithCSO(SbColor, pathPointsAboveSliceColor);
  addMemberAndAccessMethodWithCSO(float,   pathPointsAboveSliceAlpha);
  addMemberAndAccessMethodWithCSO(int,     pathPointsAboveSliceLineStyle);  

  addMemberAndAccessMethodWithCSO(int,     selectedPathPointsColorMode);  
  addMemberAndAccessMethodWithCSO(int,     selectedPathPointsLineWidthMode);
  addMemberAndAccessMethodWithCSO(float,   selectedPathPointsBrightenValue);
  addMemberAndAccessMethodWithCSO(SbColor, selectedPathPointsFixedColor);  
  addMemberAndAccessMethodWithCSO(float,   selectedPathPointsAlpha);
  addMemberAndAccessMethodWithCSO(float,   selectedPathPointsWidenValue);
  addMemberAndAccessMethodWithCSO(float,   selectedPathPointsFixedLineWidth);

  addMemberAndAccessMethodWithCSO(int,     selectedSeedPointColorMode);
  addMemberAndAccessMethodWithCSO(int,     selectedSeedPointSizeMode);
  addMemberAndAccessMethodWithCSO(float,   selectedSeedPointBrightenValue);  
  addMemberAndAccessMethodWithCSO(SbColor, selectedSeedPointFixedColor);
  addMemberAndAccessMethodWithCSO(float,   selectedSeedPointAlpha);
  addMemberAndAccessMethodWithCSO(float,   selectedSeedPointEnlargeValue);
  addMemberAndAccessMethodWithCSO(float,   selectedSeedPointFixedSize);

private:

  bool isSelected(CSO* cso) const { return cso->getCSOList()->isSelected(cso); }
  bool isSelected(CSO* cso, CSOSeedPoint* seedPoint) const { return cso->isSelectedSeedPoint(seedPoint); }

  SbColor sbColor(const Vector3& color) const { return SbColor(color[0], color[1], color[2]); }
  // components' values to [0..1].
  void multiplyColorAndClamp(SbColor& color, float factor) const;
  void multiplyValueAndClamp(float& value, float factor, float maxValue=1.0f) const;
  void addValueAndClamp(float& value, float factor, float maxValue=8.0f) const;
  unsigned short stipplePattern(int enumIndex) const
  {
    switch (enumIndex)
    {
    case 0:  return LINE_PATTERN_NONE;
    case 1:  return LINE_PATTERN_SOLID;
    case 2:  return LINE_PATTERN_DASHED;
    case 3:  return LINE_PATTERN_DOTTED;
    case 4:  return LINE_PATTERN_SHORT_DASHED;
    default: return LINE_PATTERN_SOLID;
    }
  }

  friend class ::SoCSOVisualizationSettings;

  ML_CLASS_HEADER(CSOVisualizationSettings);
};

#undef addMemberAndAccessMethodWithCSO
#undef addMemberAndAccessMethod

ML_END_NAMESPACE


class SoCSOVisualizationSettings : public SoNode
{
  SO_NODE_HEADER(SoCSOVisualizationSettings);

public:

  SoCSOVisualizationSettings();

  static void initClass();


  // Output settings
  SoSFMLBase outVisualizationSettings;

  SoSFBool autoApply;
  SoSFTrigger apply;

  // global settings
  SoSFBool  shouldUseAntiAliasing;
  SoSFFloat globalAlphaFactor;

  // time points
  SoSFBool  showCSOsOnAllTimePoints;
  SoSFBool  overwriteCurrentTimePoint;
  SoSFInt32 newCurrentTimePoint;

  // parallel to slice
  SoSFBool  showOnlyParallelCSOs;
  SoSFFloat showParallelThickness;

  // ghosting
  SoSFInt32 ghostingDepthInVoxel;

  // shadow
  SoSFBool shouldRenderShadow;

  SoSFColor shadowColor;
  SoSFFloat shadowAlpha;
  SoSFFloat shadowLineWidth;

  SoSFBool shouldRenderSeedPoints;
  SoSFBool shouldRenderPathPoints;

  // seed points
  SoSFBool shouldOverwriteSeedPointsSettings;
  SoSFBool shouldUsePathPointColorForSeedPoints;
  SoSFBool shouldRenderSeedPointsOnlyForSelectedCSOs;

  SoSFEnum  seedPointOnSliceStyle;
  SoSFFloat seedPointOnSliceSize;
  SoSFColor seedPointOnSliceColor;
  SoSFFloat seedPointOnSliceAlpha;

  SoSFBool useSeedPointBelowSliceStyle;
  SoSFBool useSeedPointBelowSliceSize;
  SoSFBool useSeedPointBelowSliceColor;
  SoSFBool useSeedPointBelowSliceAlpha;

  SoSFEnum  seedPointBelowSliceStyle;
  SoSFFloat seedPointBelowSliceSize;
  SoSFColor seedPointBelowSliceColor;
  SoSFFloat seedPointBelowSliceAlpha;

  SoSFBool useSeedPointAboveSliceStyle;
  SoSFBool useSeedPointAboveSliceSize;
  SoSFBool useSeedPointAboveSliceColor;
  SoSFBool useSeedPointAboveSliceAlpha;

  SoSFEnum  seedPointAboveSliceStyle;
  SoSFFloat seedPointAboveSliceSize;
  SoSFColor seedPointAboveSliceColor;
  SoSFFloat seedPointAboveSliceAlpha;

  // path points
  SoSFBool shouldOverwritePathPointsSettings;

  SoSFFloat pathPointsOnSliceLineWidth;
  SoSFColor pathPointsOnSliceColor;
  SoSFFloat pathPointsOnSliceAlpha;
  SoSFEnum  pathPointsOnSliceLineStyle;

  SoSFBool usePathPointsBelowSliceLineWidth;
  SoSFBool usePathPointsBelowSliceColor;
  SoSFBool usePathPointsBelowSliceAlpha;
  SoSFBool usePathPointsBelowSliceLineStyle;

  SoSFFloat pathPointsBelowSliceLineWidth;
  SoSFColor pathPointsBelowSliceColor;
  SoSFFloat pathPointsBelowSliceAlpha;
  SoSFEnum  pathPointsBelowSliceLineStyle;

  SoSFBool usePathPointsAboveSliceLineWidth;
  SoSFBool usePathPointsAboveSliceColor;
  SoSFBool usePathPointsAboveSliceAlpha;
  SoSFBool usePathPointsAboveSliceLineStyle;  

  SoSFFloat pathPointsAboveSliceLineWidth;
  SoSFColor pathPointsAboveSliceColor;
  SoSFFloat pathPointsAboveSliceAlpha;
  SoSFEnum  pathPointsAboveSliceLineStyle;  

  // selection misc
  SoSFBool  highlightSelectedGroups;

  // selection style
  SoSFBool shouldOverwriteSelectionSettings;  

  SoSFEnum  selectedPathPointsColorMode;  
  SoSFEnum  selectedPathPointsLineWidthMode;
  SoSFFloat selectedPathPointsBrightenValue;
  SoSFColor selectedPathPointsFixedColor;  
  SoSFFloat selectedPathPointsAlpha;
  SoSFFloat selectedPathPointsWidenValue;
  SoSFFloat selectedPathPointsFixedLineWidth;

  SoSFEnum  selectedSeedPointColorMode;
  SoSFEnum  selectedSeedPointSizeMode;
  SoSFFloat selectedSeedPointBrightenValue;  
  SoSFColor selectedSeedPointFixedColor;
  SoSFFloat selectedSeedPointAlpha;
  SoSFFloat selectedSeedPointEnlargeValue;
  SoSFFloat selectedSeedPointFixedSize;

  // mouse over style
  SoSFBool enableMouseOverHighlighting;

  SoSFEnum  mouseOverPathPointsColorMode;
  SoSFEnum  mouseOverPathPointsLineWidthMode;  
  SoSFFloat mouseOverPathPointsBrightenValue;
  SoSFColor mouseOverPathPointsFixedColor;
  SoSFFloat mouseOverPathPointsAlpha;
  SoSFFloat mouseOverPathPointsWidenValue;
  SoSFFloat mouseOverPathPointsFixedLineWidth;

  SoSFEnum  mouseOverSeedPointColorMode;
  SoSFEnum  mouseOverSeedPointSizeMode;
  SoSFFloat mouseOverSeedPointBrightenValue;  
  SoSFColor mouseOverSeedPointFixedColor;
  SoSFFloat mouseOverSeedPointAlpha;
  SoSFFloat mouseOverSeedPointEnlargeValue;
  SoSFFloat mouseOverSeedPointFixedSize;

protected:

  ~SoCSOVisualizationSettings();

private:

  SoNodeSensor *_nodeSensor;  
  static void nodeChangedCB(void *data, SoDataSensor* a);  
  void        nodeChanged(SoDataSensor* sensor);

  void setSettingsToFieldValues();

  ml::CSOVisualizationSettings _visualizationSettings;
};


#endif // __SoCSOVisualizationSettings_H