1 VTK（Visualization Toolkit）是一个开源的跨平台软件系统，用于三维计算机图形学、图像处理和可视化。学习VTK的主要目的有：
- 3D可视化： VTK提供了丰富的工具和算法，可以用来可视化各种科学数据，包括医学图像、有限元分析结果、流体模拟数据等。
- 图像处理： VTK支持多种图像处理操作，如滤波、分割、配准等，可以对医学图像进行预处理和分析。
- 科学计算可视化： VTK可以与其他科学计算软件（如MATLAB、Python）结合，实现科学计算结果的可视化。
- 自定义可视化： VTK提供了灵活的接口，可以自定义各种可视化组件和交互方式，满足个性化的需求。
对于有科研需求的小伙伴，可以利用VTK将你的数据和实验结果进行可视化，对数据有一个感官的理解。比如下面的图像就是一个细胞分裂增殖的模拟图像，使用VTK对数据进行了可视化。
3图1 细胞克隆增殖的模拟
VTK就是一个工具，不用刻意的去学习它。假如你不做数据的显示，也不需要做3D模型的渲染，你就不用去学习它，因为学习任何事物都是需要学习成本的。
2 学习方法
学习VTK的方法有很多种，以下是一些建议：
- 官方文档： VTK官方文档是学习VTK最权威的资料，提供了详细的类、函数和示例。
- 教程和书籍： 网上有很多关于VTK的教程和书籍，可以帮助你快速入门。
- 示例代码： VTK提供了大量的示例代码，可以帮助你理解各种概念和用法。
- 社区： VTK有一个活跃的社区，你可以通过论坛、邮件列表等方式向其他用户提问和交流。
- 实践： 最好的学习方式是实践。通过编写自己的代码，尝试实现各种功能，可以加深对VTK的理解。
3 一个比较有意思的例子
我们模拟一下太阳光线照射到地球上，然后有反射的情况，其实就是一个光线追踪算法。
图2 射线追踪算法
先看代码：
#include <iostream>
#include <vtkSmartPointer.h>
#include <vtkSphereSource.h>
#include <vtkActor.h>
#include <vtkConeSource.h>
#include <vtkRenderer.h>
#include <vtkRenderWindow.h>
#include <vtkPolyDataMapper.h>
#include <vtkProperty.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkOBBTree.h>
#include <vtkMath.h>
#include <vtkTransform.h>
#include <vtkTransformFilter.h>
#include <vtkMatrix4x4.h>
#include <vtkPolyDataNormals.h>
#include <vtkPlaneSource.h>
#include <vtkPoints.h>
#include <vtkInteractorStyleTrackballCamera.h>
#include <vtkCamera.h>
#include <vtkLight.h>
#include <vtkJPEGReader.h>
#include <vtkTexture.h>
#include <vtkTextureMapToSphere.h>
#include <vtkCellCenters.h>
#include <vtkPolyDataNormals.h>
#include <vtkVertexGlyphFilter.h>
#include <vtkGlyph3D.h>
#include <vtkArrowSource.h>
#include <vtkCellData.h>
#include <vtkPointData.h>
#include <vtkIdList.h>
#include <vtkDoubleArray.h>
#include <vtkLineSource.h>
using namespace std;
vtkSmartPointer<vtkActor> point2Actor(vtkSmartPointer<vtkPoints> points){
vtkNew<vtkPolyData> polyData;
polyData->SetPoints(points);
vtkNew<vtkVertexGlyphFilter> filter;
filter->SetInputData(polyData);
filter->Update();
vtkNew<vtkPolyDataMapper> mapper;
mapper->SetInputConnection(filter->GetOutputPort());
vtkSmartPointer<vtkActor> actor=vtkSmartPointer<vtkActor>::New();
actor->SetMapper(mapper);
return actor;
}
int main()
{
// Sun Options
// Radius of the sun half-sphere
double RadiusSun=10.0;
// Distance of the sun's center from (0,0,0)
double DistanceSun=50.0;
// Phi & Theta Resolution of sun
int ResolutionSun=10;
// Earth Options
// Radius of the earth sphere
double RadiusEarth=150.0;
// Phi & Theta Resolution of earth
int ResolutionEarth=120;
// Ray Options
double RayCastLength=500.0;
// Color Options
double ColorSun[3]={1.0,1.0,0.0};
double ColorSunEdge[3]={0.0,0.0,0.0};
double ColorEarthEdge[3]={1.0,1.0,1.0};
double ColorBackground[]={0.0,0.0,0.0};
double ColorLight[]={1.0,1.0,0.0};
double ColorSunPoints[]={1.0,1.0,0.0};
double ColorSunGlyphs[]={1.0,1.0,0.0};
double ColorRayHit[]={1.0,1.0,0.0};
double ColorRayMiss[]={1.0,1.0,1.0};
double OpacityRayMiss=0.5;
double ColorEarthGlyphs[]={0.0,0.0,1.0};
double ColorRayReflected[]={1.0,1.0,0.0};
// Load a JPEG file with an 'earth' texture
vtkNew<vtkJPEGReader> reader;
reader->SetFileName("../data/R-C.jpeg");
reader->Update();
vtkNew<vtkSphereSource> sun;
sun->SetCenter(0.0,DistanceSun,0.0);
sun->SetRadius(RadiusSun);
sun->SetThetaResolution(ResolutionSun);
sun->SetPhiResolution(ResolutionSun);
sun->SetStartTheta(180); // create a half-sphere
// Create mapper
vtkNew<vtkPolyDataMapper> sunMapper;
sunMapper->SetInputConnection(sun->GetOutputPort());
// Create actor
vtkNew<vtkActor> sunActor;
sunActor->SetMapper(sunMapper);
sunActor->GetProperty()->SetColor(ColorSun);
sunActor->GetProperty()->EdgeVisibilityOn(); // show edges/wireframe
sunActor->GetProperty()->SetEdgeColor(ColorSunEdge);
// Create and configure the earth spere
vtkNew<vtkSphereSource> earth;
earth->SetCenter(0.0,-RadiusEarth,0.0);
earth->SetThetaResolution(ResolutionEarth);
earth->SetPhiResolution(ResolutionEarth);
earth->SetRadius(RadiusEarth);
// texture to earth
vtkNew<vtkTexture> texture;
texture->SetInputConnection(reader->GetOutputPort());
texture->Update();
vtkNew<vtkTextureMapToSphere> map_to_sphere;
map_to_sphere->SetInputConnection(earth->GetOutputPort());
map_to_sphere->PreventSeamOn();
map_to_sphere->Update();
vtkNew<vtkPolyDataMapper> earthMapper;
earthMapper->SetInputConnection(map_to_sphere->GetOutputPort());
vtkNew<vtkActor> earthActor;
earthActor->SetMapper(earthMapper);
earthActor->SetTexture(texture);
earthActor->GetProperty()->EdgeVisibilityOn();
earthActor->GetProperty()->SetEdgeColor(ColorEarthEdge);
// Renderer to display
vtkNew<vtkRenderer> ren;
ren->AddActor(sunActor);
ren->AddActor(earthActor);
ren->SetBackground(ColorBackground);
vtkNew<vtkCellCenters> cellCenterCalcSun;
cellCenterCalcSun->SetInputConnection(sun->GetOutputPort());
cellCenterCalcSun->Update();
//cellCenterCalcSun->Print(cout);
//cout<<cellCenterCalcSun->GetOutput()->GetNumberOfPoints()<<endl;
vtkPoints* pointsInCellCenterCalcSun=cellCenterCalcSun->GetOutput()->GetPoints();
/*
for(vtkIdType i=0;i<pointsInCellCenterCalcSun->GetNumberOfPoints();++i){
double point[3];
pointsInCellCenterCalcSun->GetPoint(i,point);
cout<<point[0]<<","<<point[1]<<","<<point[2]<<endl;
}
*/
for(vtkIdType i=0;i<cellCenterCalcSun->GetOutput()->GetNumberOfPoints();++i){
/*
cout<<cellCenterCalcSun->GetOutput()->GetPoint(i)[0]<<","
<<cellCenterCalcSun->GetOutput()->GetPoint(i)[1]<<","
<<cellCenterCalcSun->GetOutput()->GetPoint(i)[2]<<endl;
*/
vtkNew<vtkPoints> points;
points->InsertNextPoint(cellCenterCalcSun->GetOutput()->GetPoint(i)[0],
cellCenterCalcSun->GetOutput()->GetPoint(i)[1],
cellCenterCalcSun->GetOutput()->GetPoint(i)[2]);
vtkSmartPointer<vtkActor> actor=point2Actor(points);
actor->GetProperty()->SetColor(ColorSunPoints);
actor->GetProperty()->SetPointSize(5);
ren->AddActor(actor);
}
vtkNew<vtkPolyDataNormals> normalsCalcSun;
normalsCalcSun->SetInputConnection(sun->GetOutputPort());
// Disable normal calculation at cell vertices
normalsCalcSun->ComputePointNormalsOff();
// Enable normal calculation at cell centers
normalsCalcSun->ComputeCellNormalsOn();
// Disable splitting of sharp edges
normalsCalcSun->SplittingOff();
// Disable global flipping of normal orientation
normalsCalcSun->FlipNormalsOff();
// Enable automatic determination of correct normal orientation
normalsCalcSun->AutoOrientNormalsOn();
normalsCalcSun->Update();
// Create a 'dummy' vtkCellCenters to force the glyphs to the cell-centers
vtkNew<vtkCellCenters> dummy_cellCenterCalcSun;
dummy_cellCenterCalcSun->VertexCellsOn();
dummy_cellCenterCalcSun->SetInputConnection(normalsCalcSun->GetOutputPort());
// Create a new 'default' arrow to use as a glyph
vtkNew<vtkArrowSource> arrow;
vtkNew<vtkGlyph3D> glyphSun;
glyphSun->SetInputConnection(dummy_cellCenterCalcSun->GetOutputPort());
glyphSun->SetSourceConnection(arrow->GetOutputPort());
glyphSun->SetVectorModeToUseNormal();
glyphSun->SetScaleFactor(5);
vtkNew<vtkPolyDataMapper> glyphMapperSun;
glyphMapperSun->SetInputConnection(glyphSun->GetOutputPort());
vtkNew<vtkActor> glyphActorSun;
glyphActorSun->SetMapper(glyphMapperSun);
glyphActorSun->GetProperty()->SetColor(ColorSunGlyphs);
ren->AddActor(glyphActorSun);
// Prepare for ray-tracing
vtkNew<vtkOBBTree> obbEarth;
obbEarth->SetDataSet(earth->GetOutput());
obbEarth->BuildLocator();
double tol=1.e-8;
obbEarth->SetTolerance(tol);
vtkNew<vtkPolyDataNormals> normalsCalcEarth;
normalsCalcEarth->SetInputConnection(earth->GetOutputPort());
normalsCalcEarth->ComputePointNormalsOff();
normalsCalcEarth->ComputeCellNormalsOn();
normalsCalcEarth->SplittingOff();
normalsCalcEarth->FlipNormalsOff();
normalsCalcEarth->AutoOrientNormalsOn();
normalsCalcEarth->Update();
//cout<<"Prepare the ray using point and normal"<<endl;
// Extract the normal-vector data at the sun's cells
vtkDataArray* normalsSun=normalsCalcSun->GetOutput()->GetCellData()->GetNormals();
// Extract the normal-vector data at the earth's cells
vtkDataArray* normalsEarth=normalsCalcEarth->GetOutput()->GetCellData()->GetNormals();
// Create a dummy 'vtkPoints' to act as a container for the point coordinates where intersections are found
vtkNew<vtkPoints> intersectPoints;
vtkNew<vtkIdList> intersectCells;
// Create a dummy 'vtkList' to act as a container for the normal vectors where intersections are found.
vtkNew<vtkDoubleArray> normalsVector;
normalsVector->SetNumberOfComponents(3);
// Create a dummy 'vtkPolyData' to store points and normals
vtkNew<vtkPoints> dummy_points;
vtkNew<vtkPolyData> dummy_polydata;
for(vtkIdType i=0;i<pointsInCellCenterCalcSun->GetNumberOfPoints();++i){
// Get the coordinates of sun's cell center
double pointSun[3];
cellCenterCalcSun->GetOutput()->GetPoint(i,pointSun);
// Get normal vector at that cell
double* normals=normalsSun->GetTuple(i);
//cout<<normals[0]<<","<<normals[1]<<","<<normals[2]<<endl;
// Calculate the 'target' of the ray based on 'RayCastLength'
double pointEarth[3];
pointEarth[0]=pointSun[0]+normals[0]*RayCastLength;
pointEarth[1]=pointSun[1]+normals[1]*RayCastLength;
pointEarth[2]=pointSun[2]+normals[2]*RayCastLength;
int code=obbEarth->IntersectWithLine(pointSun,pointEarth,intersectPoints,intersectCells);
if(code<0){
continue;
}
double intersection[3];
vtkIdType cellId;
double normalIntersect[3];
vtkNew<vtkLineSource> line;
vtkNew<vtkLineSource> lineRay;
for(int i=0;i<intersectPoints->GetNumberOfPoints();++i){
if(i==1)
continue;
intersectPoints->GetPoint(i,intersection);
//cout<<"Intersection "<<i<<" : "<<intersection[0]<<","<<intersection[1]<<","<<intersection[2]<<endl;
//
cellId=intersectCells->GetId(i);
//cout<<"\tCellId "<<i<<" : "<<cellId<<endl;
normalIntersect[0]=normalsEarth->GetTuple(cellId)[0];
normalIntersect[1]=normalsEarth->GetTuple(cellId)[1];
normalIntersect[2]=normalsEarth->GetTuple(cellId)[2];
normalsVector->InsertNextTuple3(normalIntersect[0],normalIntersect[1],normalIntersect[2]);
dummy_points->InsertNextPoint(intersection[0],intersection[1],intersection[2]);
// line
line->SetPoint1(pointSun);
line->SetPoint2(intersection);
// Calculate the incident ray vector
double vecInc[3];
vecInc[0]=intersection[0]-pointSun[0];
vecInc[1]=intersection[1]-pointSun[1];
vecInc[2]=intersection[2]-pointSun[2];
// Calculate reflected ray vector
double vecRef[3];
double dot=vecInc[0]*normalIntersect[0]+vecInc[1]*normalIntersect[1]+vecInc[2]*normalIntersect[2];
vecRef[0]=vecInc[0]-2.0*dot*normalIntersect[0];
vecRef[1]=vecInc[1]-2.0*dot*normalIntersect[1];
vecRef[2]=vecInc[2]-2.0*dot*normalIntersect[2];
// Calculate the target of reflected ray
double pointRayReflectedTarget[3];
pointRayReflectedTarget[0]=intersection[0]+vecRef[0]*RayCastLength;
pointRayReflectedTarget[1]=intersection[1]+vecRef[1]*RayCastLength;
pointRayReflectedTarget[2]=intersection[2]+vecRef[2]*RayCastLength;
lineRay->SetPoint1(intersection);
lineRay->SetPoint2(pointRayReflectedTarget);
}
vtkNew<vtkPolyDataMapper> lineMapper;
vtkNew<vtkPolyDataMapper> lineRayMapper;
lineMapper->SetInputConnection(line->GetOutputPort());
lineRayMapper->SetInputConnection(lineRay->GetOutputPort());
vtkNew<vtkActor> lineActor;
vtkNew<vtkActor> lineRayActor;
lineActor->SetMapper(lineMapper);
lineActor->GetProperty()->SetColor(ColorRayHit);
lineRayActor->SetMapper(lineRayMapper);
lineRayActor->GetProperty()->SetColor(ColorRayReflected);
ren->AddActor(lineActor);
ren->AddActor(lineRayActor);
}
dummy_polydata->SetPoints(dummy_points);
dummy_polydata->GetPointData()->SetNormals(normalsVector);
vtkNew<vtkGlyph3D> glyphEarth;
glyphEarth->SetInputData(dummy_polydata);
glyphEarth->SetSourceConnection(arrow->GetOutputPort());
glyphEarth->SetVectorModeToUseNormal();
glyphEarth->SetScaleFactor(5);
vtkNew<vtkPolyDataMapper> glyphMapperEarth;
glyphMapperEarth->SetInputConnection(glyphEarth->GetOutputPort());
vtkNew<vtkActor> glyphActorEarth;
glyphActorEarth->SetMapper(glyphMapperEarth);
glyphActorEarth->GetProperty()->SetColor(ColorEarthGlyphs);
ren->AddActor(glyphActorEarth);
vtkNew<vtkCamera> camera;
camera->SetPosition(RadiusEarth,DistanceSun,RadiusEarth);
camera->SetFocalPoint(0.0,0.0,0.0);
camera->SetViewAngle(30.0);
ren->SetActiveCamera(camera);
//
vtkNew<vtkRenderWindow> renWin;
renWin->SetSize(1024,1024);
renWin->AddRenderer(ren);
vtkNew<vtkRenderWindowInteractor> iren;
iren->SetRenderWindow(renWin);
vtkNew<vtkInteractorStyleTrackballCamera> style;
iren->SetInteractorStyle(style);
iren->Initialize();
iren->Start();
return 0;
}在代码中有详细的说明，等有空我会讲解一下。
