vtkMRMLPlotChartNode.h

Go to the documentation of this file.

/*==============================================================================
 
  Copyright (c) Kapteyn Astronomical Institute
  University of Groningen, Groningen, Netherlands. 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 Davide Punzo, Kapteyn Astronomical Institute,
  and was supported through the European Research Council grant nr. 291531.
 
==============================================================================*/
 
#ifndef __vtkMRMLPlotChartNode_h
#define __vtkMRMLPlotChartNode_h
 
#include "vtkMRMLNode.h"
 
class vtkCollection;
class vtkDataObject;
class vtkMRMLPlotSeriesNode;
class vtkStringArray;
 
#include <string>

class VTK_MRML_EXPORT vtkMRMLPlotChartNode : public vtkMRMLNode
{
public:
  //----------------------------------------------------------------
  //----------------------------------------------------------------
 
  static vtkMRMLPlotChartNode* New();
  vtkTypeMacro(vtkMRMLPlotChartNode, vtkMRMLNode);
 
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  vtkMRMLNode* CreateNodeInstance() override;

  void ReadXMLAttributes(const char** atts) override;

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

  vtkMRMLCopyContentMacro(vtkMRMLPlotChartNode);

  const char* GetNodeTagName() override { return "PlotChart"; };

  void ProcessMRMLEvents(vtkObject* caller, unsigned long event, void* callData) override;

  enum
  {
    PlotModifiedEvent = 17000,
  };

  enum PlotSeriesNodeProperty
  {
    PlotType,
    PlotXColumnName,
    PlotYColumnName,
    PlotMarkerStyle
  };
 
  //----------------------------------------------------------------
  //----------------------------------------------------------------

  const char* GetPlotSeriesNodeID();

  vtkMRMLPlotSeriesNode* GetPlotSeriesNode();

  const char* GetNthPlotSeriesNodeID(int n);

  vtkMRMLPlotSeriesNode* GetNthPlotSeriesNode(int n);

  int GetPlotSeriesNodeIndexFromID(const char* plotSeriesNodeID);

  virtual int GetPlotSeriesNodeIDs(std::vector<std::string>& plotSeriesNodeIDs);

  virtual int GetPlotSeriesNodeNames(std::vector<std::string>& plotSeriesNodeNames);

  int GetNumberOfPlotSeriesNodes();

  void AddAndObservePlotSeriesNodeID(const char* plotSeriesNodeID);

  void SetAndObservePlotSeriesNodeID(const char* plotSeriesNodeID);

  void SetAndObserveNthPlotSeriesNodeID(int n, const char* plotSeriesNodeID);

  void RemovePlotSeriesNodeID(const char* plotSeriesNodeID);

  void RemoveNthPlotSeriesNodeID(int n);

  void RemoveAllPlotSeriesNodeIDs();

  bool HasPlotSeriesNodeID(const char* plotSeriesNodeID);

  vtkSetStringMacro(Title);
  vtkGetStringMacro(Title);

  vtkSetMacro(TitleFontSize, int);
  vtkGetMacro(TitleFontSize, int);

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

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

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

  vtkSetMacro(LegendFontSize, int);
  vtkGetMacro(LegendFontSize, int);
 
  vtkGetMacro(XAxisRangeAuto, bool);
  vtkSetMacro(XAxisRangeAuto, bool);
  vtkBooleanMacro(XAxisRangeAuto, bool);
 
  vtkGetMacro(YAxisRangeAuto, bool);
  vtkSetMacro(YAxisRangeAuto, bool);
  vtkBooleanMacro(YAxisRangeAuto, bool);
 
  vtkGetVector2Macro(XAxisRange, double);
  vtkSetVector2Macro(XAxisRange, double);
 
  vtkGetVector2Macro(YAxisRange, double);
  vtkSetVector2Macro(YAxisRange, double);

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

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

  vtkSetStringMacro(XAxisTitle);
  vtkGetStringMacro(XAxisTitle);

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

  vtkSetStringMacro(YAxisTitle);
  vtkGetStringMacro(YAxisTitle);

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

  vtkSetMacro(AxisTitleFontSize, int);
  vtkGetMacro(AxisTitleFontSize, int);

  vtkSetMacro(AxisLabelFontSize, int);
  vtkGetMacro(AxisLabelFontSize, int);

  vtkSetStringMacro(FontType);
  vtkGetStringMacro(FontType);

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

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

  virtual const char* GetPlotSeriesNodeReferenceRole();

  void SetPropertyToAllPlotSeriesNodes(PlotSeriesNodeProperty plotProperty, const char* value);

  bool GetPropertyFromAllPlotSeriesNodes(PlotSeriesNodeProperty plotProperty, std::string& value);
 
protected:
  //----------------------------------------------------------------
  //----------------------------------------------------------------
  vtkMRMLPlotChartNode();
  ~vtkMRMLPlotChartNode() override;
  vtkMRMLPlotChartNode(const vtkMRMLPlotChartNode&);
  void operator=(const vtkMRMLPlotChartNode&);

  void OnNodeReferenceAdded(vtkMRMLNodeReference* reference) override;

  void OnNodeReferenceModified(vtkMRMLNodeReference* reference) override;

  void OnNodeReferenceRemoved(vtkMRMLNodeReference* reference) override;
 
  static const char* PlotSeriesNodeReferenceRole;
 
  char* Title{ nullptr };
  int TitleFontSize{ 20 };
  bool TitleVisibility{ true };
  bool GridVisibility{ true };
  bool LegendVisibility{ true };
  int LegendFontSize{ 16 };
  bool XAxisRangeAuto{ true };
  bool YAxisRangeAuto{ true };
  double XAxisRange[2];
  double YAxisRange[2];
  bool XAxisLogScale{ false };
  bool YAxisLogScale{ false };
  char* XAxisTitle{ nullptr };
  bool XAxisTitleVisibility{ true };
  char* YAxisTitle{ nullptr };
  bool YAxisTitleVisibility{ true };
  int AxisTitleFontSize{ 16 };
  int AxisLabelFontSize{ 12 };
  char* FontType{ nullptr };
  bool EnablePointMoveAlongX{ true };
  bool EnablePointMoveAlongY{ true };
};
 
#endif