ITK 实例 （四）

最新推荐文章于 2022-02-02 17:37:13 发布
最新推荐文章于 2022-02-02 17:37:13 发布
阅读量331 收藏 2
点赞数 2
分类专栏： ITK实例 文章标签： ITK 实例
转载请注明。
本文链接：https://blog.csdn.net/weixin_43289200/article/details/96483262
版权

ITK 官方网址：https://itk.org/ITK/project/project.html

（四）ITK 中的网格

 itk::Mesh 类用来表示空间中的形状。它派生自 itk::PoitnSet 类，因此它集成了与点相关的所有功能以及与点相关的所有像素数据的访问。网格类是 N 维的，它具有很大的灵活性。在实际应用中，网格类也可以被看作是一个点集，其中添加了许多不同维度和形状的单元格。其中，由于网格需要大量的内存，所以需要用 itk::SmartPointers 进行管理。

 （1）创建网格

#include "itkMesh.h"

int main()
{
	using PixelType = float;
	constexpr unsigned int Dimension = 3;

	using MeshType = itk::Mesh<PixelType, Dimension>;
	MeshType::Pointer mesh = MeshType::New();  

	MeshType::PointType p0;
	MeshType::PointType p1;
	MeshType::PointType p2;
	MeshType::PointType p3;

	p0[0] = -1.0; p0[1] = -1.0; p0[2] = 0.0; // 第一个点{-1,-1,0}
	p1[0] = 1.0; p1[1] = -1.0; p1[2] = 0.0;  //第二个点{1,-1,0}
	p2[0] = 1.0; p2[1] = 1.0; p2[2] = 0.0;   //第三个点{1,1,0}
	p3[0] = -1.0; p3[1] = 0.0; p3[2] = 0.0;  // 第四个点{-1,1,0}

	mesh->SetPoint(0, p0);
	mesh->SetPoint(1, p1);
	mesh->SetPoint(2, p2);
	mesh->SetPoint(3, p3);

	std::cout << "Points = " << mesh->GetNumberOfPoints() << std::endl;

	using PointsIterator = MeshType::PointsContainer::Iterator;
	PointsIterator pointIterator = mesh->GetPoints()->Begin();
	PointsIterator pointEnd = mesh->GetPoints()->End();
	while (pointIterator != pointEnd)
	{
		MeshType::PointType p = pointIterator.Value();
		std::cout << p << std::endl;
		++pointIterator;
	}
	return EXIT_SUCCESS;
}

（2）插入单元

itk::Mesh 可以包含多种类型的单元格，典型的单元类型有：itk::LineCell，itk::TriangleCell，itk::QuadrilateralCell，itk::TetrahedronCell，itk::PolygonCell

网格管理单元和管理点的区别在于，点时以复制的方式存储在点容器（PointContainer）中的，而单元是以指针的形式存储在单元容器中（CellContainer）的。

下面的实例通过建立一条多边形线，案例说明网格中是如何管理最简单的线单元的。

#include "itkMesh.h"
#include "itkLineCell.h"

int main()
{
	using PixelType = float;
	using MeshType = itk::Mesh<PixelType, 3>;

	using CellType = MeshType::CellType;
	using LineType = itk::LineCell<CellType>;
	using CellAutoPointer = CellType::CellAutoPointer;  //

	MeshType::Pointer mesh = MeshType::New();
	MeshType::PointType p0;
	MeshType::PointType p1;
	MeshType::PointType p2;

	p0[0] = -1.0; p0[1] = 0.0; p0[2] = 0.0;  //第一个点{-1,0,0}
	p1[0] = 1.0; p1[1] = 0.0; p1[2] = 0.0; //第二个点{1,0,0}
	p2[0] = 1.0; p2[1] = 1.0; p2[2] = 0.0; //第三个点{1,1,0}

	mesh->SetPoint(0, p0);
	mesh->SetPoint(1, p1);
	mesh->SetPoint(2, p2);

	CellAutoPointer line0;
	CellAutoPointer line1;
	line0.TakeOwnership(new LineType);
	line1.TakeOwnership(new LineType);

	line0->SetPointId(0, 0);
	line0->SetPointId(1, 1);  //点 0 ，1 之间的线

	line1->SetPointId(0, 1);
	line1->SetPointId(1, 2);  //点 1，2 之间的线

	mesh->SetCell(0, line0);
	mesh->SetCell(1, line1);

	std::cout << "Points = " << mesh->GetNumberOfPoints() << std::endl;
	std::cout << "Cells = " << mesh->GetNumberOfCells() << std::endl;

	using CellIterator = MeshType::CellsContainer::Iterator;
	CellIterator cellIterator = mesh->GetCells()->Begin();
	CellIterator cellEnd = mesh->GetCells()->End();

	while (cellIterator != cellEnd)
	{
		MeshType::CellType * cellptr = cellIterator.Value();
		auto * line = dynamic_cast<LineType *>(cellptr);
		if (line == nullptr)
		{
			continue;
		}
		std::cout << line->GetNumberOfPoints() << std::endl;  //两个线单元，每个单元有两个点
		++cellIterator;
	}

	return EXIT_SUCCESS;
}

（3） 管理单元格中的数据

#include "itkMesh.h"
#include "itkLineCell.h"

int main()
{
	using PixelType = float;
	using MeshType = itk::Mesh<PixelType, 2>;

	using CellType = MeshType::CellType;
	using LineType = itk::LineCell<CellType>;

	MeshType::Pointer mesh = MeshType::New();
	using PointType = MeshType::PointType;
	PointType point;

	constexpr unsigned int numberOfPoints = 10;
	for (unsigned int id = 0; id < numberOfPoints; id++)
	{
		point[0] = static_cast<PointType::ValueType>(id);
		point[1] = std::log(static_cast<double>(id) + itk::Math::eps);
		mesh->SetPoint(id, point);
	}

	CellType::CellAutoPointer line;
	const unsigned int numberOfCells = numberOfPoints - 1;
	for (unsigned int cellId = 0; cellId < numberOfCells; cellId++)
	{
		line.TakeOwnership(new LineType);
		line->SetPointId(0, cellId);
		line->SetPointId(1, cellId + 1);
		mesh->SetCell(cellId, line);
	}

	std::cout << "Points = " << mesh->GetNumberOfPoints() << std::endl;
	std::cout << "Cells = " << mesh->GetNumberOfCells() << std::endl;

	for (unsigned int cellId = 0; cellId < numberOfCells; cellId++)
	{
		mesh->SetCellData(cellId, static_cast<PixelType>(cellId * cellId));
	}

	for (unsigned int cellId = 0; cellId < numberOfCells; cellId++)
	{
		auto value = static_cast<PixelType>(0.0);
		mesh->GetCellData(cellId, &value);
		std::cout << "Cell" << cellId << " = " << value << std::endl;
	}

	using CellDataIterator = MeshType::CellDataContainer::ConstIterator;
	CellDataIterator cellDataIterator = mesh->GetCellData()->Begin();
	CellDataIterator end = mesh->GetCellData()->End();

	while (cellDataIterator != end)
	{
		PixelType cellValue = cellDataIterator.Value();
		std::cout << cellValue << std::endl;
		++cellDataIterator;
	}

	return EXIT_SUCCESS;

}

（4）自定义网格 

自定义网格有两种方法，一种是使用现成的类 “itk::DefaultStaticMeshTraits.h” ，并通过修改里面的 六个参数类型来设置。参数包括 PixelType，PointDimension，MaxTopologicalDimension，CoordinateType，InterpolationWeightType，CellDataTYpe，这些参数的顺序不可以改变。

另外一种方法是将上述类 “itk::DefaultStaticMeshTraits.h” 文件复制到其他文件中进行修改，但是一般不建议这样做。

#include "itkMesh.h"
#include "itkDefaultStaticMeshTraits.h"
#include "itkLineCell.h"
#include "itkVector.h"
#include "itkMatrix.h"

int main()
{
	constexpr unsigned int PointDimension = 3;
	constexpr unsigned int MaxTopologicalDimension = 2;

	using PixelType = itk::Vector<double, 4>;
	using CellDataType = itk::Matrix<double, 4, 3>;

	using CoordinateType = double;
	using InterpolationWeightType = double;

	using MeshTraits = itk::DefaultStaticMeshTraits<PixelType,
		PointDimension, MaxTopologicalDimension, CoordinateType,
		InterpolationWeightType, CellDataType>;

	using MeshType = itk::Mesh<PixelType, PointDimension, MeshTraits>;

	using CellType = MeshType::CellType;
	using LineType = itk::LineCell<CellType>;

	MeshType::Pointer mesh = MeshType::New();

	using PointType = MeshType::PointType;
	PointType point;

	constexpr unsigned int numberOfPoints = 10;
	for (unsigned int id = 0; id < numberOfPoints; id++)
	{
		point[0] = 1.565;
		point[1] = 3.647;
		point[2] = 4.129;
		mesh->SetPoint(id, point);
	}

	CellType::CellAutoPointer line;
	const unsigned int numberOfCells = numberOfPoints - 1;
	for (unsigned int cellId = 0; cellId < numberOfCells; cellId++)
	{
		line.TakeOwnership(new LineType);
		line->SetPointId(0, cellId);
		line->SetPointId(1, cellId + 1);
		mesh->SetCell(cellId, line);
	}

	std::cout << "Points = " << mesh->GetNumberOfPoints() << std::endl;
	std::cout << "Cell = " << mesh->GetNumberOfCells() << std::endl;

	for (unsigned int cellId = 0; cellId < numberOfCells; cellId++)
	{
		CellDataType value;
		mesh->SetCellData(cellId, value);
	}

	for (unsigned int cellId = 0; cellId < numberOfCells; cellId++)
	{
		CellDataType value;
		mesh->GetCellData(cellId, &value);
		std::cout << "Cell" << cellId << " = \n" << value << std::endl;
	}

	using CellDataIterator = MeshType::CellDataContainer::ConstIterator;
	CellDataIterator cellDataIterator = mesh->GetCellData()->Begin();
	CellDataIterator end = mesh->GetCellData()->End();

	while (cellDataIterator != end)
	{
		CellDataType cellValue = cellDataIterator.Value();
		std::cout << cellValue << std::endl;
		++cellDataIterator;
	}

	return EXIT_SUCCESS;
}

（5）拓扑与 K-Complex

itk::Mesh 类支持拓扑结构的表示。K-Complex 是一种拓扑结构，其中对于维度为 N 的每个单元，其边界面（维度为 N-1 的单元）也属于该结构。

下面的程序说明如何使用网格实例化 K-Compex 结构，示例结构由一个四面体、四个三角形面、六条边线、四个顶点组成。要理解点（points）和点单元（vertexCell）的区别。点单元可以感知其他单元类型，而点则不行。从拓扑的角度来看，点可以完全不存在于网格结构中，而点单元是表示 K-Complex 结构上完整的邻域关系所必需的的。

#include "itkMesh.h"
#include "itkLineCell.h"
#include "itkTetrahedronCell.h"

int main()
{
	using PixelType = float;
	using MeshType = itk::Mesh<PixelType, 3>;

	using CellType = MeshType::CellType;
	using VertexType = itk::VertexCell<CellType>;
	using LineType = itk::LineCell<CellType>;
	using TriangleType = itk::TriangleCell<CellType>;
	using TetrahedronType = itk::TetrahedronCell<CellType>;

	MeshType::Pointer mesh = MeshType::New();
	MeshType::PointType point0;
	MeshType::PointType point1;
	MeshType::PointType point2;
	MeshType::PointType point3;

	point0[0] = -1; point0[1] = -1; point0[2] = -1;
	point1[0] = 1; point1[1] = 1; point1[2] = -1;
	point2[0] = 1; point2[1] = -1; point2[2] = 1;
	point3[0] = -1; point3[1] = 1; point3[2] = 1;

	mesh->SetPoint(0, point0);
	mesh->SetPoint(1, point1);
	mesh->SetPoint(2, point2);
	mesh->SetPoint(3, point3);

	CellType::CellAutoPointer cellpointer;
	//创建四面体单元
	cellpointer.TakeOwnership(new TetrahedronType);  
	cellpointer->SetPointId(0, 0);
	cellpointer->SetPointId(1, 1);
	cellpointer->SetPointId(2, 2);
	cellpointer->SetPointId(3, 3);
	mesh->SetCell(0, cellpointer);

	//创建四个三角形面单元
	cellpointer.TakeOwnership(new TriangleType);
	cellpointer->SetPointId(0, 0);
	cellpointer->SetPointId(1, 1);
	cellpointer->SetPointId(2, 2);  //连接点 0,1,2
	mesh->SetCell(1, cellpointer);

	cellpointer.TakeOwnership(new TriangleType);
	cellpointer->SetPointId(0, 0);
	cellpointer->SetPointId(1, 2);
	cellpointer->SetPointId(2, 3);  //连接点 0,2,3
	mesh->SetCell(2, cellpointer);

	cellpointer.TakeOwnership(new TriangleType);
	cellpointer->SetPointId(0, 0);
	cellpointer->SetPointId(1, 3);
	cellpointer->SetPointId(2, 1);  //连接点 0,3,1
	mesh->SetCell(3, cellpointer);

	cellpointer.TakeOwnership(new TriangleType);
	cellpointer->SetPointId(0, 3);
	cellpointer->SetPointId(1, 2);
	cellpointer->SetPointId(2, 1);
	mesh->SetCell(4, cellpointer);

	//创建六个线单元
	cellpointer.TakeNoOwnership(new LineType);
	cellpointer->SetPointId(0, 0);
	cellpointer->SetPointId(1, 1);
	mesh->SetCell(5, cellpointer);

	cellpointer.TakeOwnership(new LineType);
	cellpointer->SetPointId(0, 1);
	cellpointer->SetPointId(1, 2);
	mesh->SetCell(6, cellpointer);

	cellpointer.TakeOwnership(new LineType);
	cellpointer->SetPointId(0, 2);
	cellpointer->SetPointId(1, 0);
	mesh->SetCell(7, cellpointer);

	cellpointer.TakeOwnership(new LineType);
	cellpointer->SetPointId(0, 1);
	cellpointer->SetPointId(1, 3);
	mesh->SetCell(8, cellpointer);

	cellpointer.TakeOwnership(new LineType);
	cellpointer->SetPointId(0, 3);
	cellpointer->SetPointId(1, 2);
	mesh->SetCell(9, cellpointer);

	cellpointer.TakeOwnership(new LineType);
	cellpointer->SetPointId(0, 3);
	cellpointer->SetPointId(1, 0);
	mesh->SetCell(10, cellpointer);

	//创建四点顶点单元
	cellpointer.TakeOwnership(new VertexType);
	cellpointer->SetPointId(0, 0);
	mesh->SetCell(11, cellpointer);

	cellpointer.TakeOwnership(new VertexType);
	cellpointer->SetPointId(0, 1);
	mesh->SetCell(12, cellpointer);

	cellpointer.TakeOwnership(new VertexType);
	cellpointer->SetPointId(0, 2);
	mesh->SetCell(13, cellpointer);

	cellpointer.TakeNoOwnership(new VertexType);
	cellpointer->SetPointId(0, 3);
	mesh->SetCell(14, cellpointer);

	std::cout << "# Points = " << mesh->GetNumberOfPoints() << std::endl;
	std::cout << "# Cell = " << mesh->GetNumberOfCells() << std::endl;

	using PointIterator = MeshType::PointsContainer::ConstIterator;
	PointIterator pointIterator = mesh->GetPoints()->Begin();
	PointIterator pointEnd = mesh->GetPoints()->End();
	std::cout << "=========================================" << std::endl;
	while (pointIterator != pointEnd)
	{
		std::cout << pointIterator.Value() << std::endl;
		++pointIterator;
	}

	using CellIterator = MeshType::CellsContainer::ConstIterator;
	CellIterator cellIterator = mesh->GetCells()->Begin();
	CellIterator cellEnd = mesh->GetCells()->End();
	std::cout << "=========================================" << std::endl;
	while (cellIterator != cellEnd)
	{
		CellType *cell = cellIterator.Value();
		std::cout << cell->GetNumberOfPoints() << std::endl;
		++cellIterator;
	}

	cellIterator = mesh->GetCells()->Begin();
	cellEnd = mesh->GetCells()->End();

	std::cout << "=========================================" << std::endl;
	while (cellIterator != cellEnd)
	{
		CellType *cell = cellIterator.Value();
		std::cout << "cell with " << cell->GetNumberOfPoints();
		std::cout << " points" << std::endl;

		using PointIdIterator = CellType::PointIdIterator;
		PointIdIterator pointIditer = cell->PointIdsBegin();
		PointIdIterator pointIdend = cell->PointIdsEnd();
		
		while (pointIditer != pointIdend)
		{
			std::cout << *pointIditer << std::endl;
			++pointIditer;
		}
		++cellIterator;
	}

	//单元格间邻域关系的定义
	MeshType::CellIdentifier cellId = 0;  // 四面体单元
	int dimension = 0;  //单元类型维度为 0，点单元
	MeshType::CellFeatureIdentifier featureId = 0;
	mesh->SetBoundaryAssignment(dimension, cellId, featureId++, 11);
	mesh->SetBoundaryAssignment(dimension, cellId, featureId++, 12);
	mesh->SetBoundaryAssignment(dimension, cellId, featureId++, 13);
	mesh->SetBoundaryAssignment(dimension, cellId, featureId++, 14);

	cellId = 0;  //四面体单元
	dimension = 1;   // 边界特征，维度为 1 的线单元
	featureId = 0;
	mesh->SetBoundaryAssignment(dimension, cellId, featureId++, 5);
	mesh->SetBoundaryAssignment(dimension, cellId, featureId++, 6);
	mesh->SetBoundaryAssignment(dimension, cellId, featureId++, 7);
	mesh->SetBoundaryAssignment(dimension, cellId, featureId++, 8);
	mesh->SetBoundaryAssignment(dimension, cellId, featureId++, 9);
	mesh->SetBoundaryAssignment(dimension, cellId, featureId++, 10);

	cellId = 0;  //四面体单元
	dimension = 2; //边界特征，维度为 2 的面单元
	featureId = 0;
	mesh->SetBoundaryAssignment(dimension, cellId, featureId++, 1);
	mesh->SetBoundaryAssignment(dimension, cellId, featureId++, 2);
	mesh->SetBoundaryAssignment(dimension, cellId, featureId++, 3);
	mesh->SetBoundaryAssignment(dimension, cellId, featureId++, 4);

	cellId = 0;  //四面体作为对象
	MeshType::CellFeatureCount n0;  //零维特征的数量
	MeshType::CellFeatureCount n1;  //一维特征的数量
	MeshType::CellFeatureCount n2;  //二维特征的数量

	n0 = mesh->GetNumberOfCellBoundaryFeatures(0, cellId);
	n1 = mesh->GetNumberOfCellBoundaryFeatures(1, cellId);
	n2 = mesh->GetNumberOfCellBoundaryFeatures(1, cellId);

	std::cout << "=========================================" << std::endl;
	std::cout << "Boundary features of dimension 0" << std::endl;
	dimension = 0;
	for (unsigned int b0 = 0; b0 < n0; b0++)
	{
		MeshType::CellIdentifier id;
		bool found = mesh->GetBoundaryAssignment(dimension, cellId, b0, &id);
		if (found)
			std::cout << id << std::endl;
	}

	std::cout << "=========================================" << std::endl;
	std::cout << "Boundary features of dimension 1" << std::endl;
	dimension = 1;
	for (unsigned int b1 = 0; b1 < n1; b1++)
	{
		MeshType::CellIdentifier id;
		bool found = mesh->GetBoundaryAssignment(dimension, cellId, b1, &id);
		if (found)
			std::cout << id << std::endl;
	}

	std::cout << "=========================================" << std::endl;
	std::cout << "Boundary features of dimension 2" << std::endl;
	dimension = 2;
	for (unsigned int b2 = 0; b2 < n2; b2++)
	{
		MeshType::CellIdentifier id;
		bool found = mesh->GetBoundaryAssignment(dimension, cellId, b2, &id);
		if (found)
			std::cout << id << std::endl;
	}

	cellId = 2;  // 2 号面单元
	dimension = 1; // 边界维度
	featureId = 0;

	mesh->SetBoundaryAssignment(dimension, cellId, featureId++, 7);
	mesh->SetBoundaryAssignment(dimension, cellId, featureId++, 9);
	mesh->SetBoundaryAssignment(dimension, cellId, featureId++, 10);

	std::cout << "=========================================" << std::endl;
	std::cout << "In cell Id = " << cellId << std::endl;
	std::cout << "Boundary features of dimension " << dimension;
	n1 = mesh->GetNumberOfCellBoundaryFeatures(dimension, cellId);
	std::cout << " = " << n1 << std::endl;

	std::cout << "=========================================" << std::endl;
	for (unsigned int b1 = 0; b1 < n1; b1++)
	{
		MeshType::CellIdentifier id;
		bool found = mesh->GetBoundaryAssignment(dimension, cellId, b1, &id);
		if (found)
			std::cout << id << std::endl;
	}

	return EXIT_SUCCESS;
}

（6） 折线表示

下面的示例展示了如何使用 itk::Mesh 表示经典的多线段结构。折线只涉及零维和一维单元，即 itk::VertexCell，itk::LineCell，但是这种情况下空间的维数应该是 2。 下面的例子将创建三条边形成一条多线段，连接四个顶点，围成一个类似于正方形的形状。

#include "itkMesh.h"
#include "itkLineCell.h"

int main()
{
	using PixelType = float;
	using MeshType = itk::Mesh<PixelType, 2>;

	using CellType = MeshType::CellType;
	using VertexType = itk::VertexCell<CellType>;
	using LineType = itk::LineCell<CellType>;

	MeshType::Pointer mesh = MeshType::New();
	MeshType::PointType point0;
	MeshType::PointType point1;
	MeshType::PointType point2;
	MeshType::PointType point3;

	point0[0] = -1; point0[1] = -1;
	point1[0] = 1; point1[1] = -1;
	point2[0] = 1; point2[1] = 1;
	point3[0] = -1; point3[1] = 1;

	mesh->SetPoint(0, point0);
	mesh->SetPoint(1, point1);
	mesh->SetPoint(2, point2);
	mesh->SetPoint(3, point3);

	CellType::CellAutoPointer cellpointer;
	cellpointer.TakeOwnership(new LineType);
	cellpointer->SetPointId(0, 0);
	cellpointer->SetPointId(1, 1);
	mesh->SetCell(0, cellpointer);

	cellpointer.TakeOwnership(new LineType);
	cellpointer->SetPointId(0, 1);
	cellpointer->SetPointId(1, 2);
	mesh->SetCell(1, cellpointer);

	cellpointer.TakeOwnership(new LineType);
	cellpointer->SetPointId(0, 2);
	cellpointer->SetPointId(1, 3);
	mesh->SetCell(2, cellpointer);

	cellpointer.TakeOwnership(new VertexType);
	cellpointer->SetPointId(0, 0);
	mesh->SetCell(3, cellpointer);

	cellpointer.TakeOwnership(new VertexType);
	cellpointer->SetPointId(0, 1);
	mesh->SetCell(4, cellpointer);

	cellpointer.TakeOwnership(new VertexType);
	cellpointer->SetPointId(0, 2);
	mesh->SetCell(5, cellpointer);

	cellpointer.TakeOwnership(new VertexType);
	cellpointer->SetPointId(0, 3);
	mesh->SetCell(6, cellpointer);

	std::cout << "==============================" << std::endl;
	std::cout << "# points = " << mesh->GetNumberOfPoints() << std::endl;
	std::cout << "# cell = " << mesh->GetNumberOfCells() << std::endl;

	using PointIterator = MeshType::PointsContainer::ConstIterator;
	PointIterator pointIterator = mesh->GetPoints()->Begin();
	PointIterator pointEnd = mesh->GetPoints()->End();
	std::cout << "==============================" << std::endl;
	while (pointIterator != pointEnd)
	{
		std::cout << pointIterator.Value() << std::endl;
		++pointIterator;
	}

	using CellIterator = MeshType::CellsContainer::ConstIterator;
	CellIterator cellIterator = mesh->GetCells()->Begin();
	CellIterator cellEnd = mesh->GetCells()->End();
	std::cout << "==============================" << std::endl;
	while (cellIterator != cellEnd)
	{
		CellType *cell = cellIterator.Value();
		std::cout << cell->GetNumberOfPoints() << std::endl;
		++cellIterator;
	}

	cellIterator = mesh->GetCells()->Begin();
	cellEnd = mesh->GetCells()->End();
	while (cellIterator != cellEnd)
	{
		CellType *cell = cellIterator.Value();
		std::cout << "==============================" << std::endl;
		std::cout << "cell with " << cell->GetNumberOfPoints();
		std::cout << " points " << std::endl;

		using PointIdIterator = CellType::PointIdIterator;
		PointIdIterator pointIditer = cell->PointIdsBegin();
		PointIdIterator pointend = cell->PointIdsEnd();

		while (pointIditer != pointend)
		{
			std::cout << *pointIditer << std::endl;
			++pointIditer;
		}
		++cellIterator;
	}
	return EXIT_SUCCESS;
}

（7） 简化网格创建

利用 itk::AutomaticTopologyMeshSource 类 可以根据你添加的单元格自动生成一个 K-Complex 结构。它显式地包含所有边界特征，因此可以轻松地遍历生成的网格。它合并了所有共享的边、顶点、面等，因此不会有几何特征出现一次以上。

#include "itkTriangleCell.h"
#include "itkAutomaticTopologyMeshSource.h"

int main()
{
	using PixelType = float;
	using MeshType = itk::Mesh<PixelType, 3>;

	using PointType = MeshType::PointType;
	using MeshSourceType = itk::AutomaticTopologyMeshSource<MeshType>;
	using IdentifierArrayType = MeshSourceType::IdentifierArrayType;

	MeshSourceType::Pointer meshSource;

	meshSource = MeshSourceType::New();
	meshSource->AddTetrahedron
	(
		meshSource->AddPoint(-1, -1, -1),
		meshSource->AddPoint(1, 1, -1),
		meshSource->AddPoint(1, -1, 1),
		meshSource->AddPoint(-1, 1, 1)
	);

	PointType p;
	IdentifierArrayType idArray(4);

	p[0] = -2;
	p[1] = -2;
	p[2] = -2;
	idArray[0] = meshSource->AddPoint(p);

	p[0] = 2;
	p[1] = 2;
	p[2] = -2;
	idArray[1] = meshSource->AddPoint(p);

	p[0] = 2;
	p[1] = -2;
	p[2] = 2;
	idArray[2] = meshSource->AddPoint(p);

	p[0] = -2;
	p[1] = 2;
	p[2] = 2;
	idArray[3] = meshSource->AddPoint(p);

	meshSource->AddTriangle(idArray[0], idArray[1], idArray[2]);
	meshSource->AddTriangle(idArray[1], idArray[2], idArray[3]);
	meshSource->AddTriangle(idArray[2], idArray[3], idArray[0]);
	meshSource->AddTriangle(idArray[3], idArray[0], idArray[1]);

	MeshType::Pointer mesh = meshSource->GetOutput();  //GetOutPut 不会触发更新过程
	std::cout << mesh << std::endl;

	return EXIT_SUCCESS;
}

（8）遍历单元格

#include "itkMesh.h"
#include "itkLineCell.h"
#include "itkTetrahedronCell.h"

int main()
{
	using PixelType = float;
	using MeshType = itk::Mesh<PixelType, 3>;
	using CellType = MeshType::CellType;

	using VertexType = itk::VertexCell<CellType>;
	using LineType = itk::LineCell<CellType>;
	using TriangleType = itk::TriangleCell<CellType>;
	using TetrahedronType = itk::TetrahedronCell<CellType>;
	
	MeshType::Pointer mesh = MeshType::New();
	MeshType::PointType point0;
	MeshType::PointType point1;
	MeshType::PointType point2;
	MeshType::PointType point3;

	point0[0] = -1; point0[1] = -1; point0[2] = -1;
	point1[0] = 1; point1[1] = 1; point1[2] = -1;
	point2[0] = 1; point2[1] = -1; point2[2] = 1;
	point3[0] = -1; point3[1] = 1; point3[2] = 1;

	mesh->SetPoint(0, point0);
	mesh->SetPoint(1, point1);
	mesh->SetPoint(2, point2);
	mesh->SetPoint(3, point3);

	CellType::CellAutoPointer cellpointer;
	//创建四面体单元
	cellpointer.TakeOwnership(new TetrahedronType);
	cellpointer->SetPointId(0, 0);
	cellpointer->SetPointId(1, 1);
	cellpointer->SetPointId(2, 2);
	cellpointer->SetPointId(3, 3);
	mesh->SetCell(0, cellpointer);

	//创建三角面单元
	cellpointer.TakeOwnership(new TriangleType);
	cellpointer->SetPointId(0, 0);
	cellpointer->SetPointId(1, 1);
	cellpointer->SetPointId(2, 2);
	mesh->SetCell(1, cellpointer);

	cellpointer.TakeOwnership(new TriangleType);
	cellpointer->SetPointId(0, 0);
	cellpointer->SetPointId(1, 2);
	cellpointer->SetPointId(2, 3);
	mesh->SetCell(2, cellpointer);

	cellpointer.TakeOwnership(new TriangleType);
	cellpointer->SetPointId(0, 0);
	cellpointer->SetPointId(1, 3);
	cellpointer->SetPointId(2, 1);
	mesh->SetCell(3, cellpointer);

	cellpointer.TakeOwnership(new TriangleType);
	cellpointer->SetPointId(0, 3);
	cellpointer->SetPointId(1, 2);
	cellpointer->SetPointId(2, 1);
	mesh->SetCell(4, cellpointer);

	//创建边线单元
	cellpointer.TakeOwnership(new LineType);
	cellpointer->SetPointId(0, 0);
	cellpointer->SetPointId(1, 1);
	mesh->SetCell(5, cellpointer);

	cellpointer.TakeOwnership(new LineType);
	cellpointer->SetPointId(0, 1);
	cellpointer->SetPointId(1, 2);
	mesh->SetCell(6, cellpointer);

	cellpointer.TakeOwnership(new LineType);
	cellpointer->SetPointId(0, 2);
	cellpointer->SetPointId(1, 0);
	mesh->SetCell(7, cellpointer);

	cellpointer.TakeOwnership(new LineType);
	cellpointer->SetPointId(0, 1);
	cellpointer->SetPointId(1, 3);
	mesh->SetCell(8, cellpointer);

	cellpointer.TakeOwnership(new LineType);
	cellpointer->SetPointId(0, 3);
	cellpointer->SetPointId(1, 2);
	mesh->SetCell(9, cellpointer);

	cellpointer.TakeOwnership(new LineType);
	cellpointer->SetPointId(0, 3);
	cellpointer->SetPointId(1, 0);
	mesh->SetCell(10, cellpointer);

	//创建点单元
	cellpointer.TakeOwnership(new VertexType);
	cellpointer->SetPointId(0, 0);
	mesh->SetCell(11, cellpointer);

	cellpointer.TakeOwnership(new VertexType);
	cellpointer->SetPointId(0, 1);
	mesh->SetCell(12, cellpointer);

	cellpointer.TakeOwnership(new VertexType);
	cellpointer->SetPointId(0, 2);
	mesh->SetCell(13, cellpointer);

	cellpointer.TakeOwnership(new VertexType);
	cellpointer->SetPointId(0, 3);
	mesh->SetCell(14, cellpointer);

	std::cout << "====================" << std::endl;
	std::cout << "# points = " << mesh->GetNumberOfPoints() << std::endl;
	std::cout << "# cell = " << mesh->GetNumberOfCells() << std::endl;

	using  CellIterator = MeshType::CellsContainer::ConstIterator;
	CellIterator cellIterator = mesh->GetCells()->Begin();
	CellIterator cellEnd = mesh->GetCells()->End();

	std::cout << "====================" << std::endl;
	while (cellIterator != cellEnd)
	{
		CellType *cell = cellIterator.Value();
		std::cout << cell->GetNumberOfPoints() << std::endl;
		++cellIterator;
	}

	std::cout << "====================" << std::endl;
	std::cout << "Visiting the Line cells: " << std::endl;
	cellIterator = mesh->GetCells()->Begin();
	cellEnd = mesh->GetCells()->End();

	std::cout << "====================" << std::endl;
	while (cellIterator != cellEnd)
	{
		CellType *cell = cellIterator.Value();
		if (cell->GetType() == CellType::LINE_CELL)
		{
			auto *line = static_cast<LineType *>(cell);
			std::cout << "dimension = " << line->GetDimension() << std::endl;
			std::cout << "# points = " << line->GetNumberOfPoints() << std::endl;
		}
		++cellIterator;
	}

	std::cout << "====================" << std::endl;
	std::cout << "Visiting several celltypes: " << std::endl;
	cellIterator = mesh->GetCells()->Begin();
	cellEnd = mesh->GetCells()->End();

	while (cellIterator != cellEnd)
	{
		CellType *cell = cellIterator.Value();
		switch (cell->GetType())
		{
		case CellType::VERTEX_CELL:
			{
				std::cout << "VertexCell: " << std::endl;
				auto *line = dynamic_cast<VertexType *>(cell);
				std::cout << " dimension = " << line->GetDimension() << std::endl;
				std::cout << " # points = " << line->GetNumberOfPoints() << std::endl;
				break;
			}

		case CellType::LINE_CELL:
		{
			std::cout << "LineCell : " << std::endl;
			auto * line = dynamic_cast<LineType *>(cell);
			std::cout << "dimension = " << line->GetDimension() << std::endl;
			std::cout << "# points  = " << line->GetNumberOfPoints() << std::endl;
			break;
		}

		case CellType::TRIANGLE_CELL:
		{
			std::cout << "TriangleCell : " << std::endl;
			auto * line = dynamic_cast<TriangleType *>(cell);
			std::cout << "dimension = " << line->GetDimension() << std::endl;
			std::cout << "# points  = " << line->GetNumberOfPoints() << std::endl;
			break;
		}
		default:
		{
			std::cout << "Cell with more than three points:" << std::endl;
			std::cout << "dimension = " << cell->GetDimension() << std::endl;
			std::cout << "# points  = " << cell->GetNumberOfPoints() << std::endl;
			break;
		}
		}
		++cellIterator;
	}

	return EXIT_SUCCESS;
}

（9）访问单元

需要自定义 CellVisitor 类。对这个的要求是必须提供名为 Visit( ) 的函数。

#include "itkMesh.h"
#include "itkLineCell.h"
#include "itkTetrahedronCell.h"
#include "itkCellInterfaceVisitor.h"

using PixelType = float;
using MeshType = itk::Mesh<PixelType, 3>;
using CellType = MeshType::CellType;
using VertexType = itk::VertexCell<CellType>;
using LineType = itk::LineCell<CellType>;
using TriangleType = itk::TriangleCell<CellType>;
using TetrahedronType = itk::TetrahedronCell<CellType>;

#ifndef _CUSTONTRIANGLEVISITOR
#define _CUSTONTRIANGLEVISITOR

class CustomTriangleVisitor
{
public:
	void Visit(unsigned long cellId, TriangleType*t)
	{
		std::cout << "Cell # " << cellId << " is a TriangleType, ";
		std::cout << " and number of Points: " << t->GetNumberOfPoints() << std::endl;
	}
	CustomTriangleVisitor() = default;
	virtual ~CustomTriangleVisitor() = default;
};

#endif //_CUSTONTRIANGLEVISITOR

int main()
{
	MeshType::Pointer mesh = MeshType::New();
	MeshType::PointType point0;
	MeshType::PointType point1;
	MeshType::PointType point2;
	MeshType::PointType point3;

	point0[0] = -1; point0[1] = -1; point0[2] = -1;
	point1[0] = 1; point1[1] = 1; point1[2] = -1;
	point2[0] = 1; point2[1] = -1; point2[2] = 1;
	point3[0] = -1; point3[1] = 1; point3[2] = 1;

	mesh->SetPoint(0, point0);
	mesh->SetPoint(1, point1);
	mesh->SetPoint(2, point2);
	mesh->SetPoint(3, point3);

	//创建四面体单元
	CellType::CellAutoPointer cellpointer;

	cellpointer.TakeOwnership(new TetrahedronType);
	cellpointer->SetPointId(0, 0);
	cellpointer->SetPointId(1, 1);
	cellpointer->SetPointId(2, 2);
	cellpointer->SetPointId(3, 3);
	mesh->SetCell(0, cellpointer);

	//创建三角面单元
	cellpointer.TakeOwnership(new TriangleType);
	cellpointer->SetPointId(0, 0);
	cellpointer->SetPointId(1, 1);
	cellpointer->SetPointId(2, 2);
	mesh->SetCell(1, cellpointer);

	cellpointer.TakeOwnership(new TriangleType);
	cellpointer->SetPointId(0, 0);
	cellpointer->SetPointId(1, 2);
	cellpointer->SetPointId(2, 3);
	mesh->SetCell(2, cellpointer);

	cellpointer.TakeOwnership(new TriangleType);
	cellpointer->SetPointId(0, 0);
	cellpointer->SetPointId(1, 3);
	cellpointer->SetPointId(2, 1);
	mesh->SetCell(3, cellpointer);

	cellpointer.TakeOwnership(new TriangleType);
	cellpointer->SetPointId(0, 3);
	cellpointer->SetPointId(1, 2);
	cellpointer->SetPointId(2, 1);
	mesh->SetCell(4, cellpointer);

	//创建边线单元
	cellpointer.TakeOwnership(new LineType);
	cellpointer->SetPointId(0, 0);
	cellpointer->SetPointId(1, 1);
	mesh->SetCell(5, cellpointer);

	cellpointer.TakeOwnership(new LineType);
	cellpointer->SetPointId(0, 1);
	cellpointer->SetPointId(1, 2);
	mesh->SetCell(6, cellpointer);

	cellpointer.TakeOwnership(new LineType);
	cellpointer->SetPointId(0, 2);
	cellpointer->SetPointId(1, 0);
	mesh->SetCell(7, cellpointer);

	cellpointer.TakeOwnership(new LineType);
	cellpointer->SetPointId(0, 1);
	cellpointer->SetPointId(1, 3);
	mesh->SetCell(8, cellpointer);

	cellpointer.TakeOwnership(new LineType);
	cellpointer->SetPointId(0, 3);
	cellpointer->SetPointId(1, 2);
	mesh->SetCell(9, cellpointer);

	cellpointer.TakeOwnership(new LineType);
	cellpointer->SetPointId(0, 3);
	cellpointer->SetPointId(1, 0);
	mesh->SetCell(10, cellpointer);

	//创建顶点单元
	cellpointer.TakeOwnership(new VertexType);
	cellpointer->SetPointId(0, 0);
	mesh->SetCell(11, cellpointer);

	cellpointer.TakeOwnership(new VertexType);
	cellpointer->SetPointId(0, 1);
	mesh->SetCell(12, cellpointer);

	cellpointer.TakeOwnership(new VertexType);
	cellpointer->SetPointId(0, 2);
	mesh->SetCell(13, cellpointer);

	cellpointer.TakeOwnership(new VertexType);
	cellpointer->SetPointId(0, 3);
	mesh->SetCell(14, cellpointer);

	//输出点和单元的个数
	std::cout << "=========================" << std::endl;
	std::cout << "# Points = " << mesh->GetNumberOfPoints() << std::endl;
	std::cout << "# Cell  = " << mesh->GetNumberOfCells() << std::endl;

	using TriangleVisitorInterfaceType =
		itk::CellInterfaceVisitorImplementation
		<
		PixelType,
		MeshType::CellTraits,
		TriangleType,
		CustomTriangleVisitor
		>;

	TriangleVisitorInterfaceType::Pointer triangleVisitor =
		TriangleVisitorInterfaceType::New();

	using CellMultiVisitorType = CellType::MultiVisitor;
	CellMultiVisitorType::Pointer multiVisitor = CellMultiVisitorType::New();
	multiVisitor->AddVisitor(triangleVisitor);
	mesh->Accept(multiVisitor);

	return EXIT_SUCCESS;
}

 （10）有关访问单元格的详细信息

#include "itkMesh.h"
#include "itkLineCell.h"
#include "itkTetrahedronCell.h"
#include "itkCellInterfaceVisitor.h"

using PixelType = float;
using MeshType = itk::Mesh<PixelType, 3>;
using CellType = MeshType::CellType;
using VertexType = itk::VertexCell<CellType>;
using LineType = itk::LineCell<CellType>;
using TriangleType = itk::TriangleCell<CellType>;
using TetrahedronType = itk::TetrahedronCell<CellType>;

class CustomVertexVisitor
{
public:
	void Visit(unsigned long cellId, VertexType *t)
	{
		std::cout << "==============================" << std::endl;
		std::cout << "cell " << cellId << " is a Vertex " << std::endl;
		std::cout << "associated with point id = ";
		std::cout << t->GetPointId() << std::endl;
	}
	virtual ~CustomVertexVisitor() = default;
};

class CustomLineVisitor
{
public:
	CustomLineVisitor() : m_Mesh(nullptr) {};
	virtual ~CustomLineVisitor() = default;

	void SetMesh(MeshType *mesh) { m_Mesh = mesh; }

	void Visit(unsigned long cellId, LineType *t)
	{
		std::cout << "==============================" << std::endl;
		std::cout << "cell " << cellId << " is a Line " << std::endl;
		LineType::PointIdIterator pit = t->PointIdsBegin();
		MeshType::PointType p0;
		MeshType::PointType p1;
		m_Mesh->GetPoint(*pit++, &p0);
		m_Mesh->GetPoint(*pit++, &p1);
		const double length = p0.EuclideanDistanceTo(p1);
		std::cout << "length = " << length << std::endl;
	}

private:
	MeshType::Pointer m_Mesh;
};

#ifndef _CustomTriangleVisitor
#define _CustomTriangleVisitor

class CustomTriangleVisitor
{
public:
	void Visit(unsigned long cellId, TriangleType * t)
	{
		LineType::PointIdIterator pit = t->PointIdsBegin();
		LineType::PointIdIterator end = t->PointIdsEnd();
		std::cout << "==============================" << std::endl;
		std::cout << "cell " << cellId << " is a triangle " << std::endl;
		while (pit != end)
		{
			
			std::cout << "point id = " << *pit << std::endl;
			++pit;
		}
	}
	virtual ~CustomTriangleVisitor() = default;
};

#endif //_CustomTriangleVisitor

class CustomTetrahedronVisitor
{
public:
	void Visit(unsigned long cellId, TetrahedronType *t)
	{
		std::cout << "==============================" << std::endl;
		std::cout << "cell " << cellId << " is a Tetrahedron, " << std::endl;
		std::cout << " number of faces = ";
		std::cout << t->GetNumberOfFaces() << std::endl;
	}
	virtual ~CustomTetrahedronVisitor() = default;
};

int main()
{
	MeshType::Pointer mesh = MeshType::New();

	MeshType::PointType   point0;
	MeshType::PointType   point1;
	MeshType::PointType   point2;
	MeshType::PointType   point3;

	point0[0] = -1; point0[1] = -1; point0[2] = -1;
	point1[0] = 1; point1[1] = 1; point1[2] = -1;
	point2[0] = 1; point2[1] = -1; point2[2] = 1;
	point3[0] = -1; point3[1] = 1; point3[2] = 1;

	mesh->SetPoint(0, point0);
	mesh->SetPoint(1, point1);
	mesh->SetPoint(2, point2);
	mesh->SetPoint(3, point3);

	//创建四面体单元
	CellType::CellAutoPointer cellpointer;

	cellpointer.TakeOwnership(new TetrahedronType);
	cellpointer->SetPointId(0, 0);
	cellpointer->SetPointId(1, 1);
	cellpointer->SetPointId(2, 2);
	cellpointer->SetPointId(3, 3);
	mesh->SetCell(0, cellpointer);

	//创建三角形面单元
	cellpointer.TakeOwnership(new TriangleType);
	cellpointer->SetPointId(0, 0);
	cellpointer->SetPointId(1, 1);
	cellpointer->SetPointId(2, 2);
	mesh->SetCell(1, cellpointer);

	cellpointer.TakeOwnership(new TriangleType);
	cellpointer->SetPointId(0, 0);
	cellpointer->SetPointId(1, 2);
	cellpointer->SetPointId(2, 3);
	mesh->SetCell(2, cellpointer);

	cellpointer.TakeOwnership(new TriangleType);
	cellpointer->SetPointId(0, 0);
	cellpointer->SetPointId(1, 3);
	cellpointer->SetPointId(2, 1);
	mesh->SetCell(3, cellpointer);

	cellpointer.TakeOwnership(new TriangleType);
	cellpointer->SetPointId(0, 3);
	cellpointer->SetPointId(1, 2);
	cellpointer->SetPointId(2, 1);
	mesh->SetCell(4, cellpointer);

	//创建边线单元
	cellpointer.TakeOwnership(new LineType);
	cellpointer->SetPointId(0, 0);
	cellpointer->SetPointId(1, 1);
	mesh->SetCell(5, cellpointer);

	cellpointer.TakeOwnership(new LineType);
	cellpointer->SetPointId(0, 1);
	cellpointer->SetPointId(1, 2);
	mesh->SetCell(6, cellpointer);

	cellpointer.TakeOwnership(new LineType);
	cellpointer->SetPointId(0, 2);
	cellpointer->SetPointId(1, 0);
	mesh->SetCell(7, cellpointer);

	cellpointer.TakeOwnership(new LineType);
	cellpointer->SetPointId(0, 1);
	cellpointer->SetPointId(1, 3);
	mesh->SetCell(8, cellpointer);

	cellpointer.TakeOwnership(new LineType);
	cellpointer->SetPointId(0, 3);
	cellpointer->SetPointId(1, 2);
	mesh->SetCell(9, cellpointer);

	cellpointer.TakeOwnership(new LineType);
	cellpointer->SetPointId(0, 3);
	cellpointer->SetPointId(1, 0);
	mesh->SetCell(10, cellpointer);

	//创建点单元
	cellpointer.TakeOwnership(new VertexType);
	cellpointer->SetPointId(0, 0);
	mesh->SetCell(11, cellpointer);

	cellpointer.TakeOwnership(new VertexType);
	cellpointer->SetPointId(0, 1);
	mesh->SetCell(12, cellpointer);

	cellpointer.TakeOwnership(new VertexType);
	cellpointer->SetPointId(0, 2);
	mesh->SetCell(13, cellpointer);

	cellpointer.TakeOwnership(new VertexType);
	cellpointer->SetPointId(0, 3);
	mesh->SetCell(14, cellpointer);

	std::cout << "==============================" << std::endl;
	std::cout << "# Points= " << mesh->GetNumberOfPoints() << std::endl;
	std::cout << "# Cell  = " << mesh->GetNumberOfCells() << std::endl;

	using VertexVisitorInterfaceType = itk::CellInterfaceVisitorImplementation
		<PixelType, MeshType::CellTraits, VertexType, CustomVertexVisitor>;

	using LineVisitorInterfaceType = itk::CellInterfaceVisitorImplementation
		<PixelType, MeshType::CellTraits, LineType, CustomLineVisitor>;

	using TriangleVisitorInterfaceType = itk::CellInterfaceVisitorImplementation
		<PixelType, MeshType::CellTraits, TriangleType, CustomTriangleVisitor>;

	using TetrahedronVisitorInterfaceType = itk::CellInterfaceVisitorImplementation
		<PixelType, MeshType::CellTraits, TetrahedronType, CustomTetrahedronVisitor>;

	VertexVisitorInterfaceType::Pointer vertexVisitor =
		VertexVisitorInterfaceType::New();

	LineVisitorInterfaceType::Pointer lineVisitor =
		LineVisitorInterfaceType::New();

	TriangleVisitorInterfaceType::Pointer triangleVisitor =
		TriangleVisitorInterfaceType::New();

	TetrahedronVisitorInterfaceType::Pointer tetrahedronVisitor =
		TetrahedronVisitorInterfaceType::New();

	lineVisitor->SetMesh(mesh);

	using CellMultiVisitorType = CellType::MultiVisitor;
	CellMultiVisitorType::Pointer  multiVisitor = CellMultiVisitorType::New();

	multiVisitor->AddVisitor(vertexVisitor);
	multiVisitor->AddVisitor(lineVisitor);
	multiVisitor->AddVisitor(triangleVisitor);
	multiVisitor->AddVisitor(tetrahedronVisitor);

	mesh->Accept(multiVisitor);

	std::cout << "==============================" << std::endl;
	return EXIT_SUCCESS;
}

（11）路径

 itk::PolyLineParametricPath，该类通常用于以简明的方式表示2D中的图像分割算法的输出。

#include "itkImage.h"
#include "itkImageFileReader.h"
#include "itkPolyLineParametricPath.h"

int main()
{
	constexpr unsigned int Dimension = 2;
	using ImageType = itk::Image<unsigned char, Dimension>;
	using PathType = itk::PolyLineParametricPath<Dimension>;
	using ReaderType = itk::ImageFileReader<ImageType>;
	ReaderType::Pointer reader = ReaderType::New();
	reader->SetFileName("C:\\xiaonvhai.jpg");
	try
	{
		reader->Update();
	}
	catch (itk::ExceptionObject &excp)
	{
		std::cout << "Problem reading the input image " << std::endl;
		std::cout << excp << std::endl;
		return EXIT_FAILURE;
	}

	ImageType::ConstPointer image = reader->GetOutput();
	PathType::Pointer path = PathType::New();
	path->Initialize();

	using ContinuousIndexType = PathType::ContinuousIndexType;
	ContinuousIndexType cindex;

	using ImagePointType = ImageType::PointType;
	ImagePointType origin = image->GetOrigin();

	ImageType::SpacingType spacing = image->GetSpacing();
	ImageType::SizeType size = image->GetBufferedRegion().GetSize();

	ImagePointType point;
	point[0] = origin[0] + spacing[0] * size[0];
	point[1] = origin[1] + spacing[1] * size[1];

	image->TransformPhysicalPointToContinuousIndex(origin, cindex);
	path->AddVertex(cindex);
	image->TransformPhysicalPointToContinuousIndex(point, cindex);
	path->AddVertex(cindex);

	return EXIT_SUCCESS;
}

（12）容器

下面的程序示例展示了 itk::TreeContainer  和关联的 TreeContainer 的使用，TreeContainer 实现了树的概念。

#include "itkTreeContainer.h"
#include "itkChildTreeIterator.h"
#include "itkLeafTreeIterator.h"
#include "itkLevelOrderTreeIterator.h"
#include "itkInOrderTreeIterator.h"
#include "itkPostOrderTreeIterator.h"
#include "itkRootTreeIterator.h"
#include "itkTreeIteratorClone.h"

int main()
{
	using NodeType = int;
	using TreeType = itk::TreeContainer<NodeType>;
	TreeType::Pointer tree = TreeType::New();
	tree->SetRoot(0);  //添加根节点
	tree->Add(1, 0);
	tree->Add(2, 0);
	tree->Add(3, 0);
	tree->Add(4, 2);
	tree->Add(5, 2);
	tree->Add(6, 5);
	tree->Add(7, 1);

	itk::ChildTreeIterator<TreeType> childIt(tree);
	std::cout << "==============================" << std::endl;
	for (childIt.GoToBegin(); !childIt.IsAtEnd(); ++childIt)
	{
		std::cout << childIt.Get() << std::endl;
	}
	std::cout << std::endl;

	childIt.GoToBegin();
	if (childIt.GetType() != itk::TreeIteratorBase<TreeType>::CHILD)
	{
		std::cout << "==============================" << std::endl;
		std::cerr << "Error: the iterator was not of type CHILD. " << std::endl;
		return EXIT_FAILURE;
	}

	int oldValue = childIt.Get();
	std::cout << "==============================" << std::endl;
	std::cout << "The node's value is " << oldValue << std::endl;
	int newValue = 2;
	childIt.Set(newValue);
	std::cout << "Now the node's value is " << childIt.Get() << std::endl;

	childIt.Set(oldValue);
	std::cout << "==============================" << std::endl;
	std::cout << "Is this a leaf node? " << childIt.IsLeaf() << std::endl;
	std::cout << "Is this the root node? " << childIt.IsRoot() << std::endl;
	std::cout << "Dose this node have a parent? " << childIt.HasParent() << std::endl;
	std::cout << "How many children does this node have? " << childIt.CountChildren() << std::endl;
	std::cout << "Does this node have a child 1? " << childIt.HasChild(1) << std::endl;
	std::cout << std::endl;

	tree->Clear();
	itk::PreOrderTreeIterator<TreeType> it(tree);
	it.GoToBegin();

	it.Add(0);
	it.Add(1);
	it.Add(2);
	it.Add(3);
	it.GoToChild(2);
	it.Add(4);
	it.Add(5);

	itk::TreeIteratorBase<TreeType>* childItClone = childIt.Clone();
	delete childItClone;

	using IteratorType = itk::TreeIteratorBase<TreeType>;
	using IteratorCloneType = itk::TreeIteratorClone<IteratorType>;
	IteratorCloneType anotherChildItClone = childIt;
	
	std::cout << "==============================" << std::endl;
	std::cout << "ChildTreeIterator: " << std::endl;
	for (childIt.GoToBegin(); !childIt.IsAtEnd(); ++childIt)
	{
		std::cout << childIt.Get() << std::endl;
	}
	std::cout << std::endl;

	std::cout << "==============================" << std::endl;
	std::cout << "LeafTreeIterator: " << std::endl;
	itk::LeafTreeIterator<TreeType> leafIt(tree);
	for (leafIt.GoToBegin(); !leafIt.IsAtEnd(); ++leafIt)
	{
		std::cout << leafIt.Get() << std::endl;
	}
	std::cout << std::endl;

	std::cout << "==============================" << std::endl;
	std::cout << "LevelOrderTreeIterator: " << std::endl;
	itk::LevelOrderTreeIterator<TreeType> levelIt(tree, 10, tree->GetNode(0));
	for (levelIt.GoToBegin(); !levelIt.IsAtEnd(); ++levelIt)
	{
		std::cout << levelIt.Get() << "(" << levelIt.GetLevel() << ")" << std::endl;
	}
	std::cout << std::endl;

	std::cout << "==============================" << std::endl;
	std::cout << "InOrderTreeIterator: " << std::endl;
	itk::InOrderTreeIterator<TreeType> inOrderIt(tree);
	for (inOrderIt.GoToBegin(); !inOrderIt.IsAtEnd(); ++inOrderIt)
	{
		std::cout << inOrderIt.Get() << std::endl;
	}
	std::cout << std::endl;

	std::cout << "==============================" << std::endl;
	std::cout << "PreOrderTreeIterator:" << std::endl;
	itk::PreOrderTreeIterator<TreeType> preOrderIt(tree);
	for (preOrderIt.GoToBegin(); !preOrderIt.IsAtEnd(); ++preOrderIt)
	{
		std::cout << preOrderIt.Get() << std::endl;
	}
	std::cout << std::endl;

	std::cout << "==============================" << std::endl;
	std::cout << "PostOrderTreeIterator:" << std::endl;
	itk::PostOrderTreeIterator<TreeType> postOrderIt(tree);
	for (postOrderIt.GoToBegin(); !postOrderIt.IsAtEnd(); ++postOrderIt)
	{
		std::cout << postOrderIt.Get() << std::endl;
	}
	std::cout << std::endl;

	std::cout << "==============================" << std::endl;
	std::cout << "RootTreeIterator: " << std::endl;
	itk::RootTreeIterator<TreeType> rootIt(tree, tree->GetNode(4));
	for (rootIt.GoToBegin(); !rootIt.IsAtEnd(); ++rootIt)
	{
		std::cout << rootIt.Get() << std::endl;
	}
	std::cout << std::endl;

	return EXIT_SUCCESS;
}

 

BettyDD
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ITK在VS2010中的安装和第一个例子
07-16 1万+
1，下载 CMake，选择最新版本。       地址 http://www.cmake.org/cmake/resources/software.html
ITK 实例 （一）
weidadeyaqhhya的博客
07-19 2612
ITK 是一个开源的面向对象的图像处理系统，通常被用于医学图像处理。在学习 ITK 的过程中，通过运行官网提供的实例可以深入了解和学习ITK 内部的各个类的使用及应用。 本文实例用 vs2015调试运行，cmake 配置。 ITK 官方网址：https://itk.org/ITK/project/project.html （一）认识 ITK ITK 包安装完成后可用下面这个简单程序进行...
ITK学习笔记：1.Data presentation-1.3Mesh网格（二）：自定义mesh
今天写代码了吗
06-29 343
网格的一般概念集成了许多不同的元素。原则上可以为每个这样的元素使用独立的类型。泛型编程中用于指定概念中涉及的许多不同类型的机制称为traits。它们基本上是与当前类交互的所有类型的列表。 网格通过三个参数模板化。到目前为止，我们只讨论了两个，即像素类型和维度。第三个参数是一个提供网格所需特征集的类。当省略第三个参数时，使用默认的类。这个默认类是itk::DefaultStaticMeshTraits。如果您想定制网格使用的类型，接下来的方法是修改默认特征，并将它们作为网格类实例化的第三个参数提供。有两种方法
ITK学习笔记：1.Data presentation-1.3Mesh网格（一）基操：创建mesh，嵌入cell，管理数据
今天写代码了吗
06-25 438
1.创建网格 网格类用于表示空间中的形状。 它源于itk::PointSet类，因此继承了与点相关的所有功能以及对与点关联的像素数据的访问。 Mesh类也是n维的，这使得它的使用具有很大的灵活性。 实际上，Mesh类可以看作是一个点集，其中添加了许多不同维度和形状的单元格(也称为元素)。网格中的单元格使用它们的点标识符根据现有的点定义 与PointSet相同，ITK中有静态和动态两种基本的网格样式。 第一个用于使用点的数量可预知,并不需要对其修改操作。 第二个支持插入和删除点。 区分这两种样式的原因是
ITK 读写基本例子
但求前程
02-02 522
可靠的读写图像的类位于数据处理通道的开始和结束。这些类被认为是数据源(readers)和数据槽(writers)。一般来说，它们作为滤波器被涉及了，虽然readers没有输入通道，writers也没有输出通道。 itk::ImageFileReader类管理图像的读入，而itk::ImageFileWriter管理图像的写操作。两个类对于任何文件格式都是独立的。实际上低水平的读、写特殊文件格式的任务由一组itk::ImageIO类在后台执行。 执行读...
ITK 实例 （三）
weidadeyaqhhya的博客
07-19 341
ITK 官方网址：https://itk.org/ITK/project/project.html （三） ITK 中的点集 （1） 创建点集 下面实例展示了如何创建点集，如何将生成的指定点插入到点集中，以及如何从点集中读取指定点。 #include "itkPointSet.h" int main() { using PointSetType = itk::PointSet<...
ITK实例中3D图像
09-30
总的来说，ITK实例中的3D图像数据集是测试和验证ITK在处理复杂3D医学图像时功能的强大工具。通过这些数据，研究者和开发者可以评估和改进图像处理算法，包括配准、分割、特征提取等，从而推动医学图像分析技术的发展...
使用SimpleITK读取和保存NIfTI/DICOM文件实例
09-16
本实例主要涉及如何使用SimpleITK来读取和保存NIfTI和DICOM格式的文件。 NIfTI（Neuroimaging Informatics Technology Initiative）是一种常见的神经影像存储格式，通常用于MRI或fMRI数据。`.nii.gz`是NIfTI文件的...
itk中文教程.zip
01-27
在"itkchin2.pdf"和"itkchin1.pdf"中，你可能能找到关于这些算法的详细介绍和实例代码。 在医学图像处理领域，图像分割是提取图像中有意义区域的关键步骤，例如识别肿瘤或器官。ITK提供了多种分割算法，如阈值分割...
使用ITK-SNAP进行抠图操作并保存mask的实例
09-16
在本实例中，我们将学习如何利用ITK-SNAP进行抠图操作，并保存生成的掩模（mask）以便后续处理。 首先，我们的目标是制作一个二值化的mask，它能够区分图像中的目标区域与背景。这个过程分为两个主要步骤： 1. **...
ITK与VTK结合显示图像实例
07-10
结合这两个库的一个典型实例可能是：首先，使用ITK读取和预处理图像，如应用SigmoidImageFilter改变图像的动态范围；然后，将处理后的图像数据传递给VTK，创建一个ImageData对象；接着，通过Mapper将数据映射到图形...
itk-game-simple：用于事件的纯JavaScript制作的简单游戏
02-11
简单的游戏 一个使用事件的纯JavaScript制作的简单游戏。
ITK基本介绍和实例分析
inter_peng的专栏
06-21 1万+
本文由Markdown语法编辑器编辑完成。1. ITK简介：2. ITK在windows7的编译：为了增加对ITK的直观理解，需要研究ITK的源代码和自带的很多例子。因此，在官网上下载了ITK的源代码后，接下来需要做的工作便是编译源代码和例子程序了。ITK编译完成后，既可以作为独立的一个工程，去研究它的每一个例子的实现原理。但是，更通常的应用是将ITK编译生成的lib和dll作为第三方库，引入到需要
ITK学习笔记1：从一个简单的例子出发学习ITK
暮日落流年的博客
11-15 1万+
看完东灵的vtk的相关教程，接下来就是对itk的学习了。不过网上itk的学习资源还是零零散散的，还是需要自己进行整合。 1. 参考资源 CSDN: ljp1919的专栏-ITK学习笔记 CSDN: rabbitbride的专栏-ITK医学图像处理 CSDN: inter_peng的专栏-ITK学习 ITK官方例子 ITK Software Guide ITK 4.13.0 Document...
ITK学习笔记：1.Data presentation-1.3Mesh网格（五）：简化网格的创建
今天写代码了吗
06-30 266
Mesh类是非常通用和灵活的。 可以通过itk::AutomaticTopologyMeshSource类，根据我们所添加的单元自动生成一个显性复合体。 它包括了所有的边界信息，因此产生的网格可以很容易地遍历。 它合并了所有共享的边、顶点和面，因此几何特征不会重复出现。 本文展示如何使用AutomaticTopologyMeshSource实例化表示K-Complex的网格。我们将首先从上文中生成相同的四面体，之后我们将添加一个空心的四面体来说明网格源的一些额外特性。 首先包含需要的头文件： #incl
《itk实用demo》-itkMesh
就这样吧
09-12 331
itk中的网格Mesh #include &quot;itkMesh.h&quot; MeshType ::Pointer PointsToMesh(ImageType::Pointer sliceimage) { MeshType::Pointer mesh = MeshType::New(); int size[2]; size[0]=sliceimage-&amp;gt;...
ITK学习笔记：1.Data presentation-1.3Mesh网格（三）：拓扑和k复形
今天写代码了吗
06-30 364
Mesh类支持形式化拓扑的表示。特别地，k复形的概念可以在网格中正确地表示。 k复形是一种拓扑结构，其中对于每一个维数N的单元格，其边界面为维数N−1的单元格也属于该结构。 下面演示如何使用网格实例化K-Complex结构。 该实例结构由一个四面体、四个三角形面、六个线边和四个顶点组成 #include "itkMesh.h" #include "itkVertexCell.h" #include "itkLineCell.h" #include "itkTriangleCell.h" #inc
ITK学习笔记：1.Data presentation-1.3Mesh网格（七）：访问单元
今天写代码了吗
07-01 188
为了方便访问特定的单元类型，itk::Mesh中内置了一个机制。该机制基于Visitor Pattern。 该模式旨在促进遍历共享公共基类的异构对象列表的过程。 //使用CellVisitor机制的第一个要求是包含CellInterfaceVisitor头文件 #include "itkCellInterfaceVisitor.h" typedef float PixelType; typedef itk::Mesh< PixelType, 3 > MeshType; typedef M
itk中的基本图像操作
热门推荐
就这样吧
05-12 1万+
自己会慢慢把itk的一些简单用法放在博客来，就从创建一个简单图像开始吧。 //1、创建图像 ImageType::Pointer mask_data= ImageType::New(); //2、创建一个与image_data等大的mask图像 ImageType::PointType origin_temp = image_data->GetOrigin(); ImageType:
医学图像处理：ITK基础与应用实战
"《医学图像分割与配准》(1ITK初步分册)是由周振环、王安明、王京阳、赵明四位作者合著，由电子科技大学出版社于2007年6月出版的一本专业书籍。该书主要探讨医学图像的分割与配准技术，特别是基于ITK（Insight ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值