求两个多边形数据 vtkPolyData 的相交线

最新推荐文章于 2025-03-18 19:08:46 发布
最新推荐文章于 2025-03-18 19:08:46 发布
阅读量6k 收藏 20
点赞数 4
分类专栏： VTK 文章标签： vtk
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jane_yuhui/article/details/52524457
版权

vtkIntersectionPolyDataFilter

【简介】

该滤波器计算两个多边形数据 vtkPolyData 的交集。

其第一个输出是 交集线集( a set of lines )；

第二个和第三个输出分别为第一和第二个输入 vtkPolyData.

如果需要，后两个输出可以被相交线分割。

【示例】

#include <vtkActor.h>
#include <vtkIntersectionPolyDataFilter.h>
#include <vtkPolyDataMapper.h>
#include <vtkProperty.h>
#include <vtkRenderer.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkSmartPointer.h>
#include <vtkSphereSource.h>

int main(int, char *[])
{
	vtkSmartPointer<vtkSphereSource> sphereSource1 = vtkSmartPointer<vtkSphereSource>::New();
	sphereSource1->SetCenter(0.0, 0.0, 0.0);
	sphereSource1->SetRadius(2.0f);
	sphereSource1->Update();
	vtkSmartPointer<vtkPolyDataMapper> sphere1Mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
	sphere1Mapper->SetInputConnection( sphereSource1->GetOutputPort() );
	sphere1Mapper->ScalarVisibilityOff();
	vtkSmartPointer<vtkActor> sphere1Actor = vtkSmartPointer<vtkActor>::New();
	sphere1Actor->SetMapper( sphere1Mapper );
	//sphere1Actor->GetProperty()->SetOpacity(.7);
	sphere1Actor->GetProperty()->SetColor(1,0,0);
	sphere1Actor->GetProperty()->SetRepresentationToWireframe();
	vtkSmartPointer<vtkSphereSource> sphereSource2 = vtkSmartPointer<vtkSphereSource>::New();
	sphereSource2->SetCenter(1.0, 0.0, 0.0);
	sphereSource2->SetRadius(2.0f);
	vtkSmartPointer<vtkPolyDataMapper> sphere2Mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
	sphere2Mapper->SetInputConnection( sphereSource2->GetOutputPort() );
	sphere2Mapper->ScalarVisibilityOff();
	vtkSmartPointer<vtkActor> sphere2Actor = vtkSmartPointer<vtkActor>::New();
	sphere2Actor->SetMapper( sphere2Mapper );
	//sphere2Actor->GetProperty()->SetOpacity(.7);
	sphere2Actor->GetProperty()->SetColor(0,1,0);
	sphere2Actor->GetProperty()->SetRepresentationToWireframe();

	vtkSmartPointer<vtkIntersectionPolyDataFilter> intersectionPolyDataFilter =
		vtkSmartPointer<vtkIntersectionPolyDataFilter>::New();
	intersectionPolyDataFilter->SetInputConnection( 0, sphereSource1->GetOutputPort() );
	intersectionPolyDataFilter->SetInputConnection( 1, sphereSource2->GetOutputPort() );
	intersectionPolyDataFilter->Update();

	vtkSmartPointer<vtkPolyDataMapper> intersectionMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
	intersectionMapper->SetInputConnection( intersectionPolyDataFilter->GetOutputPort() );
	intersectionMapper->ScalarVisibilityOff();

	vtkSmartPointer<vtkActor> intersectionActor = vtkSmartPointer<vtkActor>::New();
	intersectionActor->SetMapper( intersectionMapper );

	vtkSmartPointer<vtkRenderer> renderer = vtkSmartPointer<vtkRenderer>::New();
	renderer->AddViewProp(sphere1Actor);
	renderer->AddViewProp(sphere2Actor);
	renderer->AddViewProp(intersectionActor);
	intersectionActor->GetProperty()->SetColor(0,0,1);

	vtkSmartPointer<vtkRenderWindow> renderWindow = vtkSmartPointer<vtkRenderWindow>::New();
	renderWindow->AddRenderer( renderer );

	vtkSmartPointer<vtkRenderWindowInteractor> renWinInteractor =
		vtkSmartPointer<vtkRenderWindowInteractor>::New();
	renWinInteractor->SetRenderWindow( renderWindow );

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

	return EXIT_SUCCESS;
}


可以看出使用是非常简单的，

【类实现部分】

vtkSmartPointer<vtkIntersectionPolyDataFilter> intersectionPolyDataFilter =
	vtkSmartPointer<vtkIntersectionPolyDataFilter>::New();
intersectionPolyDataFilter->SetInputConnection( 0, sphereSource1->GetOutputPort() );
intersectionPolyDataFilter->SetInputConnection( 1, sphereSource2->GetOutputPort() );
intersectionPolyDataFilter->Update();

输入两个多边形数据信息，调用Update() 函数就可以得到像个多边形数据相交的数据信息： 

intersectionMapper->SetInputConnection( <span style="background-color: rgb(255, 153, 255);">intersectionPolyDataFilter->GetOutputPort()</span> );

【类实现过程的分析】

其实内部还有很多东西是可以学习的，接下来就分析一下 这个类的源代码：


可以看出该类的基类是 vtkPolyDataAlgorithm ，所以这个类中最为重要的函数就是 

intRequestData (vtkInformation *,vtkInformationVector **, vtkInformationVector *)
通过前面文章的分析可以知道，该类调用 Update()  函数的过程中系统会自动调用这个 RequestData() 这个函数。

该类的实现部分：

int vtkIntersectionPolyDataFilter::RequestData(vtkInformation* vtkNotUsed(request),
	vtkInformationVector** inputVector,
	vtkInformationVector*  outputVector)
{
	vtkInformation* inInfo0 = inputVector[0]->GetInformationObject(0);
	vtkInformation* inInfo1 = inputVector[1]->GetInformationObject(0);
	vtkInformation* outIntersectionInfo = outputVector->GetInformationObject(0);
	vtkInformation* outPolyDataInfo0 = outputVector->GetInformationObject(1);
	vtkInformation* outPolyDataInfo1 = outputVector->GetInformationObject(2);

	vtkPolyData *input0 = vtkPolyData::SafeDownCast(inInfo0->Get(vtkDataObject::DATA_OBJECT()));
	vtkPolyData *input1 = vtkPolyData::SafeDownCast(inInfo1->Get(vtkDataObject::DATA_OBJECT()));
	vtkPolyData *outputIntersection = vtkPolyData::SafeDownCast(outIntersectionInfo->Get(vtkDataObject::DATA_OBJECT()));
	vtkSmartPointer< vtkPoints > outputIntersectionPoints =	vtkSmartPointer< vtkPoints >::New();
	outputIntersection->SetPoints(outputIntersectionPoints);

	vtkPolyData *outputPolyData0 = vtkPolyData::SafeDownCast(outPolyDataInfo0->Get(vtkDataObject::DATA_OBJECT()));
	vtkPolyData *outputPolyData1 = vtkPolyData::SafeDownCast(outPolyDataInfo1->Get(vtkDataObject::DATA_OBJECT()));

	// Set up new poly data for the inputs to build cells and links.
	vtkSmartPointer< vtkPolyData > mesh0 = vtkSmartPointer< vtkPolyData >::New();
	mesh0->DeepCopy(input0);

	vtkSmartPointer< vtkPolyData > mesh1 = vtkSmartPointer< vtkPolyData >::New();
	mesh1->DeepCopy(input1);

	// Find the triangle-triangle intersections between mesh0 and mesh1
	vtkSmartPointer< vtkOBBTree > obbTree0 = vtkSmartPointer< vtkOBBTree >::New();
	obbTree0->SetDataSet(mesh0);
	obbTree0->SetNumberOfCellsPerNode(10);
	obbTree0->SetMaxLevel(1000000);
	obbTree0->SetTolerance(1e-6);
	obbTree0->AutomaticOn();
	obbTree0->BuildLocator();

	vtkSmartPointer< vtkOBBTree > obbTree1 = vtkSmartPointer< vtkOBBTree >::New();
	obbTree1->SetDataSet(mesh1);
	obbTree1->SetNumberOfCellsPerNode(10);
	obbTree1->SetMaxLevel(1000000);
	obbTree1->SetTolerance(1e-6);
	obbTree1->AutomaticOn();
	obbTree1->BuildLocator();

	// Set up the structure for determining exact triangle-triangle intersections.
	vtkIntersectionPolyDataFilter::Impl *impl = new vtkIntersectionPolyDataFilter::Impl();
	impl->Mesh[0]  = mesh0;
	impl->Mesh[1]  = mesh1;
	impl->OBBTree1 = obbTree1;

	vtkSmartPointer< vtkCellArray > lines = vtkSmartPointer< vtkCellArray >::New();
	outputIntersection->SetLines(lines);
	impl->IntersectionLines = lines;

	// Add cell data arrays that map the intersection line to the cells
	// it splits.
	impl->CellIds[0] = vtkIdTypeArray::New();
	impl->CellIds[0]->SetName("Input0CellID");
	outputIntersection->GetCellData()->AddArray(impl->CellIds[0]);
	impl->CellIds[0]->Delete();
	impl->CellIds[1] = vtkIdTypeArray::New();
	impl->CellIds[1]->SetName("Input1CellID");
	outputIntersection->GetCellData()->AddArray(impl->CellIds[1]);
	impl->CellIds[1]->Delete();

	impl->PointCellIds[0] = vtkIdTypeArray::New();
	impl->PointCellIds[0]->SetName("PointCellsIDs");
	impl->PointCellIds[1] = vtkIdTypeArray::New();
	impl->PointCellIds[1]->SetName("PointCellsIDs");

	double bounds0[6], bounds1[6];
	mesh0->GetBounds(bounds0);
	mesh1->GetBounds(bounds1);
	for (int i = 0; i < 3; i++)
	{
		int minIdx = 2*i;
		int maxIdx = 2*i+1;
		if (bounds1[minIdx] < bounds0[minIdx])
		{
			bounds0[minIdx] = bounds1[minIdx];
		}
		if (bounds1[maxIdx] > bounds0[maxIdx])
		{
			bounds0[maxIdx] = bounds1[maxIdx];
		}
	}

	vtkSmartPointer< vtkPointLocator > pointMerger = vtkSmartPointer< vtkPointLocator >::New();
	pointMerger->SetTolerance(1e-6);
	pointMerger->InitPointInsertion(outputIntersection->GetPoints(), bounds0);
	impl->PointMerger = pointMerger;

	// This performs the triangle intersection search
	obbTree0->IntersectWithOBBTree
		(obbTree1, 0, vtkIntersectionPolyDataFilter::Impl::FindTriangleIntersections,
		impl);

	// Split the first output if so desired
	if ( this->SplitFirstOutput )
	{	// 默认执行
		mesh0->BuildLinks();
		impl->SplitMesh(0, outputPolyData0, outputIntersection);
	}
	else
	{
		outputPolyData0->ShallowCopy( mesh0 );
	}

	// Split the second output if desired
	if ( this->SplitSecondOutput )
	{
		mesh1->BuildLinks();
		impl->SplitMesh(1, outputPolyData1, outputIntersection);
	}
	else
	{
		outputPolyData1->ShallowCopy( mesh1 );
	}

	impl->PointCellIds[0]->Delete();
	impl->PointCellIds[1]->Delete();
	delete impl;

	return 1;
}

分析：

  • 对输入的两个面数据 mesh0 + mesh1 分别建立一个 vtkOBBTree
  • 两个OBB树调用 IntersectWithOBBTree() ， 遍历两个树的每个节点，并通过调用  FindTriangleIntersections() 函数找所有的相交线,作为第一个输出
  • 每个面数据调用 SplitMesh() 函数 将面重新三角化,作为第二三个输出，通过调用 intersectionPolyDataFilter->SetSplitFirstOutput(0); 来决定是否重新三角化，如果用不到重新三角化的数据，可以将 off 掉这个功能，加速。
对于输入面的重新三角化的结果：


图中蓝色为相交面，绿色为源数据信息，红色为重新三角化后的输出数据。

【内部分析】

第一个有趣的地方：

typedef struct _CellEdgeLine {
	vtkIdType CellId;
	vtkIdType EdgeId;
	vtkIdType LineId;
} CellEdgeLineType;

typedef std::multimap< vtkIdType, CellEdgeLineType > PointEdgeMapType;
typedef PointEdgeMapType::iterator                   PointEdgeMapIteratorType;
根据之后代码的分析，我才发现，这个地方主要是为了实现 multimap 的遍历： 
        PointEdgeMapType    *PointEdgeMap[2];
	PointEdgeMapIteratorType iterLower =
		this->PointEdgeMap[index]->lower_bound( ptId );
	PointEdgeMapIteratorType iterUpper =
		this->PointEdgeMap[index]->upper_bound( ptId );

	while (iterLower != iterUpper)
	{
		if ( iterLower->second.CellId == cellId )
		{
			return;
		}
		++iterLower;
	}

（这样子看，觉得这个挺好的）

第二个有趣的地方：

类的定义出就写着 Private implementation to hide STL.

class vtkIntersectionPolyDataFilter::Impl
{
public:
	Impl();
	virtual ~Impl();

	static int FindTriangleIntersections(vtkOBBNode *node0, vtkOBBNode *node1,
		vtkMatrix4x4 *transform, void *arg);

	int SplitMesh(int inputIndex, vtkPolyData *output, vtkPolyData *intersectionLines);

protected:

	vtkCellArray* SplitCell(vtkPolyData *input, vtkIdType cellId,
		vtkIdType *cellPts, IntersectionMapType *map,
		vtkPolyData *interLines);

	void AddToPointEdgeMap(int index, vtkIdType ptId, double x[3],
		vtkPolyData *mesh, vtkIdType cellId,
		vtkIdType edgeId, vtkIdType lineId,
		vtkIdType triPts[3]);

	void SplitIntersectionLines(int inputIndex, vtkPolyData *sourceMesh,
		vtkPolyData *splitLines);

public:
	vtkPolyData         *Mesh[2];
	vtkOBBTree          *OBBTree1;

	// Stores the intersection lines.
	vtkCellArray        *IntersectionLines;

	// Cell data that indicates in which cell each intersection
	// lies. One array for each output surface.
	vtkIdTypeArray      *CellIds[2];

	// Map from points to the cells that contain them. Used for point
	// data interpolation. For points on the edge between two cells, it
	// does not matter which cell is recorded because the interpolation
	// will be the same.  One array for each output surface.
	vtkIdTypeArray      *PointCellIds[2];

	// Merging filter used to convert intersection lines from "line
	// soup" to connected polylines.
	vtkPointLocator     *PointMerger;

	// Map from cell ID to intersection line.
	IntersectionMapType *IntersectionMap[2];

	// Map from point to an edge on which it resides, the ID of the
	// cell, and the ID of the line.
	PointEdgeMapType    *PointEdgeMap[2];

protected:
	Impl(const Impl&); // purposely not implemented
	void operator=(const Impl&); // purposely not implemented

};


第一个公有函数:

int vtkIntersectionPolyDataFilter::Impl
	::FindTriangleIntersections(vtkOBBNode *node0, vtkOBBNode *node1,
	vtkMatrix4x4 *transform, void *arg)
{
	vtkIntersectionPolyDataFilter::Impl *info =	reinterpret_cast<vtkIntersectionPolyDataFilter::Impl*>(arg);

	vtkPolyData     *mesh0                = info->Mesh[0];
	vtkPolyData     *mesh1                = info->Mesh[1];
	vtkOBBTree      *obbTree1             = info->OBBTree1;
	vtkCellArray    *intersectionLines    = info->IntersectionLines;<span style="white-space:pre">	</span>// 相交线的几何信息
	vtkIdTypeArray  *intersectionCellIds0 = info->CellIds[0];<span style="white-space:pre">		</span>// mesh0中每个相交三角形cell 的 cellID 
	vtkIdTypeArray  *intersectionCellIds1 = info->CellIds[1];<span style="white-space:pre">		</span>// mesh1中每个相交三角形cell 的 cellID
	vtkPointLocator *pointMerger          = info->PointMerger;<span style="white-space:pre">		</span>// 相交线的点的信息

	int numCells0 = node0->Cells->GetNumberOfIds();
	int retval = 0;
	// 遍历节点0中所有的CellID
	for (vtkIdType id0 = 0; id0 < numCells0; id0++)
	{
		vtkIdType cellId0 = node0->Cells->GetId(id0);
		int type0 = mesh0->GetCellType(cellId0);

		if (type0 == VTK_TRIANGLE)
		{
			vtkIdType npts0, *triPtIds0;
			mesh0->GetCellPoints(cellId0, npts0, triPtIds0);
			double triPts0[3][3];						// 当前Cell 中所有点（也就是3个点）的坐标
			for (vtkIdType id = 0; id < npts0; id++)
			{
				mesh0->GetPoint(triPtIds0[id], triPts0[id]);
			}
			// 判断当前得到的三角形是不是与 Tree1 的 node1 上的三角形相交
			// Returns true if triangle (optionally transformed) intersects node.
			if (obbTree1->TriangleIntersectsNode
				(node1, triPts0[0], triPts0[1], triPts0[2], transform))
			{
				int numCells1 = node1->Cells->GetNumberOfIds();
				for (vtkIdType id1 = 0; id1 < numCells1; id1++)
				{
					vtkIdType cellId1 = node1->Cells->GetId(id1);
					int type1 = mesh1->GetCellType(cellId1);
					if (type1 == VTK_TRIANGLE)
					{
						// See if the two cells actually intersect. If they do,
						// add an entry into the intersection maps and add an
						// intersection line.
						vtkIdType npts1, *triPtIds1;
						mesh1->GetCellPoints(cellId1, npts1, triPtIds1);
						double triPts1[3][3];     // tree1 中 node1 所包含的 Cells 中所有点（也就是3个点）的坐标
						for (vtkIdType id = 0; id < npts1; id++)
						{
							mesh1->GetPoint(triPtIds1[id], triPts1[id]);
						}
						// 判断是否两个三角形相交
						int coplanar = 0;
						double outpt0[3], outpt1[3];
						int intersects =
							vtkIntersectionPolyDataFilter::TriangleTriangleIntersection
							(triPts0[0], triPts0[1], triPts0[2],
							triPts1[0], triPts1[1], triPts1[2],
							coplanar, outpt0, outpt1);
						// 三角形共面 : coplanar = 1
						if ( coplanar )
						{
							// Coplanar triangle intersection is not handled.
							// This intersection will not be included in the output.
							intersects = 0;
							continue;
						}
						// 两个三角形相交线，并且线段有长度不相同
						if ( intersects &&
							( outpt0[0] != outpt1[0] ||
							outpt0[1] != outpt1[1] ||
							outpt0[2] != outpt1[2] ) )
						{	// 存储相交相交线段的信息
							vtkIdType lineId = intersectionLines->GetNumberOfCells();
							intersectionLines->InsertNextCell(2);

							vtkIdType ptId0, ptId1;
							pointMerger->InsertUniquePoint(outpt0, ptId0);
							pointMerger->InsertUniquePoint(outpt1, ptId1);
							intersectionLines->InsertCellPoint(ptId0);
							intersectionLines->InsertCellPoint(ptId1);

							intersectionCellIds0->InsertNextValue(cellId0);		// 当前 Tree0.node0 对应的 cellID
							intersectionCellIds1->InsertNextValue(cellId1);     // 当前 Tree1.node1 对应的 cellID
							// Map from points to the cells that contain them, 每个点都是临近两个cell
							info->PointCellIds[0]->InsertValue( ptId0, cellId0 );		// Tree0.node0.cell0所对应的点
							info->PointCellIds[0]->InsertValue( ptId1, cellId0 );
							info->PointCellIds[1]->InsertValue( ptId0, cellId1 );       // Tree1.node1.cell1所对应的点
							info->PointCellIds[1]->InsertValue( ptId1, cellId1 );
							// IntersectionMap[0]: Tree0.node0.cell0 所对应的相交线的ID
							info->IntersectionMap[0]->insert(std::make_pair(cellId0, lineId));
							info->IntersectionMap[1]->insert(std::make_pair(cellId1, lineId));

							// Check which edges of cellId0 and cellId1 outpt0 and
							// outpt1 are on, if any.
							for (vtkIdType edgeId = 0; edgeId < 3; edgeId++)
							{
								info->AddToPointEdgeMap(0, ptId0, outpt0, mesh0, cellId0,
									edgeId, lineId, triPtIds0);
								info->AddToPointEdgeMap(0, ptId1, outpt1, mesh0, cellId0,
									edgeId, lineId, triPtIds0);
								info->AddToPointEdgeMap(1, ptId0, outpt0, mesh1, cellId1,
									edgeId, lineId, triPtIds1);
								info->AddToPointEdgeMap(1, ptId1, outpt1, mesh1, cellId1,
									edgeId, lineId, triPtIds1);
							}
							retval++;
						}
					}
				}
			}
		}
	}

	return retval;
}

遍历两个树中某两个节点中的每个 cell ，调用函数 TriangleTriangleIntersection 求出两个三角形相交的线，相交线段的两个端点 outpt0, outpt1

我自己觉得比较麻烦的地方就是为了 vtkIntersectionPolyDataFilter::Impl *info 这个变量各种成员属性的赋值，可能是最近变笨了，所以对于有很多属性的类有点迷茫，会忘记、混淆。。。

对于vtkIdTypeArray的操作也不熟

// Insert data at a specified position in the array. 
void vtkIdTypeArray::InsertValue (vtkIdType id, vtkIdType f ) 
// Insert data at the end of the array. Return its location in the array. 
vtkIdType vtkIdTypeArray::InsertNextValue (vtkIdType f)



vtkIntersectionPolyDataFilter两多边形数据集的交线
C++ 爱好者 make_it_simple888
01-13 2698
图像处理与VTK/ITK文章列表 算法思想：遍历两个树中某两个节点中的每个 cell (三角形面片)，调用函数TriangleTriangleIntersection 求出两个三角形相交的线，相交线段的两个端点outpt0, outpt1 下面实现用一个有界平面切割一个球体，得到切割的边缘多边形，多边形用红色给出，也可以只显示多边形。 本文使用的两个VtkSource类 ： 1...
【VTK】vtkImplicitFunction及其子类介绍
qq_40041064的博客
11-22 1881
主要介绍vtkImplicitFunction接口及其子类的实现原理和用途。
vtk中计算线段与vtkPolyData的交点 及 相交的cell（vtkOBBTree，vtkModifiedBSPTree）
yuxing55555的博客
05-04 3766
效果图： 1.判断交点 关键代码： // Create the locator vtkSmartPointer&lt;vtkOBBTree&gt; tree = vtkSmartPointer&lt;vtkOBBTree&gt;::New(); tree-&gt;SetDataSet(sphereSource-&gt;GetOutput()); tree-&...
四、vtkPolyData数据
最新发布
weixin_51795597的博客
03-18 440
1、vtkPolyData是VTK（Visualization ToolKit）中用于表示的核心类。它是VTK中最常用的数据类之一，。2、vtkPolyData数据由据组成。几何结构数据主要是组成模型的点集（Points）。拓扑结构数据是按一定关系组成的单元数据（Cells）。属性数据与几何机构和拓扑结构数据相关联，可以标量、向量、张量，可以用来间接表示图形的颜色。
vtk学习笔记 --- 判断三角形相交
aswang的专栏
03-18 1072
在使用三角网连接矿体的时候，需要判断当前连接的三角形和已经连接的三角形是否相交，所以，就需要进行三角形相交判断。   看了一些算法的文章，两个三角形相交的判断规则大体如下：   假设这两个三角形为A(a1,a2,a3),B(b1,b2,b3)，三角形A所在的平面为PA，法向量为NA，三角形B所在的平面为PB，法向量为NB。   1、将三角形A的所有顶点投影到平面PB上，投影得到...
VTK 学习----VTK对象-算法类-vtkPolyDataAlgorithm
charce_you的专栏
07-04 6744
4.5.6 vtkPolyDataAlgorithm vtkAdaptiveSubdivisionFilter 基于边缘和/或面积度量细分三角形。 vtkAdaptiveSubdivisionFilter是一个基于最大边长和/或三角形区域细分三角形的滤镜。 通过指定任何给定三角形可能具有的最大边长和/或三角形区域来控制三角形细分。细分继续进行，直到满足其标准。请注意，使用过小的标准值会产生巨...
VTK笔记-使用vtkOBBTree类获得直线与多边形数据的交点
黑山老妖的博客
09-24 1767
创建一个立方体和一条穿过该立方体的直线； vtkNew<vtkCubeSource> cube; cube->SetCenter(0, 0, 0); cube->SetXLength(10); cube->SetYLength(10); cube->SetZLength(10); cube->Update(); vtkNew<vtkPolyDataMapper> map; map->SetInputConnection(cube->Ge..
VTK应用CGAL布尔运算、三角剖分、补洞、模型偏置（膨胀）降采样、骨架提取
06-29
在计算机图形学领域，VTK ( Visualization Toolkit ) 和 CGAL ( Computational Geometry Algorithms Library ) 是两个强大的工具库。VTK主要用于数据可视化，而CGAL则专注于几何算法。本项目结合了两者，实现了一些...
【VTKExamples::PolyData】第二十五期 IntersectionPolyDataFilter
qq_40041064的博客
02-11 630
本文分享VTK样例IntersectionPolyDataFilter，并解析接口vtkIntersectionPolyDataFilter。包含的重要应用包括：输入PolyData数据的检查；PolyData数据自由边和坏三角形的检查等重要方法。希望对各位小伙伴有所帮助！该样例讲述了两个PolyData对象的交集结果。
第四节《VTK Bool运算不稳定解决方案-CGAL算法融合》
yumeiguo的博客
12-01 1280
前几节写的内容感觉一般般，这一节来点狠货，之前我在使用VTK做项目时，总是需要用到模型布尔运算处理一些事务，但是VTK的布尔运算不忍直视，太鸡肋了，稍稍复杂一点的模型就计算不了，算法极度不稳定，所以这种情况是不能应用在项目里面的。CGAL算法五：模型偏置，将模型按照三角网格法向进行偏置，但是偏置参数并不是网格距离，好在是线性参数，多试验几次就能获得很好的网格，这个函数执行完，需要使用原网格与偏置后的网格做一个boolean运算即可得出偏置网格。CRF_UNION, // 并集。
（04）VTK移动模型，判断是否相交
Rexinx博客
10-08 2030
前言 在模型相交检测时（碰撞检测），使用了重写vtkInteractorStyleTrackballActor函数的自己构建的交互器，实现检测鼠标按键，并显示不同颜色在不同相交情况时。 方法 重写vtkInteractorStyleTrackballActor // Define interaction style class MouseInteractorStyle6 : public vtkInteractorStyleTrackballActor { public: static Mou.
三维模型布尔运算 求并、交、差
06-18
三维模型布尔运算 相交 相减 求并 三维模型布尔运算 求并、交、差 三维模型布尔运算 求并、交、差 三维模型布尔运算 求并、交、差
VTK-输出含有两个对象的polydata 数据
小可爱的博客
12-02 704
...........................上面略.................... //输出含有两个对象的polydata 数据会用到vtkAppendPolyData vtkSmartPointer<vtkAppendPolyData> appendFilter = vtkSmartPointer<vtkAppendPolyData&...
VTK：交叉点 PolyData 过滤器用法实战
希望我的博客，能帮上你解决学习中工作中所遇到的问题
02-06 510
VTK：交叉点 PolyData 过滤器用法实战程序输出程序完整源代码 程序输出 程序完整源代码 #include <vtkActor.h> #include <vtkIntersectionPolyDataFilter.h> #include <vtkNamedColors.h> #include <vtkNew.h> #include <vtkPolyDataMapper.h> #include <vtkProperty.h> #
VTK实战：绘制相交线
.
08-22 248
接着，我们需要对数据进行剖分。剖分会将数据转换为三角形网格，以便后续的处理。VTK提供了多种剖分算法，如Delunay算法、正二十面体算法等。最后，我们需要将计算出的相交线显示出来。VTK提供了多种可视化工具，如vtkActor和vtkRenderer。我们首先需要创建一个包含图形数据的VTK数据对象。我们可以使用VTK提供的一些滤波器来计算相交线。在三维可视化中，相交线是一种非常常见的效果。在本篇文章中，我们将介绍如何使用VTK库来实现绘制相交线的效果。通过以上代码，我们可以成功实现相交线的效果。
使用vtk提取模型模型边线2021-01-24
muye2356的博客
01-24 1433
使用vtk提取模型模型边线 最近做一个项目，需要用到提取模型边线的功能，分享和记录一下提取模型边线过程和方法。 主要用到vtk类有vtkSTLReader，读取stl模型文件，vtkAppendPolyData，合并读取的stl文件，vtkFeatureEdges，提取模型边线。 相关代码如下： #include “stdafx.h” #include <vtkAutoInit.h> VTK_MODULE_INIT(vtkRenderingOpenGL...
（03）两个模型的交集、并集、差集
Rexinx博客
10-08 1452
前言 在做一碰撞检测时，犹豫一直无法实现，就行想到直接对两个模型求交集，如果交集部分为空，就说明其没有相交，于是使用了下面的方法，求模型的交集。（后来由于在不相交时一直有报错误，但在后来的研究中发现及时报错并不影响其运行，但是最后还是放弃了） 方法 构建两个模型，通过设置其相对位置，使得其可以相交，并显示相交部分。 代码如下： { //int w = intersectionPolyDataFilter->GetNumberOfIntersectionPoints(); vtkS
VTK 碰撞检测 模型相交检测 几种实现方式
q610098308的专栏
05-17 1347
原理类似于点是否在面内的判断方法，以点得到一条线段，判断其与面的交点，依据该点两侧交点个数的奇偶性判断，如果两侧交点均为偶数则在面外，如果为奇数则在面内；2，VTK自带了一个vtkCollisionDetectionFilter过滤器，来计算碰撞检测，此过滤器利用的就是OBB包围盒，使用简单，只需提供两个物体的数据集和矩阵即可。1， 求物体的包围盒，然后检测包围盒与线、面、或者另一个包围盒是否相交。包围盒主要包括球体、轴对齐包围盒(AABB)、有向包围盒(OBB)和凸包(Convex Hull)，
vtk中物体的交集等运算
qq_23158477的博客
04-29 1191
/========================================================================= Copyright © Constantine Butakoff All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTIC
使用vtkPolyData处理多边形数据——IEEE 829-2008标准
在计算机图形学和可视化领域，多边形数据（vtkPolyData）是一种核心的数据结构，用于表示复杂的几何形状。根据标题和描述，我们可以深入探讨多边形数据在VTK（Visualization Toolkit）中的重要性和使用方法。 VTK是...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值