VTK是用vtkCamera类来表示三维渲染场景中的相机。vtkCamera负责把三维场景投影到二维平面,如屏幕、图像等。
在VTK中,相机的实质是一个观测点,与人眼的功能相同,相机的视野范围是一个锥状体。
VTK中的相机的使用示意图如下:
相机位置和焦点位置定义了相机的位置和投影方向,前裁剪平面为CCD镜头平面(图像平面),后裁剪平面为物体平面。
当物体在处于静止位置时,相机可以在物体周围移动,摄取不同角度的图像;
相机的运动分为移动、旋转;
移动分为相机的移动,和相机焦点的移动;移动改变了相机相对焦点的位置,离焦点更近或者更远;这样就会改变被渲染的物体在视野中的部分;
相机的移动可以有水平上的移动,垂直方向的移动,前后的移动;
相机的旋转可以分为水平上围绕焦点旋转,垂直上围绕焦点旋转,围绕相机和焦点的连线的旋转;
物体围绕相机做水平上旋转,垂直旋转;
相机的旋转:是相机在以焦点为中心的圆球面上移动,因为相机可以水平旋转和垂直旋转;水平旋转就是在相机围绕球心过朝上方向这个轴旋转,也可以说是在球面上的维度进行旋转,但相机的镜头始终指向焦点;水平旋转就是在相机绕球面上的经线向上或者向下旋转;旋转的范围不包括90度;大家可以试试垂直旋转90度会有什么样的效果;
从上面可知,相机的旋转是跟朝上方向有关系,不同的方面,水平旋转和垂直旋转的效果不一样;
用于三维绘制的虚拟摄像机;
vtkCamera是一种用于三维渲染的虚拟相机。它提供了定位和定向视点到焦点的方法,还提供了围绕焦点移动的方便操作;更复杂的方法允许操纵计算机图形模型,包括视图上方向向量、剪裁平面和相机透视。
相机所在的位置坐标;
void SetPosition(double x, double y, double z);
void SetPosition(const double a[3]) { this->SetPosition(a[0], a[1], a[2]); }
vtkGetVector3Macro(Position, double);
相机焦点所在的位置坐标;
void SetFocalPoint(double x, double y, double z);
void SetFocalPoint(const double a[3]) { this->SetFocalPoint(a[0], a[1], a[2]); }
vtkGetVector3Macro(FocalPoint, double);
通过设置相机焦点与相机坐标的距离,来移动焦点坐标,注意:设置的值必须为正值。
void SetDistance(double);
vtkGetMacro(Distance, double);
使用SetViewUp设置相机的朝上方向;
一般默认朝上方向是Y轴正向:(0,1,0);
修改相机的朝上方向,可以实现相机绕XYZ轴旋转的功能;
一般情况都是写0或者1,如果是斜着旋转,就要输入0-1范围内的小数,大家可以动手自己实验一下;
void SetViewUp(double vx, double vy, double vz);
void SetViewUp(const double a[3]) { this->SetViewUp(a[0], a[1], a[2]); }
vtkGetVector3Macro(ViewUp, double);
设置/获取ParallelProjection实例变量的值。
这决定了相机应该进行透视投影还是平行投影。
void SetParallelProjection(vtkTypeBool flag);
vtkGetMacro(ParallelProjection, vtkTypeBool);
vtkBooleanMacro(ParallelProjection, vtkTypeBool);
投影方向是指从相机位置到焦点方向的矢量。
double DirectionOfProjection[3];
vtkGetVector3Macro(DirectionOfProjection, double);
这通常与ViewPlaneNormal相反,即垂直于屏幕的向量,除非视图是倾斜的。
void Roll(double angle):围绕投影方向旋转相机
void Azimuth(double angle); 以焦点为中心,围绕朝上方向方向向量,即在焦点为中心,焦距为半径的圆球的维度线上水平旋转;
void Elevation(double angle); 以焦点为中心,在焦点为中心,焦距为半径的圆球的经度线方向上旋转垂直旋转;
void Yaw(double angle); 同Azimuth相似,以相机为中心,移动焦点坐标;
void Pitch(double angle); 同Elevation相似,以相机为中心,移动焦点坐标;
ClippingRange即剪切平面,分为前后两个。只有在这两个剪切平面之间的内容才会被渲染和显示。默认值是(0.1,1000)。这个量一般不需要修改,而是在vtkRenderer对象中调用ResetCameraClippingRange()方法来自动重设渲染范围。如果你的图像显示不完整,但是稍微用鼠标旋转或平移一下又变完整了。建议试一下调用一次这个方法。
设置前裁剪平面和后裁剪平面,前裁剪平面就是距离相机较近的平面,后平面就是距离相机较远位置;
dNear和dFar是距离相机坐标的距离,在相机坐标向焦点方向上的距离;
void SetClippingRange(double dNear, double dFar);
void SetClippingRange(const double a[2]) { this->SetClippingRange(a[0], a[1]); }
vtkGetVector2Macro(ClippingRange, double);
vtkRenderer类可以重置使用的相机参数;
virtual void ResetCamera();
根据可见的vtkActor自动设置相机参数。使得相机会重新定位以观察演员的中心点,并沿其初始视图平面法线移动(即,从镜头位置到焦点),这样所有的vtkActor都可以在相机中看到。
从源码中可以看到ResetCamera()只会重置相机的焦点焦距朝上方向等信息,不会重置旋转角度,如果要从一个Renderer中获取多个旋转后图像,需要对角度进行修正后计算,每次ResetCamera()都会保留上一次旋转的角度;
// Automatically set up the camera based on a specified bounding box
// (xmin,xmax, ymin,ymax, zmin,zmax). Camera will reposition itself so
// that its focal point is the center of the bounding box, and adjust its
// distance and position to preserve its initial view plane normal
// (i.e., vector defined from camera position to focal point). Note: if
// the view plane is parallel to the view up axis, the view up axis will
// be reset to one of the three coordinate axes.
void vtkRenderer::ResetCamera(double bounds[6])
{
double center[3];
double distance;
double vn[3], *vup;
this->GetActiveCamera();
if ( this->ActiveCamera != nullptr )
{
this->ActiveCamera->GetViewPlaneNormal(vn);
}
else
{
vtkErrorMacro(<< "Trying to reset non-existant camera");
return;
}
// Reset the perspective zoom factors, otherwise subsequent zooms will cause
// the view angle to become very small and cause bad depth sorting.
this->ActiveCamera->SetViewAngle(30.0);
this->ExpandBounds(bounds, this->ActiveCamera->GetModelTransformMatrix());
center[0] = (bounds[0] + bounds[1])/2.0;
center[1] = (bounds[2] + bounds[3])/2.0;
center[2] = (bounds[4] + bounds[5])/2.0;
double w1 = bounds[1] - bounds[0];
double w2 = bounds[3] - bounds[2];
double w3 = bounds[5] - bounds[4];
w1 *= w1;
w2 *= w2;
w3 *= w3;
double radius = w1 + w2 + w3;
// If we have just a single point, pick a radius of 1.0
radius = (radius==0)?(1.0):(radius);
// compute the radius of the enclosing sphere
radius = sqrt(radius)*0.5;
// default so that the bounding sphere fits within the view fustrum
// compute the distance from the intersection of the view frustum with the
// bounding sphere. Basically in 2D draw a circle representing the bounding
// sphere in 2D then draw a horizontal line going out from the center of
// the circle. That is the camera view. Then draw a line from the camera
// position to the point where it intersects the circle. (it will be tangent
// to the circle at this point, this is important, only go to the tangent
// point, do not draw all the way to the view plane). Then draw the radius
// from the tangent point to the center of the circle. You will note that
// this forms a right triangle with one side being the radius, another being
// the target distance for the camera, then just find the target dist using
// a sin.
double angle=vtkMath::RadiansFromDegrees(this->ActiveCamera->GetViewAngle());
double parallelScale=radius;
this->ComputeAspect();
double aspect[2];
this->GetAspect(aspect);
if(aspect[0]>=1.0) // horizontal window, deal with vertical angle|scale
{
if(this->ActiveCamera->GetUseHorizontalViewAngle())
{
angle=2.0*atan(tan(angle*0.5)/aspect[0]);
}
}
else // vertical window, deal with horizontal angle|scale
{
if(!this->ActiveCamera->GetUseHorizontalViewAngle())
{
angle=2.0*atan(tan(angle*0.5)*aspect[0]);
}
parallelScale=parallelScale/aspect[0];
}
distance =radius/sin(angle*0.5);
// check view-up vector against view plane normal
vup = this->ActiveCamera->GetViewUp();
if ( fabs(vtkMath::Dot(vup,vn)) > 0.999 )
{
vtkWarningMacro(<<"Resetting view-up since view plane normal is parallel");
this->ActiveCamera->SetViewUp(-vup[2], vup[0], vup[1]);
}
// update the camera
this->ActiveCamera->SetFocalPoint(center[0],center[1],center[2]);
this->ActiveCamera->SetPosition(center[0]+distance*vn[0],
center[1]+distance*vn[1],
center[2]+distance*vn[2]);
this->ResetCameraClippingRange( bounds );
// setup default parallel scale
this->ActiveCamera->SetParallelScale(parallelScale);
}
如果要设定相机的坐标和焦点的坐标,需要重新调用vtkRenderer的ResetCameraClippingRange函数,重新调整前裁剪面和后裁剪面的范围,如果没有设定,就会出现渲染窗口没有被渲染的物体或者是只出现部分物体图像,是因为被渲染物体部分超出了前后裁剪平面范围;只有移动或者滚动鼠标后,出现图像,是因为vtkInteractorStyle::AutoAdjustCameraClippingRange会自动调整相机的前后裁剪平面范围,使得物体可以在前后裁剪平面范围内,得以出现在渲染窗口中;
当在点击鼠标旋转相机,会看到控制台有相机的坐标位置输出:
#include "pch.h"
#include
#include "vtkConeSource.h"
#include "vtkPolyDataMapper.h"
#include "vtkRenderer.h"
#include "vtkActor.h"
#include "vtkCommand.h"
#include "vtkRenderWindow.h"
#include "vtkCamera.h"
#include "vtkAutoInit.h"
VTK_MODULE_INIT(vtkRenderingOpenGL2);
VTK_MODULE_INIT(vtkInteractionStyle);
using namespace std;
class vtkMyCallback :public vtkCommand
{
public:
static vtkMyCallback* New()
{
return new vtkMyCallback;
}
virtual void Execute(vtkObject *caller, unsigned long, void*)
{
vtkRenderer *render = reinterpret_cast<vtkRenderer*>(caller);
cout << render->GetActiveCamera()->GetPosition()[0] << " "
<< render->GetActiveCamera()->GetPosition()[1] << " "
<< render->GetActiveCamera()->GetPosition()[2] << endl;
}
};
int main()
{
vtkConeSource *cone = vtkConeSource::New();
cone->SetHeight(3.0);
cone->SetRadius(1.0);
cone->SetResolution(10);
vtkPolyDataMapper *coneMapper = vtkPolyDataMapper::New();
coneMapper->SetInputConnection(cone->GetOutputPort());
vtkActor *coneActor = vtkActor::New();
coneActor->SetMapper(coneMapper);
vtkRenderer* ren1 = vtkRenderer::New();
ren1->AddActor(coneActor);
ren1->SetBackground(0.1, 0.2, 0.4);
ren1->ResetCamera();
vtkRenderWindow *renWin = vtkRenderWindow::New();
renWin->AddRenderer(ren1);
renWin->SetSize(300, 300);
vtkMyCallback *mo1 = vtkMyCallback::New();
ren1->AddObserver(vtkCommand::StartEvent, mo1);
mo1->Delete();
for (size_t i = 0; i < 360; i++)
{
renWin->Render();
ren1->GetActiveCamera()->Azimuth(1);
}
renWin->Delete();
ren1->Delete();
coneActor->Delete();
coneMapper->Delete();
cone->Delete();
system("pause");
return 0;
}
#pragma once
#include "vtk_include.h"
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
class Test_CameraModel1
{
public:
static void Test()
{
vtkNew<vtkNamedColors> colors;
// Set the colors.
std::array<unsigned char, 4> azArrowColor{ {255, 77, 77} };
colors->SetColor("AzimuthArrowColor", azArrowColor.data());
std::array<unsigned char, 4> elevArrowColor{ {77, 255, 77} };
colors->SetColor("ElevationArrowColor", elevArrowColor.data());
std::array<unsigned char, 4> rollArrowColor{ {255, 255, 77} };
colors->SetColor("RollArrowColor", rollArrowColor.data());
std::array<unsigned char, 4> spikeColor{ {255, 77, 255} };
colors->SetColor("SpikeColor", spikeColor.data());
// Set the background color.
std::array<unsigned char, 4> bkg{ {26, 51, 102} };
colors->SetColor("BkgColor", bkg.data());
// Create the RenderWindow, Renderer and both Actors
vtkNew<vtkRenderer> ren1;
vtkNew<vtkRenderWindow> renWin;
renWin->AddRenderer(ren1);
vtkNew<vtkRenderWindowInteractor> iren;
iren->SetRenderWindow(renWin);
// create a camera model
vtkNew<vtkConeSource> camCS;
camCS->SetHeight(1.5);
camCS->SetResolution(12);
camCS->SetRadius(0.4);
vtkNew<vtkCubeSource> camCBS;
camCBS->SetXLength(1.5);
camCBS->SetZLength(0.8);
camCBS->SetCenter(0.4, 0, 0);
vtkNew<vtkAppendFilter> camAPD;
camAPD->AddInputConnection(camCS->GetOutputPort());
camAPD->AddInputConnection(camCBS->GetOutputPort());
vtkNew<vtkDataSetMapper> camMapper;
camMapper->SetInputConnection(camAPD->GetOutputPort());
vtkNew<vtkLODActor> camActor;
camActor->SetMapper(camMapper);
camActor->SetScale(2, 2, 2);
// draw the arrows
vtkNew<vtkPolyData> pd;
vtkNew<vtkCellArray> ca;
vtkNew<vtkPoints> fp;
fp->InsertNextPoint(0, 1, 0);
fp->InsertNextPoint(8, 1, 0);
fp->InsertNextPoint(8, 2, 0);
fp->InsertNextPoint(10, 0.01, 0);
fp->InsertNextPoint(8, -2, 0);
fp->InsertNextPoint(8, -1, 0);
fp->InsertNextPoint(0, -1, 0);
ca->InsertNextCell(7);
ca->InsertCellPoint(0);
ca->InsertCellPoint(1);
ca->InsertCellPoint(2);
ca->InsertCellPoint(3);
ca->InsertCellPoint(4);
ca->InsertCellPoint(5);
ca->InsertCellPoint(6);
pd->SetPoints(fp);
pd->SetPolys(ca);
vtkNew<vtkPolyData> pd2;
vtkNew<vtkCellArray> ca2;
vtkNew<vtkPoints> fp2;
fp2->InsertNextPoint(0, 1, 0);
fp2->InsertNextPoint(8, 1, 0);
fp2->InsertNextPoint(8, 2, 0);
fp2->InsertNextPoint(10, 0.01, 0);
ca2->InsertNextCell(4);
ca2->InsertCellPoint(0);
ca2->InsertCellPoint(1);
ca2->InsertCellPoint(2);
ca2->InsertCellPoint(3);
pd2->SetPoints(fp2);
pd2->SetLines(ca2);
vtkNew<vtkImplicitModeller> arrowIM;
arrowIM->SetInputData(pd);
arrowIM->SetSampleDimensions(50, 20, 8);
vtkNew<vtkContourFilter> arrowCF;
arrowCF->SetInputConnection(arrowIM->GetOutputPort());
arrowCF->SetValue(0, 0.2);
vtkNew<vtkWarpTo> arrowWT;
arrowWT->SetInputConnection(arrowCF->GetOutputPort());
arrowWT->SetPosition(5, 0, 5);
arrowWT->SetScaleFactor(0.85);
arrowWT->AbsoluteOn();
vtkNew<vtkTransform> arrowT;
arrowT->RotateY(60);
arrowT->Translate(-1.33198, 0, -1.479);
arrowT->Scale(1, 0.5, 1);
vtkNew<vtkTransformFilter> arrowTF;
arrowTF->SetInputConnection(arrowWT->GetOutputPort());
arrowTF->SetTransform(arrowT);
vtkNew<vtkDataSetMapper> arrowMapper;
arrowMapper->SetInputConnection(arrowTF->GetOutputPort());
arrowMapper->ScalarVisibilityOff();
// draw the azimuth arrows
vtkNew<vtkLODActor> a1Actor;
a1Actor->SetMapper(arrowMapper);
a1Actor->RotateZ(180);
a1Actor->SetPosition(1, 0, -1);
a1Actor->GetProperty()->SetColor(colors->GetColor3d("AzimuthArrowColor").GetData());
a1Actor->GetProperty()->SetSpecularColor(colors->GetColor3d("White").GetData());
a1Actor->GetProperty()->SetSpecular(0.3);
a1Actor->GetProperty()->SetSpecularPower(20);
a1Actor->GetProperty()->SetAmbient(0.2);
a1Actor->GetProperty()->SetDiffuse(0.8);
vtkNew<vtkLODActor> a2Actor;
a2Actor->SetMapper(arrowMapper);
a2Actor->RotateZ(180);
a2Actor->RotateX(180);
a2Actor->SetPosition(1, 0, 1);
a2Actor->GetProperty()->SetColor(colors->GetColor3d("AzimuthArrowColor").GetData());
a2Actor->GetProperty()->SetSpecularColor(colors->GetColor3d("White").GetData());
a2Actor->GetProperty()->SetSpecular(0.3);
a2Actor->GetProperty()->SetSpecularPower(20);
a2Actor->GetProperty()->SetAmbient(0.2);
a2Actor->GetProperty()->SetDiffuse(0.8);
// draw the elevation arrows
vtkNew<vtkLODActor> a3Actor;
a3Actor->SetMapper(arrowMapper);
a3Actor->RotateZ(180);
a3Actor->RotateX(90);
a3Actor->SetPosition(1, -1, 0);
a3Actor->GetProperty()->SetColor(colors->GetColor3d("ElevationArrowColor").GetData());
a3Actor->GetProperty()->SetSpecularColor(colors->GetColor3d("White").GetData());
a3Actor->GetProperty()->SetSpecular(0.3);
a3Actor->GetProperty()->SetSpecularPower(20);
a3Actor->GetProperty()->SetAmbient(0.2);
a3Actor->GetProperty()->SetDiffuse(0.8);
vtkNew<vtkLODActor> a4Actor;
a4Actor->SetMapper(arrowMapper);
a4Actor->RotateZ(180);
a4Actor->RotateX(-90);
a4Actor->SetPosition(1, 1, 0);
a4Actor->GetProperty()->SetColor(colors->GetColor3d("ElevationArrowColor").GetData());
a4Actor->GetProperty()->SetSpecularColor(colors->GetColor3d("White").GetData());
a4Actor->GetProperty()->SetSpecular(0.3);
a4Actor->GetProperty()->SetSpecularPower(20);
a4Actor->GetProperty()->SetAmbient(0.2);
a4Actor->GetProperty()->SetDiffuse(0.8);
// draw the DOP
vtkNew<vtkTransform> arrowT2;
arrowT2->Scale(1, 0.6, 1);
arrowT2->RotateY(90);
vtkNew<vtkTransformPolyDataFilter> arrowTF2;
arrowTF2->SetInputData(pd2);
arrowTF2->SetTransform(arrowT2);
vtkNew<vtkRotationalExtrusionFilter> arrowREF;
arrowREF->SetInputConnection(arrowTF2->GetOutputPort());
arrowREF->CappingOff();
arrowREF->SetResolution(30);
vtkNew<vtkPolyDataMapper> spikeMapper;
spikeMapper->SetInputConnection(arrowREF->GetOutputPort());
vtkNew<vtkLODActor> a5Actor;
a5Actor->SetMapper(spikeMapper);
a5Actor->SetScale(.3, .3, .6);
a5Actor->RotateY(90);
a5Actor->SetPosition(-2, 0, 0);
a5Actor->GetProperty()->SetColor(colors->GetColor3d("SpikeColor").GetData());
a5Actor->GetProperty()->SetAmbient(0.2);
a5Actor->GetProperty()->SetDiffuse(0.8);
// focal point
vtkNew<vtkSphereSource> fps;
fps->SetRadius(0.5);
vtkNew<vtkPolyDataMapper> fpMapper;
fpMapper->SetInputConnection(fps->GetOutputPort());
vtkNew<vtkLODActor> fpActor;
fpActor->SetMapper(fpMapper);
fpActor->SetPosition(-9, 0, 0);
fpActor->GetProperty()->SetSpecularColor(colors->GetColor3d("White").GetData());
fpActor->GetProperty()->SetSpecular(0.3);
fpActor->GetProperty()->SetAmbient(0.2);
fpActor->GetProperty()->SetDiffuse(0.8);
fpActor->GetProperty()->SetSpecularPower(20);
// create the roll arrows
vtkNew<vtkWarpTo> arrowWT2;
arrowWT2->SetInputConnection(arrowCF->GetOutputPort());
arrowWT2->SetPosition(5, 0, 2.5);
arrowWT2->SetScaleFactor(0.95);
arrowWT2->AbsoluteOn();
vtkNew<vtkTransform> arrowT3;
arrowT3->Translate(-2.50358, 0, -1.70408);
arrowT3->Scale(0.5, 0.3, 1);
vtkNew<vtkTransformFilter> arrowTF3;
arrowTF3->SetInputConnection(arrowWT2->GetOutputPort());
arrowTF3->SetTransform(arrowT3);
vtkNew<vtkDataSetMapper> arrowMapper2;
arrowMapper2->SetInputConnection(arrowTF3->GetOutputPort());
arrowMapper2->ScalarVisibilityOff();
// draw the roll arrows
vtkNew<vtkLODActor> a6Actor;
a6Actor->SetMapper(arrowMapper2);
a6Actor->RotateZ(90);
a6Actor->SetPosition(-4, 0, 0);
a6Actor->SetScale(1.5, 1.5, 1.5);
a6Actor->GetProperty()->SetColor(colors->GetColor3d("RollArrowColor").GetData());
a6Actor->GetProperty()->SetSpecularColor(colors->GetColor3d("White").GetData());
a6Actor->GetProperty()->SetSpecular(0.3);
a6Actor->GetProperty()->SetSpecularPower(20);
a6Actor->GetProperty()->SetAmbient(0.2);
a6Actor->GetProperty()->SetDiffuse(0.8);
// Add the actors to the renderer, set the background and size
ren1->AddActor(camActor);
ren1->AddActor(a1Actor);
ren1->AddActor(a2Actor);
ren1->AddActor(a3Actor);
ren1->AddActor(a4Actor);
ren1->AddActor(a5Actor);
ren1->AddActor(a6Actor);
ren1->AddActor(fpActor);
ren1->SetBackground(colors->GetColor3d("BkgColor").GetData());
ren1->SetBackground(colors->GetColor3d("SlateGray").GetData());
renWin->SetSize(640, 480);
renWin->SetWindowName("CameraModel1");
// render the image
vtkCamera* cam1 = (ren1->GetActiveCamera());
ren1->ResetCamera();
cam1->Azimuth(150);
cam1->Elevation(30);
cam1->Dolly(1.5);
ren1->ResetCameraClippingRange();
// Create a TextActor for azimuth (a1 and a2 actor's color)
vtkNew<vtkTextActor> text;
text->SetInput("Azimuth");
vtkTextProperty* tprop = text->GetTextProperty();
tprop->SetFontFamilyToArial();
tprop->ShadowOff();
tprop->SetLineSpacing(1.0);
tprop->SetFontSize(36);
tprop->SetColor(a1Actor->GetProperty()->GetColor());
text->SetDisplayPosition(20, 50);
ren1->AddActor2D(text);
// Create a TextActor for elevation (a3 and a4 actor's color)
vtkNew<vtkTextActor> text2;
text2->SetInput("Elevation");
tprop = text2->GetTextProperty();
tprop->SetFontFamilyToArial();
tprop->ShadowOff();
tprop->SetLineSpacing(1.0);
tprop->SetFontSize(36);
tprop->SetColor(a3Actor->GetProperty()->GetColor());
text2->SetDisplayPosition(20, 100);
ren1->AddActor2D(text2);
// Create a TextActor for roll (a6 actor's color)
vtkNew<vtkTextActor> text3;
text3->SetInput("Roll");
tprop = text3->GetTextProperty();
tprop->SetFontFamilyToArial();
tprop->ShadowOff();
tprop->SetLineSpacing(1.0);
tprop->SetFontSize(36);
tprop->SetColor(a6Actor->GetProperty()->GetColor());
text3->SetDisplayPosition(20, 150);
ren1->AddActor2D(text3);
renWin->Render();
iren->Initialize();
iren->Start();
}
};
1.03-VTK基础概念(2)
2.vtkCamera Class Reference
3.VTK相机类vtkCamera原理及用法