VTK 判断一个 点 是否在一个模型 stl 内部 vtk 点是否在内部 表面 寻找最近点

判断 一个点 ,判断是否在风格 stl 模型内部，或表面：

目录

1.方案一：使用vtkCellLocator  FindClosestPoint 找到模型上距离给定点最近的一点，计算两点的距离 ，小于某一阈值 则认为此点在模型上；

2.方案二 使用 vtkKdTreePointLocator

3.方案三 使用 vtkSelectEnclosedPoints

---

1.方案一：使用vtkCellLocator  FindClosestPoint 找到模型上距离给定点最近的一点，计算两点的距离 ，小于某一阈值 则认为此点在模型上；

vtkCellLocator本身是一个octree。典型的用法就是求最近的单元或者点

bool CheckPointInsidePolyData(vtkPolyData * poly, double* pt)
{
	bool inside=false; 
	auto cellLocator = vtkSmartPointer<vtkCellLocator>::New();
	cellLocator->SetDataSet(poly);
	cellLocator->BuildLocator();
	auto assistCell = vtkSmartPointer<vtkGenericCell>::New();
	double closestPoint[3];//the coordinates of the closest point will be returned here
	double closestPointDist2; //the squared distance to the closest point will be returned here
	vtkIdType cellId; //the cell id of the cell containing the closest point will be returned here
	int subId=-1;
	cellLocator->FindClosestPoint(point, closestPoint, assistCell, cellId, subId, closestPointDist2);
 
	if (-1!= subId&&closestPointDist2 < 0.001)
	{
		return true;
	}
	return inside;
}

2.方案二 使用 vtkKdTreePointLocator

但这个只能找到最新的点，还需要自己判断一下距离

官方样例：

#include <vtkIdList.h>
#include <vtkKdTreePointLocator.h>
#include <vtkNew.h>
#include <vtkPoints.h>
#include <vtkPolyData.h>

int main(int, char*[])
{
  // Setup point coordinates
  double x[3] = {1.0, 0.0, 0.0};
  double y[3] = {0.0, 1.0, 0.0};
  double z[3] = {0.0, 0.0, 1.0};

  vtkNew<vtkPoints> points;
  points->InsertNextPoint(x);
  points->InsertNextPoint(y);
  points->InsertNextPoint(z);

  vtkNew<vtkPolyData> polydata;
  polydata->SetPoints(points);

  // Create the tree
  vtkNew<vtkKdTreePointLocator> kDTree;
  kDTree->SetDataSet(polydata);
  kDTree->BuildLocator();

  double testPoint[3] = {2.0, 0.0, 0.0};

  // Find the closest points to TestPoint
  vtkIdType iD = kDTree->FindClosestPoint(testPoint);
  std::cout << "The closest point is point " << iD << std::endl;

  // Get the coordinates of the closest point
  double closestPoint[3];
  kDTree->GetDataSet()->GetPoint(iD, closestPoint);
  std::cout << "Coordinates: " << closestPoint[0] << " " << closestPoint[1]
            << " " << closestPoint[2] << std::endl;

  return EXIT_SUCCESS;
}

3.方案三 使用 vtkSelectEnclosedPoints

vtkSelectEnclosedPoints类可以判断标记点是否在封闭表面内。
vtkSelectEnclosedPoints是一个Filter，它计算所有输入点以确定它们是否位于封闭曲面中。过滤器生成一个（0,1）掩码（以vtkDataArray的形式），指示点是在提供的曲面的外部（掩码值=0）还是内部（掩码值=1）(输出vtkDataArray的名称是“SelectedPoints”。）
运行过滤器后，可以通过调用IsInside（ptId）方法来查询点是否在内部/外部。

样例：判断三个点是否在立方体内

注意：在立方体边上的点，不属于在立方体内部；

 CODE

#include <vtkVersion.h>
#include <vtkPolyData.h>
#include <vtkPointData.h>
#include <vtkCubeSource.h>
#include <vtkSmartPointer.h>
#include <vtkSelectEnclosedPoints.h>
#include <vtkIntArray.h>
#include <vtkDataArray.h>
#include <vtkProperty.h>
#include <vtkPolyDataMapper.h>
#include <vtkActor.h>
#include <vtkRenderWindow.h>
#include <vtkRenderer.h>
#include <vtkRenderWindowInteractor.h>

int main(int, char*[])
{

	vtkNew<vtkCubeSource> cubeSource;
	cubeSource->Update();

	vtkPolyData* cube = cubeSource->GetOutput();

	double testInside[3] = { 0.0, 0.0, 0.0 };
	double testOutside[3] = { 0.7, 0.0, 0.0 };
	double testBorderOutside[3] = { 0.5, 0.0, 0.0 };
	vtkNew<vtkPoints> points;
	points->InsertNextPoint(testInside);
	points->InsertNextPoint(testOutside);
	points->InsertNextPoint(testBorderOutside);

	vtkNew<vtkPolyData> pointsPolydata;
	pointsPolydata->SetPoints(points);

	//Points inside test
	vtkNew<vtkSelectEnclosedPoints> selectEnclosedPoints;
	selectEnclosedPoints->SetInputData(pointsPolydata);
	selectEnclosedPoints->SetSurfaceData(cube);
	selectEnclosedPoints->Update();

	for (unsigned int i = 0; i < 3; i++) {
		std::cout << "Point " << i << ": " << selectEnclosedPoints->IsInside(i) << std::endl;
	}

	vtkDataArray* insideArray = vtkDataArray::SafeDownCast(selectEnclosedPoints->GetOutput()->GetPointData()->GetArray("SelectedPoints"));

	for (vtkIdType i = 0; i < insideArray->GetNumberOfTuples(); i++) {
		std::cout << i << " : " << insideArray->GetComponent(i, 0) << std::endl;
	}
	//Cube mapper, actor
	vtkNew<vtkPolyDataMapper> cubeMapper;
	cubeMapper->SetInputConnection(cubeSource->GetOutputPort());

	vtkNew<vtkActor> cubeActor;
	cubeActor->SetMapper(cubeMapper);
	cubeActor->GetProperty()->SetOpacity(0.5);

	//First, apply vtkVertexGlyphFilter to make cells around points, vtk only render cells.
	vtkNew<vtkVertexGlyphFilter> vertexGlyphFilter;

	vertexGlyphFilter->AddInputData(pointsPolydata);
	vertexGlyphFilter->Update();

	vtkNew<vtkPolyDataMapper> pointsMapper;
	pointsMapper->SetInputConnection(vertexGlyphFilter->GetOutputPort());

	vtkNew<vtkActor> pointsActor;
	pointsActor->SetMapper(pointsMapper);
	pointsActor->GetProperty()->SetPointSize(5); 
	pointsActor->GetProperty()->SetColor(1.0, 0.0, 0);

	//Create a renderer, render window, and interactor
	vtkNew<vtkRenderer> renderer;
	vtkNew<vtkRenderWindow> renderWindow;
	renderWindow->AddRenderer(renderer);
	vtkNew<vtkRenderWindowInteractor> renderWindowInteractor;
	renderWindowInteractor->SetRenderWindow(renderWindow);

	// Add the actor to the scene
	renderer->AddActor(cubeActor);
	renderer->AddActor(pointsActor);
	renderer->SetBackground(.0, 1, .0);

	renderWindow->Render();
	renderWindowInteractor->Start();
	return EXIT_SUCCESS;
}
 
 

输出：

Point 0: 1
Point 1: 0
Point 2: 0
0 : 1
1 : 0
2 : 0