CSOVisualizationSettings.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2012, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
 
 
#pragma once
 
#include <SoCSOSystem.h>
#include <SoCSODefines.h>
 
enum CSOHighlightMode
{
  HIGHLIGHT_MODE_RELATIVE = 0, 
  HIGHLIGHT_MODE_ABSOLUTE = 1  
};
 
enum CSOOrientationFilterMode
{
  ORIENTATION_MODE_ALL = 0, 
  ORIENTATION_MODE_PARALLEL = 1, 
  ORIENTATION_MODE_NON_PARALLEL = 2  
};
 
 
enum CSOParallelThicknessMode
{
  PARALLEL_THICKNESS_MODE_ABSOLUTE_MM = 0,  
  PARALLEL_THICKNESS_MODE_RELATIVE_TO_SLICE 
};
 
ML_START_NAMESPACE
 
#define addMemberAndAccessMethod(type, name) \
  public: \
  type name() const { return _##name; } \
  void name(type value) { _##name = value; } \
  protected: \
  type _##name;
 
#define addMemberAndAccessMethodWithCSO(type, name) \
  public: \
  type name() const { return _##name; } \
  virtual type name(CSO* cso) const; \
  void name(type value) { _##name = value; } \
  protected: \
  type _##name;
 
 
class SOCSO_EXPORT CSOVisualizationSettings : public Base
{
public:
  CSOVisualizationSettings();
 
  // Smart access methods. They regard the various modes and settings in the network.
  virtual void  getPathPointsOnSliceColor(CSO* cso, SbColor& color, float& alpha, bool isMouseOver=false) const;
  virtual unsigned short getPathPointsOnSliceStipplePattern(CSO* cso) const;
  virtual unsigned short getPathPointsOnSliceStipplePattern() const;
  virtual float getPathPointsOnSliceLineWidth(CSO* cso, bool isMouseOver=false) const;
  virtual void  getSeedPointOnSliceColor(CSO* cso, CSOSeedPoint* seedPoint, SbColor& color, float& alpha, bool isMouseOver=false) const;
  virtual float getSeedPointOnSliceSize (CSO* cso, CSOSeedPoint* seedPoint, bool isMouseOver=false) const;
 
  virtual void  getPathPointsBelowSliceColor(CSO* cso, SbColor& color, float& alpha, bool isMouseOver=false) const;
  virtual unsigned short getPathPointsBelowSliceStipplePattern(CSO* cso) const;
  virtual unsigned short getPathPointsBelowSliceStipplePattern() const;
  virtual float getPathPointsBelowSliceLineWidth(CSO* cso, bool isMouseOver=false) const;
  virtual void  getSeedPointBelowSliceColor(CSO* cso, CSOSeedPoint* seedPoint, SbColor& color, float& alpha, bool isMouseOver=false) const;
  virtual float getSeedPointBelowSliceSize (CSO* cso, CSOSeedPoint* seedPoint, bool isMouseOver=false) const;
 
  virtual void  getPathPointsAboveSliceColor(CSO* cso, SbColor& color, float& alpha, bool isMouseOver=false) const;
  virtual unsigned short getPathPointsAboveSliceStipplePattern(CSO* cso) const;
  virtual unsigned short getPathPointsAboveSliceStipplePattern() const;
  virtual float getPathPointsAboveSliceLineWidth(CSO* cso, bool isMouseOver=false) const;
  virtual void  getSeedPointAboveSliceColor(CSO* cso, CSOSeedPoint* seedPoint, SbColor& color, float& alpha, bool isMouseOver=false) const;
  virtual float getSeedPointAboveSliceSize (CSO* cso, CSOSeedPoint* seedPoint, bool isMouseOver=false) const;
 
  virtual bool isCSOVisible(CSO* cso);
 
  // global settings
  addMemberAndAccessMethod(bool,    shouldUseAntiAliasing);
  addMemberAndAccessMethod(float,   globalAlphaFactor);
 
  // time points
  addMemberAndAccessMethod(bool,    showCSOsOnAllTimePoints);
  addMemberAndAccessMethod(bool,    overwriteCurrentTimePoint);
  addMemberAndAccessMethod(int,     newCurrentTimePoint);
 
  // parallel to slice
  addMemberAndAccessMethod(int,     orientationFilterMode);
  addMemberAndAccessMethod(int,     parallelThicknessMode);
  addMemberAndAccessMethod(float,   showParallelThickness);
 
  // ghosting
  addMemberAndAccessMethod(int,     ghostingDepthInVoxel);
  addMemberAndAccessMethod(int,     voxelSlabAugment);
 
  // 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,    useSeedPointOnSliceStyle);
  addMemberAndAccessMethod(bool,    useSeedPointOnSliceSize);
  addMemberAndAccessMethod(bool,    useSeedPointOnSliceColor);
  addMemberAndAccessMethod(bool,    useSeedPointOnSliceAlpha);
  addMemberAndAccessMethod(bool,    useSeedPointOnSliceLineWidth);
 
  addMemberAndAccessMethod(bool,    useSeedPointBelowSliceStyle);
  addMemberAndAccessMethod(bool,    useSeedPointBelowSliceSize);
  addMemberAndAccessMethod(bool,    useSeedPointBelowSliceColor);
  addMemberAndAccessMethod(bool,    useSeedPointBelowSliceAlpha);
  addMemberAndAccessMethod(bool,    useSeedPointBelowSliceLineWidth);
 
  addMemberAndAccessMethod(bool,    useSeedPointAboveSliceStyle);
  addMemberAndAccessMethod(bool,    useSeedPointAboveSliceSize);
  addMemberAndAccessMethod(bool,    useSeedPointAboveSliceColor);
  addMemberAndAccessMethod(bool,    useSeedPointAboveSliceAlpha);
  addMemberAndAccessMethod(bool,    useSeedPointAboveSliceLineWidth);
 
  // path points
  addMemberAndAccessMethod(bool,    shouldOverwritePathPointsSettings);
 
 
  addMemberAndAccessMethod(bool,    usePathPointsOnSliceLineStyle);
  addMemberAndAccessMethod(bool,    usePathPointsOnSliceLineWidth);
  addMemberAndAccessMethod(bool,    usePathPointsOnSliceColor);
  addMemberAndAccessMethod(bool,    usePathPointsOnSliceAlpha);
 
  addMemberAndAccessMethod(bool,    usePathPointsBelowSliceLineStyle);
  addMemberAndAccessMethod(bool,    usePathPointsBelowSliceLineWidth);
  addMemberAndAccessMethod(bool,    usePathPointsBelowSliceColor);
  addMemberAndAccessMethod(bool,    usePathPointsBelowSliceAlpha);
 
  addMemberAndAccessMethod(bool,    usePathPointsAboveSliceLineStyle);
  addMemberAndAccessMethod(bool,    usePathPointsAboveSliceLineWidth);
  addMemberAndAccessMethod(bool,    usePathPointsAboveSliceColor);
  addMemberAndAccessMethod(bool,    usePathPointsAboveSliceAlpha);
 
  // 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);
 
 
  addMemberAndAccessMethod(float, mouseOverPathPointsAlpha);
  addMemberAndAccessMethod(float, mouseOverSeedPointAlpha);
  addMemberAndAccessMethod(float, shadowAlpha);
 
 
  addMemberAndAccessMethodWithCSO(int,     seedPointOnSliceStyle);
  addMemberAndAccessMethodWithCSO(float,   seedPointOnSliceSize);
  addMemberAndAccessMethodWithCSO(SbColor, seedPointOnSliceColor);
  addMemberAndAccessMethodWithCSO(float,   seedPointOnSliceAlpha);
  addMemberAndAccessMethodWithCSO(float,   seedPointOnSliceLineWidth);
 
  addMemberAndAccessMethodWithCSO(int,     seedPointBelowSliceStyle);
  addMemberAndAccessMethodWithCSO(float,   seedPointBelowSliceSize);
  addMemberAndAccessMethodWithCSO(SbColor, seedPointBelowSliceColor);
  addMemberAndAccessMethodWithCSO(float,   seedPointBelowSliceAlpha);
  addMemberAndAccessMethodWithCSO(float,   seedPointBelowSliceLineWidth);
 
  addMemberAndAccessMethodWithCSO(int,     seedPointAboveSliceStyle);
  addMemberAndAccessMethodWithCSO(float,   seedPointAboveSliceSize);
  addMemberAndAccessMethodWithCSO(SbColor, seedPointAboveSliceColor);
  addMemberAndAccessMethodWithCSO(float,   seedPointAboveSliceAlpha);
  addMemberAndAccessMethodWithCSO(float,   seedPointAboveSliceLineWidth);
 
  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);
 
protected:
 
  bool isHighlighted(CSO* cso) const;
 
  bool _isInSelectedGroup(CSO *cso) const;
  bool isSelected(CSO* cso, CSOSeedPoint* seedPoint) const;
 
 
  SbColor sbColor(const Vector3& color) const { return SbColor(static_cast<float>(color[0]), static_cast<float>(color[1]), static_cast<float>(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 PATH_POINTS_PATTERN_NONE;
    case 1:  return PATH_POINTS_PATTERN_SOLID;
    case 2:  return PATH_POINTS_PATTERN_DASHED;
    case 3:  return PATH_POINTS_PATTERN_DOTTED;
    case 4:  return PATH_POINTS_PATTERN_SHORT_DASHED;
    default: return PATH_POINTS_PATTERN_SOLID;
    }
  }
 
  ML_CLASS_HEADER(CSOVisualizationSettings);
};
 
#undef addMemberAndAccessMethodWithCSO
#undef addMemberAndAccessMethod
 
ML_END_NAMESPACE