上篇文章（VTK----VTK数据结构详解（计算机篇）-CSDN博客）从计算机数据结构（数组、链表等）的角度对数据数组、数据对象、数据属性的实现原理进行了说明，下面从代码的层面详细说明它们的使用及相关实现逻辑。

1 数据数组

以vtkFloatArray为例，下面是它的使用及其VTK内部实现的代码：

vtkNew<vtkFloatArray> scalars;
scalars->InsertTuple1(0, 1);

void vtkDataArray::InsertTuple1(vtkIdType i, double value)
{int numComp = this->GetNumberOfComponents();if (numComp != 1){vtkErrorMacro("The number of components do not match the number requested: " << numComp << " != 1");}this->InsertTuple(i, &value);
}template <class ValueTypeT>
void vtkAOSDataArrayTemplate<ValueTypeT>::InsertTuple(vtkIdType tupleIdx, const double* tuple)
{if (this->EnsureAccessToTuple(tupleIdx)){// See note in SetTuple about std::copy vs for loops on MSVC.const vtkIdType valueIdx = tupleIdx * this->NumberOfComponents;ValueTypeT* data = this->Buffer->GetBuffer() + valueIdx;for (int i = 0; i < this->NumberOfComponents; ++i){data[i] = static_cast<ValueType>(tuple[i]);}this->MaxId = std::max(this->MaxId, valueIdx + this->NumberOfComponents - 1);}
}template <class DerivedT, class ValueTypeT>
bool vtkGenericDataArray<DerivedT, ValueTypeT>::EnsureAccessToTuple(vtkIdType tupleIdx)
{if (tupleIdx < 0){return false;}vtkIdType minSize = (1 + tupleIdx) * this->NumberOfComponents;vtkIdType expectedMaxId = minSize - 1;if (this->MaxId < expectedMaxId){if (this->Size < minSize){if (!this->Resize(tupleIdx + 1)){return false;}}this->MaxId = expectedMaxId;}return true;
}

从代码可以看出，插入值采用的是数组指针偏移的方式。插入前，通过EnsureAccessToTuple函数先检查是否需要Resize。插入时，指针偏移tupleIdx * NumberOfComponents，tupleIdx是当前准备在元组中插入的索引位置，NumberOfComponents是元组大小（可以理解为子一级的数组，子一级数组大小是固定值），上面的例子调用的是InsertTuple1，对应是一元组，所以NumberOfComponents等于1。在vtkDataArray.h中可以看到其提供了InsertTuple1、InsertTuple2、InsertTuple3、InsertTuple4、InsertTuple6、InsertTuple9这些接口分别用于插入对应大小的元组元素。

2 数据对象

vtkPolyData

上一篇文章提到vtkPolyData通过维护四个单独的列表（顶点（vertices）、线（lines）、多边形（polygons）和三角形带（triangle strips））来间接表示单元的类型，下面通过一个例子来看看它的使用。

#include <vtkAutoInit.h>
VTK_MODULE_INIT(vtkRenderingOpenGL2);
VTK_MODULE_INIT(vtkInteractionStyle);
VTK_MODULE_INIT(vtkRenderingFreeType);
VTK_MODULE_INIT(vtkRenderingVolumeOpenGL2);
#include <vtkActor.h>
#include <vtkNamedColors.h>
#include <vtkPolyData.h>
#include <vtkPolyDataMapper.h>
#include <vtkProperty.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkRenderer.h>
#include <vtkSphereSource.h>
#include <vtkOpenGLRenderer.h>
#include <vtkOpenGLState.h>int main(int, char*[])
{vtkNew<vtkNamedColors> colors;static double pts[25][3] = {{0.00, 1.00, 0.00   }, {0.00, 0.71, 0.71   }, {0.00, 0.00, 1.00   }, {0.00, -0.71, 0.71  }, {0.00, -1.00, 0.00  }, {0.00, 1.00, 0.00   }, {0.71, 0.71, 0.00   }, {1.00, 0.00, 0.00   }, {0.71, -0.71, 0.00  }, {0.00, -1.00, 0.00  }, {0.00, 1.00, 0.00   }, {0.00, 0.71, -0.71  }, {0.00, 0.00, -1.00  }, {0.00, -0.71, -0.71 }, {0.00, -1.00, 0.00  }, {0.00, 1.00, 0.00   }, {-0.71, 0.71, 0.00  }, {-1.00, 0.00, 0.00  }, {-0.71, -0.71, 0.00 }, {0.00, -1.00, 0.00  }, {0.00, 1.00, 0.00   }, {0.00, 0.71, 0.71   }, {0.00, 0.00, 1.00   }, {0.00, -0.71, 0.71  }, {0.00, -1.00, 0.00  }} ;static vtkIdType lines[80][2] = {{0, 5    }, {0, 1    }, {1, 6    }, {5, 6    }, {5, 1    }, {1, 6    }, {1, 2    }, {2, 7    }, {6, 7    }, {6, 2    }, {2, 7    }, {2, 3    }, {3, 8    }, {7, 8    }, {7, 3    }, {3, 8    }, {3, 4    }, {4, 9    }, {8, 9    }, {8, 4    }, {5, 10   }, {5, 6    }, {6, 11   }, {10, 11  }, {10, 6   }, {6, 11   }, {6, 7    }, {7, 12   }, {11, 12  }, {11, 7   }, {7, 12   }, {7, 8    }, {8, 13   }, {12, 13  }, {12, 8   }, {8, 13   }, {8, 9    }, {9, 14   }, {13, 14  }, {13, 9   }, {10, 15  }, {10, 11  }, {11, 16  }, {15, 16  }, {15, 11  }, {11, 16  }, {11, 12  }, {12, 17  }, {16, 17  }, {16, 12  }, {12, 17  }, {12, 13  }, {13, 18  }, {17, 18  }, {17, 13  }, {13, 18  }, {13, 14  }, {14, 19  }, {18, 19  }, {18, 14  }, {15, 20  }, {15, 16  }, {16, 21  }, {20, 21  }, {20, 16  }, {16, 21  }, {16, 17  }, {17, 22  }, {21, 22  }, {21, 17  }, {17, 22  }, {17, 18  }, {18, 23  }, {22, 23  }, {22, 18  }, {18, 23  }, {18, 19  }, {19, 24  }, {23, 24  }, {23, 19  }};static vtkIdType strips[32][3] = {{0, 5, 1    }, {5, 1, 6    }, {1, 6, 2    }, {6, 2, 7    }, {2, 7, 3    }, {7, 3, 8    }, {3, 8, 4    }, {8, 4, 9    }, {5, 10, 6   }, {10, 6, 11  }, {6, 11, 7   }, {11, 7, 12  }, {7, 12, 8   }, {12, 8, 13  }, {8, 13, 9   }, {13, 9, 14  }, {10, 15, 11 }, {15, 11, 16 }, {11, 16, 12 }, {16, 12, 17 }, {12, 17, 13 }, {17, 13, 18 }, {13, 18, 14 }, {18, 14, 19 }, {15, 20, 16 }, {20, 16, 21 }, {16, 21, 17 }, {21, 17, 22 }, {17, 22, 18 }, {22, 18, 23 }, {18, 23, 19 }, {23, 19, 24 }};vtkIdType numVerts = 25;vtkIdType numLines = 80;vtkIdType numStrips = 32;vtkIdType numCells = numVerts + numLines + numStrips;vtkIdType i;vtkPoints* points = vtkPoints::New();points->SetNumberOfPoints(25);for (i = 0; i < 25; i++){points->InsertPoint(i, pts[i]);}vtkSmartPointer<vtkPolyData> poly = vtkSmartPointer<vtkPolyData>::New();poly->AllocateExact(numCells, numCells);poly->SetPoints(points);points->Delete();for (i = 0; i < numVerts; i++){poly->InsertNextCell(VTK_VERTEX, 1, &i);}for (i = 0; i < numLines; i++){poly->InsertNextCell(VTK_LINE, 2, lines[i]);}for (i = 0; i < numStrips; i++){poly->InsertNextCell(VTK_TRIANGLE_STRIP, 3, strips[i]);}poly->BuildCells();vtkNew<vtkPolyDataMapper> mapper;mapper->SetInputData(poly);vtkNew<vtkActor> actor;actor->SetMapper(mapper);actor->GetProperty()->SetLineWidth(6);actor->GetProperty()->SetPointSize(25);actor->GetProperty()->SetRenderLinesAsTubes(1);actor->GetProperty()->SetRenderPointsAsSpheres(1);actor->GetProperty()->SetColor(colors->GetColor3d("Cornsilk").GetData());vtkNew<vtkRenderer> renderer;vtkNew<vtkRenderWindow> renderWindow;renderWindow->SetSize(500, 500);renderWindow->AddRenderer(renderer);vtkNew<vtkRenderWindowInteractor> renderWindowInteractor;renderWindowInteractor->SetRenderWindow(renderWindow);renderer->AddActor(actor);renderer->SetBackground(colors->GetColor3d("DarkGreen").GetData());renderWindow->Render();renderWindowInteractor->Start();getchar();return EXIT_SUCCESS;
}

运行效果图如下：

从图中可以看到绘制了点、线、由三角网渲染出来的面。

vtkUnstructuredGrid

vtkUnstructuredGrid可以表示所有单元类型（规则和不规则的），下面通过一个例子来看看它的使用。

#include <vtkAutoInit.h>
VTK_MODULE_INIT(vtkRenderingOpenGL2);
VTK_MODULE_INIT(vtkInteractionStyle);
VTK_MODULE_INIT(vtkRenderingFreeType);
VTK_MODULE_INIT(vtkRenderingVolumeOpenGL2);
#include <vtkActor.h>
#include <vtkCamera.h>
#include <vtkCellType.h>
#include <vtkDataSetMapper.h>
#include <vtkNamedColors.h>
#include <vtkNew.h>
#include <vtkPoints.h>
#include <vtkProperty.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkRenderer.h>
#include <vtkUnstructuredGrid.h>int main(int, char*[])
{int i;static double x[27][3] = {{0, 0, 0}, {1, 0, 0}, {2, 0, 0}, {0, 1, 0}, {1, 1, 0}, {2, 1, 0},{0, 0, 1}, {1, 0, 1}, {2, 0, 1}, {0, 1, 1}, {1, 1, 1}, {2, 1, 1},{0, 1, 2}, {1, 1, 2}, {2, 1, 2}, {0, 1, 3}, {1, 1, 3}, {2, 1, 3},{0, 1, 4}, {1, 1, 4}, {2, 1, 4}, {0, 1, 5}, {1, 1, 5}, {2, 1, 5},{0, 1, 6}, {1, 1, 6}, {2, 1, 6}};static vtkIdType pts[12][8] = {{0, 1, 4, 3, 6, 7, 10, 9},      {1, 2, 5, 4, 7, 8, 11, 10},{6, 10, 9, 12, 0, 0, 0, 0},     {8, 11, 10, 14, 0, 0, 0, 0},{16, 17, 14, 13, 12, 15, 0, 0}, {18, 15, 19, 16, 20, 17, 0, 0},{22, 23, 20, 19, 0, 0, 0, 0},   {21, 22, 18, 0, 0, 0, 0, 0},{22, 19, 18, 0, 0, 0, 0, 0},    {23, 26, 0, 0, 0, 0, 0, 0},{21, 24, 0, 0, 0, 0, 0, 0},     {25, 0, 0, 0, 0, 0, 0, 0}};vtkNew<vtkNamedColors> colors;vtkNew<vtkRenderer> renderer;vtkNew<vtkRenderWindow> renWin;renWin->AddRenderer(renderer);vtkNew<vtkRenderWindowInteractor> iren;iren->SetRenderWindow(renWin);vtkNew<vtkPoints> points;for (i = 0; i < 27; i++) points->InsertPoint(i, x[i]);vtkNew<vtkUnstructuredGrid> ugrid;ugrid->Allocate(100);ugrid->InsertNextCell(VTK_HEXAHEDRON, 8, pts[0]);ugrid->InsertNextCell(VTK_HEXAHEDRON, 8, pts[1]);ugrid->InsertNextCell(VTK_TETRA, 4, pts[2]);ugrid->InsertNextCell(VTK_TETRA, 4, pts[3]);ugrid->InsertNextCell(VTK_POLYGON, 6, pts[4]);ugrid->InsertNextCell(VTK_TRIANGLE_STRIP, 6, pts[5]);ugrid->InsertNextCell(VTK_QUAD, 4, pts[6]);ugrid->InsertNextCell(VTK_TRIANGLE, 3, pts[7]);ugrid->InsertNextCell(VTK_TRIANGLE, 3, pts[8]);ugrid->InsertNextCell(VTK_LINE, 2, pts[9]);ugrid->InsertNextCell(VTK_LINE, 2, pts[10]);ugrid->InsertNextCell(VTK_VERTEX, 1, pts[11]);ugrid->SetPoints(points);vtkNew<vtkDataSetMapper> ugridMapper;ugridMapper->SetInputData(ugrid);vtkNew<vtkActor> ugridActor;ugridActor->SetMapper(ugridMapper);ugridActor->GetProperty()->SetColor(colors->GetColor3d("Peacock").GetData());ugridActor->GetProperty()->EdgeVisibilityOn();renderer->AddActor(ugridActor);renderer->SetBackground(colors->GetColor3d("Beige").GetData());renderer->ResetCamera();renderer->GetActiveCamera()->Elevation(60.0);renderer->GetActiveCamera()->Azimuth(30.0);renderer->GetActiveCamera()->Dolly(1.2);renWin->SetSize(640, 480);renWin->SetWindowName("UGrid)");// interact with datarenWin->Render();iren->Start();getchar();return EXIT_SUCCESS;
}

运行效果图如下：

3 数据模型

VTK中数据模型由单元（cell）和点（point）组成，点对应vtkPoints类，单元对应vtkCellArray类。

vtkPoints

vtkPoints用来表示和操作3D点。vtkPoints的数据模型是可通过（点或单元）id访问的vx-vy-vz三元组数组。

vtkPoints::vtkPoints(int dataType)
{this->Data = vtkFloatArray::New();this->Data->Register(this);this->Data->Delete();this->SetDataType(dataType);this->Data->SetNumberOfComponents(3);this->Data->SetName("Points");this->Bounds[0] = this->Bounds[2] = this->Bounds[4] = VTK_DOUBLE_MAX;this->Bounds[1] = this->Bounds[3] = this->Bounds[5] = -VTK_DOUBLE_MAX;
}

从vtkPoints类构造函数中的代码可以看出，它创建了一个vtkFloatArray数据数组，NumberOfComponents为3表示其为一个三元组。

  void InsertPoint(vtkIdType id, const float x[3]) VTK_EXPECTS(0 <= id){this->Data->InsertTuple(id, x);}void InsertPoint(vtkIdType id, const double x[3]) VTK_EXPECTS(0 <= id){this->Data->InsertTuple(id, x);}vtkIdType InsertNextPoint(const float x[3]) { return this->Data->InsertNextTuple(x); }vtkIdType InsertNextPoint(const double x[3]) { return this->Data->InsertNextTuple(x); }vtkIdType InsertNextPoint(double x, double y, double z);

InsertPoint和InsertNextPoint内部调用的是数据数组的InsertTuple和InsertNextTuple函数。

vtkCellArray

vtkCellArray用来表示单元内部连接性的对象。其将数据集的拓扑结构存为显示连接性（connectivity）表，表中列出组成每个单元的点ID。

在vtkCellArray内部，连接性表表示为两个数组：Offsets（偏移）和Connectivity（连接性）。Offsets是一个[numCells+1]值的数组，指示Connectivity数组中每个单元点开始的索引，最后一个值始终是Connectivity数组的长度。Connectivity数组存每个单元的点ID列表。因此，对于由两个三角形、一个四边形和一条线组成的数据集，内部数组将如下所示：

Topology:
---------
Cell 0: Triangle | point ids: {0, 1, 2}
Cell 1: Triangle | point ids: {5, 7, 2}
Cell 2: Quad     | point ids: {3, 4, 6, 7}
Cell 4: Line     | point ids: {5, 8}vtkCellArray (current):
-----------------------
Offsets:      {0, 3, 6, 10, 12}
Connectivity: {0, 1, 2, 5, 7, 2, 3, 4, 6, 7, 5, 8}

虽然此类提供了遍历方法（旧的InitTraversal()、GetNextCell()方法和较新的方法GetCellAtId()）,但这些方法通常不是线程安全的。最好使用本地线程安全的vtkCellArrayInterator对象，可以通过以下方式获取该对象：

auto iter = vtk::TakeSmartPointer(cellArray->NewIterator());
for (iter->GoToFirstCell(); !iter->IsDoneWithTraversal(); iter->GoToNextCell())
{// do work with iter
}

（但请注意，根据内部存的类型和结构，由于额外的数据复制，单元数组迭代器可能比直接遍历单元数组慢得多。另外，如果vtkCellArray内部存储被修改，迭代器可能变得无效。）

vtkCellArray内部的数组可以存32或64位的值，尽管大多数API更喜欢使用vtkIdType来对应数组中的元素。允许将64位存储于32位vtkIdType一起使用，但太大而无法容纳32位有符号整数的值在通过API访问时将被截断。（特定的内部存储类型对性能有影响，具体取决于vtkIdType。如果内部存储等效于vtkIdType，则返回指向点"id"数组的指针的方法可以共享内部存储，否则必须执行复制内存）。

/*--------------------------------------------------------------------------*/
/* Choose an implementation for vtkIdType.  */
#define VTK_HAS_ID_TYPE
#ifdef VTK_USE_64BIT_IDS
#if VTK_SIZEOF_LONG_LONG == 8
typedef long long vtkIdType;
#define VTK_ID_TYPE_IMPL VTK_LONG_LONG
#define VTK_SIZEOF_ID_TYPE VTK_SIZEOF_LONG_LONG
#define VTK_ID_MIN VTK_LONG_LONG_MIN
#define VTK_ID_MAX VTK_LONG_LONG_MAX
#define VTK_ID_TYPE_PRId "lld"
#elif VTK_SIZEOF_LONG == 8
typedef long vtkIdType;
#define VTK_ID_TYPE_IMPL VTK_LONG
#define VTK_SIZEOF_ID_TYPE VTK_SIZEOF_LONG
#define VTK_ID_MIN VTK_LONG_MIN
#define VTK_ID_MAX VTK_LONG_MAX
#define VTK_ID_TYPE_PRId "ld"
#else
#error "VTK_USE_64BIT_IDS is ON but no 64-bit integer type is available."
#endif
#else
typedef int vtkIdType;
#define VTK_ID_TYPE_IMPL VTK_INT
#define VTK_SIZEOF_ID_TYPE VTK_SIZEOF_INT
#define VTK_ID_MIN VTK_INT_MIN
#define VTK_ID_MAX VTK_INT_MAX
#define VTK_ID_TYPE_PRId "d"
#endif

InsertNextCell

InsertNextCell是用来插入单元的函数，各种数据对象中都有实现该接口，用以构造本对象中的各种类型的单元。下面我们通过vtkPolyData中InsertNextCell函数的内部实现代码看下它是如何构造单元的。

vtkIdType vtkPolyData::InsertNextCell(int type, vtkIdList* pts)
{return this->InsertNextCell(type, static_cast<int>(pts->GetNumberOfIds()), pts->GetPointer(0));
}vtkIdType vtkPolyData::InsertNextCell(int type, int npts, const vtkIdType ptsIn[])
{
...// Insert next cell into the lookup map:TaggedCellId& tag = this->Cells->InsertNextCell(VTKCellType(type));vtkCellArray* cells = this->GetCellArrayInternal(tag);// Validate and update the internal cell id:const vtkIdType internalCellId = cells->InsertNextCell(npts, pts);if (internalCellId < 0){vtkErrorMacro("Internal error: Invalid cell id (" << internalCellId << ").");return -1;}
...// Return the dataset cell id:return this->Cells->GetNumberOfCells() - 1;
}inline vtkCellArray* vtkPolyData::GetCellArrayInternal(vtkPolyData::TaggedCellId tag)
{switch (tag.GetTarget()){case vtkPolyData_detail::Target::Verts:return this->Verts;case vtkPolyData_detail::Target::Lines:return this->Lines;case vtkPolyData_detail::Target::Polys:return this->Polys;case vtkPolyData_detail::Target::Strips:return this->Strips;}return nullptr; // unreachable
}

vtkPolyData::InsertNextCell函数中调用：

vtkCellArray* cells = this->GetCellArrayInternal(tag);

获取当前要插入单元的类型对应的vtkCellArray。然后调用：

const vtkIdType internalCellId = cells->InsertNextCell(npts, pts);

插入单元到vtkCellArray。

inline vtkIdType vtkCellArray::InsertNextCell(vtkIdType npts, const vtkIdType* pts)VTK_SIZEHINT(pts, npts)
{return this->Visit(vtkCellArray_detail::InsertNextCellImpl{}, npts, pts);
}template <typename Functor, typename... Args,typename = typename std::enable_if<!ReturnsVoid<Functor, Args...>::value>::type>
GetReturnType<Functor, Args...> Visit(Functor&& functor, Args&&... args)
{if (this->Storage.Is64Bit()){// If you get an error on the next line, a call to Visit(functor, Args...)// is being called with arguments that do not match the functor's call// signature. See the Visit documentation for details.return functor(this->Storage.GetArrays64(), std::forward<Args>(args)...);}else{// If you get an error on the next line, a call to Visit(functor, Args...)// is being called with arguments that do not match the functor's call// signature. See the Visit documentation for details.return functor(this->Storage.GetArrays32(), std::forward<Args>(args)...);}
}

Visit(Functor&& functor, Args&&... args)函数的第一个参数是一个InsertNextCellImpl对象（&&可以理解为std::move操作），第二个参数是一个可变参数列表。

functor(this->Storage.GetArrays64(), std::forward<Args>(args)...);调用的是InsertNextCellImpl中()操作符函数：

struct InsertNextCellImpl
{// Insert full celltemplate <typename CellStateT>vtkIdType operator()(CellStateT& state, const vtkIdType npts, const vtkIdType pts[]){using ValueType = typename CellStateT::ValueType;auto* conn = state.GetConnectivity();auto* offsets = state.GetOffsets();const vtkIdType cellId = offsets->GetNumberOfValues() - 1;offsets->InsertNextValue(static_cast<ValueType>(conn->GetNumberOfValues() + npts));for (vtkIdType i = 0; i < npts; ++i){conn->InsertNextValue(static_cast<ValueType>(pts[i]));}return cellId;}
...
};

operator()函数的第一个参数通过this->Storage.GetArrays64()获得。

  struct Storage{// Union type that switches 32 and 64 bit array storageunion ArraySwitch {ArraySwitch() = default;  // handled by Storage~ArraySwitch() = default; // handle by StorageVisitState<ArrayType32>* Int32;VisitState<ArrayType64>* Int64;};Storage(){
#ifdef VTK_USE_MEMKINDthis->Arrays =static_cast<ArraySwitch*>(vtkObjectBase::GetCurrentMallocFunction()(sizeof(ArraySwitch)));
#elsethis->Arrays = new ArraySwitch;
#endif// Default to the compile-time setting:
#ifdef VTK_USE_64BIT_IDSthis->Arrays->Int64 = new VisitState<ArrayType64>;this->StorageIs64Bit = true;#else // VTK_USE_64BIT_IDSthis->Arrays->Int32 = new VisitState<ArrayType32>;this->StorageIs64Bit = false;#endif // VTK_USE_64BIT_IDS
#ifdef VTK_USE_MEMKINDif (vtkObjectBase::GetUsingMemkind()){this->IsInMemkind = true;}
#else(void)this->IsInMemkind; // comp warning workaround
#endif}...// Get the VisitState for 32-bit arraysVisitState<ArrayType32>& GetArrays32(){assert(!this->StorageIs64Bit);return *this->Arrays->Int32;}const VisitState<ArrayType32>& GetArrays32() const{assert(!this->StorageIs64Bit);return *this->Arrays->Int32;}// Get the VisitState for 64-bit arraysVisitState<ArrayType64>& GetArrays64(){assert(this->StorageIs64Bit);return *this->Arrays->Int64;}const VisitState<ArrayType64>& GetArrays64() const{assert(this->StorageIs64Bit);return *this->Arrays->Int64;}private:// Access restricted to ensure proper union construction/destruction thru// API.ArraySwitch* Arrays;bool StorageIs64Bit;bool IsInMemkind = false;};

Storage内通过联合体（union）管理一个32位或64位的VisitState。

  template <typename ArrayT>struct VisitState{using ArrayType = ArrayT;using ValueType = typename ArrayType::ValueType;using CellRangeType = decltype(vtk::DataArrayValueRange<1>(std::declval<ArrayType>()));// We can't just use is_same here, since binary compatible representations// (e.g. int and long) are distinct types. Instead, ensure that ValueType// is a signed integer the same size as vtkIdType.// If this value is true, ValueType pointers may be safely converted to// vtkIdType pointers via reinterpret cast.static constexpr bool ValueTypeIsSameAsIdType = std::is_integral<ValueType>::value &&std::is_signed<ValueType>::value && (sizeof(ValueType) == sizeof(vtkIdType));ArrayType* GetOffsets() { return this->Offsets; }const ArrayType* GetOffsets() const { return this->Offsets; }ArrayType* GetConnectivity() { return this->Connectivity; }const ArrayType* GetConnectivity() const { return this->Connectivity; }...friend class vtkCellArray;protected:VisitState(){this->Connectivity = vtkSmartPointer<ArrayType>::New();this->Offsets = vtkSmartPointer<ArrayType>::New();this->Offsets->InsertNextValue(0);if (vtkObjectBase::GetUsingMemkind()){this->IsInMemkind = true;}}vtkSmartPointer<ArrayType> Connectivity;vtkSmartPointer<ArrayType> Offsets;...};

回到InsertNextCellImpl的operator()函数。我们可以看到，函数中根据InsertNextCell传入的单元类型对应的点数（npts）在进行遍历，依次插入单元对应的点的索引集合；将conn->GetNumberOfValues() + npts（当前已经插入的索引值总数+要插入单元的元组大小）的值作为偏移值插入Offsets数组中。

4 数据属性

vtkPointData 和 vtkCellData

上一篇文章讲到数据属性通常与点和单元关联关联的（也可以通过GetFieldData()关联到整个数据模型），VTK中使用vtkPointData和vtkCellData分别表示数据点和单元的属性，它们都是vtkFieldData的子类。下面我们通过一个例子来看下它们的使用。

#include <vtkAutoInit.h>
VTK_MODULE_INIT(vtkRenderingOpenGL2);
VTK_MODULE_INIT(vtkInteractionStyle);
VTK_MODULE_INIT(vtkRenderingFreeType);
VTK_MODULE_INIT(vtkRenderingVolumeOpenGL2);
#include <vtkActor.h>
#include <vtkArrowSource.h>
#include <vtkCamera.h>
#include <vtkGlyph3D.h>
#include <vtkNamedColors.h>
#include <vtkNew.h>
#include <vtkPolyData.h>
#include <vtkPolyDataMapper.h>
#include <vtkProperty.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkRenderer.h>
#include <vtkCubeSource.h>
#include <vtkCellArray.h>
#include <vtkFloatArray.h>
#include <vtkPointData.h>
#include <vtkCellData.h>
#include <vtkPoints.h>int main(int, char*[])
{vtkNew<vtkNamedColors> colors;std::array<std::array<double, 3>, 8> pts = {{{{0, 0, 0}},{{1, 0, 0}},{{1, 1, 0}},{{0, 1, 0}},{{0, 0, 1}},{{1, 0, 1}},{{1, 1, 1}},{{0, 1, 1}}}};// The ordering of the corner points on each face.std::array<std::array<vtkIdType, 4>, 6> ordering = {{{{0, 3, 2, 1}},{{4, 5, 6, 7}},{{0, 1, 5, 4}},{{1, 2, 6, 5}},{{2, 3, 7, 6}},{{3, 0, 4, 7}}}};std::array<std::array<double, 3>, 8> vertex_normals;     for(auto i = 0; i < 8; ++i){for(auto j = 0; j < 3; ++j){vertex_normals[i][j] = pts[i][j] - 0.5;}}       // We'll create the building blocks of polydata including data attributes.vtkNew<vtkPolyData> cube;vtkNew<vtkPoints> points;vtkNew<vtkCellArray> polys;vtkNew<vtkFloatArray> vertex_normals_array;vtkNew<vtkFloatArray> scalar_array;// Load the point, cell, and data attributes.for (auto i = 0ul; i < pts.size(); ++i){points->InsertPoint(i, pts[i].data());}for (auto&& i : ordering){polys->InsertNextCell(vtkIdType(i.size()), i.data());}vertex_normals_array->SetNumberOfComponents(3);for(auto i = 0; i < vertex_normals.size(); ++i){vertex_normals_array->InsertNextTuple3(vertex_normals[i][0], vertex_normals[i][1], vertex_normals[i][2]);}scalar_array->SetNumberOfComponents(1);for(auto i = 0; i < ordering.size(); ++i){scalar_array->InsertNextTuple1(i);}// We now assign the pieces to the vtkPolyData.cube->SetPoints(points);cube->SetPolys(polys);cube->GetPointData()->SetNormals(vertex_normals_array);cube->GetCellData()->SetScalars(scalar_array);vtkNew<vtkPolyData> input;input->ShallowCopy(cube);vtkNew<vtkArrowSource> arrowSource;vtkNew<vtkGlyph3D> glyph3D;glyph3D->SetSourceConnection(arrowSource->GetOutputPort());glyph3D->SetInputData(input);glyph3D->ScalingOn();glyph3D->SetVectorModeToUseNormal();glyph3D->SetScaleFactor(0.25);glyph3D->Update();// VisualizevtkNew<vtkPolyDataMapper> mapper;mapper->SetInputConnection(glyph3D->GetOutputPort());vtkNew<vtkPolyDataMapper> cube_mapper;cube_mapper->SetInputData(cube);cube_mapper->SetScalarRange(cube->GetScalarRange());vtkNew<vtkActor> actor;actor->SetMapper(mapper);actor->GetProperty()->SetColor(colors->GetColor3d("Gold").GetData());vtkNew<vtkActor> cube_actor;cube_actor->SetMapper(cube_mapper);vtkNew<vtkRenderer> renderer;vtkNew<vtkRenderWindow> renderWindow;renderWindow->AddRenderer(renderer);renderWindow->SetWindowName("OrientedGlyphs");vtkNew<vtkRenderWindowInteractor> renderWindowInteractor;renderWindowInteractor->SetRenderWindow(renderWindow);renderer->AddActor(actor);renderer->AddActor(cube_actor);renderer->SetBackground(colors->GetColor3d("DarkGreen").GetData());renderWindow->Render();renderWindowInteractor->Start();getchar();return EXIT_SUCCESS;
}

运行效果如下：

上面的代码中：

cube->GetPointData()->SetNormals(vertex_normals_array);将法向量数据数组设置给点，所以从图中可以看到箭头是在点的位置进行显示。

cube->GetCellData()->SetScalars(scalar_array);将标量数据数组设置给单元，可以看到每个单元（面）根据标量显示不同的颜色。

数据属性不仅仅只包含标量、向量，其所能支持的类型包括以下这些：

  // Always keep NUM_ATTRIBUTES as the last entryenum AttributeTypes{SCALARS = 0,VECTORS = 1,NORMALS = 2,TCOORDS = 3,TENSORS = 4,GLOBALIDS = 5,PEDIGREEIDS = 6,EDGEFLAG = 7,TANGENTS = 8,RATIONALWEIGHTS = 9,HIGHERORDERDEGREES = 10,NUM_ATTRIBUTES};

Ghost属性

考虑如下图所示的提取外表面（face）的操作。外表面操作用于识别没有本地邻居的所有面。当我们把这些面片放置一起时，我们发现一些面被错误地识别为外部面。当两个相邻的单元被放置在单独的处理中时，这些面的错误识别就会发生。

上图提取外部面结果错误是因为处理中丢失了一些重要的全局信息，这些单独的处理过程不需要所有的数据，但需要一些不属于它们自己数据，即它们需要知道相邻的其他分区中的单元。

这个问题可以通过引入Ghost单元来解决这个局部/全局问题。Ghost单元是属于数据的一个分区并重复在其他分区上的单元。Ghost单元的引入是通过领域信息进行的，并按层次进行组织。对于给定的分区，与分区中的单元相邻但不属于分区本身的任何单元都是Ghost单元1。与不属于层次1或原始分区层次1的Ghost单元相邻的任何单元都处于层次2。递归定义更深的层次。

将Ghost引用到提取外表面的示例中，效果如下图，图中某些面仍然被分类为外表面，但是，所有这些面都附着在Ghost单元上。这些Ghost面很容易被剔除，最终结果就是合适的外表面。

下面通过一个例子来看看VTK中Ghost单元的使用：

#include <vtkAutoInit.h>
VTK_MODULE_INIT(vtkRenderingOpenGL2);
VTK_MODULE_INIT(vtkInteractionStyle);
VTK_MODULE_INIT(vtkRenderingFreeType);
VTK_MODULE_INIT(vtkRenderingVolumeOpenGL2);
#include "vtkActor.h"
#include "vtkCellData.h"
#include "vtkCellType.h"
#include "vtkDataSetSurfaceFilter.h"
#include "vtkGeometryFilter.h"
#include "vtkNew.h"
#include "vtkPoints.h"
#include "vtkPolyDataMapper.h"
#include "vtkRegressionTestImage.h"
#include "vtkRenderWindow.h"
#include "vtkRenderWindowInteractor.h"
#include "vtkRenderer.h"
#include "vtkSmartPointer.h"
#include "vtkUnsignedCharArray.h"
#include "vtkUnstructuredGrid.h"
#include "vtkFloatArray.h"
#include "vtkColorTransferFunction.h"
#include "vtkTextActor.h"
#include "vtkTextProperty.h"
#include "vtkCamera.h"
#include "vtkCallbackCommand.h"
#include "vtkRendererCollection.h"
#include "vtkActor2DCollection.h"void CallbackFunction(vtkObject* caller, long unsigned int eventId,void* clientData, void* callData)
{vtkRenderWindowInteractor* iren = static_cast<vtkRenderWindowInteractor*>(caller);vtkRenderer* renderer = iren->GetRenderWindow()->GetRenderers()->GetFirstRenderer();if(clientData == nullptr)return;auto points = static_cast<vtkPoints*>(clientData);auto ac = renderer->GetActors2D();vtkActor2D* anActor;vtkCollectionSimpleIterator ait;for (ac->InitTraversal(ait); (anActor = ac->GetNextActor2D(ait));){auto ta = vtkTextActor::SafeDownCast(anActor);if(ta == nullptr) continue;std::string text = ta->GetInput();int idx = std::stoi(text);auto pt = points->GetPoint(idx);renderer->WorldToDisplay(pt[0], pt[1], pt[2]);ta->SetDisplayPosition(pt[0], pt[1]);}
}int main(int argc, char* argv[])
{vtkNew<vtkPoints> points;points->InsertPoint(0, 0, 0, 0);points->InsertPoint(1, 1, 0, 0);points->InsertPoint(2, 0.5, 1, 0);points->InsertPoint(3, 0.5, 0.5, 1);points->InsertPoint(4, 0.5, -1, 0);points->InsertPoint(5, 0.5, -0.5, 1);vtkIdType v[3][4] = { { 0, 1, 2, 3 }, { 0, 4, 1, 5 }, { 5, 3, 1, 0 } };//vtkIdType v[3][4] = { { 0, 1, 2, 3 }, { 5, 3, 1, 0 }, { 0, 4, 1, 5 } };vtkSmartPointer<vtkUnstructuredGrid> grid = vtkSmartPointer<vtkUnstructuredGrid>::New();grid->InsertNextCell(VTK_TETRA, 4, v[0]);grid->InsertNextCell(VTK_TETRA, 4, v[1]);grid->InsertNextCell(VTK_TETRA, 4, v[2]);grid->SetPoints(points);vtkNew<vtkFloatArray> cell_scalar_array;cell_scalar_array->SetNumberOfComponents(1);cell_scalar_array->InsertNextTuple1(0);cell_scalar_array->InsertNextTuple1(3);cell_scalar_array->InsertNextTuple1(7);grid->GetCellData()->SetScalars(cell_scalar_array);// vtkNew<vtkUnsignedCharArray> ghosts;// ghosts->InsertNextValue(0);// ghosts->InsertNextValue(1);// ghosts->InsertNextValue(2);// ghosts->SetName(vtkDataSetAttributes::GhostArrayName()); // grid->GetCellData()->AddArray(ghosts);// this filter removes the ghost cellsvtkNew<vtkGeometryFilter> surfaces;surfaces->SetInputData(grid);surfaces->Update(); vtkNew<vtkColorTransferFunction> clrTransferFunc;clrTransferFunc->SetColorSpaceToRGB();clrTransferFunc->AddRGBPoint(0, 1, 0, 0);clrTransferFunc->AddRGBPoint(3, 0, 1, 0);clrTransferFunc->AddRGBPoint(7, 0, 1, 1);vtkNew<vtkPolyDataMapper> mapper;mapper->SetInputConnection(surfaces->GetOutputPort());mapper->SetScalarRange(grid->GetScalarRange());mapper->SetLookupTable(clrTransferFunc);vtkNew<vtkActor> actor;actor->SetMapper(mapper);vtkNew<vtkCamera> camera;camera->SetPosition(0, 0, 5);camera->SetFocalPoint(0, 0, 0);vtkNew<vtkRenderer> renderer;renderer->SetActiveCamera(camera);renderer->ResetCamera();renderer->AddActor(actor);vtkNew<vtkRenderWindow> renwin;renwin->AddRenderer(renderer);renwin->SetSize(500, 500);vtkNew<vtkRenderWindowInteractor> iren;iren->SetRenderWindow(renwin);iren->Initialize();vtkNew<vtkCallbackCommand> callback;callback->SetCallback(CallbackFunction);callback->SetClientData(points);iren->AddObserver(vtkCommand::LeftButtonPressEvent, callback);for(int i = 0; i < points->GetNumberOfPoints(); ++i){auto pt = points->GetPoint(i);std::string text = std::to_string(i);vtkNew<vtkTextActor> ta;ta->SetInput(text.c_str());ta->GetTextProperty()->SetColor(0.5, 1.0, 0.0);renderer->WorldToDisplay(pt[0], pt[1], pt[2]);ta->SetDisplayPosition(pt[0], pt[1]);ta->GetTextProperty()->SetFontSize(32);renderer->AddActor(ta.Get());}renwin->Render();iren->Start();getchar();return EXIT_SUCCESS;
}

没应用ghost单元代码的情况下，效果如下图：

应用ghost单元代码的情况下，效果如下图：

可以看到vtkGeometryFilter移除了第二个Ghost单元。将第二个单元和第三个单元顺序换一下的效果图如下：