vtk用户指南 第十一章 随时间变化的数据

11.1时序支持简介

创建可视化工具包的目的是允许人们可视化，从而探索具有空间范围的数据中的特征。它允许人们回答一些问题，比如“在这些数据中，最大价值的区域在哪里?”“它们有什么形状和价值?”以及“这些形状是如何分布的?”VTK提供了大量的技术来显示和分析数据，因为它存在于一个单一的时刻。探索具有时间范围的数据也很重要。一个人也想回答这样的问题。“随着时间的推移，这些形状是如何增长、移动和缩小的?”

由于VTK代表一个只有X、Y和Z坐标值的点，这个目标变得复杂了。添加T是不切实际的，因为向后兼容性需求和在T不重要的最常见情况下需要节省RAM。在可视化工具包的早期版本中，人们实现了各种解决方法来克服对时间支持的基本不足。例如，有时会加载多个属性数组集(每个时间步一个集合)，并告诉过滤器遍历这些集合。

创建这样的变通方法是困难的，不仅因为缺乏对VTK的支持，而且还因为存储时变数据的格式多种多样。一些从业者将整个数据集存储在一个顺序命名的文件中，用于每个时间点(定期或不定期采样)。另一些则将随时间变化的数据部分存储在一个或多个单独的文件中。有些像上面建议的那样将T坐标与X、Y和Z坐标一起存储，有些则以高度压缩的编码格式存储数据。

随着计算能力的增长和普及，对时变科学数据的探索和分析已经变得司空见惯。自5.2版以来，VTK包含了一个用于时变可视化的通用基础设施。该基础结构不浪费内存，并且向后兼容。在通常情况下，当时间无关紧要时，不会消耗额外的RAM或磁盘空间，并且大多数对时间不敏感的过滤器不需要任何修改。基础设施也是开放式的和可扩展的。除了支持flipbook风格的，这将允许人们回答上面提出的时间问题，它还允许人们以编程方式回答定量问题，例如:

•“在什么时候形状呈现最大体积?”

•“他们在什么时候行动最快?”

•“特定时间段内的平均属性值是多少?”

•“特定元素或位置的2D数值图是什么样的?”

11.2 VTK实施时间支持

VTK支持管道级别的时变数据。vtkExecutives是将相邻的vtkAlgorithms粘合在一起，从而组成管道的粘合剂。除了将算法连接在一起之外，高管还负责告诉每个算法该做什么。执行器通过在执行其附加的算法之前，在管道中上下传递元信息，即小块数据(存储在vtkInformation容器中)来实现这一点。例如，每个算法都有一个vtkInformation对象，该对象指定要填充的位置或空间子域。在进行时间可视化时，执行人员还会告诉每个算法何时或在什么时间点执行此操作。现在可以给每个算法一个vtkInformation对象，该对象指定处理应该发生在哪个时间子域中。

确切地说，管道现在支持时态可视化，因为它可以识别以下元信息键，并了解如何以及何时传输它们，并对它们的存在做出反应，以驱动过滤器的执行。

TIME_RANGE

该键由时变数据的读取器在管道的源或开始处注入到管道中。它包含两个浮点数，它们是读取器在时域范围内(换句话说)产生数据的最小和最大时间。

TIME_STEPS

当读取器产生的数据在离散的时间点上是精确的，这个键也会被时变数据的读取器注入到管道中。它包含任意数量的浮点数，这些浮点数可能被规则地或不规则地放置在时域内。

UPDATE_TIME_STEPS

该键被注入到管道的下游端。它包含一个或多个浮点数，这些浮点数对应于管道更新要处理的时间集。

DATA_TIME_STEPS

当更新请求到达读取器时，它可能能够也可能不能提供恰好在那个时间的结果。例如，渲染器可能会请求TIME_STEPS中两个点之间的时间。读取器将此键注入管道，以指示与响应请求产生的数据相对应的确切数据时间。

CONTINUE_EXECUTING

这个标志被注入到管道中，使管道保持迭代，以完成一组时间请求。

由于时间支持是在管道级别添加的，因此必须了解可视化管道是如何执行的，以便理解上述元信息引起的操作，从而理解VTK的时间支持可以用于什么。VTK的标准流媒体需求驱动管道分为四个阶段。同样的四个过程用于时变可视化，但它们通常(对于整个管道的子集或整个管道)在循环中迭代。

在第一次传递(称为REQUEST_DATA_OBJECT)期间，每个执行器创建一个算法所需的任何类型的空数据对象。例如，一个vtkjpereader会生成一个空的vtkImageData。当时间感知过滤器向上游非时间感知过滤器请求多个时间步长时，执行器将过滤器的输出类型更改为vtkTemporalDataSet。该输出充当每个请求时间产生的实际数据集的缓存。

在第二次传递(称为REQUEST_INFORMATION)期间，过滤器会生成关于它们将要创建的数据的任何轻量级元信息。例如，一个vtkjpereader将提供一个图像范围。这个通道从上游端开始，并向显示方向前进。在此期间，需要时间感知读取器注入它们的TIME_RANGE和TIME_STEPS键，下游过滤器和应用程序可以使用这些键来指导它们的操作。

在第三次传递(称为REQUEST_UPDATE_EXTENT)期间，过滤器从下游端开始并向读取器返回，它们同意需要输入的哪一部分来生成它们自己被请求的输出。正是在这一阶段，UPDATE_TIME_STEPS请求向后移动。

在最后一次传递(称为REQUEST_DATA)期间，算法实际上完成了请求它们的工作，这意味着对于时变数据，在请求的时间生成数据并填充DATA_TIME_STEPS参数。

起初，这似乎仍然是一种蛮力方法。人们仍然通过时间步进来制作flipbook动画，每次更新管道以绘制图像。在旧版本的VTK迭代循环中，在读取器上设置时间参数，然后呈现显示，经常这样做。在现代VTK中也是如此。从用户的角度来看，唯一的区别是所请求的时间是在呈现器而不是阅读器上设置的。然而，实施中的几个细节使VTK的新时间支持比以前更有效，更容易使用和更灵活。

首先，算法可以自由地请求和提供多次。这使得任何过滤器都可以同时考虑多个时间步，实际上合并了一个时间管道。这使得比翻页书更高级的时变可视化，例如时间步长之间的插值和高级运动模糊效果(时间轨迹)。

其次，执行者有能力自动迭代管道中没有时间意识的部分。这使得程序员不必显式地控制管道中的各个算法。要计算运行平均值，只需在平均过滤器上设置宽度或支持度作为参数，然后告诉管道执行一次。在此之前，通过显式地在多个通道上更新管道，并在每个通道上告诉读者运行平均值的活动部分所需的确切时间，可以完成此操作。

第三，执行者，甚至算法本身，都能够操纵元信息密钥，从而实现时间转移、缩放和回归等技术。这在将数据源规范化到公共参考框架等情况下非常有用。

最后，管道将缓存临时结果(也可以手动执行)，并且不会同时将读取器的所有结果保存在内存中。缓存可以大大提高速度，并使同一管道在不同时间点的比较可视化等技术变得有效。

使用时间支持

由VTK程序创建的默认管道由vtkStreamingDemandDrivenPipeline Executives连接的算法组成。此执行器不执行自动迭代或临时缓存。
因此，使用VTK进行时间分析的第一步是用更新的管道替换默认管道
这是高管阶层的做法。下面的代码片段就是这样做的。要使用它，只需在创建任何过滤器之前将这两行放在程序的顶部。

vtkSmartPointer<vtkCompositeDataPipeline> cdp =
vtkSmartPointer<vtkCompositeDataPipeline>::New();
vtkAlgorithm::SetDefaultExecutivePrototype(cdp);

与任何其他类型的数据一样，使用VTK可视化时变数据的最重要步骤是将数据转换为VTK管道可以处理的格式。正如第9章所解释的，这本质上意味着找到一个阅读器，它可以读取您正在处理的文件。如果数据是时变的，您还必须确保读者知道上面(2)中描述的新管道特性，或者换句话说是有时间意识的。

VTK的读者越来越多，他们有时间意识。示例包括(以及以下的子类和相关类):

•vtkExodusReader -读者桑迪亚国家实验室的Exodus文件格式

•vtkEnsightReader -读者CEI的EnSight文件格式

•vtkLSDynaReader -读者利弗莫尔软件技术公司的多物理场仿真软件包文件

•vtkXMLReader -读者Kitware的较新的基于XML的文件格式

一旦你找到这样的阅读器，使用它就变成了实例化阅读器的问题，设置一个文件名，并调用更新。您可以通过在阅读器上调用UpdateInformation以编程的方式从文件中获得可用的时间域，并且可以通过调用SetUpdateTimeStep(int port, double time)告诉它在特定时间更新，然后调用update()。

下面的代码段演示了如何实例化一个时间感知读取器并在文件中查询它的时域。

vtkSmartPointer<vtkGenericEnSightReader> r =
vtkSmartPointer<vtkGenericEnSightReader>::New();
r->SetCaseFileName(".../VTKData/Data/EnSight/naca.bin.case");
// Update meta-data. This reads time information and other meta-data.
r->UpdateInformation();
// The meta-data is in the output information
vtkInformation* outInfo = r->GetExecutive()->GetOutputInformation(0);
if (outInfo.Has(vtkStreamingDemandDrivenPipeline::TIME_STEPS()))
 {
 cout << "Times are:" << endl;
 for(int i=0; i<outInfo-
>Length(vtkStreamingDemandDrivenPipeline::TIME_STEPS()), i++)
 {
 cout << outInfo->Get(vtkStreamingDemandDrivenPipeline::TIME_STEPS(),
i) << endl;
 }
 }
else
 {
 cout << "That file has not time content." << endl;
 }

在VTK中，越来越多的读者有时间意识，但更多的读者没有时间意识。还有更多的文件格式还没有阅读器。读者到底需要做些什么来支持时间可视化?它必须至少做两件事。它必须宣布它拥有数据的时间范围，并且必须尊重管道请求它的时间。

在REQUEST_INFORMATION管道传递期间宣布范围。这可以通过填充TIME_STEPS和TIME_RANGE键来实现。

int vtkTimeAwareReader::RequestInformation(
 vtkInformation* vtkNotUsed(request),
 vtkInformationVector** vtkNotUsed(inputVector),
 vtkInformationVector* outputVector )
{
 vtkInformation* outInfo = outputVector->GetInformationObject(0);
 // Read the time information from the file here.
 // ...
 // Let timeValues be an array of times (type double)
 // nSteps is the number of time steps in the array.
 outInfo->Set(vtkStreamingDemandDrivenPipeline::TIME_STEPS(),
timeValue, nSteps);
 double timeRange[2];
timeRange[0] = timeValue[0];
 timeRange[1] = timeValue[nSteps - 1];
 outInfo->Set(vtkStreamingDemandDrivenPipeline::TIME_RANGE(),
timeRange, 2);
 return 1;
}

读取器在REQUEST_DATA传递期间找出当前请求的时间或次数，并相应地做出响应。时间请求来自UPDATE_TIME_STEPS键。

int vtkTimeAwareReader::RequestData(
 vtkInformation* vtkNotUsed(request),
 vtkInformationVector** vtkNotUsed(inputVector),
 vtkInformationVector* outputVector )
{
 vtkInformation* outInfo = outputVector->GetInformationObject(0);
 if (outInfo->Has(
vtkStreamingDemandDrivenPipeline::UPDATE_TIME_STEPS()))
 {
 // Get the requested time steps.
 int numRequestedTimeSteps = outInfo-
>Length(vtkStreamingDemandDrivenPipeline::UPDATE_TIME_STEPS());
 double* requestedTimeValues = outInfo-
>Get(vtkStreamingDemandDrivenPipeline::UPDATE_TIME_STEPS());
 double firstTime = requestedTimeValues[0];
 double lastTime = requestedTimeValues[numRequestedTimeSteps-1];
 // ...
 }
 // ..
 return 1;
}

读者可以随心所欲地解释这个请求。大多数人使用底函数来找到他们拥有数据的最接近的较小精确时间值。由于这个原因，提供阅读器产生的数据实际对应的确切时间是有用的。在输出数据对象中放置DATA_TIME_STEPS键可以做到这一点。

double myAnswerTime = this->Floor_in_timeValue(firstTime);
vtkDataObject *output= outInfo->Get(vtkDataObject::DATA_OBJECT());
output->GetInformation()->Set(vtkDataObject::DATA_TIME_STEPS(),
&myAnswerTime, 1);

在任何给定的调用中，许多读取器只能满足一个时间请求。在这种情况下，他们可以自由地生成任何特定的vtkDataSet子类。它们通常只处理前面代码中第一个请求的值。其他阅读器可以有效地满足多个时间请求。一个例子可能是阅读器的实现，用于文件格式，该格式仅存储在后续时间步骤中更改的值。在这种情况下，数据常量部分的浅拷贝是有效的。当阅读器可以多次提供数据时，它必须生成一个vtkTemporalDataSet，并为每个答案填充数据。下面是过滤器如何创建时间为0.1和0.3的数据集。

vtkSmartPointer<vtkTemporalDataSet>tds =
vtkSmartPointer<vtkTemporalDataSet>::New();
vtkSmartPointer<vtkPolyData> pd0 = vtkSmartPointer<vtkPolyData>::New();
pd0->GetInformation()->Append(vtkDataObject::DATA_TIME_STEPS(), 0.1);
tds->SetTimeStep(0, pd0);
vtkSmartPointer<vtkPolyData> pd1 = vtkSmartPointer<vtkPolyData>::New();
pd1->GetInformation()->Append(vtkDataObject::DATA_TIME_STEPS(), 0.3);
tds->SetTimeStep(1, pd1);
4) Time aware filters
(Time aware filters using)

在VTK中也有越来越多的时间感知滤波器。时态统计过滤器就是一个例子。它计算所有时间步长的输入数据中每个点和单元格的所有属性值的平均值、最小值和最大值以及标准偏差等统计信息。
在大多数情况下，如果您正在使用适当的执行器，并且在管道中有一个时间感知源或读取器，那么使用时间感知过滤器与使用任何标准过滤器没有什么不同。只需设置管道并调用update。下面的代码演示。

vtkSmartPointer<vtkTemporalStatistics> ts =
vtkSmartPointer<vtkTemporalStatistics>::New()
ts->SetInputConnection(r->GetOutputPort())
ts->Update()
cout
 << ts->GetOutput()->GetBlock(0)->GetPointData()->GetArray(1)-
>GetName()
 << endl;
cout
 << ts->GetOutput()->GetBlock(0)->GetPointData()->GetArray(1)-
>GetTuple1(0)
 << endl;
(Time aware filters creating)

尽管VTK中时间感知滤波器的数量正在增长，但它永远不会涵盖所有可能的时间分析技术。当您发现工具箱缺少所需的技术时，您可以编写一个新的过滤器。时间感知过滤器必须能够与执行器合作，以便操纵时间维度以完成其工作。例如，时态统计过滤器检查其输入上的所有时间步骤，并总结信息。在这样做的过程中，它从下游过滤器的考虑中删除了时间。绘制随时间变化的值的图形过滤器也做同样的事情。输出图沿着x轴有时间，它是“永恒的”，它本身不会随着时间的移动而改变。这样做的过滤器应该从REQUEST_INFORMATION传递的输出中删除TIME键。

int vtkTemporalStatistics::RequestInformation(
 vtkInformation *vtkNotUsed(request),
 vtkInformationVector **vtkNotUsed(inputVector),
 vtkInformationVector *outputVector)
{
 vtkInformation *outInfo = outputVector->GetInformationObject(0);
 // The output data of this filter has no time associated with it. It
is the
 // result of computations that happen over all time.
 outInfo->Remove(vtkStreamingDemandDrivenPipeline::TIME_STEPS());
 outInfo->Remove(vtkStreamingDemandDrivenPipeline::TIME_RANGE());
 return 1;
}

时态统计过滤器生成单个值，但它需要请求自己的输入来生成它所能生成的所有时间步长。它填充UPDATE_TIME_STEPS键，以询问输入过滤器为什么时间生成数据。注意，此过滤器一次只需要检查一个时间步长，实际上是在聚合结果时流式处理时间。因此，在本例中，我们只要求下一个时间步长。其他过滤器可能会请求多个时间步，或者所有时间步，但在这样做时应注意不要占用内存。

int vtkTemporalStatistics::RequestUpdateExtent(
 vtkInformation *vtkNotUsed(request),
 vtkInformationVector **inputVector,
 vtkInformationVector *vtkNotUsed(outputVector))
{
 vtkInformation *inInfo = inputVector[0]->GetInformationObject(0);
 // The RequestData method will tell the pipeline Executive to iterate
the
 // upstream pipeline to get each time step in order. On every
iteration,
 // this method will be called first which gives this filter the
opportunity
 // to ask for the next time step.
 double *inTimes = inInfo-
>Get(vtkStreamingDemandDrivenPipeline::TIME_STEPS());
 if (inTimes)
 {
 inInfo->Set(vtkStreamingDemandDrivenPipeline::UPDATE_TIME_STEPS(),
 &inTimes[this->CurrentTimeIndex], 1);
 }
 return 1;
}

此过滤器一次检查一个时间步骤，因此它需要遍历所有时间步骤以产生正确的结果。应用程序不必为我们做迭代，因为过滤器可以告诉Executive自己去做。它设置continue_execution()标志来执行循环。在第一次调用时，过滤器设置循环并设置标志。这将导致REQUEST_UPDATE_EXTENT和REQUEST_DATA传递持续发生，直到过滤器决定删除该标志。在每次迭代中，过滤器请求不同的时间步长(参见上面的RequestUpdateExtent)。在检查了所有的时间步骤后，它清除了旗帜。此时，输出将具有计算出的总体统计信息。

int vtkTemporalStatistics::RequestData(vtkInformation *request,
 vtkInformationVector **inputVector,
 vtkInformationVector *outputVector)
{
 vtkInformation *inInfo = inputVector[0]->GetInformationObject(0);
 vtkInformation *outInfo = outputVector->GetInformationObject(0);
 vtkDataObject *input = vtkDataObject::GetData(inInfo);
 vtkDataObject *output = vtkDataObject::GetData(outInfo);
 if (this->CurrentTimeIndex == 0)
 {
 // First execution, initialize arrays.
 this->InitializeStatistics(input, output);
 }
 else
 {
 // Subsequent execution, accumulate new data.
 this->AccumulateStatistics(input, output);
 }
 this->CurrentTimeIndex++;
 if ( this->CurrentTimeIndex
 < inInfo-
>Length(vtkStreamingDemandDrivenPipeline::TIME_STEPS()))
 {
 // There is still more to do.
 request-
>Set(vtkStreamingDemandDrivenPipeline::CONTINUE_EXECUTING(), 1);
 }
 else
 {
 // We are done. Finish up.
 this->PostExecute(input, output);
 request-
>Remove(vtkStreamingDemandDrivenPipeline::CONTINUE_EXECUTING());
this->CurrentTimeIndex = 0;
 }
 return 1;
}

在前面的示例中，过滤器被编写为每次查看一个时间步骤。对于其他操作，这可能不太实际，例如几何插值需要两个时间步长。这个示例演示了过滤器如何同时请求多个时间步并一起处理它们。要请求多个时间步骤，可以将UPDATE_TIME_STEPS设置为在REQUEST_UPDATE_EXTENT传递期间包含多个值。

int vtkSimpleTemporalInterpolator::RequestUpdateExtent (
 vtkInformation * vtkNotUsed(request),
 vtkInformationVector **inputVector,
 vtkInformationVector *outputVector)
{
 // get the info objects
 vtkInformation* outInfo = outputVector->GetInformationObject(0);
 vtkInformation *inInfo = inputVector[0]->GetInformationObject(0);
 // Find the time step requested by downstream
 if (outInfo-
>Has(vtkStreamingDemandDrivenPipeline::UPDATE_TIME_STEPS()))
 {
 if (outInfo-
>Length(vtkStreamingDemandDrivenPipeline::UPDATE_TIME_STEPS()) != 1)
 {
 vtkErrorMacro("This filter can only handle 1 time request");
 return 0;
 }
 upTime =
 outInfo-
>Get(vtkStreamingDemandDrivenPipeline::UPDATE_TIME_STEPS())[0];
 double inUpTimes[2];
// Find two time steps that surround upTime here and set inUpTimes
// This requests two time steps from upstream.
 inInfo->Set(vtkStreamingDemandDrivenPipeline::UPDATE_TIME_STEPS(),
 inUpTimes, 2);
 }
 return 1;
}

现在，REQUEST_DATA将只被调用一次，但是当它被调用时，它将得到一个包含两个时间步长的临时数据集。这些可以提取和处理如下:

int vtkSimpleTemporalInterpolator::RequestData(
 vtkInformation *vtkNotUsed(request),
vtkInformationVector **inputVector,
 vtkInformationVector *outputVector)
{
 vtkInformation *inInfo = inputVector[0]->GetInformationObject(0);
 vtkInformation *outInfo = outputVector->GetInformationObject(0);
 vtkTemporalDataSet *inData = vtkTemporalDataSet::SafeDownCast(
 inInfo->Get(vtkDataObject::DATA_OBJECT()));
 vtkTemporalDataSet *outData = vtkTemporalDataSet::SafeDownCast(
 outInfo->Get(vtkDataObject::DATA_OBJECT()));
 // get the input times
 double *inTimes = inData->GetInformation()-
>Get(vtkDataObject::DATA_TIME_STEPS());
 int numInTimes = inData->GetInformation()-
>Length(vtkDataObject::DATA_TIME_STEPS());
 // get the requested update time
 upTime =
 outInfo-
>Get(vtkStreamingDemandDrivenPipeline::UPDATE_TIME_STEPS())[0];
 vtkDataObject *in0 = inData->GetTimeStep(0);
 vtkDataObject *in1 = inData->GetTimeStep(1);
 // Interpolate in0 and in1 at upTime and produce outData here.
 // set the resulting time
 outData->GetInformation()->Set(vtkDataObject::DATA_TIME_STEPS(),
 upTime, 1);
 return 1;
}

本书为英文翻译而来，供学习vtk.js的人参考。