vtkfigFigure.h

Go to the documentation of this file.

 
#ifndef VTKFIG_FIGURE_H
#define VTKFIG_FIGURE_H
 
#include <memory>
#include <vector>
 
#include <vtkSmartPointer.h>
#include <vtkActor.h>
#include <vtkContextActor.h>
#include <vtkActor2D.h>
#include <vtkContourFilter.h>
#include <vtkPolyDataAlgorithm.h>
#include <vtkTransformPolyDataFilter.h>
#include <vtkRenderer.h>
#include <vtkCutter.h>
#include <vtkPlane.h>
#include <vtkTransform.h>
#include <vtkCornerAnnotation.h>
#include <vtkGlyphSource2D.h>
#include <vtkArrowSource.h>
#include <vtkIdList.h>
#include <vtkCubeAxesActor2D.h>
#include <vtkTrivialProducer.h>
 
 
#include "vtkfigTools.h"
#include "vtkfigDataSet.h"
 
#include "internals/vtkfigCommunicator.h"
 
namespace vtkfig
{
 
 
  namespace internals
  {
    class vtkfigRenderThread;
    class vtkfigInteractorStyle;
    class vtkfigTimerCallback;  
    class Client;           
  }
 
  class Figure
  {
 
  public:
    
    static std::shared_ptr<Figure> New();
 
    void SetBackground(double r, double g, double b) { bgcolor[0]=r; bgcolor[1]=g; bgcolor[2]=b;}
 
 
 
    template <class V>
    void SetIsolevels(V&v)
    {
      isoline_filter->SetNumberOfContours(v.size());
      for (size_t i=0;i<v.size(); i++)
        isoline_filter->SetValue(i,v[i]);
      isoline_filter->Modified();
      state.isolevels_locked=true;
    }
  
    void SetData(std::shared_ptr<DataSet> data, const std::string name="");    
 
  
    void SetMaskedData(std::shared_ptr<DataSet> data, const std::string name, const std::string maskname);
 
    void SetContourRGBTable(RGBTable & tab, int lutsize);
 
    void SetTitle(std::string xtitle) { title=xtitle;}
 
    void SetViewVolume(double xmin, double xmax, double ymin, double ymax, double zmin, double zmax)   { state.xmin=xmin; state.xmax=xmax; state.ymin=ymin; state.ymax=ymax; state.zmin=zmin; state.zmax=zmax; transform_dirty=true;}
    
    void SetViewVolumeToDataSetBounds() { state.xmax=-1; state.xmin=1; transform_dirty=true;}
 
    void SetValueRange(double vmin, double vmax){state.vmin_set=vmin; state.vmax_set=vmax;}
    
    void SetAccumulateRange(bool b){ state.accumulate_range=b;}
 
    void SetXYAspect(double a) {state.aspect=a;}
    
    void KeepXYAspect(bool b) {state.keep_aspect=b;}
 
    void SetTransformDirty();
 
    void ShowDomainAxes(bool b) { state.show_domain_axes=b;}
 
    void ShowDomainBox(bool b) { state.show_domain_box=b;}
 
    void ShowDomainOutline(bool b) { state.show_domain_outline=b;}
 
    
    void AddContextActor(vtkSmartPointer<vtkContextActor> prop) {RTAddContextActor(prop);}
 
    void AddActor(vtkSmartPointer<vtkActor> prop) {RTAddActor(prop);};
 
    void AddActor2D(vtkSmartPointer<vtkActor2D> prop) {RTAddActor2D(prop);};
 
    void Message(std::string msg) {RTMessage(msg);}
 
    void AddAnnotations(){RTAddAnnotations();}
 
    
  public:
    friend class Frame;
    friend class internals::vtkfigRenderThread;
    friend class internals::Client;
    friend class internals::vtkfigInteractorStyle;
    friend class internals::vtkfigTimerCallback;
 
    void RTAddContextActor(vtkSmartPointer<vtkContextActor> prop);
 
    void RTAddActor(vtkSmartPointer<vtkActor> prop);
 
    void RTAddActor2D(vtkSmartPointer<vtkActor2D> prop);
 
    void RTMessage(std::string msg);
 
    void RTAddAnnotations();
 
    void RTInitAnnotations();
 
 
 
    static void MPSendRGBTable(vtkSmartPointer<internals::Communicator> communicator, RGBTable & rgbtab);
 
    static void MPReceiveRGBTable(vtkSmartPointer<internals::Communicator> communicator, RGBTable & rgbtab);
    
    void RTCalcTransform();
 
 
 
    void SetVMinMax();
 
    void GenIsolevels();
 
 
    virtual void RTBuildVTKPipeline(){};
 
    void RTBuildDomainPipeline(vtkSmartPointer<vtkRenderer> renderer);
 
    template <class DATA>
      void RTBuildDomainPipeline0(vtkSmartPointer<vtkRenderer> renderer);
 
    virtual void RTBuildAllVTKPipelines(vtkSmartPointer<vtkRenderer> renderer) 
    {
      RTBuildVTKPipeline();
      RTBuildDomainPipeline(renderer);
      RTAddAnnotations();
    };
 
    virtual void RTPreRender() {};
 
    virtual void ServerMPSend(vtkSmartPointer<internals::Communicator> communicator){} 
 
    virtual void ClientMPReceive(vtkSmartPointer<internals::Communicator> communicator) {};
    
    void ServerMPSendData(vtkSmartPointer<internals::Communicator> communicator);
 
    void ClientMPReceiveData(vtkSmartPointer<internals::Communicator> communicator);
 
 
    virtual void RTProcessKey(const std::string key);
 
    virtual void RTProcessMove(int dx, int dy);
 
    void RTRefreshState();
    void RefreshState();
 
    
    int RTProcessPlaneKey(const std::string plane,int idim, const std::string key, bool & edit, vtkSmartPointer<vtkCutter> planecut);
    int RTProcessPlaneMove(const std::string plane,int idim, int dx, int dy, bool & edit, vtkSmartPointer<vtkCutter> planecut );
    void RTShowPlanePos(vtkSmartPointer<vtkCutter> planecut,const std::string plane,  int idim);
 
    int RTProcessIsoKey(const std::string key, bool & edit);
    int RTProcessIsoMove(int dx, int dy, bool & edit);
    void RTShowIsolevel();
    void RTUpdateIsoSurfaceFilter();
 
    int RTProcessArrowKey(const std::string key, bool & edit);
 
    int RTProcessArrowMove(int dx, int dy, bool & edit);
 
    void RTShowArrowScale();
 
    void RTShowActive();
 
    void RTShowInActive();
    
    bool IsEmpty();
    
    virtual std::string SubClassName() {return std::string("FigureBase");}
    
    void RTUpdateActors();
           
    void SetRange();
 
    vtkSmartPointer<vtkCornerAnnotation> annot;
 
    vtkSmartPointer<vtkTransform> transform=0;
 
    vtkSmartPointer<vtkCutter> planecutX;
    vtkSmartPointer<vtkCutter> planecutY;
    vtkSmartPointer<vtkCutter> planecutZ;
 
    vtkSmartPointer<vtkPlane> planeX;
    vtkSmartPointer<vtkPlane> planeY;
    vtkSmartPointer<vtkPlane> planeZ;
 
    vtkSmartPointer<vtkGlyphSource2D> arrow2d;    
    vtkSmartPointer<vtkTransformPolyDataFilter> arrow3d;    
    vtkSmartPointer<vtkTransform> arrow3dt;
    vtkSmartPointer<vtkArrowSource> arrow3ds;
 
    vtkSmartPointer<vtkActor>     isosurface_plot;
    vtkSmartPointer<vtkContourFilter> isosurface_filter;
 
    vtkSmartPointer<vtkActor>     isoline_plot;
    vtkSmartPointer<vtkContourFilter> isoline_filter;
 
    vtkSmartPointer<vtkActor>     elevation_plot;
 
    vtkSmartPointer<vtkActor>     surface_plot;
 
    vtkSmartPointer<vtkTransform> warp_transform;
 
    vtkSmartPointer<vtkCubeAxesActor2D> axes;
 
    vtkSmartPointer<vtkActor> box;
 
    vtkSmartPointer<vtkActor> outline;
 
 
 
 
    vtkSmartPointer<vtkTrivialProducer> data_producer=NULL;
 
    vtkSmartPointer<vtkTrivialProducer> boundary_data_producer=NULL;
 
    double coordinate_scale_factor;
 
    std::string dataname;
 
    vtkSmartPointer<vtkIdList> celllist=0;
 
    std::string title;
 
    vtkSmartPointer<vtkLookupTable> surface_lut;
 
    RGBTable surface_rgbtab{{0,0,0,1},{1,1,0,0}};
 
    vtkSmartPointer<vtkLookupTable> quiver_lut;
 
    RGBTable quiver_rgbtab{{0,0,0,0},{1,0,0,0}};
 
    vtkSmartPointer<vtkLookupTable> stream_lut;
 
    RGBTable stream_rgbtab{{0,0,0,1},{1,1,0,0}};
 
 
    vtkSmartPointer<vtkLookupTable> elevation_lut;
 
    
    RGBTable elevation_rgbtab{{0.0,0.9,0.9,0.9},{1.0,0.9,0.9,0.9}};
 
    
    vtkSmartPointer<vtkLookupTable> cell_lut;
 
    
    RGBTable cell_rgbtab{
      {0.00, 1.0, 0.5, 0.5},
      {0.25, 1.0, 1.0, 0.5},
      {0.50, 0.5, 1.0, 0.5},
      {0.75, 0.5, 1.0, 1.0},
      {1.00, 0.5, 0.5, 1.0}};
    int cell_rgbtab_size=65;
 
 
    vtkSmartPointer<vtkLookupTable> bface_lut;
 
    RGBTable bface_rgbtab{
      {0.00, 0.8, 0.0, 0.0},
      {0.25, 0.8, 0.8, 0.0},
      {0.50, 0.0, 0.8, 0.0},
      {0.75, 0.0, 0.8, 0.8},
      {1.00, 0.0, 0.0, 0.8}};
    int bface_rgbtab_size=65;
 
    vtkSmartPointer<vtkScalarBarActor> cbar=NULL;
 
    vtkSmartPointer<vtkScalarBarActor> bcbar=NULL;
 
    
    struct
    {
 
      double vmin_set=1.0e100;
      double vmax_set=-1.0e100;
      
      double real_vmin=0;
      double real_vmax=1;
      
      double data_vmin=0;
      double data_vmax=1;
 
 
      double xmin=1.0;
      double xmax=-1.0;
      double ymin=1.0;
      double ymax=-1.0;
      double zmin=1.0;
      double zmax=-1.0;
 
      double coordinate_scale_factor_xyz[3]={1,1,1};
      
      bool accumulate_range=false;
 
      bool isolevels_locked=false;
 
      double eps_geom=1.0e-8;
      
      bool keep_aspect=true;
 
      int surface_colorbar_num_labels=11;
      
      char surface_colorbar_label_format[32]=" %+9.2e";
      
      double aspect=1.0;
 
      bool show_grid_edges=true;
      
      bool show_surface=true;
      
      bool show_quiver=true;
      
      bool show_stream=false;
      
      bool show_isolines=true;
 
      bool show_isosurfaces=false;
      
      bool show_slider=false;
      
      bool show_surface_colorbar=true;
 
      bool show_grid_colorbar=true;
 
      bool show_quiver_colorbar=false;
 
      bool show_stream_colorbar=false;
      
      bool show_contour_colorbar=false;
      
      bool show_elevation=false;
 
      int contour_rgbtab_size=2;
      
      bool contour_rgbtab_modified=false;
 
      int surface_rgbtab_size=63;
      
      bool surface_rgbtab_modified=true;
 
      int quiver_rgbtab_size=2;
      
      bool quiver_rgbtab_modified=true;
 
      int stream_rgbtab_size=63;
      
      bool stream_rgbtab_modified=true;
 
      int elevation_rgbtab_size=2;
      
      bool wireframe=false;
 
      bool show_domain_axes=true;
      
      bool show_domain_outline=true;
      
      bool show_domain_box=true;
      
      double domain_opacity=0.1;
      
      double domain_surface_color[3]={0.8,0.8,0.8};
 
      int spacedim=2;
      
      double isoline_width=2;
      
      double quiver_arrowscale_user=1.0;
 
      double quiver_arrowscale_geometry=0.1;
 
      double stream_maximum_propagation=1;
 
      int stream_maximum_number_of_steps=500;
 
      double stream_ribbonwidth=0.01;
 
      double stream_initial_integration_step=0.001;
 
      double stream_maximum_integration_step=0.1;
 
      double warp_ztran=0.0;
 
      double elevation_scale=1.0;
 
      DataSet::DataType datatype;
      
      
    } state;
 
 
    struct
    {
      bool x_plane=false;
      bool y_plane=false;
      bool z_plane=false;
      bool l_iso=false;
      bool a_scale=false;
    } edit;   
 
    double data_bounds[6];
    double data_center[3];
 
    double trans_bounds[6];
    double trans_center[3];
 
 
  protected:
    Figure();
    virtual ~Figure(){};
    
    //private:
  public:
    std::vector<vtkSmartPointer<vtkContextActor>> ctxactors;
    std::vector<vtkSmartPointer<vtkActor>> actors;
    std::vector<vtkSmartPointer<vtkActor2D>> actors2d;
 
    bool transform_dirty=true;
 
    double bgcolor[3]={1,1,1};
 
    int framepos=0;
    
    int framenum=-1;
  };
 
  
 
}
 
#endif