VTK_測距&隨機數&變換&投影

vtk測距：

點-點：

#include <iostream>
#include <vtkMath.h>

int main(int argc, char* argv[])
{
	// 創建兩個空間點
	double p0[3] = { 0.0, 0.0, 0.0 };
	double p1[3] = { 1.0, 1.0, 1.0 };
	// 平方距離
	double squaredDistance = vtkMath::Distance2BetweenPoints(p0, p1);
	// 真實距離
	double distance = sqrt(squaredDistance);
	// 輸出
	std::cout << "SquaredDistance = " << squaredDistance << std::endl;
	std::cout << "Distance = " << distance << std::endl;
	
	return 0;
}

vtk測量距離非常簡單，通常需要與vtk拾取一起使用，及拾取兩個點，計算間距，其距離計算算法也很簡單。

點-線：

#include <iostream>
#include <vtkSmartPointer.h>
#include <vtkLine.h>
#include <vtkPoints.h>

int main(int argc, char* argv[])
{
	double lineP0[3] = { 0.0, 0.0, 0.0 };	// 一條線的兩個點
	double lineP1[3] = { 2.0, 0.0, 0.0 };

	double p0[3] = { 3.0, 0, 0 };		// 點
	double p1[3] = { 1.0, 2.0, 0 };

	// Distance**2
	double dist0 = vtkLine::DistanceToLine(p0, lineP0, lineP1);
	std::cout << "Dist0: " << dist0 << std::endl;
	double dist1 = vtkLine::DistanceToLine(p1, lineP0, lineP1);
	std::cout << "Dist1: " << dist1 << std::endl;

	// Distance**2，此外，還可得到最近點的座標
	double t;	// 保存的比例，點處於第一個點到第二個點之間的比例，在第二個點之外就大於1
	double closest[3];
	dist0 = vtkLine::DistanceToLine(p0, lineP0, lineP1, t, closest);
	std::cout << "Dist0: " << dist0 << " closest point: " << closest[0] << " " << closest[1] << " " << closest[2] << std::endl;

	dist1 = vtkLine::DistanceToLine(p1, lineP0, lineP1, t, closest);
	std::cout << "Dist1: " << dist1 << " closest point: " << closest[0] << " " << closest[1] << " " << closest[2] << std::endl;

//-----Line
	vtkSmartPointer<vtkLine> pLine = vtkLine::New();	// vtk智能指針
	pLine->GetPoints()->SetPoint(0, lineP0);
	pLine->GetPoints()->SetPoint(0, lineP1);

	// Distance	計算距離只能用直線的兩點。
	dist0 = vtkLine::DistanceToLine(p0, lineP0, lineP1);
	std::cout << "Dist0: " << sqrt(dist0) << std::endl;
	dist1 = vtkLine::DistanceToLine(p1, lineP0, lineP1);
	std::cout << "Dist1: " << sqrt(dist1) << std::endl;

	return 0;
}

點到先的距離計算函數在vtkLine裏面，計算的時候，不能直接使用線對象，需要制定線的兩個端點，或者之間的點也是可以的，但這樣返回的t（比例）就沒有參考價值了。

生成高斯分佈的隨機數：

#include <vtkMath.h>
#include <ctime>

int main(int, char *[])
{
	unsigned int numRand = 20;

	// 沒有這行，生成的全是一樣的
	vtkMath::RandomSeed(time(NULL));

	//高斯分佈生成隨機數（基本規律是中間多，兩邊少）
	for (unsigned int i = 0; i < numRand; i++)
	{
		double a = vtkMath::Gaussian(0.0, 2.0);	// 生成0~2之間的隨機數
		std::cout << a << std::endl;
	}

	return 0;
}

高斯分佈具體可百度，大致規律是中間多，兩邊少。

vtk隨機數生成方法：

#include <vtkMath.h>
#include <ctime>

int main(int argc, char* argv[])
{
	unsigned int numRand = 20;

	vtkMath::RandomSeed(time(NULL));

	for (unsigned int i = 0; i < numRand; i++)
	{
		double a = vtkMath::Random(0.0, 2.0);	// 0~2隨機數
		std::cout << a << std::endl;
	}

	return 0;
}

Random是生成的隨機數，不具有分佈性質，完全的隨機的。

點的透視變換，標準變換：

#include <vtkSmartPointer.h>
#include <vtkPerspectiveTransform.h>
#include <vtkTransform.h>
#include <vtkMatrix4x4.h>

int main(int, char *[])
{
	// 一個4*4的矩陣，
	// 	1，2，3，4
	// 	2，2，3，4
	// 	3，2，3，4
	// 	4，2，3，4
	vtkSmartPointer<vtkMatrix4x4> m = vtkSmartPointer<vtkMatrix4x4>::New();
	m->SetElement(0, 0, 1);
	m->SetElement(0, 1, 2);
	m->SetElement(0, 2, 3);
	m->SetElement(0, 3, 4);
	m->SetElement(1, 0, 2);
	m->SetElement(1, 1, 2);
	m->SetElement(1, 2, 3);
	m->SetElement(1, 3, 4);
	m->SetElement(2, 0, 3);
	m->SetElement(2, 1, 2);
	m->SetElement(2, 2, 3);
	m->SetElement(2, 3, 4);
	m->SetElement(3, 0, 4);
	m->SetElement(3, 1, 2);
	m->SetElement(3, 2, 3);
	m->SetElement(3, 3, 4);

	vtkSmartPointer<vtkPerspectiveTransform> perspectiveTransform =
		vtkSmartPointer<vtkPerspectiveTransform>::New();	// 透視變換
	perspectiveTransform->SetMatrix(m);

	vtkSmartPointer<vtkTransform> transform =
		vtkSmartPointer<vtkTransform>::New();
	transform->SetMatrix(m);

	double p[3];	// 一個點
	p[0] = 1.0;
	p[1] = 2.0;
	p[2] = 3.0;

	double normalProjection[3];
	transform->TransformPoint(p, normalProjection);		// 將p點標準變換，結果保存在normalProjection

	std::cout << "Standard projection: "
		<< normalProjection[0] << " "
		<< normalProjection[1] << " "
		<< normalProjection[2] << std::endl;

	double perspectiveProjection[3];
	perspectiveTransform->TransformPoint(p, perspectiveProjection);		// 將p點透視變換，結果保存在perspectiveProjection
	std::cout << "Perspective projection: "
		<< perspectiveProjection[0]
		<< " " << perspectiveProjection[1] << " "
		<< perspectiveProjection[2] << std::endl;

	return 0;
}

在上面，這個4*4的矩陣就是變換矩陣，當作爲透視變換和標準變換的時候，得到的點不是一樣的

點投影到面：

#include <vtkSmartPointer.h>
#include <vtkPlane.h>

int main(int, char *[])
{
	// 一個平面，實際上這是一個位於0，0，0，面向z軸（顯示器外）的平面
	vtkSmartPointer<vtkPlane> plane = vtkSmartPointer<vtkPlane>::New();
	plane->SetOrigin(0.0, 0.0, 0.0);	// 通過點
	plane->SetNormal(0.0, 0.0, 1.0);	// 法線

	double p[3] = { 23.1, 54.6, 9.2 };		// 需要投影的點
	double origin[3] = { 0.0, 0.0, 0.0 };	// 平面通過點
	double normal[3] = { 0.0, 0.0, 1.0 };	// 平面法向量
	double projected[3];					// 用於保存投影的點

	plane->ProjectPoint(p, origin, normal, projected);

	std::cout << "Projected: " << projected[0] << " "
		<< projected[1] << " " << projected[2] << std::endl;

	return 0;
}

點投影到面，與點線距離有點類似，都不能直接傳入面或者線的對象，而需要直接傳入其決定性的參數。