vtk_Code

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
int 多边形圆球剪切()
{
    vtkSmartPointer sphereSource =
        vtkSmartPointer::New();
    sphereSource->SetCenter(0.0, 0.0, 0.0);
    sphereSource->SetRadius(5.0);
    sphereSource->Update();

    vtkPlane* vPlane = vtkPlane::New();
    vtkSmartPointer plane =
        vtkSmartPointer::New();
    plane->SetOrigin(0, 3, 0);
    plane->SetNormal(0, -1, 0);

    vtkSmartPointer clipPolyData =
        vtkSmartPointer::New();
    clipPolyData->SetInputConnection(sphereSource->GetOutputPort());
    clipPolyData->SetClipFunction(plane);
    clipPolyData->GenerateClippedOutputOn();
    clipPolyData->Update();

    vtkSmartPointer mapper1 =
        vtkSmartPointer::New();
    mapper1->SetInputConnection(clipPolyData->GetOutputPort());

    vtkSmartPointer actor1 =
        vtkSmartPointer::New();
    actor1->SetMapper(mapper1);

    vtkSmartPointer mapper2 =
        vtkSmartPointer::New();
    mapper2->SetInputConnection(clipPolyData->GetClippedOutputPort());

    vtkSmartPointer actor2 =
        vtkSmartPointer::New();
    actor2->SetMapper(mapper2);

    vtkSmartPointer colors =
        vtkSmartPointer::New();

    vtkSmartPointer renderer1 =
        vtkSmartPointer::New();
    renderer1->SetBackground(colors->GetColor3d("Slate_grey").GetData());
    renderer1->AddActor(actor1);
    renderer1->SetViewport(0, 0, 0.5, 1);

    vtkSmartPointer renderer2 =
        vtkSmartPointer::New();
    renderer2->SetBackground(colors->GetColor3d("Slate_blue").GetData());
    renderer2->AddActor(actor2);
    renderer2->SetViewport(0.5, 0, 1, 1);

    vtkSmartPointer renderWindow =
        vtkSmartPointer::New();
    renderWindow->SetSize(600, 300);
    renderWindow->AddRenderer(renderer1);
    renderWindow->AddRenderer(renderer2);

    vtkSmartPointer renderWindowInteractor =
        vtkSmartPointer::New();
    renderWindowInteractor->SetRenderWindow(renderWindow);

    vtkSmartPointer style =
        vtkSmartPointer::New();
    renderWindowInteractor->SetInteractorStyle(style);

    renderWindow->Render();
    renderWindowInteractor->Initialize();
    renderWindowInteractor->Start();

    return EXIT_SUCCESS;
}

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

// Readers
#include 
#include 
#include 
#include 
#include 
#include 

namespace {
    vtkSmartPointer ReadPolyData(std::string const& fileName);
}

//
// Demonstrate the use of clipping and capping on polyhedral data
//

int main(int argc, char* argv[])
{
    // Define colors
    vtkNew colors;
    auto backgroundColor = colors->GetColor3d("steel_blue");
    auto boundaryColor = colors->GetColor3d("banana");
    auto clipColor = colors->GetColor3d("tomato");
    // PolyData to process
    auto polyData = ReadPolyData(argc > 1 ? argv[1] : "");

    vtkNew plane;
    plane->SetOrigin(polyData->GetCenter());
    plane->SetNormal(1.0, -1.0, -1.0);

    vtkNew clipper;
    clipper->SetInputData(polyData);
    clipper->SetClipFunction(plane);
    clipper->SetValue(0);
    clipper->Update();

    polyData = clipper->GetOutput();

    vtkNew clipMapper;
    clipMapper->SetInputData(polyData);

    vtkNew clipActor;
    clipActor->SetMapper(clipMapper);
    clipActor->GetProperty()->SetDiffuseColor(clipColor.GetData());
    clipActor->GetProperty()->SetInterpolationToFlat();
    clipActor->GetProperty()->EdgeVisibilityOn();

    // Now extract feature edges
    vtkNew boundaryEdges;
    boundaryEdges->SetInputData(polyData);
    boundaryEdges->BoundaryEdgesOn();
    boundaryEdges->FeatureEdgesOff();
    boundaryEdges->NonManifoldEdgesOff();
    boundaryEdges->ManifoldEdgesOff();

    vtkNew boundaryStrips;
    boundaryStrips->SetInputConnection(boundaryEdges->GetOutputPort());
    boundaryStrips->Update();

    // Change the polylines into polygons
    vtkNew boundaryPoly;
    boundaryPoly->SetPoints(boundaryStrips->GetOutput()->GetPoints());
    boundaryPoly->SetPolys(boundaryStrips->GetOutput()->GetLines());

    vtkNew boundaryMapper;
    boundaryMapper->SetInputData(boundaryPoly);

    vtkNew boundaryActor;
    boundaryActor->SetMapper(boundaryMapper);
    boundaryActor->GetProperty()->SetDiffuseColor(boundaryColor.GetData());

    // Create graphics stuff
    //
    vtkNew renderer;
    renderer->SetBackground(backgroundColor.GetData());
    renderer->UseHiddenLineRemovalOn();

    vtkNew renderWindow;
    renderWindow->AddRenderer(renderer);
    renderWindow->SetSize(640, 480);

    vtkNew interactor;
    interactor->SetRenderWindow(renderWindow);

    // Add the actors to the renderer, set the background and size
    //
    renderer->AddActor(clipActor);
    renderer->AddActor(boundaryActor);

    // Generate an interesting view
    //
    renderer->ResetCamera();
    renderer->GetActiveCamera()->Azimuth(30);
    renderer->GetActiveCamera()->Elevation(30);
    renderer->GetActiveCamera()->Dolly(1.2);
    renderer->ResetCameraClippingRange();

    renderWindow->Render();
    renderWindow->SetWindowName("CapClip");
    renderWindow->Render();

    interactor->Start();

    return EXIT_SUCCESS;
}

namespace {
    vtkSmartPointer ReadPolyData(std::string const& fileName)
    {
        vtkSmartPointer polyData;
        std::string extension = "";
        if (fileName.find_last_of(".") != std::string::npos)
        {
            extension = fileName.substr(fileName.find_last_of("."));
        }
        // Make the extension lowercase
        std::transform(extension.begin(), extension.end(), extension.begin(),
            ::tolower);
        if (extension == ".ply")
        {
            vtkNew reader;
            reader->SetFileName(fileName.c_str());
            reader->Update();
            polyData = reader->GetOutput();
        }
        else if (extension == ".vtp")
        {
            vtkNew reader;
            reader->SetFileName(fileName.c_str());
            reader->Update();
            polyData = reader->GetOutput();
        }
        else if (extension == ".obj")
        {
            vtkNew reader;
            reader->SetFileName(fileName.c_str());
            reader->Update();
            polyData = reader->GetOutput();
        }
        else if (extension == ".stl")
        {
            vtkNew reader;
            reader->SetFileName(fileName.c_str());
            reader->Update();
            polyData = reader->GetOutput();
        }
        else if (extension == ".vtk")
        {
            vtkNew reader;
            reader->SetFileName(fileName.c_str());
            reader->Update();
            polyData = reader->GetOutput();
        }
        else if (extension == ".g")
        {
            vtkNew reader;
            reader->SetGeometryFileName(fileName.c_str());
            reader->Update();
            polyData = reader->GetOutput();
        }
        else
        {
            // Return a polydata sphere if the extension is unknown.
            vtkNew source;
            source->SetThetaResolution(20);
            source->SetPhiResolution(11);
            source->Update();
            polyData = source->GetOutput();
        }
        return polyData;
    }
} // namespace

  1 #include 
  2 #include 
  3 #include 
  4 
  5 #include 
  6 #include 
  7 #include 
  8 
  9 #include 
 10 #include 
 11 #include 
 12 
 13 #include 
 14 #include 
 15 #include 
 16 
 17 #include 
 18 
 19 #include "vtkSphereSource.h"
 20 #include "vtkShrinkFilter.h"
 21 #include "vtkElevationFilter.h"
 22 
 23 #include "vtkCullerCollection.h"
 24 
 25 #include 
 26 #include 
 27 #include 
 28 #include 
 29 
 30 #include 
 31 #include 
 32 
 33 #include
 34 
 35 #include 
 36 #include 
 37 
 38 #include 
 39 
 40 #include 
 41 #include 
 42 #include 
 43 #include 
 44 #include 
 45 #include 
 46 #include 
 47 #include 
 48 //#include"InteractorStyle.hpp"
 49 #include 
 50 #include 
 51 #include 
 52 #include 
 53 //#include"CustomPlaneCuteInteractorStyle.hpp"
 54 
 55 
 56 
 57 #include 
 58 #include 
 59 #include 
 60 #include 
 61 #include 
 62 #include 
 63 #include 
 64 #include 
 65 #include 
 66 #include 
 67 #include 
 68 #include 
 69 #include 
 70 #include 
 71 #include 
 72 #include 
 73 #include 
 74 #include 
 75 #include 
 76 #include 
 77 #include 
 78 #include 
 79 #include 
 80 #include 
 81 #include 
 82 #include 
 83 VTK_MODULE_INIT(vtkRenderingOpenGL2)
 84 VTK_MODULE_INIT(vtkRenderingContextOpenGL2)
 85 VTK_MODULE_INIT(vtkInteractionStyle);
 86 using namespace std;
 87 using namespace vtk;
 88 
 89 #include 
 90 #include 
 91 #include 
 92 #include 
 93 #include 
 94 #include 
 95 #include 
 96 #include 
 97 #include 
 98 #include 
 99 #include 
100 #include 
101 #include 
102 #include 
103 #include 
104 
105 #include "vtkPolyDataReader.h"
106 #include 
107 #include 
108 #include 
109 #include 
110 #include 
111 #include 
112 #include 
113 #include 
114 #include 
115 #include 
116 #include 
117 #include 
118 #include 
119 #include 
120 #include 
121 #include 
122 #include 
123 #include 
124 #include 
125 #include "vtkDecimatePro.h"
126 #include "vtkSmoothPolyDataFilter.h"
127 #include "vtkPolyDataNormals.h"
128 #include "vtkAppendFilter.h"
129 #include "vtkDataSetCollection.h"
130 #include "vtkCollection.h"
131 #include "vtkIdFilter.h"
132 #include "vtkDataSet.h"
133 #include "vtkAreaPicker.h"
134 #include "vtkInteractorStyleRubberBandPick.h"
135 #include "vtkPlanes.h"
136 #include "vtkExtractGeometry.h"
137 
138 // An highlighted block
139 #include 
140 
141 #include 
142 #include 
143 #include 
144 #include 
145 #include 
146 #include 
147 #include 
148 #include 
149 #include 
150 #include 
151 #include 
152 #include 
153 #include 
154 #include 
155 #include 
156 #include 
157 #include 
158 #include 
159 #include 
160 #include 
161 #include 
162 #include 
163 #include 
164 
165 #define VTKISRBP_ORIENT 0
166 #define VTKISRBP_SELECT 1
167 
168 class InteractorStyle : public vtkInteractorStyleRubberBandPick
169 {
170 public:
171     static InteractorStyle* New();
172     vtkTypeMacro(InteractorStyle, vtkInteractorStyleRubberBandPick);
173 
174     InteractorStyle()
175     {
176         selectedMapper = vtkSmartPointer::New();
177         selectedActor = vtkSmartPointer::New();
178     }
179 
180     virtual void OnLeftButtonUp()
181     {
182         // Forward events
183         vtkInteractorStyleRubberBandPick::OnLeftButtonUp();
184 
185         vtkPlanes* frustum = static_cast(this->GetInteractor()->GetPicker())->GetFrustum();
186 
187         vtkSmartPointer extractGeometry =
188             vtkSmartPointer::New();
189         extractGeometry->SetImplicitFunction(frustum);
190 #if VTK_MAJOR_VERSION <= 5
191         extractGeometry->SetInput(this->Data);
192 #else
193         extractGeometry->SetInputData(this->Data);
194 #endif
195         extractGeometry->Update();
196         this->selectedMapper->SetInputConnection(extractGeometry->GetOutputPort());
197         this->selectedMapper->ScalarVisibilityOff();
198 
199         this->selectedActor->SetMapper(selectedMapper);
200 
201         this->selectedActor->GetProperty()->SetColor(1.0, 0.0, 0.0); //(R,G,B)
202 
203                                                                      //this->CurrentRenderer->AddActor(SelectedActor);
204         this->Interactor->GetRenderWindow()->GetRenderers()->GetFirstRenderer()->AddActor(selectedActor);
205         this->GetInteractor()->GetRenderWindow()->Render();
206     }
207 
208 
209 
210     vtkSmartPointer Data;
211     vtkSmartPointer selectedMapper;
212     vtkSmartPointer selectedActor;
213 
214 };
215 
216 
217 vtkStandardNewMacro(InteractorStyle);
218 
219 int main(int, char* [])
220 {
221 
222     vtkSmartPointer sphereSource =
223         vtkSmartPointer::New();
224     sphereSource->Update();
225 
226     vtkSmartPointer mapper =
227         vtkSmartPointer::New();
228     mapper->SetInputData(sphereSource->GetOutput());
229 
230     vtkSmartPointer actor =
231         vtkSmartPointer::New();
232     actor->SetMapper(mapper);
233     actor->GetProperty()->SetColor(0.0, 0.6, 0.5);
234     //    actor->GetProperty()->SetRepresentationToWireframe();
235 
236         //actor->GetProperty()->SetRepresentationToPoints();
237 
238     vtkSmartPointer renderer =
239         vtkSmartPointer::New();
240     vtkSmartPointer renderWindow =
241         vtkSmartPointer::New();
242     renderWindow->AddRenderer(renderer);
243     renderWindow->SetSize(640, 480);
244     vtkSmartPointer areaPicker = vtkSmartPointer::New();
245     vtkSmartPointer renderWindowInteractor =
246         vtkSmartPointer::New();
247     renderWindowInteractor->SetRenderWindow(renderWindow);
248     renderWindowInteractor->SetPicker(areaPicker);
249     renderWindowInteractor->Initialize();
250 
251     // Set the custom stype to use for interaction.
252     vtkSmartPointer style =
253         vtkSmartPointer::New();
254     //style->SetDefaultRenderer(renderer);
255     style->Data = sphereSource->GetOutput();
256 
257     renderWindowInteractor->SetInteractorStyle(style);
258 
259     renderer->AddActor(actor);
260     renderer->ResetCamera();
261 
262     renderer->SetBackground(0.6, 0.8, 0.8); // Blue
263 
264     renderWindow->Render();
265     renderWindowInteractor->Start();
266 
267     return EXIT_SUCCESS;
268 }

  1 #include 
  2 #include 
  3 #include 
  4 #include 
  5 #include 
  6 #include 
  7 #include 
  8 #include 
  9 #include 
 10 #include 
 11 #include 
 12 #include 
 13 #include 
 14 #include 
 15 #include 
 16 #include 
 17 
 18 int main(int argc, char* argv[]) {
 19     vtkNew colors;
 20 
 21     // PolyData to process
 22     vtkSmartPointer polyData;
 23 
 24     if (argc > 1) {
 25         vtkNew reader;
 26         reader->SetFileName(argv[1]);
 27         reader->Update();
 28         polyData = reader->GetOutput();
 29     }
 30     else {
 31         // Create a sphere
 32         vtkNew sphereSource;
 33         sphereSource->SetThetaResolution(20);
 34         sphereSource->SetPhiResolution(11);
 35         sphereSource->Update();
 36 
 37         polyData = sphereSource->GetOutput();
 38     }
 39 
 40     auto center = polyData->GetCenter();
 41     vtkNew plane1;
 42     plane1->SetOrigin(center[0], center[1], center[2]);
 43     plane1->SetNormal(0.0, -1.0, 0.0);
 44     vtkNew plane2;
 45     plane2->SetOrigin(center[0], center[1], center[2]);
 46     plane2->SetNormal(0.0, 0.0, 1.0);
 47     vtkNew plane3;
 48     plane3->SetOrigin(center[0], center[1], center[2]);
 49     plane3->SetNormal(-1.0, 0.0, 0.0);
 50 
 51     vtkNew planes;
 52     planes->AddItem(plane1);
 53     planes->AddItem(plane2);
 54     planes->AddItem(plane3);
 55 
 56     vtkNew clipper;
 57     clipper->SetInputData(polyData);
 58     clipper->SetClippingPlanes(planes);
 59     clipper->SetActivePlaneId(2);
 60     clipper->SetScalarModeToColors();
 61     clipper->SetClipColor(colors->GetColor3d("Banana").GetData());
 62     clipper->SetBaseColor(colors->GetColor3d("Tomato").GetData());
 63     clipper->SetActivePlaneColor(colors->GetColor3d("SandyBrown").GetData());
 64 
 65     vtkNew clipMapper;
 66     clipMapper->SetInputConnection(clipper->GetOutputPort());
 67 
 68     vtkNew clipActor;
 69     clipActor->SetMapper(clipMapper);
 70     clipActor->GetProperty()->SetColor(1.0000, 0.3882, 0.2784);
 71     clipActor->GetProperty()->SetInterpolationToFlat();
 72 
 73     // Create graphics stuff
 74     vtkNew ren1;
 75     ren1->SetBackground(colors->GetColor3d("SteelBlue").GetData());
 76 
 77     vtkNew renWin;
 78     renWin->AddRenderer(ren1);
 79     renWin->SetSize(512, 512);
 80     renWin->SetWindowName("ClipClosedSurface");
 81 
 82     vtkNew iren;
 83     iren->SetRenderWindow(renWin);
 84 
 85     // Add the actors to the renderer, set the background and size
 86     ren1->AddActor(clipActor);
 87 
 88     // Generate an interesting view
 89     ren1->ResetCamera();
 90     ren1->GetActiveCamera()->Azimuth(120);
 91     ren1->GetActiveCamera()->Elevation(30);
 92     ren1->GetActiveCamera()->Dolly(1.0);
 93     ren1->ResetCameraClippingRange();
 94 
 95     renWin->Render();
 96     iren->Initialize();
 97     iren->Start();
 98 
 99     return EXIT_SUCCESS;
100 }