vtkMRMLSegmentationDisplayNode.h

Go to the documentation of this file.

/*==============================================================================
 
  Program: 3D Slicer
 
  Copyright (c) Laboratory for Percutaneous Surgery (PerkLab)
  Queen's University, Kingston, ON, Canada. All Rights Reserved.
 
  See COPYRIGHT.txt
  or http://www.slicer.org/copyright/copyright.txt for details.
 
  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
 
  This file was originally developed by Csaba Pinter, PerkLab, Queen's University
  and was supported through the Applied Cancer Research Unit program of Cancer Care
  Ontario with funds provided by the Ontario Ministry of Health and Long-Term Care
 
==============================================================================*/
 
#ifndef __vtkMRMLSegmentationDisplayNode_h
#define __vtkMRMLSegmentationDisplayNode_h
 
#include "vtkMRMLDisplayNode.h"
 
#include <set>
 
class vtkMRMLColorTableNode;
class vtkSegmentation;
class vtkStringArray;
class vtkVector3d;

class VTK_MRML_EXPORT vtkMRMLSegmentationDisplayNode : public vtkMRMLDisplayNode
{
public:
  // Define constants
  static const double SEGMENT_COLOR_NO_OVERRIDE;

  struct SegmentDisplayProperties
  {
    double OverrideColor[3];
    bool Visible{ true }; // Turns visibility on/off in general. Useful for allowing the user to show/hide a segment without changing any detailed visibility options.
    bool Visible3D{ true };
    bool Visible2DFill{ true }; // This one is used for labelmap volume related operations (color table, merged labelmap)
    bool Visible2DOutline{ true };
    double Opacity3D{ 1.0 };
    double Opacity2DFill{ 1.0 }; // This one is used for labelmap volume related operations (color table, merged labelmap)
    double Opacity2DOutline{ 1.0 };
    bool Pickable{ true };
 
    // Initialize with default values
    SegmentDisplayProperties()
    {
      OverrideColor[0] = SEGMENT_COLOR_NO_OVERRIDE;
      OverrideColor[1] = SEGMENT_COLOR_NO_OVERRIDE;
      OverrideColor[2] = SEGMENT_COLOR_NO_OVERRIDE;
    }
 
    // Automatically generated operator= and copy constructor work
    // correctly for these members, so there is no need to define them.
 
    bool operator==(const SegmentDisplayProperties& rhs) const
    {
      // color comparison
      for (int i = 0; i < 3; ++i)
      {
        if (fabs(OverrideColor[i] - rhs.OverrideColor[i]) > VTK_DBL_EPSILON)
        {
          return false;
        }
      }
      return                                        //
        Visible == rhs.Visible                      //
        && Visible3D == rhs.Visible3D               //
        && Visible2DFill == rhs.Visible2DFill       //
        && Visible2DOutline == rhs.Visible2DOutline //
        && Opacity3D == rhs.Opacity3D               //
        && Opacity2DFill == rhs.Opacity2DFill       //
        && Opacity2DOutline == rhs.Opacity2DOutline //
        && Pickable == rhs.Pickable;
    }
  };
 
  typedef std::map<std::string, SegmentDisplayProperties> SegmentDisplayPropertiesMap;
 
public:
  static vtkMRMLSegmentationDisplayNode* New();
  vtkTypeMacro(vtkMRMLSegmentationDisplayNode, vtkMRMLDisplayNode);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  vtkMRMLNode* CreateNodeInstance() override;

  void ReadXMLAttributes(const char** atts) override;

  void WriteXML(ostream& of, int indent) override;

  vtkMRMLCopyContentMacro(vtkMRMLSegmentationDisplayNode);

  const char* GetNodeTagName() override { return "SegmentationDisplay"; }
 
public:
  vtkGetStringMacro(PreferredDisplayRepresentationName2D);
  vtkSetStringMacro(PreferredDisplayRepresentationName2D);
  vtkGetStringMacro(PreferredDisplayRepresentationName3D);
  vtkSetStringMacro(PreferredDisplayRepresentationName3D);

  vtkGetMacro(Visibility2DFill, bool);
  vtkSetMacro(Visibility2DFill, bool);
  vtkBooleanMacro(Visibility2DFill, bool);
  vtkGetMacro(Visibility2DOutline, bool);
  vtkSetMacro(Visibility2DOutline, bool);
  vtkBooleanMacro(Visibility2DOutline, bool);

  vtkGetMacro(Opacity3D, double);
  vtkSetMacro(Opacity3D, double);
  vtkGetMacro(Opacity2DFill, double);
  vtkSetMacro(Opacity2DFill, double);
  vtkGetMacro(Opacity2DOutline, double);
  vtkSetMacro(Opacity2DOutline, double);
 
public:
  bool GetSegmentDisplayProperties(std::string segmentID, SegmentDisplayProperties& properties);

  void SetSegmentDisplayProperties(std::string segmentID, SegmentDisplayProperties& properties);

  void SetSegmentDisplayPropertiesToDefault(const std::string& segmentId);

  void RemoveSegmentDisplayProperties(std::string segmentID);

  void ClearSegmentDisplayProperties();

  bool CalculateAutoOpacitiesForSegments();

  void GenerateSegmentColor(double color[3], int colorNumber = 0);
  void GenerateSegmentColor(double& r, double& g, double& b);


  void SetSegmentColorGeneratorSourceColorNodeID(const char* colorNodeID);
  const char* GetSegmentColorGeneratorSourceColorNodeID();

  void GetPolyDataRepresentationNames(std::set<std::string>& representationNames);

  std::string GetDisplayRepresentationName3D();

  std::string GetDisplayRepresentationName2D();
 
  // Convenience and python compatibility functions
public:
  vtkVector3d GetSegmentColor(std::string segmentID);
  bool GetSegmentColor(std::string segmentID, double* color);
  bool GetSegmentColor(std::string segmentID, double& r, double& g, double& b);

  vtkVector3d GetSegmentOverrideColor(std::string segmentID);
  void SetSegmentOverrideColor(std::string segmentID, double r, double g, double b);
  void SetSegmentOverrideColor(std::string segmentID, vtkVector3d overrideColor);
  void UnsetSegmentOverrideColor(std::string segmentID);

  bool GetSegmentVisibility(std::string segmentID);
  void SetSegmentVisibility(std::string segmentID, bool visible);
  void SetAllSegmentsVisibility(bool visible);

  bool GetSegmentVisibility3D(std::string segmentID);
  void SetSegmentVisibility3D(std::string segmentID, bool visible);
  void SetAllSegmentsVisibility3D(bool visible, bool changeVisibleSegmentsOnly = false);

  bool GetSegmentVisibility2DFill(std::string segmentID);
  void SetSegmentVisibility2DFill(std::string segmentID, bool visible);
  void SetAllSegmentsVisibility2DFill(bool visible, bool changeVisibleSegmentsOnly = false);

  bool GetSegmentVisibility2DOutline(std::string segmentID);
  void SetSegmentVisibility2DOutline(std::string segmentID, bool visible);
  void SetAllSegmentsVisibility2DOutline(bool visible, bool changeVisibleSegmentsOnly = false);

  double GetSegmentOpacity3D(std::string segmentID);
  void SetSegmentOpacity3D(std::string segmentID, double opacity);
  void SetAllSegmentsOpacity3D(double opacity, bool changeVisibleSegmentsOnly = false);

  double GetSegmentOpacity2DFill(std::string segmentID);
  void SetSegmentOpacity2DFill(std::string segmentID, double opacity);
  void SetAllSegmentsOpacity2DFill(double opacity, bool changeVisibleSegmentsOnly = false);

  double GetSegmentOpacity2DOutline(std::string segmentID);
  void SetSegmentOpacity2DOutline(std::string segmentID, double opacity);
  void SetAllSegmentsOpacity2DOutline(double opacity, bool changeVisibleSegmentsOnly = false);

  void SetSegmentOpacity(std::string segmentID, double opacity);
  void SetAllSegmentsOpacity(double opacity, bool changeVisibleSegmentsOnly = false);

  bool GetSegmentPickable(std::string segmentID);
  void SetSegmentPickable(std::string segmentID, bool pickable);
  void SetAllSegmentsPickable(bool pickable, bool changeVisibleSegmentsOnly = false);

  void GetVisibleSegmentIDs(vtkStringArray* segmentIDs);

  void GetVisibleSegmentIDs(std::vector<std::string>& segmentIDs);

  std::vector<std::string> GetVisibleSegmentIDs();


  vtkGetMacro(RemoveUnusedDisplayProperties, bool);
  vtkSetMacro(RemoveUnusedDisplayProperties, bool);
  vtkBooleanMacro(RemoveUnusedDisplayProperties, bool);


  vtkGetMacro(ClippingCapSurface, bool);
  vtkSetMacro(ClippingCapSurface, bool);
  vtkBooleanMacro(ClippingCapSurface, bool);


  vtkGetMacro(ClippingCapOpacity, double);
  vtkSetMacro(ClippingCapOpacity, double);


  vtkGetMacro(ClippingOutline, bool);
  vtkSetMacro(ClippingOutline, bool);
  vtkBooleanMacro(ClippingOutline, bool);
 
protected:
  void GetSegmentIDs(std::vector<std::string>& segmentIDs, bool visibleSegmentsOnly);


  void UpdateSegmentList();
  void UpdateSegmentList(bool removeUnusedDisplayProperties);
 
protected:
  vtkMRMLSegmentationDisplayNode();
  ~vtkMRMLSegmentationDisplayNode() override;
  vtkMRMLSegmentationDisplayNode(const vtkMRMLSegmentationDisplayNode&);
  void operator=(const vtkMRMLSegmentationDisplayNode&);
 
  friend class vtkMRMLSegmentationNode; // Access to UpdateSegmentList();
 
protected:
  char* PreferredDisplayRepresentationName2D{ nullptr };

  char* PreferredDisplayRepresentationName3D{ nullptr };

  SegmentDisplayPropertiesMap SegmentationDisplayProperties;

  unsigned int NumberOfGeneratedColors{ 0 };

  vtkMTimeType SegmentListUpdateTime{ 0 };
  vtkSegmentation* SegmentListUpdateSource{ nullptr };

  bool Visibility2DFill{ true };
  bool Visibility2DOutline{ true };

  double Opacity3D{ 1.0 };
  double Opacity2DFill{ 0.5 };
  double Opacity2DOutline{ 1.0 };
 
  bool RemoveUnusedDisplayProperties{ true };
 
  bool ClippingCapSurface{ false };
  double ClippingCapOpacity{ 1.0 };
  bool ClippingOutline{ false };
};
 
#endif