vtk读取后缀名为.ply、.vtp、.obj、.stl、.vtk、.g文件并显示

//Description¶
//Given a filename, uses the appropriate vtkPolyData reader to read any vtkPolyData file.
//To use the snippet, click the Copy to clipboard at the upper right of the code blocks.

// Readers
#include <vtkBYUReader.h>
#include <vtkOBJReader.h>
#include <vtkPLYReader.h>
#include <vtkPolyDataReader.h>
#include <vtkSTLReader.h>
#include <vtkXMLPolyDataReader.h>
#include<vtkPolyDataMapper.h>
#include <vtkPolyData.h>
#include <vtkSphereSource.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkInteractorStyleTrackballCamera.h>
#include<vtkRenderer.h>
#include<vtkNamedColors.h>
#include <vtkProperty.h>
#include <vtkActor.h>
#include <algorithm> // For transform()
#include <string> // For find_last_of()
#include <cctype> // For to_lower
#include "vtkAutoInit.h"
VTK_MODULE_INIT(vtkRenderingOpenGL2)
VTK_MODULE_INIT(vtkInteractionStyle)
VTK_MODULE_INIT(vtkRenderingFreeType)
namespace {

    vtkSmartPointer<vtkPolyData> ReadPolyData(const char* fileName)
    {
        vtkSmartPointer<vtkPolyData> polyData;
        std::string extension =
            vtksys::SystemTools::GetFilenameExtension(std::string(fileName));
        if (extension == ".ply")
        {
            vtkNew<vtkPLYReader> reader;
            reader->SetFileName(fileName);
            reader->Update();
            polyData = reader->GetOutput();
        }
        else if (extension == ".vtp")
        {
            vtkNew<vtkXMLPolyDataReader> reader;
            reader->SetFileName(fileName);
            reader->Update();
            polyData = reader->GetOutput();
        }
        else if (extension == ".obj")
        {
            vtkNew<vtkOBJReader> reader;
            reader->SetFileName(fileName);
            reader->Update();
            polyData = reader->GetOutput();
        }
        else if (extension == ".stl")
        {
            vtkNew<vtkSTLReader> reader;
            reader->SetFileName(fileName);
            reader->Update();
            polyData = reader->GetOutput();
        }
        else if (extension == ".vtk")
        {
            vtkNew<vtkPolyDataReader> reader;
            reader->SetFileName(fileName);
            reader->Update();
            polyData = reader->GetOutput();
        }
        else if (extension == ".g")
        {
            vtkNew<vtkBYUReader> reader;
            reader->SetGeometryFileName(fileName);
            reader->Update();
            polyData = reader->GetOutput();
        }
        else
        {
            vtkNew<vtkSphereSource> source;
            source->SetPhiResolution(25);
            source->SetThetaResolution(25);
            source->Update();
            polyData = source->GetOutput();
        }
        return polyData;
    }

} // namespace

int main()
{
    vtkNew<vtkNamedColors> colors;

    auto ployData = ReadPolyData("Intergalactic_Spaceship-(Wavefront).obj");
    // 创建映射器并将数据源连接到映射器
    vtkSmartPointer<vtkPolyDataMapper> myMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
    myMapper->SetInputData(ployData); 

    vtkNew<vtkActor> coneActor;
    coneActor->SetMapper(myMapper);
    coneActor->GetProperty()->SetColor(colors->GetColor3d("Bisque").GetData());

    //
    // Create the Renderer and assign actors to it. A renderer is like a
    // viewport. It is part or all of a window on the screen and it is
    // responsible for drawing the actors it has.  We also set the background
    // color here.
    //
    vtkNew<vtkRenderer> ren1;
    ren1->AddActor(coneActor);
    ren1->SetBackground(colors->GetColor3d("MidnightBlue").GetData());

    //
    // Finally we create the render window which will show up on the screen.
    // We put our renderer into the render window using AddRenderer. We also
    // set the size to be 300 pixels by 300.
    //
    vtkNew<vtkRenderWindow> renWin;
    renWin->AddRenderer(ren1);
    renWin->SetSize(300, 300);
    renWin->SetWindowName("ReadPolyData");

    //
    // The vtkRenderWindowInteractor class watches for events (e.g., keypress,
    // mouse) in the vtkRenderWindow. These events are translated into
    // event invocations that VTK understands (see VTK/Common/vtkCommand.h
    // for all events that VTK processes). Then observers of these VTK
    // events can process them as appropriate.
    vtkNew<vtkRenderWindowInteractor> iren;
    iren->SetRenderWindow(renWin);

    //
    // By default the vtkRenderWindowInteractor instantiates an instance
    // of vtkInteractorStyle. vtkInteractorStyle translates a set of events
    // it observes into operations on the camera, actors, and/or properties
    // in the vtkRenderWindow associated with the vtkRenderWinodwInteractor.
    // Here we specify a particular interactor style.
    vtkNew<vtkInteractorStyleTrackballCamera> style;
    iren->SetInteractorStyle(style);

    //
    // Unlike the previous scripts where we performed some operations and then
    // exited, here we leave an event loop running. The user can use the mouse
    // and keyboard to perform the operations on the scene according to the
    // current interaction style. When the user presses the "e" key, by default
    // an ExitEvent is invoked by the vtkRenderWindowInteractor which is caught
    // and drops out of the event loop (triggered by the Start() method that
    // follows.
    //
    iren->Initialize();
    iren->Start();

    //
    // Final note: recall that observers can watch for particular events and
    // take appropriate action. Pressing "u" in the render window causes the
    // vtkRenderWindowInteractor to invoke a UserEvent. This can be caught to
    // popup a GUI, etc. See the Tcl Cone5.tcl example for an idea of how this
    // works.

    return EXIT_SUCCESS;

}