QT學習VTK序列: Planes

學習VTK繪製平面

/*
 * ModuleName: 模塊名稱
 * Description:
 * 參考代碼：https://lorensen.github.io/VTKExamples/site/Cxx/GeometricObjects/Planes/
 * Author: hsw
 * Date: 2020-03-15
 *
*/

// QT
#include <QMainWindow>
#include <QDebug>

// VTK
#include <vtkActor.h>
#include <vtkActor2D.h>
#include <vtkCamera.h>
#include <vtkHull.h>
#include <vtkNamedColors.h>
#include <vtkPlanes.h>
#include <vtkPolyData.h>
#include <vtkPolyDataMapper.h>
#include <vtkProperty.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkRenderer.h>
#include <vtkSmartPointer.h>
#include <vtkSphereSource.h>
#include <vtkTextMapper.h>
#include <vtkTextProperty.h>
#include <vtkAutoInit.h>

// C++
#include <array>
#include <vector>
#include <string>

namespace Ui {
class MainWindow;
}

VTK_MODULE_INIT(vtkRenderingOpenGL2);
VTK_MODULE_INIT(vtkInteractionStyle);
VTK_MODULE_INIT(vtkRenderingContextOpenGL2);
VTK_MODULE_INIT(vtkRenderingFreeType);

// For compatibility with new VTK generic data arrays
#ifdef vtkGenericDataArray_h
#define InsertNextTupleValue InsertNextTypedTuple
#endif

class MainWindow : public QMainWindow
{
    Q_OBJECT
public:
    explicit MainWindow(QWidget *parent = 0);
    ~MainWindow();
private:
    void createActors();
    void createGridWindows(int gridRow, int gridCol);
private:
    Ui::MainWindow *ui;
private:
    vtkSmartPointer<vtkNamedColors>                  namedColors;
    std::vector<vtkSmartPointer<vtkPlanes>>          planes;
    std::vector<vtkSmartPointer<vtkHull>>            hulls;
    std::vector<vtkSmartPointer<vtkPolyData>>        planesPolys;
    std::vector<vtkSmartPointer<vtkPolyDataMapper>>  planeMappers;
    std::vector<vtkSmartPointer<vtkTextMapper>>      planeTextMappers;
    std::vector<vtkSmartPointer<vtkActor>>           planeActors;
    std::vector<vtkSmartPointer<vtkActor2D>>         planeTextActors;
    std::vector<vtkSmartPointer<vtkRenderer>>        renderers;
private:
    const std::vector<std::string>             titles = {"Using frustum planes",
                                                        "Using bounds"};
};

 

#include "mainwindow.h"
#include "ui_mainwindow.h"

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);

    for(int iter = 0; iter < titles.size(); ++iter)
    {
        planes.push_back(vtkSmartPointer<vtkPlanes>::New());
    }

    // Using Frustum Planes
    vtkSmartPointer<vtkCamera> camera = vtkSmartPointer<vtkCamera>::New();
    double planesArray[24];
    camera->GetFrustumPlanes(1, planesArray);
    planes[0]->SetFrustumPlanes(planesArray);

    // Using vtkSphereSource bounds
    vtkSmartPointer<vtkSphereSource> sphereSource = vtkSmartPointer<vtkSphereSource>::New();
    sphereSource->Update();
    double bounds[6];
    sphereSource->GetOutput()->GetBounds(bounds);
    planes[1]->SetBounds(bounds);

    // vtkNamedColors
    namedColors = vtkSmartPointer<vtkNamedColors>::New();

    // 創建角色
    createActors();

    // 創建網格化窗口
    createGridWindows(1, 2);
}


MainWindow::~MainWindow()
{
    delete ui;
}

void MainWindow::createActors()
{
    hulls.clear();
    planesPolys.clear();
    planeActors.clear();
    planeTextMappers.clear();
    planeTextActors.clear();

    vtkSmartPointer<vtkTextProperty> textProperty = vtkSmartPointer<vtkTextProperty>::New();
    textProperty->SetFontSize(16);
    textProperty->SetJustificationToCentered();

    int i;
    for(i = 0; i < titles.size(); ++i)
    {
        hulls.push_back(vtkSmartPointer<vtkHull>::New());
        hulls[i]->SetPlanes(planes[i]);

        planesPolys.push_back(vtkSmartPointer<vtkPolyData>::New());

        hulls[i]->GenerateHull(planesPolys[i], -200, 200, -200, 200, -200, 200);

        planeMappers.push_back(vtkSmartPointer<vtkPolyDataMapper>::New());
        planeMappers[i]->SetInputData(planesPolys[i]);

        planeActors.push_back(vtkSmartPointer<vtkActor>::New());
        planeActors[i]->SetMapper(planeMappers[i]);

        planeTextMappers.push_back(vtkSmartPointer<vtkTextMapper>::New());
        planeTextMappers[i]->SetInput(titles[i].c_str());
        planeTextMappers[i]->SetTextProperty(textProperty);

        planeTextActors.push_back(vtkSmartPointer<vtkActor2D>::New());
        planeTextActors[i]->SetMapper(planeTextMappers[i]);
        planeTextActors[i]->SetPosition(120, 16);
    }
}

void MainWindow::createGridWindows(int gridRow, int gridCol)
{
    renderers.clear();

    double gridRowStep = 1.0 / gridRow;
    double gridColStep = 1.0 / gridCol;

    int iterRow, iterCol;
    int winIndex = 0;
    for(iterRow = 0; iterRow < gridRow; ++iterRow)
    {
        for(iterCol = 0; iterCol < gridCol; ++iterCol)
        {
            double viewport[4] = {gridColStep * iterCol               ,
                                  (gridRow - iterRow - 1) * gridRowStep,
                                  gridColStep * (iterCol + 1)          ,
                                  (gridRow - iterRow   ) * gridRowStep};

            renderers.push_back(vtkSmartPointer<vtkRenderer>::New());

            renderers[winIndex]->SetViewport(viewport);
            renderers[winIndex]->AddActor(planeActors[winIndex]);
            renderers[winIndex]->AddActor2D(planeTextActors[winIndex]);
            renderers[winIndex]->SetBackground(namedColors->GetColor3d("DarkSlateGray").GetData());
            renderers[winIndex]->ResetCamera();
            renderers[winIndex]->GetActiveCamera()->Azimuth(30);
            renderers[winIndex]->GetActiveCamera()->Elevation(-30);
            renderers[winIndex]->ResetCameraClippingRange();

            ui->qvtkWidget->GetRenderWindow()->AddRenderer(renderers[winIndex]);
            winIndex++;
        }
    }
}