vtkfigFrame.h

Go to the documentation of this file.

#ifndef VTKFIG_FRAME_H
#define VTKFIG_FRAME_H
 
#include <memory>
#include <vector>
#include <set>
 
 
#include <vtkSmartPointer.h>
#include <vtkRenderer.h>
#include <vtkCornerAnnotation.h>
#include <vtkOggTheoraWriter.h>
 
#include "internals/vtkfigCommunicator.h"
 
namespace vtkfig
{
  class Figure;
 
  namespace internals
  {
    class Thread;
    class InteractorStyle;
    class TimerCallback;  
    class Client;           
  }
 
  class Frame
  {
    
  public:
    
 
    
    
    static std::shared_ptr<Frame> New();
 
 
    void SetLayout(int nvpx, int nvpy);
 
    void RefreshState(int figurepos);
    
    void WritePNG(std::string fname);
 
 
    void StartVideo(std::string fname);
 
    
    void StopVideo();
 
 
    void AddFigure(std::shared_ptr<Figure> figure);
 
 
    void AddFigure(std::shared_ptr<Figure> figure, int ipos);
 
 
    void RemoveFigure(std::shared_ptr<Figure> figure);
 
    void Clear(void);
 
    
    void Unmap();
 
    void LinkCamera(int ivp,Frame& frame, int livp);
 
    void LinkCamera(int ivp, std::shared_ptr<Frame> frame, int livp) {LinkCamera(ivp,*frame,livp);}
 
    void LinkCamera(int ivp, Frame*frame, int livp) {LinkCamera(ivp, *frame,livp);}
 
    void LinkCamera(std::shared_ptr<Frame> frame)  {LinkCamera(0,*frame,0);}
 
    void LinkCamera(Frame& frame)  {LinkCamera(0,frame,0);}
 
    void SetSize(int x, int y);
 
    void SetWindowTitle(const std::string title);
 
 
    void SetFrameTitle(const std::string title);
 
    void SetPosition(int x, int y);
 
 
    void SetSingleSubFrameView(bool b);
 
    void SetActiveSubFrame(int iframe);
 
    void SetActiveSubFrameCameraViewAngle(double angle);
 
    void SetActiveSubFrameCameraFocalPoint(double x, double y, double z);
 
    void SetActiveSubFrameCameraPosition(double x, double y, double z);
 
    void Show();
 
    void Interact();
 
 
    static Frame& FindFrame(int number_in_framelist);
 
    int GetStepNumber() { return step_number;}
    void SetStepNumber(int n) { step_number=std::max(n,0);}
 
 
    vtkSmartPointer<vtkRenderer> GetRenderer(std::shared_ptr<Figure> fig);
 
 
    static constexpr const char* KeyboardHelp=
R"(
--------------------------------------
   Key    Realm    Action
 
    Space Frame    Block/unblock calculation, increase step number
BackSpace Frame    Block/unblock calculation, decrease step number
   Escape Figure   Finish plane/level editing
   Return Figure   Store edited plane/level value and create new one
   Delete Figure   Delete last plane/level value
    Prior Frame    Show previous figure in single figure mode
    Next  Frame    Show next figure in single figure mode
        a Figure   Start arrow scale editing
        h Frame    Print this help to standard output
        l Figure   Start isolevel editing
        p Frame    Write frame to png
        r Figure   Reset camera (must left click to see the result)
        x Figure   Start x plane editing (3D only)
        y Figure   Start y plane editing (3D only)
        z Figure   Start z plane editing (3D only)
        A Figure   Toggle axis+box visibility
        B Figure   Toggle boundary cell visibility in vtkfig::GridView
        C Figure   Toggle interior cell visibility in vtkfig::GridView
        E Figure   Toggle elevation view (2D only)
        I Figure   Toggle isosurface view (3D only)
        L Figure   Generate 11 equally spaced isolevels.
        O Figure   Toggle outline visibility
        S Figure   Toggle surface visibility
        W Figure   Toggle wireframe mode 
        * Frame    Toggle single/multi figure view
        ? Frame    Print this help to standard output
        / Figure   Switch signs of cut plane
   ctrl-q Frame    Abort (calls std::terminate)
 
In  edit   mode,  left  mouse,   as  well  as  cursor   keys  increase
resp. decrease the value of the plane/isolevel/arrowscale, respectively.
 
Figures must be first clicked on before editing works.
--------------------------------------
)";
 
  protected:
    Frame();
    ~Frame();
  public:
 
    friend class internals::Thread;
    friend class internals::InteractorStyle;
    friend class internals::TimerCallback;
    friend class internals::Client;
 
    int step_number=0;
 
    int number_in_frame_list=-1;
 
    std::set<std::shared_ptr<Figure>>figures;
 
    int nvpx;
 
    int nvpy;
 
    struct SubFrame;
 
    void RTSetLayout(int nvpx, int nvpy);
    void RTCalculateViewports(int nx, int ny);
    void RTSetSingleViewport(int nx, int ny);
    void RTResetRenderers(bool from_scratch);
    void RTResetCamera(SubFrame& sf);
 
    void RTSetActiveSubFrameCameraViewAngle(SubFrame& sf, double a);
    void RTSetActiveSubFrameCameraFocalPoint(SubFrame& sf, double a[3]);
    void RTSetActiveSubFrameCameraPosition(SubFrame& sf, double a[3]);
 
 
    void RTAddFigures();
    void RTRemoveFigure(std::shared_ptr<Figure> figure);
    void RTHideSubframe(SubFrame &subframe);
    void RTUnHideSubframe(SubFrame &subframe);
    void RTSetSingleView(bool single_viewport);
    void RTSetActiveSubFrame(int isub, bool hide_old);
    void SetAutoLayout(int nfig);
 
 
    struct SubFrame
    {
      SubFrame(){};
 
      SubFrame(const double vp[4]):viewport{vp[0],vp[1],vp[2],vp[3]}{};
      
 
      vtkSmartPointer<vtkRenderer>    renderer;
 
      double viewport[4]={0,0,1,1};
 
      bool hidden=false;
    };
    bool single_subframe_view=false;
    size_t active_subframe=0;
    
    std::vector<SubFrame> subframes;
    SubFrame title_subframe;
 
    int pos(const int ivpx, const int ivpy) { return (nvpy-ivpy-1)*nvpx+ivpx;}
    int ivpx(const int pos) { return pos%nvpx;}
    int ivpy(const int pos) { return nvpy-pos/nvpx-1;}
 
 
    const double default_camera_focal_point[3]={0.65,0.5,0};
    const double default_camera_position[3]={0.65,0.5,10};
    const double default_camera_view_angle={15};
    // double default_camera_zoom={1};
 
 
    struct
    {
      std::string filename; 
      std::string wintitle="vtkfig";
      std::string frametitle="";
      
      int winsize_x=400;
      int winsize_y=400;
      
      int winposition_x=0;
      int winposition_y=0;
      
      double camera_view_angle=15;
      double camera_focal_point[3]={0.65,0.5,0};
      double camera_position[3]={0.65,0.5,10};
 
      int camlinkthisframepos;
      int camlinkframepos;
      int camlinkframenum;
      
      int nvpx;
      int nvpy;
      
      int single_subframe_view;
      int active_subframe;
 
      std::shared_ptr<Figure> current_figure;
      int figurepos;
    } parameter;
    std::shared_ptr<internals::Thread> mainthread;
    
    void SendCommand(std::string source, internals::Communicator::Command cmd);
    
    vtkSmartPointer<vtkRenderWindow> window;
    
    vtkSmartPointer<vtkCornerAnnotation> title_actor=0;
 
    void RTInit();
 
    vtkSmartPointer<vtkOggTheoraWriter> videowriter=0;
 
 
  };
}
 
#endif