vtkMRMLXYPlotManagerNode.h

Go to the documentation of this file.

/*=auto=========================================================================

  Portions (c) Copyright 2009 Brigham and Women's Hospital (BWH) All Rights Reserved.

  See Doc/copyright/copyright.txt
  or http://www.slicer.org/copyright/copyright.txt for details.

  Program:   3D Slicer
  Module:    $RCSfile: vtkMRMLCurveAnalysisNode.h,v $
  Date:      $Date: 2006/03/19 17:12:29 $
  Version:   $Revision: 1.3 $

=========================================================================auto=*/
#ifndef __vtkMRMLXYPlotManagerNode_h
#define __vtkMRMLXYPlotManagerNode_h

#include <string>
#include <vector>

#include "vtkObject.h"
#include "vtkCollection.h"

#include "vtkMRML.h"
#include "vtkMRMLNode.h"
#include "vtkMRMLStorageNode.h"
#include "vtkMRMLDoubleArrayNode.h"
#include "vtkMRMLPlotNode.h"


class vtkIntArray;

class VTK_MRML_EXPORT vtkMRMLXYPlotManagerNode : public vtkMRMLNode
{

 public:

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

  //BTX
  enum {
    UpdateGraphEvent = 11900
  };
  //ETX

  //BTX
  enum {
    INTERP_LINEAR = 0
  };
  enum {
    TYPE_CURVE = 0,
    TYPE_VERTICAL_LINE,
    TYPE_HORIZONTAL_LINE
  };
  //ETX

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

  static vtkMRMLXYPlotManagerNode *New();
  vtkTypeMacro(vtkMRMLXYPlotManagerNode,vtkMRMLNode);
  
  void PrintSelf(ostream& os, vtkIndent indent);

  virtual vtkMRMLNode* CreateNodeInstance();

  virtual void ReadXMLAttributes( const char** atts);

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

  virtual void Copy(vtkMRMLNode *node);

  virtual const char* GetNodeTagName() { return "XYPlot"; };

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

  //----------------------------------------------------------------
  //----------------------------------------------------------------
  
  int AddPlotNode(vtkMRMLPlotNode* node);

  void RemovePlotNode(int id);

  void RemovePlotNodeByNodeID(const char* nodeID);

  void ClearPlotNodes();

  unsigned int GetNumberOfPlotNodes();

  vtkIntArray* GetPlotNodeIDList();

  vtkMRMLPlotNode* GetPlotNode(int id);

  vtkCollection* GetPlotNodes(const char* tag=NULL);


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

  void SetVisibilityAll(int i);

  void SetErrorBarAll(int i);


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

  void Refresh();

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

  void SetTitle(const char* str)
  {
    this->Title = str;
    this->Modified();
  };

  const char* GetTitle()
  {
    return this->Title.c_str();
  };

  void SetXLabel(const char* str)
  {
    this->XLabel = str;
    this->Modified();
  };

  const char* GetXLabel()
  {
    return this->XLabel.c_str();
  };

  void SetYLabel(const char* str)
  {
    this->YLabel = str;
    this->Modified();
  };
  
  const char* GetYLabel()
  {
    return this->YLabel.c_str();
  };

  vtkSetMacro ( AutoXRange, int );
  vtkGetMacro ( AutoXRange, int );
  vtkSetMacro ( AutoYRange, int );
  vtkGetMacro ( AutoYRange, int );

  void SetXRange(double* range)
  {
    if (range[0] <= range[1])
      {
        this->XRange[0] = range[0];
        this->XRange[1] = range[1];
        this->Modified();
      }
  };

  void SetYRange(double* range)
  {
    if (range[0] <= range[1])
      {
        this->YRange[0] = range[0];
        this->YRange[1] = range[1];
        this->Modified();
      }
  };

  void GetXRange(double* range)
  {
    range[0] = this->YRange[0];
    range[1] = this->YRange[1];
  };
 
  void GetYRange(double* range)
  {
    range[0] = this->YRange[0];
    range[1] = this->YRange[1];
  };

  vtkSetVector3Macro( AxesColor, double );
  vtkGetVector3Macro( AxesColor, double );

  void SetBackgroundColor(double r, double g, double b)
  {
    this->BackgroundColor[0] = r;
    this->BackgroundColor[1] = g;
    this->BackgroundColor[2] = b;
    this->Modified();
  };

  void GetBackgroundColor(double* r, double* g, double* b)
  {
    *r = this->BackgroundColor[0];
    *g = this->BackgroundColor[1];
    *b = this->BackgroundColor[2];
  };

  
 protected:
  //----------------------------------------------------------------
  //----------------------------------------------------------------
  
  vtkMRMLXYPlotManagerNode();
  ~vtkMRMLXYPlotManagerNode();
  vtkMRMLXYPlotManagerNode(const vtkMRMLXYPlotManagerNode&);
  void operator=(const vtkMRMLXYPlotManagerNode&);


 protected:
  //----------------------------------------------------------------
  //----------------------------------------------------------------

  //BTX
  std::string Title;             
  std::string XLabel;            
  std::string YLabel;            
  std::map< int, vtkMRMLPlotNode* > Data;  
  //ETX

  int LastArrayID;

  int    AutoXRange;  
  int    AutoYRange;  
  double XRange[2];
  double YRange[2];

  double AxesColor[3];
  double BackgroundColor[3];
  
};

#endif