MyRenderer.h

Go to the documentation of this file.

#pragma once

#include <vtkSmartPointer.h>
#include <vtkActor.h>
#include <vtkOpenGLPolyDataMapper.h>
#include <vtkRenderer.h>
#include <vtkRenderWindow.h>
#include <vtkPolyDataReader.h>
#include <vtkPolyData.h>
#include <vtkPolyDataNormals.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkProperty.h>
#include <vtkCamera.h>
#include <vtkLight.h>
#include <MyActor.h>
#include <vtkPlaneSource.h>

#include "utils.h"
#include "MyShaderCallback.h"

// not used anymore
namespace
{
    bool SUCCESS = 1;
    bool FAIL = 0;

    double AMBIENTCOLOR[3]{ 0.2, 0.2, 1.0 };
    double DIFFUSECOLOR[3]{ 1.0, 0.0, 0.0 };
    double SPECULARCOLOR[3]{ 1.0, 1.0, 1.0 };
    double AMBIENT = 0.5;
    double DIFFUSE = 0.7;
    double SPECULAR = 0.5;
    double SPECULARPOWER = 20.0;
    double OPACITY = 1.0;

    double CAMERAPOSITION[3]{ -0.2, 0.4, 1 };
    double FOCALPOINT[3]{ 0, 0, 0 };
    double CAMERAVIEWUP[3]{ 0, 1, 0 };
    double ZOOM = 1.0;

    double BACKGROUNDCOLOR[3]{ 0.0, 0.0, 0.0 };

    int isoLineDistance = 20;

    int RENDERWINDOWSIZE[2]{ 400, 400 };
}


class MyRenderer
{
public:
    MyRenderer(bool isSplitted, vtkRenderWindow* renderWindow = nullptr);
    ~MyRenderer();

    void claculateDistanceToActor(int keyMainActor, int keyTumorActor, bool splittedMiddle = false, bool splittedBorder = false);

    void LoadPolydataFromFile(const char* filename, vtkMatrix4x4* viewMatrix = NULL);


    void LoadShaders(QString path);

    vtkSmartPointer<MyActor> CopyActor(vtkSmartPointer<MyActor> actor, QString name);


    void SplitPolygons();

    void LinkLabelToShader(int label, QString name, vtkSmartPointer<MyShaderCallback> callback = 0);

    void SetShadingProperties();

    void SetCameraProperties(
        double cameraPosition[3] = CAMERAPOSITION,
        double focalPoint[3] = FOCALPOINT,
        double viewUp[3] = CAMERAVIEWUP,
        double zoom = ZOOM
    );

    void Begin();

    void SetDefaults();

    vtkSmartPointer<vtkPolyData> FusePolygons(vtkSmartPointer<vtkPolyData> polyData1,
                                              vtkSmartPointer<vtkPolyData> polyData2);

    vtkSmartPointer<vtkPolyData> CloseOpenPolygons(vtkSmartPointer<vtkPolyData> polyData);

    void showTargetStructure(int keyTargetStructure, int keyRiskStructure);

    vtkSmartPointer<vtkPolyData> SplitPolygon(int actorID, bool safeToPolyDataMap = true);

    /*
     * returns the current vtkRenderWindow
     */
    vtkSmartPointer<vtkRenderWindow> GetRenderWindow() const { return renderWindow; };

    void ConnectInteractors();

    vtkSmartPointer<vtkRenderer> GetRenderer() const { return renderer; }



    void copyData(MyRenderer* renderer);

    double* GetOriginOfClipping() { return clippingPlaneSource->GetOrigin(); }

    double* GetNormalOfClipping() { return clippingPlaneSource->GetNormal(); }

    vtkSmartPointer<vtkPlaneSource> GetClippingPlane() { return clippingPlaneSource; }

    void CreateClippingPlane(vtkSmartPointer<vtkPlaneSource> from);

    void CreateClippingPlane();

    void UpdateClippingPlane(double normal[3]);

    void UpdateClippingPlane(double step);

private:

    // contains the polydata of the whole dataset
    vtkSmartPointer<vtkPolyData>            completeData;
    // contains for each label the corresponding vtkPolyData
    QMap<int, vtkSmartPointer<vtkPolyData>> labeledPolydata;
    // contains for each label the corresponding vtkPolyData (is used for the clipped view)
    QMap<int, vtkSmartPointer<vtkPolyData>> labeledPolydataSplitted;
    // maps name of the structure (i.e. context, risk, ... ) to the corresponding actor
    QMap<QString, vtkSmartPointer<MyActor>> actorMap;

    // the renderer of the scene, renderwindow and interactor
    vtkSmartPointer<vtkRenderer>            renderer;
    vtkSmartPointer<vtkRenderWindow>        renderWindow;
    vtkNew<vtkRenderWindowInteractor>       iren;

    // flag which is set if the window with the splitted view should be shown
    bool isSplitted;


    // Plane which defines at which position the polydata shall be clipped
    vtkSmartPointer<vtkPlaneSource> clippingPlaneSource;
    // actor for the visualization of the clippingPlane
    vtkSmartPointer<vtkActor> clippingActor;
    

};