vtkfigXYPlot.h

Go to the documentation of this file.

 
#ifndef VTKFIG_XYPLOT_H
#define VTKFIG_XYPLOT_H
 
#include <vtkDoubleArray.h>
#include <vtkXYPlotActor.h>
#include <vtkRectilinearGrid.h>
#include <vtkPointData.h>
#include <vtkXYPlotWidget.h>
#include <vtkLegendBoxActor.h>
 
 
#include "vtkfigFigure.h"
 
namespace vtkfig
{
  
  class XYPlot: public Figure
  {
    
  public:
 
 
    static std::shared_ptr<XYPlot> New();
 
    
    virtual std::string SubClassName() override final;
 
    void Clear();
    
    void SetTitle(const std::string t);
    
    void SetXTitle(const std::string t);
 
    void SetYTitle(const  std::string t );
 
    void SetXRange(double x0, double x1);
 
 
    void SetYRange(double y0, double y1);
 
    void SetNumberOfXLabels(int n);
 
    void SetNumberOfYLabels(int n);
    
    void SetXAxisLabelFormat(const std::string fmt);
 
    void SetYAxisLabelFormat(const std::string fmt);
 
    void AdjustLabels(bool b );
 
    void ShowGrid(bool b ); 
 
    void SetGridColor(double r, double g, double b);
 
 
    void SetAxesColor(double r, double g, double b);
 
    
    void ShowLegend(bool b );
 
 
    void SetLegendPosition(double x, double y);
 
 
    void SetLegendSize(double w, double h);
 
    void SetPlotLineType(const std::string type);
 
 
    void SetPlotLegend(const std::string legend);
 
    void SetPlotColor(double r, double g, double b);
 
    void SetLineWidth(double w);
 
    void SetMarkerSize(double s);
 
    void SetPlotMarkerType(const std::string type);
 
 
    //    void SetPlotMarkerSequence(offset,stride);
    //    void SetPlotMarkerColor();
 
    template<typename V>  void AddPlot(const V &x,  const V &y);
 
 
  protected:
    XYPlot();
    ~XYPlot(){};
 
    
  private:
 
    void AddPlot();
 
    void PlotGrid(); 
 
    void ServerMPSend(vtkSmartPointer<internals::Communicator> communicator) override final;
 
    void ClientMPReceive(vtkSmartPointer<internals::Communicator> communicator) override final; 
 
    void RTBuildAllVTKPipelines(vtkSmartPointer<vtkRenderer> renderer) override final;
 
    void RTPreRender() override final;
  
    static std::map<std::string,int> marker_types;
    
    size_t num_plots=0;
    
    int num_gridlines=0;
    
    int num_curves=0;
 
    vtkSmartPointer<vtkXYPlotActor> XYPlotActor;
 
    vtkSmartPointer<vtkLegendBoxActor> LegendActor;
  
 
    static const int desclen=32;
    std::string title="";
    std::string ytitle="y";
    std::string xtitle="x";
 
    class GridLine
    {
      vtkSmartPointer<vtkDoubleArray> X;
      vtkSmartPointer<vtkDoubleArray> Y;
      vtkSmartPointer<vtkRectilinearGrid> curve;
      const int ds_num;
    public:
      int GetDataSetNumber(){return ds_num;}
      void SetYLine(double xrange[2], double y);
      void SetXLine(double yrange[2], double x);
      GridLine(vtkSmartPointer<vtkXYPlotActor> plot, int & ds_num, double rgb[3]);
    };
    
    std::vector<GridLine> XGridLines;
 
    std::vector<GridLine> YGridLines;
 
    class  PlotData
    {
      vtkSmartPointer<vtkRectilinearGrid> curve;
      const int ds_num;
    public:
      vtkSmartPointer<vtkDoubleArray> X;
      vtkSmartPointer<vtkDoubleArray> Y;
      void FixSize();
      int GetDataSetNumber();
      PlotData(vtkSmartPointer<vtkXYPlotActor> plot, int & ds_num);
    };
    
    
    std::vector<PlotData> AllPlotData;
 
    struct 
    {
      // has to have fixed size for easy c-s transfer
 
      char xlabel_format[desclen]="%8.2e";
      char ylabel_format[desclen]="%8.2e";
      bool grid_show=true;
      double grid_rgb[3]={0.8,0.8,0.8};
      double line_width=1;
      double marker_size=1;
 
      double axes_rgb[3]={0,0,0};
      bool legend_show=true;
      double legend_posx=0.8;
      double legend_posy=0.7;
      double legend_w=0.1;
      double legend_h=0.2;
      bool adjust_labels=false;
 
      double dynXMin=1.0e100;
      double dynXMax=-1.0e100;
      double dynYMin=1.0e100;
      double dynYMax=-1.0e100;
      double fixXMin=1.0e100;
      double fixXMax=-1.0e100;
      double fixYMin=1.0e100;
      double fixYMax=-1.0e100;
      int nxlabels=5;
      int nylabels=5;
    } PlotState;
 
    struct PlotInfo
    {
      // has to have fixed size for easy c-s transfer
      char line_type[desclen]={'-',0};
      char marker_type[desclen]={0};
      char legend[desclen]={0};
      double line_rgb[3]={0,0,0};
      PlotInfo(){};
      ~PlotInfo(){};
    };
    
    std::vector<PlotInfo> AllPlotInfo;
    
    PlotInfo NextPlotInfo;
        
  };
  
  
  template<typename V>
    inline
  void XYPlot::AddPlot(const V &x, const V &y)
  {
 
    while (num_plots>=AllPlotData.size())
    {
      AllPlotData.emplace_back(XYPlotActor,num_curves);
    }
    auto plot=AllPlotData[num_plots];
 
    int N=x.size();
    assert(x.size()==y.size());
    
    plot.X->SetNumberOfTuples(N);
    plot.Y->SetNumberOfTuples(N);
 
    double xmin=1.0e100;
    double xmax=-1.0e100;
    double ymin=1.0e100;
    double ymax=-1.0e100;
 
 
    for (int i=0; i<N; i++)
    {
      plot.X->InsertTuple1(i,x[i]);
      plot.Y->InsertTuple1(i,y[i]);
      xmin=std::min(xmin,x[i]);
      ymin=std::min(ymin,y[i]);
      xmax=std::max(xmax,x[i]);
      ymax=std::max(ymax,y[i]);
    }
 
    PlotState.dynXMin=std::min(xmin,PlotState.dynXMin);
    PlotState.dynXMax=std::max(xmax,PlotState.dynXMax);
    PlotState.dynYMin=std::min(ymin,PlotState.dynYMin);
    PlotState.dynYMax=std::max(ymax,PlotState.dynYMax);
    
    AddPlot();
  }
  
 
}
 
#endif