【转】VTK修炼之道2_VTK体系结构1

我不是女神ヾ 2022-11-06 11:53 24阅读 0赞

# 1.OverView综述 #

> The Visualization Toolkit consists of two basic subsystems: a compiled C++ class library （一个已经编译好的C++类库）and an “interpreted” wrapper layer（一个用于解释的语言层） that lets you manipulate the compiled classes using the languages Java, Tcl, and Python.
> 
> **Tcl**(最早称为“工具[命令语言][Link 1]”"Tool Command Language", 但是目前已经不是这个含义，不过我们仍然称呼它为TCL)是一种[脚本语言][Link 2]。 由John Ousterhout创建。 TCL很好学，功能很强大。TCL经常被用于 快速原型开发,脚本编程，[GUI][]和测试等方面。TCL念作“踢叩” "tickle".
> 
> The Visualization Toolkit is an object-oriented system（面向对象的体系）. The key to using VTK effectively is to  
> develop a good understanding of the underlying object models（想使用好VTK，就要充分理解最基本的对象模型）. Doing so will remove much of the mystery surrounding the use of the hundreds of objects in the system. With this understanding in place it’s much easier to combine objects to build applications. You’ll also need to know something about the capabilities of the many objects in the system（同时，我们也应该理解体系中很多对象的基本功能）。

# 2.Low-Level Object Model低级对象模型 #

> The VTK object model can be thought of as being rooted in the superclass vtkObject. Nearly all VTK 
> classes are derived from this class, or in some special cases from its superclass vtkObjectBase.（几乎所有的VTK对象都源于超类：vtkObject；除了一些特殊情况下是来源于vtkObjectBase；这里提及到的超类是指一个或者多个来由此派生；） All VTK must be created using the object's New() method, and must be destroyed using the object's Delete() method. VTK objects cannot be allocated on the stack because the constructor is a protected method. （因为VTK的构造函数采用保护类型，所以VTK的对象无法在堆上进行创建并分配内存，只能通过New()和Delete()方法进行对象的创建与销毁）Using a common superclass and a unified method of creating and destroying object, VTK is able to provide several basic object-oriented operations.
> 
> # 2.1 Reference Counting引用计数 #
> 
> Objects explicitly store a count of the number of pointers referencing them. When an object is created through the static New() method of a class its initial reference count is 1 because a raw pointer must be used to refer to the new object:
> 
> vtkObjectBase* obj = vtkExampleClass::New();
> 
> When other references to the object are created or destroyed the reference count is incremented and 
> decremented using the Register() and UnRegister() methods. Usually this is handled automatically by 
> the various “set” methods provided in the object’s API:
> 
> otherObject->SetExample(obj);
> 
> The reference count is now 2 because both the original pointer and a pointer stored inside the otherobject both refer to it. When the raw pointer originally storing the object is no longer needed the reference is removed using the Delete() method:
> 
> obj->Delete();
> 
>  
> 
> 从上面我们可以看到，对象的创建以及销毁完全靠手动完成，一旦我们处理不好，就会造成内存泄漏。为了避免这是，可以采用  **“智能指针”**。（智能指针是通过类模板进行定义的）
> 
> 因此，上面的程序代码我们可以改写成：
> 
> vtkSmartPointer<vtkObjectBase> obj = vtkSmartPointer<vtkExampleClass>::New();
> otherObject->SetExample(obj);
> 
> 此时，我们就没有必要再去调用Delete()方法撤销对象。
> 
> ## 2.2 Run-Time Type Information运行时类型信息 ##
> 
> In C++ the real type of an object may be different from the type of pointer used to reference it. （真实的对象类型可能和引用的指针类型不同）All classes in the public interface of VTK have simple identifiers for class names (no templates), so a string is sufficient to identify them. （用一个字符串来标识）The type of a VTK object may be 
> obtained at run-time with the GetClassName() method（用GetClassName()可以得到VTK对象的类型）:

> const char* type = obj->GetClassName();
> 
> An object may be tested for whether it is an instance of a particular class or one of its subclasses using 
> the IsA() method（通过下面的方法我们可以检测一个对象是否是一个类的实例）:
> 
> if(obj->IsA("vtkExampleClass")) { ... }
> 
> ## 2.3 Object State Display对象状态显示 ##
> 
> When debugging（调试中很有用，可以了解到对象当前的描述） it is often useful to display a human-readable description of the current state of an object. This can be obtained for VTK objects using the Print() method:
> 
> obj->Print(cout);

# 3.The Rendering Engine渲染引擎 #

> The VTK rendering engine consists of the classes in VTK that are responsible for taking the results of the visualization pipeline and displaying them into a window（渲染引擎的工作在于获得可视化管道的结果，然后将他们显示在窗口上）. This involves the following components. Note that this is not an exhaustive list（此处没有给出详细的清单）, but rather a sense of the most commonly used objects in the rendering engine. The subheadings used here are the highest level superclass in VTK that represents this type of object, and in many cases where there are multiple choices these are abstract classes defining the basic API across the various concrete subclasses that implement the functionality.
> 
> ## 3.1 vtkProp（道具？） ##
> 
> Visible depictions of data that exist in the scene are represented by a subclass of vtkProp（vtkProp子类用来呈现数据的可视化）.The most commonly used subclasses of vtkProp for displaying objects in 3D are vtkActor (used to  
> represent geometric data in the scene) and vtkVolume (used to represent volumetric data in the scene).There are also props that represent data in 2D such as vtkActor2D. The vtkProp subclass is generally responsible for knowing its position, size, and orientation in the scene（vtkProp子类通常负责知晓视图的位置、尺寸和方向）. The parameters used to control the placement of the prop generally depend on whether the prop is for example a 3D object in the scene, or a 2D annotation. For 3D props such as vtkActor and vtkVolume , you can either directly control parameters such as  the object's 3D position, orientation and scale, or you can use a 4x4 transformation matrix（利用一个4\*4的矩阵直接控制3D立体的位置、方向和尺寸）. For 2D  props that provide annotation such as the vtkScalarBarActor, the size and position of the annotation  can be defined in a variety of ways including specifying a position, width, and height relative to the  size of the entire viewport. In addition to providing placement control, props generally have a mapper  object that holds the data and knows how to render it, and a property object that controls parameters  such as color and opacity.（除了提供位置上的控制，Prop通常也会提供一个映射器对象，这个映射其对象持有数据并且知道如何渲染这些数据；此外还控制一个属性对象，控制颜色和透明度参数）
> 
> ![20161103181743661][]
> 
> There are a large number (over 50) of specialized props（专用道具） such as vtkImageActor (used to display  
> an image) and vtkPieChartActor (used to create a pie chart visual representation of an array of datavalues). Some of these specialized props directly contain the parameters that control appearance, and directly have a reference to the input data to be rendered, and therefore do not require the use of a property or a mapper. The vtkFollower prop is a specialized subclass of vtkActor that will automatically update its orientation in order to continually face a specified camera. This is useful for displaying billboards or text in the 3D scene and having them remain visible as the user rotates. The vtkLODActor is also a subclass of vtkActor that automatically changes its geometric representation in order to maintain interactive frame rates, and vtkLODProp3D is a subclass of vtkProp3D that  
> selects between a number of different mappers (perhaps even a mixture of volumetric and geometric  
> mappers) in order to provide interactivity. vtkAssembly allows hierarchies of actors, properly managing the transformations when the hierarchy is translated, rotated or scaled.
> 
> ## 3.1 vtkAbstractMapper 抽象映射器 ##
> 
> Some props such as vtkActor and vtkVolume use a subclass of vtkAbstractMapper to hold a reference to the input data（保持对输入数据的引用） and to provide the actual rendering functionality（提供实际的渲染功能）. The  vtkPolyDataMapper is the primary mapper for rendering polygonal geometry.（对于渲染多边形几何 vtkPolyDataMapper是最主要的映射器） For volumetric objects（对于容积对象）, VTK provides several rendering techniques including the vtkFixedPointVolumeRayCastMapper that can be used to rendering vtkImageData, and the vtkProjectedTetrahedra mapper that can be used to  
> render vtkUnstructuredGrid data.
> 
> ## 3.2 vtkProperty and vtkVolumeProperty 属性和体积属性 ##
> 
> Some props use a separate property object to hold the various parameters that control the appearance of the data.（属性对象用来控制数据的外观） This allows you to more easily share appearance settings between different objects in your scene. The **vtkActor object uses a vtkProperty to store parameters** such as color, opacity, and the ambient, diffuse, and specular coefficient of the material.（颜色、透明度、阴影、镜面反射系数）The **vtkVolume** object instead uses a vtkVolumeProperty to capture the parameters that are applicable to a volumetric object, such as the transfer functions that map the scalar value to color and opacity. Many mappers also provide functionality to set clipping planes that can be used to reveal interior structure.
> 
> ## 3.3 vtkCamera 摄像机 ##
> 
> The vtkCamera contains the parameters that control how you view the scene.（如何去看一个场景） The vtkCamera has a position, a focal point, and a vector defining the direction of "up" in the scene（位置信息、焦点信息、定义“向上”）. Other parameters control the specific viewing transformation (parallel or perspective), the scale or view angle of the image, and the near and far clipping planes of the view frustum.（平行/透视、尺寸、角度、视锥体的远近裁剪平面）.
> 
> ## 3.4 vtkLight 灯光 ##
> 
> When lighting is computed for a scene, one or more vtkLight objects are required. The vtkLight objects store the position and orientation of the light, as well as the color and intensity.（该对象储存着灯光的位置的方向信息，以及灯光的颜色和强度信息） Lights also have a type that describes how the light will move with respect to the camera.（灯光还有一个参数信息，那就是定义灯光如何相对于摄像机移动） For example, a Headlight is always located at the camera's position and shines on the camera's focal point, whereas a SceneLight is located at a stationary position in the scene.
> 
> ## 3.5 vtkRenderer 渲染器 ##
> 
> The objects that make up a scene including the props, the camera and the lights are collected together in a vtkRenderer. （渲染器对象用于将道具、摄像机、灯光收集到一起组成一个场景）The vtkRenderer is responsible for managing the rendering process for the scene. Multiple vtkRenderer objects can be used together in a single vtkRenderWindow. （在一个舞台上我们可以构建多个渲染器对象，这就是我们平常说的多视窗技术）These  renderers may render into different rectangular regions (known as viewports) of the render window,or may be overlapping.
> 
> ## 3.6 vtkRenderWindow 渲染窗口 ##
> 
> The vtkRenderWindow provides a connection between the operating system and the VTK rendering engine（渲染窗口类用于联系当地操作系统和VTK渲染引擎）. Platform specific subclasses of vtkRenderWindow are responsible for opening a window in the native windowing system on your computer and managing the display pro-cess（主要负责打开一个本地的窗口，然后管理图像显示过程）. When you develop with VTK, you simply use the platform-independent vtkRenderWindow which is automatically replaced with the correct platform-specific subclass at runtime. The vtkRenderWindow contains a collection of vtkRenderers, and parameters that control rendering features such as stereo, anti-aliasing, motion blur and focal depth（渲染窗口类主要负责收集渲染器信息以及控制渲染特征的信息，比如立体？运动模糊？焦点深度？）.
> 
> ## 3.7 vtkRenderWindowInteractor 渲染窗口交互 ##
> 
> The vtkRenderWindowInteractor is responsible for processing mouse, key, and timer events （负责处理鼠标、键盘和定时器事件的消息）and routing these through VTK's implementation of the command /observer design pattern. A vtkInteractorStyle listens for these events and processes them in order to provide motion controls such as rotating, panning and zooming. （可以提供类似平移、旋转、缩放的功能）The vtkRenderWindowInteractor automatically creates a default interactor style that works well for 3D scenes, but you can instead select one for 2D image viewing for example, or create your own custom interactor style.
> 
> ## 3.8 vtkLookupTable, vtkColorTransferFunction, and vtkPiecewiseFunction ##
> 
> Visualizing scalar data often involves defining a mapping from a scalar value to a color and opacity（标量数据可视化通常会涉及到定义一个标量值到颜色/透明度的映射）. This is true both in geometric surface rendering where the opacity will define the translucency of the surface, and in volume rendering where the opacity will represent the opacity accumulated along some length of of ray passing through the volume. For geometric rendering, this mapping is typically created using a vtkLookupTable, and in volume rendering both the vtkColorTransferFunction and the vtkPiecewiseFunction will be utilized.

# 4.渲染引擎的测试程序 #

> #include "vtkCylinderSource.h"
> #include "vtkPolyDataMapper.h"
> #include "vtkActor.h"
> #include "vtkRenderer.h"
> #include "vtkRenderWindow.h"
> #include "vtkRenderWindowInteractor.h"
> #include "vtkProperty.h"
> #include "vtkCamera.h"
> 
> #include <vtkAutoInit.h>
> VTK_MODULE_INIT(vtkRenderingOpenGL);
> 
> int main()
> {
> // This creates a polygonal cylinder model with eight circumferential facets.
> vtkCylinderSource *cylinder = vtkCylinderSource::New();
> cylinder->SetResolution(8);
> 
> // The mapper is responsible for pushing the geometry into the graphics
> // library. It may also do color mapping, if scalars or other attributes
> // are defined.
> vtkPolyDataMapper *cylinderMapper = vtkPolyDataMapper::New();
> cylinderMapper->SetInputConnection(cylinder->GetOutputPort());
> 
> // The actor is a grouping mechanism: besides the geometry (mapper), it
> // also has a property, transformation matrix, and/or texture map.
> // Here we set its color and rotate it -22.5 degrees.
> vtkActor *cylinderActor = vtkActor::New();
> cylinderActor->SetMapper(cylinderMapper);
> cylinderActor->GetProperty()->SetColor(1.0000, 0.3882, 0.2784);
> cylinderActor->RotateX(30.0);
> cylinderActor->RotateY(-45.0);
> 
> // Create the graphics structure. The renderer renders into the
> // render window. The render window interactor captures mouse events
> // and will perform appropriate camera or actor manipulation
> // depending on the nature of the events.
> vtkRenderer *ren1 = vtkRenderer::New();
> vtkRenderWindow *renWin = vtkRenderWindow::New();
> renWin->AddRenderer(ren1);
> vtkRenderWindowInteractor *iren = vtkRenderWindowInteractor::New();
> iren->SetRenderWindow(renWin);
> 
> // Add the actors to the renderer, set the background and size
> ren1->AddActor(cylinderActor);
> ren1->SetBackground(0.1, 0.2, 0.4);
> renWin->SetSize(200, 200);
> // We'll zoom in a little by accessing the camera and invoking a "Zoom"
> // method on it.
> ren1->ResetCamera();
> ren1->GetActiveCamera()->Zoom(1.5);
> renWin->Render();
> // This starts the event loop and as a side effect causes an initial render.
> iren->Start();
> // Exiting from here, we have to delete all the instances that
> // have been created.
> cylinder->Delete();
> cylinderMapper->Delete();
> cylinderActor->Delete();
> ren1->Delete();
> renWin->Delete();
> iren->Delete();
> 
> return 0;
> }
> 
> 程序运行结果：
> 
> ![20161103212722310][]

[Link 1]: https://baike.baidu.com/item/%E5%91%BD%E4%BB%A4%E8%AF%AD%E8%A8%80
[Link 2]: https://baike.baidu.com/item/%E8%84%9A%E6%9C%AC%E8%AF%AD%E8%A8%80
[GUI]: https://baike.baidu.com/item/GUI
[20161103181743661]: /images/20221023/1810c50889b846b9848045f07d02dd0d.png
[20161103212722310]: /images/20221023/a80cfcaed53c4bad9c39d9ccd514d2cc.png