第16章体渲染基础

体渲染（Volume Rendering）是科学可视化中最为强大的技术之一。与传统的表面渲染不同，体渲染直接处理三维标量场数据，通过沿视线方向采样、累积颜色和不透明度来生成最终图像。本章将从基本概念出发，逐步介绍VTK中体渲染的管线、传递函数设计以及完整的代码实现。

16.1 什么是体渲染

16.1.1 表面渲染与体渲染的根本区别

在计算机图形学中，有两种根本不同的渲染范式：表面渲染（Surface Rendering）和体渲染（Volume Rendering）。

表面渲染的工作流程是：

三维物体由显式的几何图元（三角形、多边形）定义边界表面。
图形管线将这些图元投影到屏幕空间，通过光栅化生成片段。
每个片段的颜色由光照模型、纹理映射等计算得出。
深度缓冲（Z-buffer）解决遮挡关系——只有最前面的表面可见。

在VTK中，表面渲染的典型管线是：

vtkPolyData (几何数据) → vtkPolyDataMapper → vtkActor → vtkRenderer

表面渲染的核心假设是：物体是"实心"的，其光学属性完全由表面定义。光线击中表面后要么被反射、要么被吸收，不会"穿透"物体内部。

体渲染则采用了完全不同的思路：

三维数据是一个标量场（Scalar Field）——空间中的每个点都有一个标量值。
没有显式的几何表面。整个体积被视为一个"发光的半透明云团"。
从每个像素发射一条视线（Ray），穿过整个体积。
沿视线方向按照固定步长进行采样，每个采样点的标量值通过传递函数（Transfer Function）映射为颜色和不透明度。
按照从后向前或从前向后的顺序，累积所有采样点的颜色和不透明度，得到该像素的最终颜色。

这种渲染方式可以揭示数据内部的细微结构，而不需要预先提取等值面。

16.1.2 体数据作为半透明点云

体渲染的核心思想可以用一个简单的物理类比来理解：

将三维标量场想象成一个充满半透明"云雾"的空间。每个点的颜色和透明度由该点的标量值决定。当我们从某个方向观察这个云雾时，近处的云雾会部分遮挡远处的云雾。光线穿过云雾时，一部分被吸收，一部分被散射并传向观察者。

数学上，这由体积渲染积分方程（Volume Rendering Integral）描述：

[ I(D) = \int_{s=0}^{D} C(s) \cdot \alpha(s) \cdot \exp\left(-\int_{t=0}^{s} \alpha(t) \, dt\right) \, ds ]

其中： - (s) 是沿光线的距离参数。 - (C(s)) 是位置 (s) 处采样点的颜色。 - (\alpha(s)) 是位置 (s) 处采样点的不透明度（0表示完全透明，1表示完全不透明）。 - (\exp(-\int \alpha(t) dt)) 是从光线起点到 (s) 处的累积透明度（即尚未被吸收的光线比例）。

这个公式的含义是：每个采样点对最终图像的贡献不仅取决于其自身的颜色和不透明度，还取决于光线在到达该点之前已经被前方材料吸收了多少。

在实际计算中，VTK使用离散化的近似方法——沿光线以固定步长采样，然后使用alpha合成（Alpha Compositing）逐步累积颜色。

从前向后合成（Front-to-Back Compositing）：

累积颜色 = 累积颜色 + (1 - 累积不透明度) × 当前颜色 × 当前不透明度
累积不透明度 = 累积不透明度 + (1 - 累积不透明度) × 当前不透明度

这种合成方式有一个重要优点：当累积不透明度接近1时，可以提前终止光线（Early Ray Termination），因为后面的采样点对最终图像已经没有贡献。这大大提高了渲染效率。

16.1.3 体渲染的应用场景

体渲染在以下领域有广泛应用：

医学影像：CT（计算机断层扫描）和MRI（磁共振成像）产生三维标量场数据。体渲染可以让医生看到皮肤、骨骼、软组织和血管的三维空间关系，而无需在不同切片之间来回切换。典型的应用包括：
骨骼重建（高不透明度分配给骨骼的CT值范围）
血管造影（增强血管的CT值后做体渲染）
牙科种植规划（观察下颌神经管与骨组织的关系）
科学计算可视化：CFD（计算流体力学）模拟产生密度、压力、温度等标量场。体渲染可以直观展示：
超音速飞行器周围的激波结构
燃烧室内的火焰温度和燃料浓度分布
气象数据的云团和降水分布
天体物理模拟中的星云气体密度
工业无损检测（NDT）：工业CT扫描被用于检测零件内部的缺陷：
铸件内部的气孔和裂纹
焊接接头的融合质量
复合材料的分层和脱粘
电子元器件的内部结构验证（如BGA焊球）
石油地质：地震勘探产生的三维数据体可以揭示地下构造：
油气储层的空间形态
断层和褶皱的几何关系
盐丘和河道砂体等特殊地质体

16.2 体渲染管线

16.2.1 核心组件概览

VTK的体渲染管线由以下核心组件构成，每个组件承担特定的职责：

组件	类型	职责
`vtkImageData`	数据	存储三维体数据（规则的标量场）
`vtkVolumeMapper`	映射器	将体数据转换为可渲染的图元（与`vtkPolyDataMapper`对应）
`vtkVolume`	道具	场景中的体渲染对象（与`vtkActor`对应）
`vtkVolumeProperty`	属性	定义传递函数、光照、插值等渲染属性（与`vtkProperty`对应）

16.2.2 vtkVolume——体的Actor

vtkVolume 是体渲染中的"演员"，它在场景中代表一个可以被渲染的体对象。其角色完全平行于vtkActor：

// 表面渲染
vtkNew<vtkActor> actor;
actor->SetMapper(polyDataMapper);
actor->SetProperty(property);

// 体渲染
vtkNew<vtkVolume> volume;
volume->SetMapper(volumeMapper);
volume->SetProperty(volumeProperty);

vtkVolume继承自vtkProp3D，因此支持所有标准的三维变换操作：平移（SetPosition）、旋转（SetOrientation）、缩放（SetScale），以及通过vtkProp3D的GetMatrix/SetUserMatrix进行任意变换。

16.2.3 vtkAbstractVolumeMapper 及其子类

体渲染映射器的继承体系如下：

vtkAbstractVolumeMapper (抽象基类)
├── vtkVolumeMapper (已弃用，保留用于向后兼容)
├── vtkFixedPointVolumeRayCastMapper (CPU光线投射，固定精度)
├── vtkGPUVolumeRayCastMapper (GPU光线投射，需要OpenGL)
├── vtkOpenGLGPUVolumeRayCastMapper (OpenGL GPU实现)
├── vtkSmartVolumeMapper (智能映射器，自动选择最佳后端)
└── vtkMultiVolume (多体渲染支持)

在现代VTK（9.x）中，推荐使用 vtkSmartVolumeMapper。它会自动检测硬件能力并选择最优的渲染后端：

如果支持GPU光线投射（有可用的GPU且VTK编译时启用了相应模块），则使用GPU光线投射。
否则回退到CPU光线投射。

vtkSmartVolumeMapper 还支持通过 SetRequestedRenderMode() 手动指定渲染模式：

vtkNew<vtkSmartVolumeMapper> mapper;
mapper->SetRequestedRenderModeToGPU();    // 强制GPU渲染
mapper->SetRequestedRenderModeToRayCast(); // 强制CPU光线投射
mapper->SetRequestedRenderModeToDefault(); // 自动选择（默认）

16.2.4 vtkVolumeProperty——传递函数的容器

vtkVolumeProperty 是体渲染中最为关键的类之一。它管理与外观相关的所有设置，包括：

不透明度传递函数：SetScalarOpacity(vtkPiecewiseFunction*)
颜色传递函数：SetColor(vtkColorTransferFunction*)
梯度不透明度传递函数：SetGradientOpacity(vtkPiecewiseFunction*)（可选，用于增强表面效果）
光照属性：SetShade(bool)、SetAmbient(), SetDiffuse(), SetSpecular()
插值方式：SetInterpolationTypeToLinear() / SetInterpolationTypeToNearest()

vtkNew<vtkVolumeProperty> volumeProperty;
volumeProperty->SetColor(colorTransferFunction);
volumeProperty->SetScalarOpacity(scalarOpacityFunction);
volumeProperty->ShadeOn();              // 启用光照，增强深度感
volumeProperty->SetInterpolationTypeToLinear(); // 三线性插值

16.2.5 完整管线对比

将表面渲染管线和体渲染管线并列，可以清晰地看到设计上的对称性：

表面渲染管线：

vtkPolyData (source → filter) 
    → vtkPolyDataMapper (mapToSurfacePrimitives)
        → vtkActor (position, orientation, scale)
            → vtkProperty (color, lighting, representation)
                → vtkRenderer → vtkRenderWindow

体渲染管线：

vtkImageData (source → filter)
    → vtkSmartVolumeMapper (mapToVolumePrimitives)
        → vtkVolume (position, orientation, scale)
            → vtkVolumeProperty (color TF, opacity TF, shading)
                → vtkRenderer → vtkRenderWindow

16.2.6 管线搭建的基本步骤

构建一个最小化的体渲染管线通常需要以下步骤：

// 1. 创建或加载体数据
vtkNew<vtkImageData> volumeData;
// ... 填充数据 ...

// 2. 创建映射器
vtkNew<vtkSmartVolumeMapper> volumeMapper;
volumeMapper->SetInputData(volumeData);

// 3. 创建传递函数
vtkNew<vtkPiecewiseFunction> opacityTF;
opacityTF->AddPoint(minValue, 0.0);
opacityTF->AddPoint(maxValue, 1.0);

vtkNew<vtkColorTransferFunction> colorTF;
colorTF->AddRGBPoint(minValue, 0.0, 0.0, 1.0);
colorTF->AddRGBPoint(maxValue, 1.0, 0.0, 0.0);

// 4. 创建体属性
vtkNew<vtkVolumeProperty> volumeProperty;
volumeProperty->SetColor(colorTF);
volumeProperty->SetScalarOpacity(opacityTF);
volumeProperty->ShadeOn();
volumeProperty->SetInterpolationTypeToLinear();

// 5. 创建体
vtkNew<vtkVolume> volume;
volume->SetMapper(volumeMapper);
volume->SetProperty(volumeProperty);

// 6. 添加到渲染器
renderer->AddVolume(volume);

16.3 传递函数（Transfer Functions）

传递函数是体渲染的"灵魂"。它们决定了体数据中每个标量值被赋予什么颜色和不透明度，直接决定了最终图像的外观和可解读性。可以将传递函数理解为体数据的"材质编辑器"。

16.3.1 vtkPiecewiseFunction——不透明度传递函数

vtkPiecewiseFunction 定义了一个分段线性函数，将标量值映射到不透明度（opacity）。

vtkNew<vtkPiecewiseFunction> opacityTransferFunction;

关键方法： - AddPoint(double scalarValue, double opacity) —— 添加控制点 - RemovePoint(double scalarValue) —— 删除控制点 - RemoveAllPoints() —— 清除所有控制点 - GetValue(double scalarValue) —— 查询函数值

不透明度的取值范围为 [0.0, 1.0]： - 0.0 表示完全透明（该标量值对应的区域不可见） - 1.0 表示完全不透明（该标量值对应的区域完全遮挡后方内容） - 中间值表示半透明效果

设计原则： - 希望突出的结构应该分配较高的不透明度。 - 希望忽略的背景或干扰结构应该分配较低的不透明度（或直接设为0）。 - 不透明度函数的形状直接影响深度感知——变化剧烈的区域表面感强，变化平缓的区域云雾感强。 - 可以使用"梯形"或"山峰"形状来突出特定标量值范围的结构。

16.3.2 vtkColorTransferFunction——颜色传递函数

vtkColorTransferFunction 定义了一个颜色映射，将标量值映射到RGB颜色。

vtkNew<vtkColorTransferFunction> colorTransferFunction;

关键方法： - AddRGBPoint(double scalarValue, double r, double g, double b) —— 添加RGB控制点 - AddHSVPoint(double scalarValue, double h, double s, double v) —— 添加HSV控制点 - RemovePoint(double scalarValue) —— 删除控制点 - RemoveAllPoints() —— 清除所有控制点 - GetColor(double scalarValue, double rgb[3]) —— 查询颜色

RGB分量的取值范围为 [0.0, 1.0]。颜色空间中的插值是分段线性的，与不透明度传递函数类似。

颜色设计原则： - 使用颜色对比来区分不同组织/结构。 - 暖色（红、橙、黄）通常用于突出重要结构。 - 冷色（蓝、绿）通常用于背景或次要结构。 - 可以利用HSV空间更方便地设计基于色相变化的方案。

16.3.3 传递函数的协同工作

当光线穿过体积时，在每一个采样点：

通过三线性插值从体数据中获取该位置的标量值 (s)。
调用 opacityTF->GetValue(s) 获取不透明度 (\alpha)。
调用 colorTF->GetColor(s, rgb) 获取颜色 (C = (r, g, b))。
使用前面介绍的从前向后或从后向前的alpha合成公式，将 ((C, \alpha)) 累积到该像素的最终颜色中。

这个过程的伪代码可以表示为：

for each pixel (i, j) on screen:
    ray = computeRayFromCamera(i, j)
    accumulatedColor = (0, 0, 0)
    accumulatedOpacity = 0.0

    for t = entryPoint to exitPoint step stepSize:
        scalar = sampleVolume(ray.at(t))
        color = colorTF.getColor(scalar)
        opacity = opacityTF.getValue(scalar)

        // Front-to-back compositing
        accumulatedColor += (1 - accumulatedOpacity) * color * opacity
        accumulatedOpacity += (1 - accumulatedOpacity) * opacity

        if accumulatedOpacity > 0.99:
            break  // Early ray termination

    pixel(i, j) = accumulatedColor

16.3.4 典型传递函数设计案例

案例一：CT骨骼渲染

CT数据中，不同组织的HU值（Hounsfield Units）大致范围如下：

组织	HU值范围
空气	-1000 至 -800
肺	-800 至 -400
脂肪	-100 至 -50
水	0
软组织	20 至 60
骨骼	200 至 3000
致密骨	500 至 3000

骨骼可视化的传递函数设计策略：

// 不透明度传递函数 —— 突出骨骼
vtkNew<vtkPiecewiseFunction> boneOpacityTF;
boneOpacityTF->AddPoint(-1000, 0.0);   // 空气完全透明
boneOpacityTF->AddPoint(-500,  0.0);   // 肺也透明
boneOpacityTF->AddPoint(0,     0.0);   // 水/软组织透明
boneOpacityTF->AddPoint(60,    0.0);   // 软组织上界
boneOpacityTF->AddPoint(200,   0.2);   // 松质骨开始出现
boneOpacityTF->AddPoint(500,   0.6);   // 致密骨半透明
boneOpacityTF->AddPoint(1000,  0.9);   // 致密骨基本不透明
boneOpacityTF->AddPoint(3000,  1.0);   // 牙釉质/金属完全不透明

// 颜色传递函数 —— 白色到暖黄色
vtkNew<vtkColorTransferFunction> boneColorTF;
boneColorTF->AddRGBPoint(-1000, 0.0, 0.0, 0.0);   // 黑色
boneColorTF->AddRGBPoint(0,     0.3, 0.3, 0.3);   // 灰色
boneColorTF->AddRGBPoint(200,   0.8, 0.7, 0.5);   // 米色
boneColorTF->AddRGBPoint(500,   0.9, 0.8, 0.6);   // 暖白
boneColorTF->AddRGBPoint(1000,  1.0, 0.95, 0.8);  // 骨白
boneColorTF->AddRGBPoint(3000,  1.0, 1.0, 0.9);   // 亮白

案例二：CT软组织渲染

软组织可视化的策略完全不同——需要让皮肤、肌肉和器官可见，同时抑制骨骼的遮挡：

// 不透明度传递函数 —— 突出软组织
vtkNew<vtkPiecewiseFunction> softTissueOpacityTF;
softTissueOpacityTF->AddPoint(-1000, 0.0);   // 空气透明
softTissueOpacityTF->AddPoint(-800,  0.0);
softTissueOpacityTF->AddPoint(-100,  0.05);  // 脂肪轻微可见
softTissueOpacityTF->AddPoint(0,     0.1);   // 水/体液
softTissueOpacityTF->AddPoint(40,    0.3);   // 肌肉
softTissueOpacityTF->AddPoint(80,    0.5);   // 肝脏等器官
softTissueOpacityTF->AddPoint(200,   0.1);   // 降低骨骼不透明度
softTissueOpacityTF->AddPoint(500,   0.05);  // 致密骨基本透明
softTissueOpacityTF->AddPoint(3000,  0.0);   // 金属透明

// 颜色传递函数 —— 暖色调
vtkNew<vtkColorTransferFunction> softTissueColorTF;
softTissueColorTF->AddRGBPoint(-1000, 0.0, 0.0, 0.0);
softTissueColorTF->AddRGBPoint(-100,  0.9, 0.8, 0.3); // 脂肪：黄色
softTissueColorTF->AddRGBPoint(0,     0.5, 0.5, 0.6); // 水：灰蓝
softTissueColorTF->AddRGBPoint(20,    0.8, 0.4, 0.3); // 肌肉：红褐
softTissueColorTF->AddRGBPoint(60,    0.9, 0.3, 0.3); // 器官：红色
softTissueColorTF->AddRGBPoint(200,   0.8, 0.8, 0.7); // 骨骼：浅灰
softTissueColorTF->AddRGBPoint(3000,  1.0, 1.0, 1.0);

16.3.5 交互式传递函数设计

在实际应用中，传递函数的设计通常是一个反复试验的过程。常见的交互式设计工具包括：

直方图引导：在传递函数编辑器上叠加体数据的标量值直方图，帮助识别数据中的峰值（对应不同的组织/材料）。
多窗口联动：同时显示三维体渲染结果和二维切片（轴向、冠状、矢状面），帮助验证传递函数是否正确显示了目标结构。
预设库：为常见的扫描协议（如CT胸部、CT头部、CTA血管造影）准备预设的传递函数。
梯度不透明度：除了基于标量值的不透明度，还可以使用基于梯度幅值的不透明度来增强材料边界的显示效果：

vtkNew<vtkPiecewiseFunction> gradientOpacityTF;
gradientOpacityTF->AddPoint(0,    0.0);   // 均匀区域透明
gradientOpacityTF->AddPoint(50,   0.0);
gradientOpacityTF->AddPoint(100,  0.3);   // 边界区域半透明
gradientOpacityTF->AddPoint(200,  0.8);   // 强边界不透明
gradientOpacityTF->AddPoint(500,  1.0);   // 非常强的边界

volumeProperty->SetGradientOpacity(gradientOpacityTF);

梯度不透明度传递函数的原理是：梯度幅值大的地方通常对应材料边界，通过赋予这些区域更高的不透明度，可以增强表面效果，使体渲染看起来更像表面渲染。

16.4 vtkSmartVolumeMapper

16.4.1 智能后端选择

vtkSmartVolumeMapper 是VTK 9.x中体渲染的推荐入口。它在内部维护了多个渲染后端，并在运行时自动选择最合适的一个。

vtkNew<vtkSmartVolumeMapper> mapper;
mapper->SetRequestedRenderModeToDefault(); // 自动选择

自动选择的优先级逻辑如下：

检查 VTK_MODULE_ENABLE_VTK_RenderingVolumeOpenGL2 是否启用。
检查GPU是否支持所需的OpenGL扩展（着色器、3D纹理、帧缓冲对象等）。
如果GPU可用，使用 vtkGPUVolumeRayCastMapper（OpenGL GPU光线投射）。
如果GPU不可用或不满足要求，回退到 vtkFixedPointVolumeRayCastMapper（CPU光线投射）。

16.4.2 手动指定渲染模式

// 强制使用GPU光线投射
mapper->SetRequestedRenderModeToGPU();

// 强制使用CPU光线投射
mapper->SetRequestedRenderModeToRayCast();

// 使用默认的自动选择
mapper->SetRequestedRenderModeToDefault();

// 查询实际使用的渲染模式
int actualMode = mapper->GetLastUsedRenderMode();
// 返回值: vtkSmartVolumeMapper::GPURenderMode 或 
//         vtkSmartVolumeMapper::RayCastRenderMode

16.4.3 GPU渲染与CPU渲染的对比

特性	GPU光线投射	CPU光线投射
性能	非常高（实时交互）	较慢（取决于CPU和数据大小）
图像质量	高（支持高级光照和着色）	中等（简化光照模型）
内存要求	体数据必须完整加载到GPU显存	使用系统内存，容量更大
硬件依赖	需要支持OpenGL 3.2+的GPU	仅需要CPU
可扩展性	受限于GPU显存大小	可处理超大体积
特性支持	完整（光照、梯度不透明度、裁剪平面等）	完整（但性能较低）
并行处理	天然并行（成千上万个着色器核心）	支持多线程（OpenMP/TBB）

16.4.4 大体积数据的内存考量

对于大型体数据（例如2048x2048x2048的uint16），需要仔细考虑内存使用：

GPU渲染：数据大小 = 2048 × 2048 × 2048 × 2 字节 = 16 GB。这超过了大多数消费级GPU的显存（通常8-12 GB）。对于这种情况，需要考虑：
使用CPU光线投射模式。
对数据进行降采样（使用vtkImageResample或vtkImageShrink3D）。
使用vtkImageData的流式处理扩展。
CPU渲染：16 GB + 渲染开销在具有64 GB或更多系统内存的工作站上通常是可行的。启用多线程可以显著提高CPU渲染的性能：

mapper->SetRequestedRenderModeToRayCast(); // CPU渲染
// CPU渲染器默认使用系统内存，不需要将数据复制到GPU显存

数据降采样策略：

// 对大数据进行降采样
vtkNew<vtkImageResample> resample;
resample->SetInputData(largeVolumeData);
resample->SetAxisOutputSpacing(0, 2, 2, 2); // 在每个维度上减少到原来的1/2
resample->Update();

mapper->SetInputData(resample->GetOutput());

16.4.5 其他重要设置

// 设置采样距离（光线步长）
// 步长越小图像质量越高，但性能越低
mapper->SetSampleDistance(0.5); // 默认值通常合适

// 设置图像采样距离（用于屏幕空间自适应采样）
mapper->SetImageSampleDistance(1.0); // 1.0 = 全分辨率

// 启用/禁用自动调整采样距离
mapper->SetAutoAdjustSampleDistances(true); // 根据交互状态自动调整

// 设置全局不透明度乘数（可用于淡入淡出效果）
// 通过 vtkVolumeProperty 设置：
volumeProperty->SetScalarOpacityUnitDistance(0, 1.0);

// 使用交互质量模式（旋转/缩放时降低采样率以保持流畅）
mapper->SetInteractiveUpdateRate(1.0); // 降低交互时的采样距离

16.5 代码示例：体渲染入门

本节提供一个完整的C++程序，演示如何在VTK中创建并渲染一个合成的三维体数据。该程序创建一个包含多个球体的体数据（模拟不同密度的结构），设置传递函数，并使用交互式窗口进行渲染。

16.5.1 完整C++源代码

// ============================================================================
// VolumeRenderingBasics.cxx
// VTK 9.5.2 体渲染入门示例
//
// 描述:
//   创建一个合成的三维体数据（包含多个不同标量值的球体），
//   使用vtkSmartVolumeMapper进行体渲染。
//   演示传递函数的设置和交互式体渲染。
//
// 编译 (需要CMake, 见随附的 CMakeLists.txt):
//   mkdir build && cd build
//   cmake .. && cmake --build .
// ============================================================================

#include <vtkActor.h>
#include <vtkCamera.h>
#include <vtkColorTransferFunction.h>
#include <vtkConeSource.h>
#include <vtkImageData.h>
#include <vtkInteractorStyleTrackballCamera.h>
#include <vtkMath.h>
#include <vtkMinimalStandardRandomSequence.h>
#include <vtkNamedColors.h>
#include <vtkNew.h>
#include <vtkPiecewiseFunction.h>
#include <vtkPointData.h>
#include <vtkPolyData.h>
#include <vtkPolyDataMapper.h>
#include <vtkProperty.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkRenderer.h>
#include <vtkSmartVolumeMapper.h>
#include <vtkUnsignedShortArray.h>
#include <vtkVolume.h>
#include <vtkVolumeProperty.h>

#include <cmath>
#include <iostream>
#include <vector>

// --------------------------------------------------------------------------
// 函数: CreateSyntheticVolume
//
// 创建一个合成的三维体数据（vtkImageData）。
// 数据中包含多个具有不同标量值的球体区域，模拟不同的"组织"或"材料"。
//
// 参数:
//   dimensions - 体数据的尺寸（每个维度的体素数量）
//   spacing    - 体素的物理间距（控制宽高比）
//
// 数据设计:
//   - 背景值为 0 (表示"空气")
//   - 球体 1: 标量值 ~500 (代表"骨骼"), 半径较大，位于中心
//   - 球体 2: 标量值 ~200 (代表"软组织"), 半径中等
//   - 球体 3: 标量值 ~350 (代表"软骨"), 半径较小
//   - 球体 4: 标量值 ~100 (代表"脂肪"), 半径较小
//
//  每个球体的边缘使用高斯平滑，使标量值从球体内部到外部平滑过渡。
//  这模拟了真实CT数据中组织的逐渐过渡特性。
// --------------------------------------------------------------------------
vtkSmartPointer<vtkImageData> CreateSyntheticVolume(
    int dimensions[3], double spacing[3])
{
  int dimX = dimensions[0];
  int dimY = dimensions[1];
  int dimZ = dimensions[2];

  // 创建 vtkImageData 对象
  vtkNew<vtkImageData> imageData;
  imageData->SetDimensions(dimX, dimY, dimZ);
  imageData->SetSpacing(spacing);
  imageData->SetOrigin(0.0, 0.0, 0.0);

  // 分配标量数组 (unsigned short 类型)
  // unsigned short 的范围是 [0, 65535]，提供了足够的精度
  vtkNew<vtkUnsignedShortArray> scalars;
  scalars->SetNumberOfComponents(1);
  scalars->SetNumberOfTuples(static_cast<vtkIdType>(dimX) * dimY * dimZ);
  scalars->SetName("Scalars");
  scalars->FillValue(0); // 全部初始化为 0

  // 定义球体的中心位置（在世界坐标/体素索引空间中）
  // 注意：这里使用的是体素索引，而非实际物理坐标
  double cx = dimX / 2.0;
  double cy = dimY / 2.0;
  double cz = dimZ / 2.0;

  // 球体参数: {centerX, centerY, centerZ, radius, peakValue, sigma}
  // peakValue: 球体中心的标量值
  // sigma: 高斯平滑参数（控制边缘的过渡宽度）
  struct Sphere
  {
    double cx, cy, cz;
    double radius;
    double peakValue;
    double sigma;
  };

  std::vector<Sphere> spheres = {
      // 中心大球体 (模拟骨骼)
      {cx, cy, cz, dimX * 0.3, 500.0, 5.0},
      // 偏右上方 (模拟软组织)
      {cx + dimX * 0.15, cy + dimY * 0.10, cz - dimZ * 0.05,
       dimX * 0.18, 200.0, 4.0},
      // 偏左方 (模拟软骨)
      {cx - dimX * 0.2, cy - dimY * 0.05, cz + dimZ * 0.1,
       dimX * 0.12, 350.0, 3.0},
      // 偏下方 (模拟脂肪)
      {cx + dimX * 0.05, cy - dimY * 0.2, cz - dimZ * 0.08,
       dimX * 0.10, 100.0, 2.5},
      // 小的高密度结节
      {cx + dimX * 0.25, cy + dimY * 0.2, cz - dimZ * 0.15,
       dimX * 0.06, 600.0, 2.0},
  };

  std::cout << "Creating synthetic volume data..." << std::endl;
  std::cout << "Volume dimensions: " << dimX << " x " << dimY << " x " << dimZ
            << std::endl;
  std::cout << "Total voxels: "
            << (static_cast<long long>(dimX) * dimY * dimZ) << std::endl;
  std::cout << "Number of spheres: " << spheres.size() << std::endl;

  // 对每个体素计算标量值
  // 遍历顺序: z -> y -> x (以保持内存局部性)
  for (int z = 0; z < dimZ; ++z)
  {
    if (z % 20 == 0)
    {
      std::cout << "  Processing slice " << z << " / " << dimZ << std::endl;
    }

    for (int y = 0; y < dimY; ++y)
    {
      for (int x = 0; x < dimX; ++x)
      {
        double value = 0.0;

        // 对每个球体累加其贡献值
        for (const auto& sphere : spheres)
        {
          double dx = x - sphere.cx;
          double dy = y - sphere.cy;
          double dz = z - sphere.cz;
          double dist = std::sqrt(dx * dx + dy * dy + dz * dz);

          // 使用高斯函数使球体边缘平滑过渡
          // f(dist) = peakValue * exp( -dist^2 / (2 * sigma^2) )
          // 当 dist 远大于 radius 时，贡献趋于 0
          double sigma2 = 2.0 * sphere.sigma * sphere.sigma;
          double contribution =
              sphere.peakValue * std::exp(-(dist * dist) / sigma2);

          // 对距离远大于半径的点（dist > radius + 3*sigma），跳过计算
          // 但高斯函数已经自然衰减，这个优化不是必须的

          value += contribution;
        }

        // 限制在 unsigned short 的有效范围内
        if (value > 65535.0)
        {
          value = 65535.0;
        }
        else if (value < 0.0)
        {
          value = 0.0;
        }

        // 计算体素索引
        vtkIdType index = static_cast<vtkIdType>(z) * dimY * dimX +
                          static_cast<vtkIdType>(y) * dimX + x;

        scalars->SetValue(index, static_cast<unsigned short>(value));
      }
    }
  }

  imageData->GetPointData()->SetScalars(scalars);

  // 打印统计信息
  double range[2];
  scalars->GetRange(range);
  std::cout << "Scalar range: [" << range[0] << ", " << range[1] << "]"
            << std::endl;
  std::cout << "Volume data creation complete." << std::endl;

  return imageData;
}

// --------------------------------------------------------------------------
// 函数: PrintUsage
//
// 打印程序使用说明和交互操作指南。
// --------------------------------------------------------------------------
void PrintUsage()
{
  std::cout << "\n"
            << "============================================\n"
            << "  VTK Volume Rendering Basics Demo\n"
            << "  Chapter 16 - Volume Rendering Basics\n"
            << "============================================\n"
            << "\n"
            << "Mouse Controls:\n"
            << "  Left button   - Rotate the volume\n"
            << "  Middle button - Pan (translate) the volume\n"
            << "  Right button  - Zoom in/out\n"
            << "  Mouse wheel   - Zoom in/out\n"
            << "\n"
            << "Keyboard Controls:\n"
            << "  r - Reset camera to default view\n"
            << "  w - Toggle wireframe/volume mode\n"
            << "  s - Save current view to screenshot (if supported)\n"
            << "  q / e / Esc - Quit the application\n"
            << "\n"
            << "Transfer Function Design:\n"
            << "  The volume contains 5 spherical regions with different\n"
            << "  scalar values:\n"
            << "    - ~500: Central large sphere (bone-like)\n"
            << "    - ~200: Upper-right sphere (soft-tissue-like)\n"
            << "    - ~350: Left sphere (cartilage-like)\n"
            << "    - ~100: Lower sphere (fat-like)\n"
            << "    - ~600: Small dense nodule\n"
            << "============================================\n"
            << std::endl;
}

// --------------------------------------------------------------------------
// 函数: main
// --------------------------------------------------------------------------
int main(int argc, char* argv[])
{
  PrintUsage();

  // =========================================================================
  // 第一步：创建合成的体数据
  // =========================================================================

  int dimensions[3] = {100, 100, 100}; // 100^3 = 1,000,000 体素
  double spacing[3] = {0.05, 0.05, 0.05}; // 体素间距

  vtkSmartPointer<vtkImageData> volumeData =
      CreateSyntheticVolume(dimensions, spacing);

  // =========================================================================
  // 第二步：设置不透明度传递函数
  // =========================================================================
  //
  // 设计思路:
  //   - 背景值(0附近): 完全透明
  //   - 脂肪(~100): 低不透明度 (半透明，可以看到内部结构)
  //   - 软组织(~200): 中等不透明度
  //   - 软骨(~350): 中等偏高不透明度
  //   - 骨骼(~500): 高不透明度
  //   - 致密结节(~600): 非常高不透明度
  //

  vtkNew<vtkPiecewiseFunction> opacityTransferFunction;

  // 获取数据的标量值范围
  double scalarRange[2];
  volumeData->GetPointData()->GetScalars()->GetRange(scalarRange);

  double minVal = scalarRange[0];
  double maxVal = scalarRange[1];

  std::cout << "\nConfiguring transfer functions..." << std::endl;
  std::cout << "Scalar range for transfer functions: [" 
            << minVal << ", " << maxVal << "]" << std::endl;

  // 不透明度传递函数 —— 越高的标量值越不透明
  opacityTransferFunction->AddPoint(minVal,        0.0);   // 背景透明
  opacityTransferFunction->AddPoint(minVal + 1.0,  0.0);   // 确保0附近透明
  opacityTransferFunction->AddPoint(50.0,          0.02);  // 低值几乎透明
  opacityTransferFunction->AddPoint(100.0,         0.08);  // 脂肪：稍微可见
  opacityTransferFunction->AddPoint(150.0,         0.15);  // 
  opacityTransferFunction->AddPoint(200.0,         0.25);  // 软组织：半透明
  opacityTransferFunction->AddPoint(300.0,         0.40);  //
  opacityTransferFunction->AddPoint(400.0,         0.60);  // 软骨：更不透明
  opacityTransferFunction->AddPoint(500.0,         0.85);  // 骨骼：高度不透明
  opacityTransferFunction->AddPoint(600.0,         0.95);  // 致密结节：近乎不透明
  opacityTransferFunction->AddPoint(maxVal,        1.0);   // 最高值完全不透明

  // =========================================================================
  // 第三步：设置颜色传递函数
  // =========================================================================
  //
  // 颜色方案:
  //   - 低值(背景): 深蓝色/黑色
  //   - 脂肪(~100): 黄色
  //   - 软组织(~200): 红色/肉色
  //   - 软骨(~350): 橙色
  //   - 骨骼(~500): 白色/骨色
  //   - 结节(~600): 亮白色
  //

  vtkNew<vtkColorTransferFunction> colorTransferFunction;

  colorTransferFunction->AddRGBPoint(minVal,        0.0, 0.0, 0.1);  // 深蓝黑
  colorTransferFunction->AddRGBPoint(50.0,          0.0, 0.0, 0.3);  // 
  colorTransferFunction->AddRGBPoint(100.0,         0.9, 0.8, 0.2);  // 黄色(脂肪)
  colorTransferFunction->AddRGBPoint(150.0,         0.8, 0.5, 0.2);  // 
  colorTransferFunction->AddRGBPoint(200.0,         0.9, 0.3, 0.2);  // 肉红色(软组织)
  colorTransferFunction->AddRGBPoint(300.0,         0.9, 0.5, 0.3);  // 
  colorTransferFunction->AddRGBPoint(400.0,         1.0, 0.7, 0.4);  // 橙色(软骨)
  colorTransferFunction->AddRGBPoint(500.0,         1.0, 0.9, 0.8);  // 白色(骨骼)
  colorTransferFunction->AddRGBPoint(600.0,         1.0, 1.0, 0.95); // 亮白(结节)
  colorTransferFunction->AddRGBPoint(maxVal,        1.0, 1.0, 1.0);  // 纯白

  // =========================================================================
  // 第四步：设置梯度不透明度传递函数（可选）
  // =========================================================================
  //
  // 梯度不透明度使材料边界更加清晰可见。
  // 梯度幅值高的位置（即材料边界）被赋予更高的不透明度，
  // 这会产生类似表面渲染的增强边界效果。
  //

  vtkNew<vtkPiecewiseFunction> gradientOpacityTF;
  gradientOpacityTF->AddPoint(0.0,   0.0);    // 均匀区域：透明
  gradientOpacityTF->AddPoint(50.0,  0.0);    //
  gradientOpacityTF->AddPoint(100.0, 0.15);   // 弱边界
  gradientOpacityTF->AddPoint(200.0, 0.40);   // 中等边界
  gradientOpacityTF->AddPoint(400.0, 0.70);   // 强边界
  gradientOpacityTF->AddPoint(800.0, 1.0);    // 非常强的边界

  // 注意：在这个示例中梯度不透明度是可选的。
  // 如果希望看到更柔和的"云雾"效果，可以注释掉下面设置梯度不透明度的行。

  // =========================================================================
  // 第五步：创建 vtkVolumeProperty
  // =========================================================================

  vtkNew<vtkVolumeProperty> volumeProperty;
  volumeProperty->SetColor(colorTransferFunction);
  volumeProperty->SetScalarOpacity(opacityTransferFunction);

  // 可选: 启用梯度不透明度以增强边界显示
  // volumeProperty->SetGradientOpacity(gradientOpacityTF);

  // 启用光照以增强深度感
  volumeProperty->ShadeOn();
  volumeProperty->SetAmbient(0.15);    // 环境光系数
  volumeProperty->SetDiffuse(0.85);    // 漫反射系数
  volumeProperty->SetSpecular(0.3);    // 镜面反射系数
  volumeProperty->SetSpecularPower(20.0); // 高光指数

  // 设置插值类型为线性（三线性插值），产生更平滑的结果
  volumeProperty->SetInterpolationTypeToLinear();

  // =========================================================================
  // 第六步：创建 vtkSmartVolumeMapper
  // =========================================================================

  vtkNew<vtkSmartVolumeMapper> volumeMapper;
  volumeMapper->SetInputData(volumeData);

  // 请求使用默认渲染模式（自动选择）
  volumeMapper->SetRequestedRenderModeToDefault();

  // 如果需要强制使用特定渲染模式，请取消以下注释:
  // volumeMapper->SetRequestedRenderModeToGPU();     // 强制GPU
  // volumeMapper->SetRequestedRenderModeToRayCast(); // 强制CPU

  // =========================================================================
  // 第七步：创建 vtkVolume
  // =========================================================================

  vtkNew<vtkVolume> volume;
  volume->SetMapper(volumeMapper);
  volume->SetProperty(volumeProperty);

  // 可选：设置体积在场景中的位置
  // volume->SetPosition(0.0, 0.0, 0.0);
  // volume->SetOrigin(dimX*spacing[0]/2, dimY*spacing[1]/2, dimZ*spacing[2]/2);

  // =========================================================================
  // 第八步：创建渲染器、渲染窗口和交互器
  // =========================================================================

  vtkNew<vtkRenderer> renderer;
  renderer->AddVolume(volume);
  renderer->SetBackground(0.15, 0.15, 0.2); // 深蓝灰色背景

  vtkNew<vtkRenderWindow> renderWindow;
  renderWindow->AddRenderer(renderer);
  renderWindow->SetSize(1024, 768);
  renderWindow->SetWindowName("VTK Volume Rendering Basics - Chapter 16");

  vtkNew<vtkRenderWindowInteractor> interactor;
  interactor->SetRenderWindow(renderWindow);

  // 设置交互样式（相机控制）
  vtkNew<vtkInteractorStyleTrackballCamera> style;
  interactor->SetInteractorStyle(style);

  // =========================================================================
  // 第九步：设置初始相机视角
  // =========================================================================
  //
  // 将相机定位在合适的位置，使体积在初始视图中可见。
  //

  vtkCamera* camera = renderer->GetActiveCamera();
  double centerX = dimensions[0] * spacing[0] / 2.0;
  double centerY = dimensions[1] * spacing[1] / 2.0;
  double centerZ = dimensions[2] * spacing[2] / 2.0;

  // 设置焦点（旋转中心）为体积的中心
  camera->SetFocalPoint(centerX, centerY, centerZ);

  // 设置相机位置：从右上角前方向体积中心观察
  double dist = dimensions[0] * spacing[0] * 2.0;
  camera->SetPosition(centerX + dist, centerY + dist * 0.6, centerZ + dist);

  // 设置上方向
  camera->SetViewUp(0.0, 0.0, 1.0);

  // 重置裁剪范围，使整个体积可见
  renderer->ResetCameraClippingRange();

  // =========================================================================
  // 第十步：打印诊断信息
  // =========================================================================

  int actualRenderMode = volumeMapper->GetLastUsedRenderMode();
  std::cout << "\nRendering Configuration:" << std::endl;
  std::cout << "  Requested render mode: Default (auto-select)" << std::endl;
  std::cout << "  Actual render mode: "
            << (actualRenderMode == vtkSmartVolumeMapper::GPURenderMode
                    ? "GPU Ray Casting"
                    : "CPU Ray Casting")
            << std::endl;
  std::cout << "  Shading: "
            << (volumeProperty->GetShade() ? "Enabled" : "Disabled")
            << std::endl;
  std::cout << "  Interpolation: Linear (trilinear)" << std::endl;
  std::cout << "  Window size: 1024 x 768" << std::endl;

  double* bgColor = renderer->GetBackground();
  std::cout << "  Background: (" << bgColor[0] << ", " << bgColor[1] << ", "
            << bgColor[2] << ")" << std::endl;

  std::cout << "\nStarting interactive renderer..." << std::endl;
  std::cout << "Close the render window or press 'q' to exit.\n" << std::endl;

  // =========================================================================
  // 第十一步：开始交互渲染
  // =========================================================================

  renderWindow->Render();
  interactor->Start();

  // =========================================================================
  // 第十二步：清理并退出
  // =========================================================================

  std::cout << "\nVolume rendering demo finished." << std::endl;
  return EXIT_SUCCESS;
}

16.5.2 代码说明

上述程序演示了构建一个完整体渲染应用的十二个步骤：

第一步：创建合成体数据。 由于我们没有真实的CT或MRI数据文件，程序使用CreateSyntheticVolume()函数生成一个包含多个球体的三维标量场。每个球体有不同的中心位置、半径和峰值标量值，使用高斯函数实现平滑的边缘过渡。这种设计模拟了实际数据中不同组织之间的渐变特性。

第二步：设置不透明度传递函数。 使用vtkPiecewiseFunction定义了标量值到不透明度的映射。标量值越高（即材料越致密），不透明度越高。这使得内部的致密结构能够"穿透"外层较透明的结构显示出来。

第三步：设置颜色传递函数。 使用vtkColorTransferFunction定义了标量值到颜色的映射。不同的标量值范围被赋予不同的颜色：低值为深蓝黑色，中等值为肉红色，高值为白色。这模拟了医学影像中常见的"热"颜色映射方案。

第四步：设置梯度不透明度。 这是可选的增强功能。梯度不透明度传递函数根据数据中梯度（变化率）的大小来调整不透明度——在材料边界处梯度大，因此边界会比均匀区域显得更不透明，产生更清晰的表面效果。

第五步：创建vtkVolumeProperty。 将所有传递函数和渲染属性（光照、插值方式）打包到一个vtkVolumeProperty对象中。

第六步：创建vtkSmartVolumeMapper。 使用智能映射器自动选择GPU或CPU渲染后端。

第七步：创建vtkVolume。 将映射器和属性关联到体积对象。

第八步至第十步： 创建渲染器、窗口和交互器，设置初始相机位置。

第十一步： 调用renderWindow->Render()和interactor->Start()启动交互式渲染循环。

第十二步： 交互循环结束后正常退出。

16.5.3 CMakeLists.txt

cmake_minimum_required(VERSION 3.16 FATAL_ERROR)

# --------------------------------------------------------------------------
# 项目设置
# --------------------------------------------------------------------------
project(VolumeRenderingBasics
    VERSION 1.0
    DESCRIPTION "VTK Volume Rendering Basics - Chapter 16 Example"
    LANGUAGES CXX
)

# --------------------------------------------------------------------------
# C++ 标准设置
# --------------------------------------------------------------------------
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)

# --------------------------------------------------------------------------
# 查找 VTK 9.x
# --------------------------------------------------------------------------
# 选项 1: 如果 VTK 通过 CMake 配置安装，以下命令可以自动查找
find_package(VTK
    ${VTK_MAJOR_VERSION}.${VTK_MINOR_VERSION}
    REQUIRED
    COMPONENTS
        CommonCore
        CommonDataModel
        CommonExecutionModel
        RenderingCore
        RenderingVolume
        RenderingVolumeOpenGL2   
        RenderingOpenGL2        
        InteractionStyle
)

# 选项 2: 如果使用 vcpkg 安装 VTK，请取消以下注释并注释上面的 find_package:
# find_package(VTK REQUIRED)

# --------------------------------------------------------------------------
# 检查 VTK 版本
# --------------------------------------------------------------------------
if(VTK_VERSION VERSION_LESS "9.0")
    message(FATAL_ERROR "This example requires VTK 9.0 or newer. "
                        "Found VTK ${VTK_VERSION}")
endif()

message(STATUS "VTK version: ${VTK_VERSION}")
message(STATUS "VTK include directories: ${VTK_INCLUDE_DIRS}")

# --------------------------------------------------------------------------
# 可执行文件
# --------------------------------------------------------------------------
add_executable(VolumeRenderingBasics
    VolumeRenderingBasics.cxx
)

# --------------------------------------------------------------------------
# 链接 VTK 库
# --------------------------------------------------------------------------
target_link_libraries(VolumeRenderingBasics
    PRIVATE ${VTK_LIBRARIES}
)

# --------------------------------------------------------------------------
# 包含目录
# --------------------------------------------------------------------------
target_include_directories(VolumeRenderingBasics
    PRIVATE ${VTK_INCLUDE_DIRS}
)

# --------------------------------------------------------------------------
# 编译器警告
# --------------------------------------------------------------------------
if(MSVC)
    target_compile_options(VolumeRenderingBasics PRIVATE /W4)
else()
    target_compile_options(VolumeRenderingBasics PRIVATE -Wall -Wextra)
endif()

# --------------------------------------------------------------------------
# 安装规则 (可选)
# --------------------------------------------------------------------------
install(TARGETS VolumeRenderingBasics
    RUNTIME DESTINATION bin
)

16.5.4 编译和运行

在Windows、Linux或macOS上编译和运行此示例的步骤：

Windows (Visual Studio):

mkdir build
cd build
cmake .. -G "Visual Studio 17 2022"
cmake --build . --config Release
.\Release\VolumeRenderingBasics.exe

Linux / macOS:

mkdir build
cd build
cmake ..
cmake --build .
./VolumeRenderingBasics

16.5.5 预期的渲染结果

运行程序后，应该看到一个交互式窗口显示：

一个暗蓝色背景下，由五个半透明球体组成的体积渲染图像。
中央最大的球体呈白色/骨色（标量值约500），由于不透明度设置较高，它是可见度最高的结构。
右下方的球体呈黄色（标量值约100，代表脂肪），不透明度较低，呈半透明状。
上方的球体呈肉红色（标量值约200，代表软组织），中等不透明度。
左侧的球体呈橙色（标量值约350，代表软骨）。
右上方有一个小的亮白色结节（标量值约600），几乎完全不透明。

使用鼠标可以旋转、平移和缩放体积，从不同角度观察这些结构的空间关系。

16.6 本章小结

本章介绍了VTK中体渲染的基本概念和实现方法。以下是本章的关键要点：

概念层面：

体渲染 vs 表面渲染：表面渲染处理显式几何表面，而体渲染直接处理三维标量场。体渲染通过沿视线方向采样并累积颜色和不透明度来生成图像，揭示了数据内部的结构特征。
体积渲染积分方程：这是体渲染的数学基础。它描述了每个采样点对最终图像的贡献如何不仅取决于该点的颜色和不透明度，还取决于光线在到达该点之前被遮挡的程度。
alpha合成：VTK使用离散化的alpha合成来近似连续的光线积分。从前向后的合成方式允许提前终止光线，这是体渲染性能优化的关键技术。

管线层面：

体渲染管线：vtkImageData (数据) → vtkSmartVolumeMapper (映射器) → vtkVolume (道具) → vtkVolumeProperty (属性)。这与表面渲染管线 vtkPolyData → vtkPolyDataMapper → vtkActor → vtkProperty 在结构上完全对称。
vtkSmartVolumeMapper：推荐在VTK 9.x中使用。它自动检测硬件能力并选择最优渲染后端（GPU或CPU）。也可以通过SetRequestedRenderMode()手动指定。

传递函数层面：

不透明度传递函数（vtkPiecewiseFunction）：将标量值映射到[0,1]范围的不透明度。设计不透明度传递函数是体渲染中最具创造性和最关键的步骤——它决定了哪些结构可见以及如何可见。
颜色传递函数（vtkColorTransferFunction）：将标量值映射到RGB颜色。颜色选择影响信息传达的清晰度和美学质量。
梯度不透明度传递函数：基于梯度幅值增强材料边界的不透明度，使体渲染产生类似表面渲染的清晰边界效果。
传递函数设计：没有"通用"的传递函数——它高度依赖于数据类型、应用目标和用户偏好。CT骨骼渲染和CT软组织渲染需要完全不同的传递函数设计。

实践层面：

合成体数据：当没有真实数据时，可以使用数学函数（如多个高斯球体叠加）创建合成的三维标量场，用于学习和测试体渲染管线。
交互式体渲染：与表面渲染一样，VTK的体渲染支持完整的交互操作（旋转、平移、缩放），以及光照和着色设置。

扩展方向：

掌握了本章的基础知识后，读者可以进一步学习：

体数据裁剪：使用vtkPlane裁剪体积以查看内部结构。
多体渲染：在同一个场景中渲染多个vtkVolume。
时间序列体渲染：渲染随时间变化的三维标量场（如4D CT）。
GPU着色器自定义：为vtkGPUVolumeRayCastMapper编写自定义GLSL着色器。
大规模体数据：使用多分辨率技术或流式处理渲染超大体积数据。

体渲染是科学可视化工具箱中功能最强大的技术之一。虽然掌握传递函数设计需要大量实践，但一旦理解其原理，便能以前所未有的方式探索和理解三维数据的内部结构。

第16章 体渲染基础