VTK资料分享：张晓东的《VTK图形图像开发进阶》全套资料（包含书籍电子版，配套每章节所有源码、实现效果图和工程配置文件）
水灵VTK学习全套资料（包含全部视频、PPT、源码和每个项目对应的工程配置文件CmakeLists.txt）
水灵VT视频在线观看
本文参考的主要是张晓东的《VTK图形图像开发进阶》和水灵的视频Study VTK Together。使用的平台是VS2019+VTK8.2
#include "vtkAutoInit.h"
VTK_MODULE_INIT(vtkRenderingOpenGL2);
VTK_MODULE_INIT(vtkInteractionStyle);
#include <vtkSmartPointer.h>
#include <vtkPointData.h>
#include <vtkPolyDataMapper.h>
#include <vtkActor.h>
#include <vtkScalarBarActor.h>
#include <vtkRenderWindow.h>
#include <vtkRenderer.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkPolyData.h>
#include <vtkCubeSource.h>
#include <vtkProperty.h>
#include <vtkTriangleFilter.h>
#include <vtkMassProperties.h>
int main(int argc, char *argv[])
{
vtkSmartPointer<vtkCubeSource> cubeSource =
vtkSmartPointer<vtkCubeSource>::New();
cubeSource->Update();
vtkSmartPointer<vtkTriangleFilter> triFilter =
vtkSmartPointer<vtkTriangleFilter>::New();
triFilter->SetInputData(cubeSource->GetOutput());
triFilter->Update();
vtkSmartPointer<vtkMassProperties> massProp =
vtkSmartPointer<vtkMassProperties>::New();
massProp->SetInputData(triFilter->GetOutput());
float vol = massProp->GetVolume();
float area= massProp->GetSurfaceArea();
float maxArea = massProp->GetMaxCellArea();
float minArea = massProp->GetMinCellArea();
std::cout<<"Volume :"<<vol<<std::endl;
std::cout<<"Surface Area:"<<area<<std::endl;
std::cout<<"Max Area :"<<maxArea<<std::endl;
std::cout<<"Min Area :"<<minArea<<std::endl;
vtkSmartPointer<vtkPolyDataMapper> mapper =
vtkSmartPointer<vtkPolyDataMapper>::New();
//mapper->SetInput(cubeSource->GetOutput());
mapper->SetInputData(triFilter->GetOutput());
vtkSmartPointer<vtkActor> actor =
vtkSmartPointer<vtkActor>::New();
actor->SetMapper(mapper);
actor->GetProperty()->SetColor(0,1,0);
actor->GetProperty()->SetEdgeColor(1,0,0);
actor->GetProperty()->SetEdgeVisibility(1);
vtkSmartPointer<vtkRenderer> renderer =
vtkSmartPointer<vtkRenderer>::New();
renderer->AddActor(actor);
renderer->SetBackground(1.0,1.0,1.0);
vtkSmartPointer<vtkRenderWindow> renderWindow =
vtkSmartPointer<vtkRenderWindow>::New();
renderWindow->AddRenderer(renderer);
renderWindow->SetSize( 640, 480 );
renderWindow->Render();
renderWindow->SetWindowName("PolyDataMassProperty");
vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
vtkSmartPointer<vtkRenderWindowInteractor>::New();
renderWindowInteractor->SetRenderWindow(renderWindow);
renderWindow->Render();
renderWindowInteractor->Start();
return EXIT_SUCCESS;
}
#include "vtkAutoInit.h"
VTK_MODULE_INIT(vtkRenderingOpenGL2);
VTK_MODULE_INIT(vtkInteractionStyle);
#include <vtkSphereSource.h>
#include <vtkProperty.h>
#include <vtkPolyData.h>
#include <vtkSmartPointer.h>
#include <vtkPolyDataMapper.h>
#include <vtkActor.h>
#include <vtkRenderWindow.h>
#include <vtkRenderer.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkDijkstraGraphGeodesicPath.h>
int main(int , char *[])
{
vtkSmartPointer<vtkSphereSource> sphereSource =
vtkSmartPointer<vtkSphereSource>::New();
sphereSource->Update();
vtkSmartPointer<vtkDijkstraGraphGeodesicPath> dijkstra =
vtkSmartPointer<vtkDijkstraGraphGeodesicPath>::New();
dijkstra->SetInputData(sphereSource->GetOutput());
dijkstra->SetStartVertex(0);
dijkstra->SetEndVertex(10);
dijkstra->Update();
vtkSmartPointer<vtkPolyDataMapper> pathMapper =
vtkSmartPointer<vtkPolyDataMapper>::New();
pathMapper->SetInputData(dijkstra->GetOutput());
vtkSmartPointer<vtkActor> pathActor =
vtkSmartPointer<vtkActor>::New();
pathActor->SetMapper(pathMapper);
pathActor->GetProperty()->SetColor(1,0,0);
pathActor->GetProperty()->SetLineWidth(4);
vtkSmartPointer<vtkPolyDataMapper> mapper =
vtkSmartPointer<vtkPolyDataMapper>::New();
mapper->SetInputData(sphereSource->GetOutput());
vtkSmartPointer<vtkActor> actor =
vtkSmartPointer<vtkActor>::New();
actor->SetMapper(mapper);
vtkSmartPointer<vtkRenderer> renderer =
vtkSmartPointer<vtkRenderer>::New();
renderer->AddActor(actor);
renderer->AddActor(pathActor);
renderer->SetBackground(1.0, 1.0, 1.0);
vtkSmartPointer<vtkRenderWindow> renderWindow =
vtkSmartPointer<vtkRenderWindow>::New();
renderWindow->AddRenderer(renderer);
renderWindow->SetSize( 640, 480 );
renderWindow->Render();
renderWindow->SetWindowName("PolyDataGeodesic");
vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
vtkSmartPointer<vtkRenderWindowInteractor>::New();
renderWindowInteractor->SetRenderWindow(renderWindow);
renderWindow->Render();
renderWindowInteractor->Start();
return EXIT_SUCCESS;
}
#include "vtkAutoInit.h"
VTK_MODULE_INIT(vtkRenderingOpenGL2);
VTK_MODULE_INIT(vtkInteractionStyle);
#include <vtkSmartPointer.h>
#include <vtkPolyDataReader.h>
#include <vtkPolyDataNormals.h> //计算法向量
#include <vtkMaskPoints.h>
#include <vtkArrowSource.h>
#include <vtkGlyph3D.h>
#include <vtkPointData.h>
#include <vtkProperty.h>
//
#include <vtkPolyDataMapper.h>
#include <vtkActor.h>
#include <vtkRenderer.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
int main()
{
vtkSmartPointer<vtkPolyDataReader> plyReader =
vtkSmartPointer<vtkPolyDataReader>::New();
plyReader->SetFileName("C:\\Users\\Administrator\\Desktop\\VTK2\\hellovtk\\vtk_图像处理学习\\第六章_图像处理\\data\\fran_cut.vtk");
plyReader->Update();
vtkSmartPointer<vtkPolyDataNormals> normFilter =
vtkSmartPointer<vtkPolyDataNormals>::New();
normFilter->SetInputData(plyReader->GetOutput());
normFilter->SetComputePointNormals(1);//开启点法向量计算
normFilter->SetComputeCellNormals(0); //关闭单元法向量计算
normFilter->SetAutoOrientNormals(1);
normFilter->SetSplitting(0);
normFilter->Update();
vtkSmartPointer<vtkMaskPoints> mask =
vtkSmartPointer<vtkMaskPoints>::New();
mask->SetInputData(normFilter->GetOutput());
mask->SetMaximumNumberOfPoints(300);
mask->RandomModeOn();
mask->Update();
vtkSmartPointer<vtkArrowSource> arrow =
vtkSmartPointer<vtkArrowSource>::New();
arrow->Update(); //一定要更新 否则数据没有添加进来，程序会报错
vtkSmartPointer<vtkGlyph3D> glyph =
vtkSmartPointer<vtkGlyph3D>::New();
glyph->SetInputData(mask->GetOutput());
glyph->SetSourceData(arrow->GetOutput());//每一点用箭头代替
glyph->SetVectorModeToUseNormal();//设置向量显示模式和法向量一致
glyph->SetScaleFactor(0.01); //设置伸缩比例
glyph->Update();
vtkSmartPointer<vtkPolyDataMapper> mapper =
vtkSmartPointer<vtkPolyDataMapper>::New();
mapper->SetInputData(plyReader->GetOutput());
vtkSmartPointer<vtkPolyDataMapper> normMapper =
vtkSmartPointer<vtkPolyDataMapper>::New();
normMapper->SetInputData(normFilter->GetOutput());
vtkSmartPointer<vtkPolyDataMapper> glyphMapper =
vtkSmartPointer<vtkPolyDataMapper>::New();
glyphMapper->SetInputData(glyph->GetOutput());
vtkSmartPointer<vtkActor> actor =
vtkSmartPointer<vtkActor>::New();
actor->SetMapper(mapper);
vtkSmartPointer<vtkActor> normActor =
vtkSmartPointer<vtkActor>::New();
normActor->SetMapper(normMapper);
vtkSmartPointer<vtkActor> glyphActor =
vtkSmartPointer<vtkActor>::New();
glyphActor->SetMapper(glyphMapper);
glyphActor->GetProperty()->SetColor(1, 0, 0);
double origView[4] = { 0, 0, 0.33, 1 };
double normView[4] = { 0.33, 0, 0.66, 1 };
double glyphView[4] = { 0.66, 0, 1, 1 };
vtkSmartPointer<vtkRenderer> origRender =
vtkSmartPointer<vtkRenderer>::New();
origRender->SetViewport(origView);
origRender->AddActor(actor);
origRender->SetBackground(1, 0, 0);
vtkSmartPointer<vtkRenderer> normRender =
vtkSmartPointer<vtkRenderer>::New();
normRender->SetViewport(normView);
normRender->AddActor(normActor);
normRender->SetBackground(0, 1, 0);
vtkSmartPointer<vtkRenderer> glyphRender =
vtkSmartPointer<vtkRenderer>::New();
glyphRender->SetViewport(glyphView);
glyphRender->AddActor(glyphActor);
glyphRender->AddActor(normActor);
glyphRender->SetBackground(0, 0, 1);
vtkSmartPointer<vtkRenderWindow> rw =
vtkSmartPointer<vtkRenderWindow>::New();
rw->AddRenderer(origRender);
rw->AddRenderer(normRender);
rw->AddRenderer(glyphRender);
rw->SetWindowName("Calculating Point Norm & Cell Norm");
rw->SetSize(960, 320);
rw->Render();
vtkSmartPointer<vtkRenderWindowInteractor> rwi =
vtkSmartPointer<vtkRenderWindowInteractor>::New();
rwi->SetRenderWindow(rw);
rwi->Initialize();
rwi->Start();
return 0;
}
#include "vtkAutoInit.h"
//VTK_MODULE_INIT(vtkRenderingOpenGL2);
//VTK_MODULE_INIT(vtkInteractionStyle);
VTK_MODULE_INIT(vtkRenderingOpenGL2);
VTK_MODULE_INIT(vtkInteractionStyle);
VTK_MODULE_INIT(vtkRenderingFreeType);
#include <vtkSmartPointer.h>
#include <vtkPolyDataReader.h>
#include <vtkCurvatures.h>
#include <vtkLookupTable.h>
#include <vtkPolyDataMapper.h>
#include <vtkActor.h>
#include <vtkScalarBarActor.h>
#include <vtkPointData.h>
#include <vtkRenderer.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
int main()
{
vtkSmartPointer<vtkPolyDataReader> reader =
vtkSmartPointer<vtkPolyDataReader>::New();
reader->SetFileName("C:\\Users\\Administrator\\Desktop\\VTK2\\hellovtk\\vtk_图像处理学习\\第六章_图像处理\\data\\fran_cut.vtk");
reader->Update();
vtkSmartPointer<vtkCurvatures> curvaturesFilter =
vtkSmartPointer<vtkCurvatures>::New();
curvaturesFilter->SetInputConnection(reader->GetOutputPort());
//curvaturesFilter->SetCurvatureTypeToMinimum(); //最小曲率
curvaturesFilter->SetCurvatureTypeToMaximum(); //最大曲率
//curvaturesFilter->SetCurvatureTypeToGaussian();//高斯曲率
//curvaturesFilter->SetCurvatureTypeToMean(); //平均曲率
curvaturesFilter->Update();
double scalarRange[2];
curvaturesFilter->GetOutput()->GetScalarRange(scalarRange);
//建立查找表 做颜色映射
vtkSmartPointer<vtkLookupTable> lut =
vtkSmartPointer<vtkLookupTable>::New();
lut->SetHueRange(0.0, 0.6);
lut->SetAlphaRange(1.0, 1.0);
lut->SetValueRange(1.0, 1.0);
lut->SetSaturationRange(1.0, 1.0);
lut->SetNumberOfTableValues(256);
lut->SetRange(scalarRange);
lut->Build();
///
vtkSmartPointer<vtkPolyDataMapper> mapper =
vtkSmartPointer<vtkPolyDataMapper>::New();
mapper->SetInputData(curvaturesFilter->GetOutput());
mapper->SetLookupTable(lut);
mapper->SetScalarRange(scalarRange);
vtkSmartPointer<vtkActor> actor =
vtkSmartPointer<vtkActor>::New();
actor->SetMapper(mapper);
vtkSmartPointer<vtkScalarBarActor> scalarBar =
vtkSmartPointer<vtkScalarBarActor>::New();
scalarBar->SetLookupTable(mapper->GetLookupTable());
scalarBar->SetTitle(curvaturesFilter->GetOutput()->GetPointData()->GetScalars()->GetName());
scalarBar->SetNumberOfLabels(5); //设置5个标签
vtkSmartPointer<vtkRenderer> render =
vtkSmartPointer<vtkRenderer>::New();
render->AddActor(actor);
render->AddActor2D(scalarBar);
render->SetBackground(0, 0, 0);
vtkSmartPointer<vtkRenderWindow> rw =
vtkSmartPointer<vtkRenderWindow>::New();
rw->AddRenderer(render);
rw->SetSize(640, 480);
rw->SetWindowName("Calculating PolyData Curvature");
vtkSmartPointer<vtkRenderWindowInteractor> rwi =
vtkSmartPointer<vtkRenderWindowInteractor>::New();
rwi->SetRenderWindow(rw);
rwi->Initialize();
rwi->Start();
return 0;
}
#include "vtkAutoInit.h"
VTK_MODULE_INIT(vtkRenderingOpenGL2);
VTK_MODULE_INIT(vtkInteractionStyle);
#include <vtkSmartPointer.h>
#include <vtkPolyDataReader.h>
#include <vtkPolyData.h>
#include <vtkSmoothPolyDataFilter.h>
#include <vtkWindowedSincPolyDataFilter.h>
#include <vtkSphereSource.h>
#include <vtkPolyDataMapper.h>
#include <vtkActor.h>
#include <vtkRenderWindow.h>
#include <vtkRenderer.h>
#include <vtkRenderWindowInteractor.h>
//测试文件：../data/fran_cut.vtk
int main(int argc, char *argv[])
{
vtkSmartPointer<vtkPolyDataReader> reader =
vtkSmartPointer<vtkPolyDataReader>::New();
reader->SetFileName("C:\\Users\\Administrator\\Desktop\\VTK2\\hellovtk\\vtk_图像处理学习\\第六章_图像处理\\data\\fran_cut.vtk");
reader->Update();
vtkSmartPointer<vtkSmoothPolyDataFilter> smoothFilter =
vtkSmartPointer<vtkSmoothPolyDataFilter>::New();
smoothFilter->SetInputConnection(reader->GetOutputPort());
smoothFilter->SetNumberOfIterations(200);
smoothFilter->Update();
vtkSmartPointer<vtkPolyDataMapper> inputMapper =
vtkSmartPointer<vtkPolyDataMapper>::New();
inputMapper->SetInputConnection(reader->GetOutputPort());
vtkSmartPointer<vtkActor> inputActor =
vtkSmartPointer<vtkActor>::New();
inputActor->SetMapper(inputMapper);
vtkSmartPointer<vtkPolyDataMapper> smoothedMapper =
vtkSmartPointer<vtkPolyDataMapper>::New();
smoothedMapper->SetInputConnection(smoothFilter->GetOutputPort());
vtkSmartPointer<vtkActor> smoothedActor =
vtkSmartPointer<vtkActor>::New();
smoothedActor->SetMapper(smoothedMapper);
double leftViewport[4] = {0.0, 0.0, 0.5, 1.0};
double rightViewport[4] = {0.5, 0.0, 1.0, 1.0};
vtkSmartPointer<vtkRenderer> leftRenderer =
vtkSmartPointer<vtkRenderer>::New();
leftRenderer->SetViewport(leftViewport);
leftRenderer->AddActor(inputActor);
leftRenderer->SetBackground(0.8, 0.8, 0.8);
leftRenderer->ResetCamera();
vtkSmartPointer<vtkRenderer> rightRenderer =
vtkSmartPointer<vtkRenderer>::New();
rightRenderer->SetViewport(rightViewport);
rightRenderer->AddActor(smoothedActor);
rightRenderer->SetBackground(0.8, 0.8, 0.8);
rightRenderer->SetActiveCamera(leftRenderer->GetActiveCamera());
rightRenderer->ResetCamera();
vtkSmartPointer<vtkRenderWindow> renderWindow =
vtkSmartPointer<vtkRenderWindow>::New();
renderWindow->AddRenderer(leftRenderer);
renderWindow->AddRenderer(rightRenderer);
renderWindow->SetSize(640, 320);
renderWindow->Render();
renderWindow->SetWindowName("PolyDataLapLasianSmooth");
vtkSmartPointer<vtkRenderWindowInteractor> interactor =
vtkSmartPointer<vtkRenderWindowInteractor>::New();
interactor->SetRenderWindow(renderWindow);
renderWindow->Render();
interactor->Start();
return EXIT_SUCCESS;
}
#include "vtkAutoInit.h"
VTK_MODULE_INIT(vtkRenderingOpenGL2);
VTK_MODULE_INIT(vtkInteractionStyle);
#include <vtkSmartPointer.h>
#include <vtkSelectionNode.h>
#include <vtkInformation.h>
#include <vtkUnstructuredGrid.h>
#include <vtkPolyData.h>
#include <vtkPolyDataNormals.h>
#include <vtkPointData.h>
#include <vtkXMLPolyDataReader.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkRenderer.h>
#include <vtkSelection.h>
#include <vtkSelectionNode.h>
#include <vtkSphereSource.h>
#include <vtkPolyDataMapper.h>
#include <vtkActor.h>
#include <vtkCamera.h>
#include <vtkProperty.h>
#include <vtkIdTypeArray.h>
#include <vtkExtractSelection.h>
#include <vtkDataSetSurfaceFilter.h>
#include <vtkFeatureEdges.h>
#include <vtkFillHolesFilter.h>
void GenerateData(vtkSmartPointer<vtkPolyData> input)
{
vtkSmartPointer<vtkSphereSource> sphereSource =
vtkSmartPointer<vtkSphereSource>::New();
sphereSource->Update();
vtkSmartPointer<vtkIdTypeArray> ids =
vtkSmartPointer<vtkIdTypeArray>::New();
ids->SetNumberOfComponents(1);
ids->InsertNextValue(2);
ids->InsertNextValue(10);
vtkSmartPointer<vtkSelectionNode> selectionNode =
vtkSmartPointer<vtkSelectionNode>::New();
selectionNode->SetFieldType(vtkSelectionNode::CELL);
selectionNode->SetContentType(vtkSelectionNode::INDICES);
selectionNode->SetSelectionList(ids);
selectionNode->GetProperties()->Set(vtkSelectionNode::INVERSE(), 1);
vtkSmartPointer<vtkSelection> selection =
vtkSmartPointer<vtkSelection>::New();
selection->AddNode(selectionNode);
vtkSmartPointer<vtkExtractSelection> extractSelection =
vtkSmartPointer<vtkExtractSelection>::New();
extractSelection->SetInputData(0, sphereSource->GetOutput());
extractSelection->SetInputData(1, selection);
extractSelection->Update();
vtkSmartPointer<vtkDataSetSurfaceFilter> surfaceFilter =
vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
surfaceFilter->SetInputConnection(extractSelection->GetOutputPort());
surfaceFilter->Update();
input->ShallowCopy(surfaceFilter->GetOutput());
}
int main(int argc, char *argv[])
{
vtkSmartPointer<vtkPolyData> input =
vtkSmartPointer<vtkPolyData>::New();
GenerateData(input);
vtkSmartPointer<vtkFeatureEdges> featureEdges =
vtkSmartPointer<vtkFeatureEdges>::New();
featureEdges->SetInputData(input);
featureEdges->BoundaryEdgesOn();
featureEdges->FeatureEdgesOff();
featureEdges->ManifoldEdgesOff();
featureEdges->NonManifoldEdgesOff();
featureEdges->Update();
int numberOfOpenEdges = featureEdges->GetOutput()->GetNumberOfCells();
if(numberOfOpenEdges)
{
std::cout<<"该网格模型不是封闭的..."<<std::endl;
}
else
{
std::cout<<"该网格模型是封闭的..."<<std::endl;
return EXIT_SUCCESS;
}
vtkSmartPointer<vtkFillHolesFilter> fillHolesFilter =
vtkSmartPointer<vtkFillHolesFilter>::New();
fillHolesFilter->SetInputData(input);
fillHolesFilter->Update();
vtkSmartPointer<vtkPolyDataNormals> normals =
vtkSmartPointer<vtkPolyDataNormals>::New();
normals->SetInputConnection(fillHolesFilter->GetOutputPort());
normals->ConsistencyOn();
normals->SplittingOff();
normals->Update();
//
double leftViewport[4] = {0.0, 0.0, 0.5, 1.0};
double rightViewport[4] = {0.5, 0.0, 1.0, 1.0};
vtkSmartPointer<vtkPolyDataMapper> originalMapper =
vtkSmartPointer<vtkPolyDataMapper>::New();
originalMapper->SetInputData(input);
vtkSmartPointer<vtkProperty> backfaceProp =
vtkSmartPointer<vtkProperty>::New();
backfaceProp->SetDiffuseColor(0.89,0.81,0.34);
vtkSmartPointer<vtkActor> originalActor =
vtkSmartPointer<vtkActor>::New();
originalActor->SetMapper(originalMapper);
originalActor->SetBackfaceProperty(backfaceProp);
originalActor->GetProperty()->SetDiffuseColor(1.0, 0.3882, 0.2784);
vtkSmartPointer<vtkPolyDataMapper> edgeMapper =
vtkSmartPointer<vtkPolyDataMapper>::New();
edgeMapper->SetInputData(featureEdges->GetOutput());
vtkSmartPointer<vtkActor> edgeActor =
vtkSmartPointer<vtkActor>::New();
edgeActor->SetMapper(edgeMapper);
edgeActor->GetProperty()->SetEdgeColor(0.,0.,1.0);
edgeActor->GetProperty()->SetEdgeVisibility(1);
edgeActor->GetProperty()->SetLineWidth(5);
vtkSmartPointer<vtkPolyDataMapper> filledMapper =
vtkSmartPointer<vtkPolyDataMapper>::New();
filledMapper->SetInputData(normals->GetOutput());
vtkSmartPointer<vtkActor> filledActor =
vtkSmartPointer<vtkActor>::New();
filledActor->SetMapper(filledMapper);
filledActor->GetProperty()->SetDiffuseColor(1.0, 0.3882, 0.2784);
vtkSmartPointer<vtkRenderer> leftRenderer =
vtkSmartPointer<vtkRenderer>::New();
leftRenderer->SetViewport(leftViewport);
leftRenderer->AddActor(originalActor);
leftRenderer->AddActor(edgeActor);
leftRenderer->SetBackground(1.0, 1.0, 1.0);
vtkSmartPointer<vtkRenderer> rightRenderer =
vtkSmartPointer<vtkRenderer>::New();
rightRenderer->SetViewport(rightViewport);
rightRenderer->AddActor(filledActor);
rightRenderer->SetBackground(1.0, 1.0, 1.0);
vtkSmartPointer<vtkRenderWindow> renderWindow =
vtkSmartPointer<vtkRenderWindow>::New();
renderWindow->AddRenderer(leftRenderer);
renderWindow->AddRenderer(rightRenderer);
renderWindow->SetSize(640, 320);
renderWindow->Render();
renderWindow->SetWindowName("PolyDataClosed");
vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
vtkSmartPointer<vtkRenderWindowInteractor>::New();
renderWindowInteractor->SetRenderWindow(renderWindow);
leftRenderer->GetActiveCamera()->SetPosition(0, -1, 0);
leftRenderer->GetActiveCamera()->SetFocalPoint(0, 0, 0);
leftRenderer->GetActiveCamera()->SetViewUp(0, 0, 1);
leftRenderer->GetActiveCamera()->Azimuth(30);
leftRenderer->GetActiveCamera()->Elevation(30);
leftRenderer->ResetCamera();
rightRenderer->SetActiveCamera(leftRenderer->GetActiveCamera());
renderWindow->Render();
renderWindowInteractor->Start();
return EXIT_SUCCESS;
}
左图为原始模型，右图为漏洞填补后的结果
#include <vtkAutoInit.h>
VTK_MODULE_INIT(vtkRenderingOpenGL2);
VTK_MODULE_INIT(vtkRenderingFreeType);
VTK_MODULE_INIT(vtkInteractionStyle);
#include <vtkSmartPointer.h>
#include <vtkSphereSource.h>
#include <vtkConeSource.h>
#include <vtkPolyDataConnectivityFilter.h>
#include <vtkPolyDataMapper.h>
#include <vtkActor.h>
#include <vtkProperty.h>
#include <vtkRenderer.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkAppendPolyData.h>
int main(int, char *[])
{
vtkSmartPointer<vtkSphereSource> sphereSource =
vtkSmartPointer<vtkSphereSource>::New();
sphereSource->SetRadius(10);
sphereSource->SetThetaResolution(10);
sphereSource->SetPhiResolution(10);
sphereSource->Update();
vtkSmartPointer<vtkConeSource> coneSource =
vtkSmartPointer<vtkConeSource>::New();
coneSource->SetRadius(5);
coneSource->SetHeight(10);
coneSource->SetCenter(25,0,0);
coneSource->Update();
vtkSmartPointer<vtkAppendPolyData> appendFilter =
vtkSmartPointer<vtkAppendPolyData>::New();
appendFilter->AddInputData(sphereSource->GetOutput());
appendFilter->AddInputData(coneSource->GetOutput());
appendFilter->Update();
vtkSmartPointer<vtkPolyDataConnectivityFilter> connectivityFilter =
vtkSmartPointer<vtkPolyDataConnectivityFilter>::New();
connectivityFilter->SetInputData(appendFilter->GetOutput());
connectivityFilter->SetExtractionModeToCellSeededRegions();
connectivityFilter->AddSeed(100);
connectivityFilter->Update();
vtkSmartPointer<vtkPolyDataMapper> originalMapper =
vtkSmartPointer<vtkPolyDataMapper>::New();
originalMapper->SetInputConnection(appendFilter->GetOutputPort());
originalMapper->Update();
vtkSmartPointer<vtkActor> originalActor =
vtkSmartPointer<vtkActor>::New();
originalActor->SetMapper(originalMapper);
vtkSmartPointer<vtkPolyDataMapper> extractedMapper =
vtkSmartPointer<vtkPolyDataMapper>::New();
extractedMapper->SetInputConnection(connectivityFilter->GetOutputPort());
extractedMapper->Update();
vtkSmartPointer<vtkActor> extractedActor =
vtkSmartPointer<vtkActor>::New();
extractedActor->SetMapper(extractedMapper);
double leftViewport[4] = {0.0, 0.0, 0.5, 1.0};
double rightViewport[4] = {0.5, 0.0, 1.0, 1.0};
vtkSmartPointer<vtkRenderer> leftRenderer =
vtkSmartPointer<vtkRenderer>::New();
leftRenderer->SetViewport(leftViewport);
leftRenderer->AddActor(originalActor);
leftRenderer->SetBackground(0.8, 0.8, 0.8);
vtkSmartPointer<vtkRenderer> rightRenderer =
vtkSmartPointer<vtkRenderer>::New();
rightRenderer->SetViewport(rightViewport);
rightRenderer->AddActor(extractedActor);
rightRenderer->SetBackground(1.0, 1.0, 1.0);
vtkSmartPointer<vtkRenderWindow> renderWindow =
vtkSmartPointer<vtkRenderWindow>::New();
renderWindow->AddRenderer(leftRenderer);
renderWindow->AddRenderer(rightRenderer);
renderWindow->SetSize(640, 320);
renderWindow->Render();
renderWindow->SetWindowName("PolyDataConnectedCompExtract");
leftRenderer->ResetCamera();
rightRenderer->SetActiveCamera(leftRenderer->GetActiveCamera());
vtkSmartPointer<vtkRenderWindowInteractor> interactor =
vtkSmartPointer<vtkRenderWindowInteractor>::New();
interactor->SetRenderWindow(renderWindow);
interactor->Initialize();
interactor->Start();
return EXIT_SUCCESS;
}
SetExtractionModeToLargestRegion()：用于提取具有最多点数的连通区域；
SetExtractionModeToAllRegions()：该模式主要用于连通区域标记，配合函数ColorRegionsOn()使用，在连通区域像是的同时，生成一个名为RegionId的点属性数据。
SetExtractionModeToSpecifiedRegions()：该模式用于提取一个或多个连通区域，在该模式下，需要通过AddSpecifiedRegion()来添加西药提取的区域号，区域号从零开始。
SetExtractionModeToClosestPointRegion()：该模式需要使用SetClosestPoint()函数设置一个空间点坐标，执行结果为离该点最近的连通区域。
SetExtractionModeToPointSeededRegions()：该模式下需要使用AddSeed()函数添加种子点，提取种子点所在的区域。
SetExtractionModeToCellSeededRegions()：该模式下需要使用AddSeed()函数调价种子单元，提取种子单元所在的区域。
#include <vtkAutoInit.h>
VTK_MODULE_INIT(vtkRenderingOpenGL2);
VTK_MODULE_INIT(vtkRenderingFreeType);
VTK_MODULE_INIT(vtkInteractionStyle);
#include <vtkPolyData.h>
#include <vtkSphereSource.h>
#include <vtkDecimatePro.h>
#include <vtkQuadricDecimation.h>
#include <vtkQuadricClustering.h>
#include <vtkSmartPointer.h>
#include <vtkPolyDataMapper.h>
#include <vtkProperty.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkRenderer.h>
#include <vtkPolydataReader.h>
#include <vtkCamera.h>
//测试文件：../data/fran_cut.vtk
int main(int argc, char * argv[])
{
vtkSmartPointer<vtkPolyDataReader> reader =
vtkSmartPointer<vtkPolyDataReader>::New();
reader->SetFileName("C:\\Users\\Administrator\\Desktop\\VTK2\\hellovtk\\vtk_图像处理学习\\第六章_图像处理\\data\\fran_cut.vtk");
reader->Update();
vtkSmartPointer<vtkPolyData> original = reader->GetOutput();
std::cout << "抽取前：" << std::endl << "------------" << std::endl;
std::cout << "模型点数为： " << original->GetNumberOfPoints() << std::endl;
std::cout << "模型面数为： " << original->GetNumberOfPolys() << std::endl;
vtkSmartPointer<vtkDecimatePro> decimate =
vtkSmartPointer<vtkDecimatePro>::New();
decimate->SetInputData(original);
decimate->SetTargetReduction(.80); //80%的三角面片被移除
decimate->Update();
vtkSmartPointer<vtkPolyData> decimated = decimate->GetOutput();
std::cout << "抽取后" << std::endl << "------------" << std::endl;
std::cout << "模型点数为：" << decimated->GetNumberOfPoints()<< std::endl;
std::cout << "模型面数为：" << decimated->GetNumberOfPolys()<< std::endl;
vtkSmartPointer<vtkPolyDataMapper> origianlMapper =
vtkSmartPointer<vtkPolyDataMapper>::New();
origianlMapper->SetInputData(original);
vtkSmartPointer<vtkActor> origianlActor =
vtkSmartPointer<vtkActor>::New();
origianlActor->SetMapper(origianlMapper);
vtkSmartPointer<vtkPolyDataMapper> decimatedMapper =
vtkSmartPointer<vtkPolyDataMapper>::New();
decimatedMapper->SetInputData(decimated);
vtkSmartPointer<vtkActor> decimatedActor =
vtkSmartPointer<vtkActor>::New();
decimatedActor->SetMapper(decimatedMapper);
double leftViewport[4] = {0.0, 0.0, 0.5, 1.0};
double rightViewport[4] = {0.5, 0.0, 1.0, 1.0};
vtkSmartPointer<vtkRenderer> leftRenderer =
vtkSmartPointer<vtkRenderer>::New();
leftRenderer->SetViewport(leftViewport);
leftRenderer->AddActor(origianlActor);
leftRenderer->SetBackground(1.0, 1.0, 1.0);
vtkSmartPointer<vtkRenderer> rightRenderer =
vtkSmartPointer<vtkRenderer>::New();
rightRenderer->SetViewport(rightViewport);
rightRenderer->AddActor(decimatedActor);
rightRenderer->SetBackground(1.0, 1.0, 1.0);
leftRenderer->GetActiveCamera()->SetPosition(0, -1, 0);
leftRenderer->GetActiveCamera()->SetFocalPoint(0, 0, 0);
leftRenderer->GetActiveCamera()->SetViewUp(0, 0, 1);
leftRenderer->GetActiveCamera()->Azimuth(30);
leftRenderer->GetActiveCamera()->Elevation(30);
leftRenderer->ResetCamera();
rightRenderer->SetActiveCamera(leftRenderer->GetActiveCamera());
vtkSmartPointer<vtkRenderWindow> renderWindow =
vtkSmartPointer<vtkRenderWindow>::New();
renderWindow->AddRenderer(leftRenderer);
renderWindow->AddRenderer(rightRenderer);
renderWindow->SetSize(640, 320);
renderWindow->Render();
renderWindow->SetWindowName("PolyDataDecimation");
vtkSmartPointer<vtkRenderWindowInteractor> interactor =
vtkSmartPointer<vtkRenderWindowInteractor>::New();
interactor->SetRenderWindow(renderWindow);
renderWindow->Render();
interactor->Start();
return EXIT_SUCCESS;
}
#include <vtkAutoInit.h>
VTK_MODULE_INIT(vtkRenderingOpenGL2);
VTK_MODULE_INIT(vtkRenderingFreeType);
VTK_MODULE_INIT(vtkInteractionStyle);
#include <vtkSmartPointer.h>
#include <vtkPolyDataReader.h>
#include <vtkPolyData.h>
#include <vtkLinearSubdivisionFilter.h>
#include <vtkLoopSubdivisionFilter.h>
#include <vtkButterflySubdivisionFilter.h>
#include <vtkPolyDataMapper.h>
#include <vtkActor.h>
#include <vtkRenderer.h>
#include <vtkRenderWindow.h>
#include <vtkCamera.h>
#include <vtkRenderWindowInteractor.h>
int main()
{
//读数据
vtkSmartPointer<vtkPolyDataReader> reader =
vtkSmartPointer<vtkPolyDataReader>::New();
reader->SetFileName("C:\\Users\\Administrator\\Desktop\\VTK2\\hellovtk\\vtk_图像处理学习\\第六章_图像处理\\data\\fran_cut.vtk");
reader->Update();
vtkSmartPointer<vtkPolyData> orig = reader->GetOutput();
std::cout << "original" << "-----------------------" << std::endl;
std::cout << "模型点数为： " << orig->GetNumberOfPoints() << std::endl;
std::cout << "模型面数为： " << orig->GetNumberOfPolys() << std::endl;
//线性网格细分滤波器
vtkSmartPointer<vtkLinearSubdivisionFilter> linear =
vtkSmartPointer<vtkLinearSubdivisionFilter>::New();
linear->SetInputData(orig);
linear->SetNumberOfSubdivisions(4);
linear->Update();
vtkSmartPointer<vtkPolyData> linearInfo = linear->GetOutput();
std::cout << "linear" << "-----------------------" << std::endl;
std::cout << "模型点数为： " << linearInfo->GetNumberOfPoints() << std::endl;
std::cout << "模型面数为： " << linearInfo->GetNumberOfPolys() << std::endl;
//Loop网格细分滤波器
vtkSmartPointer<vtkLoopSubdivisionFilter> loop =
vtkSmartPointer<vtkLoopSubdivisionFilter>::New();
loop->SetInputData(orig);
loop->SetNumberOfSubdivisions(4);
loop->Update();
vtkSmartPointer<vtkPolyData> loopInfo = loop->GetOutput();
std::cout << "loop" << "-----------------------" << std::endl;
std::cout << "模型点数为： " << loopInfo->GetNumberOfPoints() << std::endl;
std::cout << "模型面数为： " << loopInfo->GetNumberOfPolys() << std::endl;
//butterfly网格细分滤波器
vtkSmartPointer<vtkButterflySubdivisionFilter> butterfly =
vtkSmartPointer<vtkButterflySubdivisionFilter>::New();
butterfly->SetInputData(orig);
butterfly->SetNumberOfSubdivisions(4);
butterfly->Update();
vtkSmartPointer<vtkPolyData> butterflyInfo = butterfly->GetOutput();
std::cout << "butterfly" << "-----------------------" << std::endl;
std::cout << "模型点数为： " << butterflyInfo->GetNumberOfPoints() << std::endl;
std::cout << "模型面数为： " << butterflyInfo->GetNumberOfPolys() << std::endl;
vtkSmartPointer<vtkPolyDataMapper> origMapper =
vtkSmartPointer<vtkPolyDataMapper>::New();
origMapper->SetInputData(orig);
vtkSmartPointer<vtkActor> origActor =
vtkSmartPointer<vtkActor>::New();
origActor->SetMapper(origMapper);
vtkSmartPointer<vtkPolyDataMapper> linearMapper =
vtkSmartPointer<vtkPolyDataMapper>::New();
linearMapper->SetInputData(linear->GetOutput());
vtkSmartPointer<vtkActor> linearActor =
vtkSmartPointer<vtkActor>::New();
linearActor->SetMapper(linearMapper);
vtkSmartPointer<vtkPolyDataMapper> loopMapper =
vtkSmartPointer<vtkPolyDataMapper>::New();
loopMapper->SetInputData(loop->GetOutput());
vtkSmartPointer<vtkActor> loopActor =
vtkSmartPointer<vtkActor>::New();
loopActor->SetMapper(loopMapper);
vtkSmartPointer<vtkPolyDataMapper> butterflyMapper =
vtkSmartPointer<vtkPolyDataMapper>::New();
butterflyMapper->SetInputData(butterfly->GetOutput());
vtkSmartPointer<vtkActor> butterflyActor =
vtkSmartPointer<vtkActor>::New();
butterflyActor->SetMapper(butterflyMapper);
//
double ltView[4] = { 0, 0, 0.5, 0.5 };
double rtView[4] = { 0.5, 0, 1, 0.5 };
double lbView[4] = { 0, 0.5, 0.5, 1 };
double rbView[4] = { 0.5, 0.5, 1, 1 };
vtkSmartPointer<vtkRenderer> origRender =
vtkSmartPointer<vtkRenderer>::New();
origRender->SetViewport(ltView);
origRender->AddActor(origActor);
origRender->SetBackground(1, 0, 0);
vtkSmartPointer<vtkRenderer> linearRender =
vtkSmartPointer<vtkRenderer>::New();
linearRender->SetViewport(rtView);
linearRender->AddActor(linearActor);
linearRender->SetBackground(0, 1, 0);
vtkSmartPointer<vtkRenderer> loopRender =
vtkSmartPointer<vtkRenderer>::New();
loopRender->SetViewport(lbView);
loopRender->AddActor(loopActor);
loopRender->SetBackground(0, 0, 1);
vtkSmartPointer<vtkRenderer> butterflyRender =
vtkSmartPointer<vtkRenderer>::New();
butterflyRender->SetViewport(rbView);
butterflyRender->AddActor(butterflyActor);
butterflyRender->SetBackground(0, 0, 0);
//
vtkSmartPointer<vtkRenderWindow> rw =
vtkSmartPointer<vtkRenderWindow>::New();
rw->AddRenderer(origRender);
rw->AddRenderer(linearRender);
rw->AddRenderer(loopRender);
rw->AddRenderer(butterflyRender);
rw->SetSize(640, 640);
rw->SetWindowName("PolyData Subdivision");
origRender->GetActiveCamera()->SetPosition(0, -1, 0);
origRender->GetActiveCamera()->SetFocalPoint(0, 0, 0);
origRender->GetActiveCamera()->SetViewUp(0, 0, 1);
origRender->GetActiveCamera()->Azimuth(30);
origRender->GetActiveCamera()->Elevation(30);
origRender->ResetCamera();//刷新照相机
linearRender->SetActiveCamera(origRender->GetActiveCamera());
loopRender->SetActiveCamera(origRender->GetActiveCamera());
butterflyRender->SetActiveCamera(origRender->GetActiveCamera());
vtkSmartPointer<vtkRenderWindowInteractor> rwi =
vtkSmartPointer<vtkRenderWindowInteractor>::New();
rwi->SetRenderWindow(rw);
rwi->Start();
rw->Render();
return 0;
}
放大细节 
红色视窗为原始三角网格模型，绿色视窗采用了线性细分算法；蓝色视窗采用Loop细分算法；黑色视窗采用了Butterfly细分算法。可见Loop细分、Butterfly细分能够得到较为光滑的效果；效果优于线性细分算法。
#include <vtkAutoInit.h>
VTK_MODULE_INIT(vtkRenderingOpenGL2);
VTK_MODULE_INIT(vtkRenderingFreeType);
VTK_MODULE_INIT(vtkInteractionStyle);
#include <vtkSmartPointer.h>
#include <vtkProperty.h>
#include <vtkPoints.h>
#include <vtkPolyData.h>
#include <vtkPointData.h>
#include <vtkDelaunay2D.h>
#include <vtkMath.h>
#include <vtkPolyDataMapper.h>
#include <vtkActor.h>
#include <vtkRenderWindow.h>
#include <vtkRenderer.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkVertexGlyphFilter.h>
int main(int, char *[])
{
unsigned int gridSize = 10;
vtkSmartPointer<vtkPoints> points =
vtkSmartPointer<vtkPoints>::New();
for(unsigned int x = 0; x < gridSize; x++)
{
for(unsigned int y = 0; y < gridSize; y++)
{
points->InsertNextPoint(x, y, vtkMath::Random(0.0, 3.0));
}
}
vtkSmartPointer<vtkPolyData> polydata =
vtkSmartPointer<vtkPolyData>::New();
polydata->SetPoints(points);
vtkSmartPointer<vtkDelaunay2D> delaunay =
vtkSmartPointer<vtkDelaunay2D>::New();
delaunay->SetInputData(polydata);
delaunay->Update();
vtkSmartPointer<vtkVertexGlyphFilter> glyphFilter =
vtkSmartPointer<vtkVertexGlyphFilter>::New();
glyphFilter->SetInputData(polydata);
glyphFilter->Update();
vtkSmartPointer<vtkPolyDataMapper> pointsMapper =
vtkSmartPointer<vtkPolyDataMapper>::New();
pointsMapper->SetInputData(glyphFilter->GetOutput());
vtkSmartPointer<vtkActor> pointsActor =
vtkSmartPointer<vtkActor>::New();
pointsActor->SetMapper(pointsMapper);
pointsActor->GetProperty()->SetPointSize(3);
pointsActor->GetProperty()->SetColor(1,0,0);
vtkSmartPointer<vtkPolyDataMapper> triangulatedMapper =
vtkSmartPointer<vtkPolyDataMapper>::New();
triangulatedMapper->SetInputData(delaunay->GetOutput());
vtkSmartPointer<vtkActor> triangulatedActor =
vtkSmartPointer<vtkActor>::New();
triangulatedActor->SetMapper(triangulatedMapper);
vtkSmartPointer<vtkRenderer> renderer =
vtkSmartPointer<vtkRenderer>::New();
renderer->AddActor(pointsActor);
renderer->AddActor(triangulatedActor);
renderer->SetBackground(1.0, 1.0, 1.0);
vtkSmartPointer<vtkRenderWindow> renderWindow =
vtkSmartPointer<vtkRenderWindow>::New();
renderWindow->AddRenderer(renderer);
vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
vtkSmartPointer<vtkRenderWindowInteractor>::New();
renderWindowInteractor->SetRenderWindow(renderWindow);
renderWindow->SetSize(640, 320);
renderWindow->Render();
renderWindow->SetWindowName("PolyDataDelaunay2D");
renderWindow->Render();
renderWindowInteractor->Start();
return EXIT_SUCCESS;
}
#include <vtkAutoInit.h>
VTK_MODULE_INIT(vtkRenderingOpenGL2);
VTK_MODULE_INIT(vtkRenderingFreeType);
VTK_MODULE_INIT(vtkInteractionStyle);
#include <vtkSmartPointer.h>
#include <vtkProperty.h>
#include <vtkPolygon.h>
#include <vtkCellArray.h>
#include <vtkPoints.h>
#include <vtkPolyData.h>
#include <vtkPointData.h>
#include <vtkDelaunay2D.h>
#include <vtkMath.h>
#include <vtkPolyDataMapper.h>
#include <vtkActor.h>
#include <vtkRenderWindow.h>
#include <vtkRenderer.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkVertexGlyphFilter.h>
int main(int, char *[])
{
vtkSmartPointer<vtkPoints> points =
vtkSmartPointer<vtkPoints>::New();
unsigned int gridSize = 10;
for(unsigned int x = 0; x < gridSize; x++)
{
for(unsigned int y = 0; y < gridSize; y++)
{
points->InsertNextPoint(x, y, vtkMath::Random(0.0, 3.0));
}
}
vtkSmartPointer<vtkPolyData> polydata =
vtkSmartPointer<vtkPolyData>::New();
polydata->SetPoints(points);
vtkSmartPointer<vtkPolygon> poly =
vtkSmartPointer<vtkPolygon>::New();
/*poly->GetPointIds()->InsertNextId(22);
poly->GetPointIds()->InsertNextId(23);
poly->GetPointIds()->InsertNextId(24);
poly->GetPointIds()->InsertNextId(25);
poly->GetPointIds()->InsertNextId(35);
poly->GetPointIds()->InsertNextId(45);
poly->GetPointIds()->InsertNextId(44);
poly->GetPointIds()->InsertNextId(43);
poly->GetPointIds()->InsertNextId(42);
poly->GetPointIds()->InsertNextId(32);*/
poly->GetPointIds()->InsertNextId(32);
poly->GetPointIds()->InsertNextId(42);
poly->GetPointIds()->InsertNextId(43);
poly->GetPointIds()->InsertNextId(44);
poly->GetPointIds()->InsertNextId(45);
poly->GetPointIds()->InsertNextId(35);
poly->GetPointIds()->InsertNextId(25);
poly->GetPointIds()->InsertNextId(24);
poly->GetPointIds()->InsertNextId(23);
poly->GetPointIds()->InsertNextId(22);
vtkSmartPointer<vtkCellArray> cell =
vtkSmartPointer<vtkCellArray>::New();
cell->InsertNextCell(poly);
vtkSmartPointer<vtkPolyData> boundary =
vtkSmartPointer<vtkPolyData>::New();
boundary->SetPoints(points);
boundary->SetPolys(cell);
vtkSmartPointer<vtkDelaunay2D> delaunay =
vtkSmartPointer<vtkDelaunay2D>::New();
delaunay->SetInputData(polydata);
delaunay->SetSourceData(boundary);
delaunay->Update();
vtkSmartPointer<vtkVertexGlyphFilter> glyphFilter =
vtkSmartPointer<vtkVertexGlyphFilter>::New();
glyphFilter->SetInputData(polydata);
glyphFilter->Update();
vtkSmartPointer<vtkPolyDataMapper> pointsMapper =
vtkSmartPointer<vtkPolyDataMapper>::New();
pointsMapper->SetInputData(glyphFilter->GetOutput());
vtkSmartPointer<vtkActor> pointsActor =
vtkSmartPointer<vtkActor>::New();
pointsActor->SetMapper(pointsMapper);
pointsActor->GetProperty()->SetPointSize(3);
pointsActor->GetProperty()->SetColor(1,0,0);
vtkSmartPointer<vtkPolyDataMapper> triangulatedMapper =
vtkSmartPointer<vtkPolyDataMapper>::New();
triangulatedMapper->SetInputData(delaunay->GetOutput());
vtkSmartPointer<vtkActor> triangulatedActor =
vtkSmartPointer<vtkActor>::New();
triangulatedActor->SetMapper(triangulatedMapper);
vtkSmartPointer<vtkRenderer> renderer =
vtkSmartPointer<vtkRenderer>::New();
renderer->AddActor(pointsActor);
renderer->AddActor(triangulatedActor);
renderer->SetBackground(1.0, 1.0, 1.0);
vtkSmartPointer<vtkRenderWindow> renderWindow =
vtkSmartPointer<vtkRenderWindow>::New();
renderWindow->AddRenderer(renderer);
vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
vtkSmartPointer<vtkRenderWindowInteractor>::New();
renderWindowInteractor->SetRenderWindow(renderWindow);
renderWindow->SetSize(640, 480);
renderWindow->Render();
renderWindow->SetWindowName("PolyDataConstrainedDelaunay2D");
renderWindow->Render();
renderWindowInteractor->Start();
return EXIT_SUCCESS;
}
#include <vtkAutoInit.h>
VTK_MODULE_INIT(vtkRenderingOpenGL2);
VTK_MODULE_INIT(vtkRenderingFreeType);
VTK_MODULE_INIT(vtkInteractionStyle);
#include <vtkSmartPointer.h>
#include <vtkMarchingCubes.h>
#include <vtkContourFilter.h>
#include <vtkVoxelModeller.h>
#include <vtkSphereSource.h>
#include <vtkImageData.h>
#include <vtkMetaImageReader.h>
#include <vtkInteractorStyleImage.h>
#include <vtkActor.h>
#include <vtkPolyDataMapper.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkRenderWindow.h>
#include <vtkRenderer.h>
#include <vtkImageActor.h>
#include <vtkProperty.h>
//测试：../data/HeadMRVolume.mhd 200
int main(int argc, char *argv[])
{
vtkSmartPointer<vtkMetaImageReader> reader =
vtkSmartPointer<vtkMetaImageReader>::New();
reader->SetFileName("C:\\Users\\Administrator\\Desktop\\VTK2\\hellovtk\\vtk_图像处理学习\\第六章_图像处理\\data\\HeadMRVolume.mhd");
reader->Update();
double isoValue = atof("200");//设置等值面值为200
vtkSmartPointer<vtkMarchingCubes> surface =
vtkSmartPointer<vtkMarchingCubes>::New();
surface->SetInputData(reader->GetOutput());
surface->ComputeNormalsOn();
surface->SetValue(0, isoValue);
//surface->GenerateValues(5, 150,200);
/*vtkSmartPointer<vtkContourFilter> surface =
vtkSmartPointer<vtkContourFilter>::New();
surface->SetInput(reader->GetOutput());
surface->ComputeNormalsOn();
surface->SetValue(0, isoValue);*/
vtkSmartPointer<vtkPolyDataMapper> surfMapper =
vtkSmartPointer<vtkPolyDataMapper>::New();
surfMapper->SetInputConnection(surface->GetOutputPort());
surfMapper->ScalarVisibilityOff();
vtkSmartPointer<vtkActor> surfActor =
vtkSmartPointer<vtkActor>::New();
surfActor->SetMapper(surfMapper);
surfActor->GetProperty()->SetColor(1.0, 0.0, 0.0);
vtkSmartPointer<vtkRenderer> renderer =
vtkSmartPointer<vtkRenderer>::New();
renderer->AddActor(surfActor);
renderer->SetBackground(1.0, 1.0, 1.0);
vtkSmartPointer<vtkRenderWindow> renderWindow =
vtkSmartPointer<vtkRenderWindow>::New();
renderWindow->AddRenderer(renderer);
renderWindow->SetSize(640, 480);
renderWindow->Render();
renderWindow->SetWindowName("PolyDataMarchingCubes");
renderWindow->Render();
vtkSmartPointer<vtkRenderWindowInteractor> interactor =
vtkSmartPointer<vtkRenderWindowInteractor>::New();
interactor->SetRenderWindow(renderWindow);
renderWindow->Render();
interactor->Start();
return EXIT_SUCCESS;
}
#include <vtkAutoInit.h>
VTK_MODULE_INIT(vtkRenderingOpenGL2);
VTK_MODULE_INIT(vtkRenderingFreeType);
VTK_MODULE_INIT(vtkInteractionStyle);
#include <vtkSmartPointer.h>
#include <vtkPolyDataReader.h>
#include <vtkPolyData.h>
#include <vtkSurfaceReconstructionFilter.h>
#include <vtkContourFilter.h>
#include <vtkVertexGlyphFilter.h>
#include <vtkPolyDataMapper.h>
#include <vtkActor.h>
#include <vtkRenderer.h>
#include <vtkCamera.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkProperty.h>
int main()
{
vtkSmartPointer<vtkPolyDataReader> reader =
vtkSmartPointer<vtkPolyDataReader>::New();
reader->SetFileName("C:\\Users\\Administrator\\Desktop\\VTK2\\hellovtk\\vtk_图像处理学习\\第六章_图像处理\\data\\fran_cut.vtk");
reader->Update();
vtkSmartPointer<vtkPolyData> points =
vtkSmartPointer<vtkPolyData>::New();
points->SetPoints(reader->GetOutput()->GetPoints()); //获得网格模型中的几何数据：点集
vtkSmartPointer<vtkSurfaceReconstructionFilter> surf =
vtkSmartPointer<vtkSurfaceReconstructionFilter>::New();
surf->SetInputData(points);
surf->SetNeighborhoodSize(20);
surf->SetSampleSpacing(0.005);
surf->Update();
vtkSmartPointer<vtkContourFilter> contour =
vtkSmartPointer<vtkContourFilter>::New();
contour->SetInputConnection(surf->GetOutputPort());
contour->SetValue(0, 0.0);
contour->Update();
//
vtkSmartPointer <vtkVertexGlyphFilter> vertexGlyphFilter =
vtkSmartPointer<vtkVertexGlyphFilter>::New();
vertexGlyphFilter->AddInputData(points);
vertexGlyphFilter->Update();
vtkSmartPointer<vtkPolyDataMapper> pointMapper =
vtkSmartPointer<vtkPolyDataMapper>::New();
pointMapper->SetInputData(vertexGlyphFilter->GetOutput());
pointMapper->ScalarVisibilityOff();
vtkSmartPointer<vtkActor> pointActor =
vtkSmartPointer<vtkActor>::New();
pointActor->SetMapper(pointMapper);
pointActor->GetProperty()->SetColor(1, 0, 0);
pointActor->GetProperty()->SetPointSize(4);
vtkSmartPointer<vtkPolyDataMapper> contourMapper =
vtkSmartPointer<vtkPolyDataMapper>::New();
contourMapper->SetInputData(contour->GetOutput());
vtkSmartPointer<vtkActor> contourActor =
vtkSmartPointer<vtkActor>::New();
contourActor->SetMapper(contourMapper);
///
double pointView[4] = { 0, 0, 0.5, 1 };
double contourView[4] = { 0.5, 0, 1, 1 };
vtkSmartPointer<vtkRenderer> pointRender =
vtkSmartPointer<vtkRenderer>::New();
pointRender->AddActor(pointActor);
pointRender->SetViewport(pointView);
pointRender->SetBackground(1, 1, 1);
vtkSmartPointer<vtkRenderer> contourRender =
vtkSmartPointer<vtkRenderer>::New();
contourRender->AddActor(contourActor);
contourRender->SetViewport(contourView);
contourRender->SetBackground(0, 1, 0);
pointRender->GetActiveCamera()->SetPosition(0, -1, 0);
pointRender->GetActiveCamera()->SetFocalPoint(0, 0, 0);
pointRender->GetActiveCamera()->SetViewUp(0, 0, 1);
pointRender->GetActiveCamera()->Azimuth(30);
pointRender->GetActiveCamera()->Elevation(30);
pointRender->ResetCamera();
contourRender->SetActiveCamera(pointRender->GetActiveCamera());
vtkSmartPointer<vtkRenderWindow> rw =
vtkSmartPointer<vtkRenderWindow>::New();
rw->AddRenderer(pointRender);
rw->AddRenderer(contourRender);
rw->SetSize(640, 320);
rw->SetWindowName("3D Surface Reconstruction ");
rw->Render();
vtkSmartPointer<vtkRenderWindowInteractor> rwi =
vtkSmartPointer<vtkRenderWindowInteractor>::New();
rwi->SetRenderWindow(rw);
rwi->Initialize();
rwi->Start();
return 0;
}
#include <vtkAutoInit.h>
VTK_MODULE_INIT(vtkRenderingOpenGL2);
VTK_MODULE_INIT(vtkRenderingFreeType);
VTK_MODULE_INIT(vtkInteractionStyle);
#include <vtkPoints.h>
#include <vtkSmartPointer.h>
#include <vtkLandmarkTransform.h>
#include <vtkMatrix4x4.h>
#include <vtkPolyDataMapper.h>
#include <vtkActor.h>
#include <vtkRenderWindow.h>
#include <vtkRenderer.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkProperty.h>
#include <vtkTransformPolyDataFilter.h>
#include <vtkVertexGlyphFilter.h>
#include <vtkAxesActor.h>
int main(int, char *[])
{
vtkSmartPointer<vtkPoints> sourcePoints =
vtkSmartPointer<vtkPoints>::New();
double sourcePoint1[3] = {0.5, 0.0, 0.0};
sourcePoints->InsertNextPoint(sourcePoint1);
double sourcePoint2[3] = {0.0, 0.5, 0.0};
sourcePoints->InsertNextPoint(sourcePoint2);
double sourcePoint3[3] = {0.0, 0.0, 0.5};
sourcePoints->InsertNextPoint(sourcePoint3);
vtkSmartPointer<vtkPoints> targetPoints =
vtkSmartPointer<vtkPoints>::New();
double targetPoint1[3] = {0.0, 0.0, 0.55};
targetPoints->InsertNextPoint(targetPoint1);
double targetPoint2[3] = {0.0, 0.55, 0.0};
targetPoints->InsertNextPoint(targetPoint2);
double targetPoint3[3] = {-0.55, 0.0, 0.0};
targetPoints->InsertNextPoint(targetPoint3);
vtkSmartPointer<vtkLandmarkTransform> landmarkTransform =
vtkSmartPointer<vtkLandmarkTransform>::New();
landmarkTransform->SetSourceLandmarks(sourcePoints);
landmarkTransform->SetTargetLandmarks(targetPoints);
landmarkTransform->SetModeToRigidBody();
landmarkTransform->Update();
vtkSmartPointer<vtkPolyData> source =
vtkSmartPointer<vtkPolyData>::New();
source->SetPoints(sourcePoints);
vtkSmartPointer<vtkPolyData> target =
vtkSmartPointer<vtkPolyData>::New();
target->SetPoints(targetPoints);
vtkSmartPointer<vtkVertexGlyphFilter> sourceGlyphFilter =
vtkSmartPointer<vtkVertexGlyphFilter>::New();
sourceGlyphFilter->SetInputData(source);
sourceGlyphFilter->Update();
vtkSmartPointer<vtkVertexGlyphFilter> targetGlyphFilter =
vtkSmartPointer<vtkVertexGlyphFilter>::New();
targetGlyphFilter->SetInputData(target);
targetGlyphFilter->Update();
vtkSmartPointer<vtkTransformPolyDataFilter> transformFilter =
vtkSmartPointer<vtkTransformPolyDataFilter>::New();
transformFilter->SetInputData(sourceGlyphFilter->GetOutput());
transformFilter->SetTransform(landmarkTransform);
transformFilter->Update();
vtkSmartPointer<vtkPolyDataMapper> sourceMapper =
vtkSmartPointer<vtkPolyDataMapper>::New();
sourceMapper->SetInputConnection(sourceGlyphFilter->GetOutputPort());
vtkSmartPointer<vtkActor> sourceActor =
vtkSmartPointer<vtkActor>::New();
sourceActor->SetMapper(sourceMapper);
sourceActor->GetProperty()->SetColor(1,1,0);
sourceActor->GetProperty()->SetPointSize(5);
vtkSmartPointer<vtkPolyDataMapper> targetMapper =
vtkSmartPointer<vtkPolyDataMapper>::New();
targetMapper->SetInputConnection(targetGlyphFilter->GetOutputPort());
vtkSmartPointer<vtkActor> targetActor =
vtkSmartPointer<vtkActor>::New();
targetActor->SetMapper(targetMapper);
targetActor->GetProperty()->SetColor(1,0,0);
targetActor->GetProperty()->SetPointSize(5);
vtkSmartPointer<vtkPolyDataMapper> solutionMapper =
vtkSmartPointer<vtkPolyDataMapper>::New();
solutionMapper->SetInputConnection(transformFilter->GetOutputPort());
vtkSmartPointer<vtkActor> solutionActor =
vtkSmartPointer<vtkActor>::New();
solutionActor->SetMapper(solutionMapper);
solutionActor->GetProperty()->SetColor(0,0,1);
solutionActor->GetProperty()->SetPointSize(5);
vtkSmartPointer<vtkRenderer> renderer =
vtkSmartPointer<vtkRenderer>::New();
vtkSmartPointer<vtkRenderWindow> renderWindow =
vtkSmartPointer<vtkRenderWindow>::New();
renderWindow->AddRenderer(renderer);
renderer->AddActor(sourceActor);
renderer->AddActor(targetActor);
renderer->AddActor(solutionActor);
vtkSmartPointer<vtkAxesActor> axes =
vtkSmartPointer<vtkAxesActor>::New();
axes->SetScale(30);
renderer->AddActor(axes);
renderer->SetBackground(.3, .6, .3);
vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
vtkSmartPointer<vtkRenderWindowInteractor>::New();
renderWindowInteractor->SetRenderWindow(renderWindow);
renderWindow->SetSize(640, 480);
renderWindow->Render();
renderWindow->SetWindowName("PolyDataLandmarkReg");
renderWindow->Render();
renderWindowInteractor->Start();
return EXIT_SUCCESS;
}
#include <vtkAutoInit.h>
VTK_MODULE_INIT(vtkRenderingOpenGL2);
VTK_MODULE_INIT(vtkRenderingFreeType);
VTK_MODULE_INIT(vtkInteractionStyle);
#include <vtkPoints.h>
#include <vtkSmartPointer.h>
#include <vtkLandmarkTransform.h>
#include <vtkMatrix4x4.h>
#include <vtkPolyDataMapper.h>
#include <vtkActor.h>
#include <vtkRenderWindow.h>
#include <vtkRenderer.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkProperty.h>
#include <vtkTransformPolyDataFilter.h>
#include <vtkVertexGlyphFilter.h>
#include <vtkIterativeClosestPointTransform.h>
#include <vtkPolyDataReader.h>
#include <vtkTransform.h>
//测试文件：../data/fran_cut.vtk
int main(int argc, char * argv[])
{
vtkSmartPointer<vtkPolyDataReader> reader =
vtkSmartPointer<vtkPolyDataReader>::New();
reader->SetFileName("C:\\Users\\Administrator\\Desktop\\VTK2\\hellovtk\\vtk_图像处理学习\\第六章_图像处理\\data\\fran_cut.vtk");
reader->Update();
vtkSmartPointer<vtkPolyData> original = reader->GetOutput();
vtkSmartPointer<vtkTransform> translation =
vtkSmartPointer<vtkTransform>::New();
translation->Translate(0.2, 0.0, 0.0);
translation->RotateX(30);
vtkSmartPointer<vtkTransformPolyDataFilter> transformFilter1 =
vtkSmartPointer<vtkTransformPolyDataFilter>::New();
transformFilter1->SetInputData(reader->GetOutput());
transformFilter1->SetTransform(translation);
transformFilter1->Update();
vtkSmartPointer<vtkPolyData> source =
vtkSmartPointer<vtkPolyData>::New();
source->SetPoints(original->GetPoints());
vtkSmartPointer<vtkPolyData> target =
vtkSmartPointer<vtkPolyData>::New();
target->SetPoints(transformFilter1->GetOutput()->GetPoints());
vtkSmartPointer<vtkVertexGlyphFilter> sourceGlyphFilter =
vtkSmartPointer<vtkVertexGlyphFilter>::New();
sourceGlyphFilter->SetInputData(source);
sourceGlyphFilter->Update();
vtkSmartPointer<vtkVertexGlyphFilter> targetGlyphFilter =
vtkSmartPointer<vtkVertexGlyphFilter>::New();
targetGlyphFilter->SetInputData(target);
targetGlyphFilter->Update();
vtkSmartPointer<vtkIterativeClosestPointTransform> icpTransform =
vtkSmartPointer<vtkIterativeClosestPointTransform>::New();
icpTransform->SetSource(sourceGlyphFilter->GetOutput());
icpTransform->SetTarget(targetGlyphFilter->GetOutput());
icpTransform->GetLandmarkTransform()->SetModeToRigidBody();
icpTransform->SetMaximumNumberOfIterations(20);
icpTransform->StartByMatchingCentroidsOn();
icpTransform->Modified();
icpTransform->Update();
vtkSmartPointer<vtkTransformPolyDataFilter> transformFilter2 =
vtkSmartPointer<vtkTransformPolyDataFilter>::New();
transformFilter2->SetInputData(sourceGlyphFilter->GetOutput());
transformFilter2->SetTransform(icpTransform);
transformFilter2->Update();
vtkSmartPointer<vtkPolyDataMapper> sourceMapper =
vtkSmartPointer<vtkPolyDataMapper>::New();
sourceMapper->SetInputConnection(sourceGlyphFilter->GetOutputPort());
vtkSmartPointer<vtkActor> sourceActor =
vtkSmartPointer<vtkActor>::New();
sourceActor->SetMapper(sourceMapper);
sourceActor->GetProperty()->SetColor(0,1,0);
sourceActor->GetProperty()->SetPointSize(3);
vtkSmartPointer<vtkPolyDataMapper> targetMapper =
vtkSmartPointer<vtkPolyDataMapper>::New();
targetMapper->SetInputConnection(targetGlyphFilter->GetOutputPort());
vtkSmartPointer<vtkActor> targetActor =
vtkSmartPointer<vtkActor>::New();
targetActor->SetMapper(targetMapper);
targetActor->GetProperty()->SetColor(1,0,0);
targetActor->GetProperty()->SetPointSize(3);
vtkSmartPointer<vtkPolyDataMapper> solutionMapper =
vtkSmartPointer<vtkPolyDataMapper>::New();
solutionMapper->SetInputConnection(transformFilter2->GetOutputPort());
vtkSmartPointer<vtkActor> solutionActor =
vtkSmartPointer<vtkActor>::New();
solutionActor->SetMapper(solutionMapper);
solutionActor->GetProperty()->SetColor(0,0,1);
solutionActor->GetProperty()->SetPointSize(3);
vtkSmartPointer<vtkRenderer> renderer =
vtkSmartPointer<vtkRenderer>::New();
renderer->SetBackground(1.0, 1.0, 1.0);
vtkSmartPointer<vtkRenderWindow> renderWindow =
vtkSmartPointer<vtkRenderWindow>::New();
renderWindow->AddRenderer(renderer);
renderer->AddActor(sourceActor);
renderer->AddActor(targetActor);
renderer->AddActor(solutionActor);
vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
vtkSmartPointer<vtkRenderWindowInteractor>::New();
renderWindowInteractor->SetRenderWindow(renderWindow);
renderWindow->SetSize(640, 480);
renderWindow->Render();
renderWindow->SetWindowName("PolyDataICP");
renderWindow->Render();
renderWindow->Render();
renderWindowInteractor->Start();
return EXIT_SUCCESS;
}
#include <vtkAutoInit.h>
VTK_MODULE_INIT(vtkRenderingOpenGL2);
VTK_MODULE_INIT(vtkRenderingFreeType);
VTK_MODULE_INIT(vtkInteractionStyle);
#include <vtkSmartPointer.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkRenderWindow.h>
#include <vtkRenderer.h>
#include <vtkActor.h>
#include <vtkPolyDataMapper.h>
#include <vtkTransformTextureCoords.h>
#include <vtkTexture.h>
#include <vtkTextureMapToSphere.h>
#include <vtkTextureMapToCylinder.h>
#include <vtkBMPReader.h>
#include <vtkTexturedSphereSource.h>
#include <vtkXMLPolyDataReader.h>
//测试：../data/masonry.bmp ../data/cow.vtp
int main (int argc, char *argv[])
{
double translate[3];
translate[0] = 10.0;
translate[1] = 0.0;
translate[2] = 0.0;
std::cout << translate[0] << ", "
<< translate[1] << ", "
<< translate[2] << "\n";
vtkSmartPointer<vtkBMPReader> texReader =
vtkSmartPointer<vtkBMPReader>::New();
texReader->SetFileName("C:\\Users\\Administrator\\Desktop\\VTK2\\hellovtk\\vtk_图像处理学习\\第六章_图像处理\\data\\masonry.bmp");//读取纹理图像
vtkSmartPointer<vtkTexture> texture =
vtkSmartPointer<vtkTexture>::New();
texture->SetInputConnection(texReader->GetOutputPort());
vtkSmartPointer<vtkXMLPolyDataReader> modelReader =
vtkSmartPointer<vtkXMLPolyDataReader>::New();
modelReader->SetFileName("C:\\Users\\Administrator\\Desktop\\VTK2\\hellovtk\\vtk_图像处理学习\\第六章_图像处理\\data\\cow.vtp");//读取模型
vtkSmartPointer<vtkTextureMapToCylinder> texturemap =
vtkSmartPointer<vtkTextureMapToCylinder>::New();
texturemap->SetInputConnection(modelReader->GetOutputPort());
vtkSmartPointer<vtkPolyDataMapper> mapper =
vtkSmartPointer<vtkPolyDataMapper>::New();
mapper->SetInputConnection(texturemap->GetOutputPort());
vtkSmartPointer<vtkActor> actor =
vtkSmartPointer<vtkActor>::New();
actor->SetMapper( mapper );
actor->SetTexture( texture );
vtkSmartPointer<vtkRenderer> renderer =
vtkSmartPointer<vtkRenderer>::New();
renderer->AddActor(actor);
renderer->SetBackground(1.0, 1.0, 1.0);
vtkSmartPointer<vtkRenderWindow> renderWindow =
vtkSmartPointer<vtkRenderWindow>::New();
renderWindow->AddRenderer( renderer );
vtkSmartPointer<vtkRenderWindowInteractor> renWinInteractor =
vtkSmartPointer<vtkRenderWindowInteractor>::New();
renWinInteractor->SetRenderWindow( renderWindow );
renderWindow->SetSize(640, 480);
renderWindow->Render();
renderWindow->SetWindowName("TextureMap");
renderWindow->Render();
renderWindow->Render();
renWinInteractor->Start();
return EXIT_SUCCESS;
}
