-----------------------------------------3D---------------------------------------
文章出处：https://www.cnblogs.com/graphics/archive/2010/08/05/1793393.html
原作者：zdd
注明：我只是为了自己学习照搬
概述：给定三角形ABC和一点P(x,y,z)，判断点P是否在ABC内。这是游戏设计中一个常见的问题。需要注意的是，这里假定点和三角形位于同一个平面内。
本文介绍三种不同的方法，由浅入深
一内角和法
连接点P和三角形的三个顶点得到三条线段PA，PB和PC，求出这三条线段与三角形各边的夹角，如果所有夹角之和为180度，那么点P在三角形内，否则不在，此法直观，但效率低下。
二同向法
假设点P位于三角形内，会有这样一个规律，当我们沿着ABCA的方向在三条边上行走时，你会发现点P始终位于边AB，BC和CA的右侧。我们就利用这一点，但是如何判断一个点在线段的左侧还是右侧呢？我们可以从另一个角度来思考，当选定线段AB时，点C位于AB的右侧，同理选定BC时，点A位于BC的右侧，最后选定CA时，点B位于CA的右侧，所以当选择某一条边时，我们只需验证点P与该边所对的点在同一侧即可。问题又来了，如何判断两个点在某条线段的同一侧呢？可以通过叉积来实现，连接PA，将PA和AB做叉积，再将CA和AB做叉积，如果两个叉积的结果方向一致，那么两个点在同一测。判断两个向量的是否同向可以用点积实现，如果点积大于0，则两向量夹角是锐角，否则是钝角。
代码如下，为了实现程序功能，添加了一个Vector3类，该类表示三维空间中的一个向量。
// 3D vector
class Vector3
{
public:
Vector3(float fx, float fy, float fz)
:x(fx), y(fy), z(fz)
{
}
// Subtract
Vector3 operator - (const Vector3& v) const
{
return Vector3(x - v.x, y - v.y, z - v.z) ;
}
// Dot product
float Dot(const Vector3& v) const
{
return x * v.x + y * v.y + z * v.z ;
}
// Cross product
Vector3 Cross(const Vector3& v) const
{
return Vector3(
y * v.z - z * v.y,
z * v.x - x * v.z,
x * v.y - y * v.x ) ;
}
public:
float x, y, z ;
};
// Determine whether two vectors v1 and v2 point to the same direction
// v1 = Cross(AB, AC)
// v2 = Cross(AB, AP)
bool SameSide(Vector3 A, Vector3 B, Vector3 C, Vector3 P)
{
Vector3 AB = B - A ;
Vector3 AC = C - A ;
Vector3 AP = P - A ;
Vector3 v1 = AB.Cross(AC) ;
Vector3 v2 = AB.Cross(AP) ;
// v1 and v2 should point to the same direction
return v1.Dot(v2) >= 0 ;
}
// Same side method
// Determine whether point P in triangle ABC
bool PointinTriangle1(Vector3 A, Vector3 B, Vector3 C, Vector3 P)
{
return SameSide(A, B, C, P) &&
SameSide(B, C, A, P) &&
SameSide(C, A, B, P) ;
}
//类定义：二维向量 2D vector
Laya ts写法
//确定两个向量v1和v2是否指向相同的方向
public SameSide(A: Laya.Vector3, B: Laya.Vector3, C: Laya.Vector3, P: Laya.Vector3) {
let AB: Laya.Vector3 = new Laya.Vector3();
let AC: Laya.Vector3 = new Laya.Vector3();
let AP: Laya.Vector3 = new Laya.Vector3();
Laya.Vector3.subtract(B, A, AB);
Laya.Vector3.subtract(C, A, AC);
Laya.Vector3.subtract(P, A, AP);
let v1: Laya.Vector3 = new Laya.Vector3();
let v2: Laya.Vector3 = new Laya.Vector3();
Laya.Vector3.cross(AB, AC, v1);
Laya.Vector3.cross(AB, AP, v2);
// 判断v1和v2是否指向同一个方向
let num = Laya.Vector3.dot(v1, v2)
return num >= 0;
}
//确定三角形ABC三点中的点P
public PointinTriangle1(A: Laya.Vector3, B: Laya.Vector3, C: Laya.Vector3, P: Laya.Vector3) {
return this.SameSide(A, B, C, P) && this.SameSide(B, C, A, P) && this.SameSide(C, A, B, P);
}
三 重心法
上面这个方法简单易懂，速度也快，下面这个方法速度更快，只是稍微多了一点数学而已
三角形的三个点在同一个平面上，如果选中其中一个点，其他两个点不过是相对该点的位移而已，比如选择点A作为起点，那么点B相当于在AB方向移动一段距离得到，而点C相当于在AC方向移动一段距离得到
所以对于平面内任意一点，都可以由如下方程来表示
P = A + u * (C – A) + v * (B - A) // 方程1
如果系数u或v为负值，那么相当于朝相反的方向移动，即BA或CA方向。那么如果想让P位于三角形ABC内部，u和v必须满足什么条件呢？有如下三个条件
u >= 0
v >= 0
u + v <= 1
几个边界情况，当u = 0且v = 0时，就是点A，当u = 0,v = 1时，就是点B，而当u = 1, v = 0时，就是点C
整理方程1得到P – A = u(C - A) + v(B - A)
令v0 = C – A, v1 = B – A, v2 = P – A，则v2 = u * v0 + v * v1，现在是一个方程，两个未知数，无法解出u和v，将等式两边分别点乘v0和v1的到两个等式
(v2) • v0 = (u * v0 + v * v1) • v0
(v2) • v1 = (u * v0 + v * v1) • v1
注意到这里u和v是数，而v0，v1和v2是向量，所以可以将点积展开得到下面的式子。
v2 • v0 = u * (v0 • v0) + v * (v1 • v0) // 式1
v2 • v1 = u * (v0 • v1) + v * (v1• v1) // 式2
解这个方程得到
u = ((v1•v1)(v2•v0)-(v1•v0)(v2•v1)) / ((v0•v0)(v1•v1) - (v0•v1)(v1•v0))
v = ((v0•v0)(v2•v1)-(v0•v1)(v2•v0)) / ((v0•v0)(v1•v1) - (v0•v1)(v1•v0))
是时候上代码了，这段代码同样用到上面的Vector3类
// Determine whether point P in triangle ABC
bool PointinTriangle(Vector3 A, Vector3 B, Vector3 C, Vector3 P)
{
Vector3 v0 = C - A ;
Vector3 v1 = B - A ;
Vector3 v2 = P - A ;
float dot00 = v0.Dot(v0) ;
float dot01 = v0.Dot(v1) ;
float dot02 = v0.Dot(v2) ;
float dot11 = v1.Dot(v1) ;
float dot12 = v1.Dot(v2) ;
float inverDeno = 1 / (dot00 * dot11 - dot01 * dot01) ;
float u = (dot11 * dot02 - dot01 * dot12) * inverDeno ;
if (u < 0 || u > 1) // if u out of range, return directly
{
return false ;
}
float v = (dot00 * dot12 - dot01 * dot02) * inverDeno ;
if (v < 0 || v > 1) // if v out of range, return directly
{
return false ;
}
return u + v <= 1 ;
Laya ts写法
//确定三角形ABC三点中的点P
public PointinTriangle2(A: Laya.Vector3, B: Laya.Vector3, C: Laya.Vector3, P: Laya.Vector3) {
let v0: Laya.Vector3 = new Laya.Vector3();
let v1: Laya.Vector3 = new Laya.Vector3();
let v2: Laya.Vector3 = new Laya.Vector3();
Laya.Vector3.subtract(C, A, v0);
Laya.Vector3.subtract(B, A, v1);
Laya.Vector3.subtract(P, A, v2);
let dot00 = Laya.Vector3.dot(v0, v0);
let dot01 = Laya.Vector3.dot(v0, v1);
let dot02 = Laya.Vector3.dot(v0, v2);
let dot11 = Laya.Vector3.dot(v1, v1);
let dot12 = Laya.Vector3.dot(v1, v2);
let inverDeno = 1 / (dot00 * dot11 - dot01 * dot01);
let u = (dot11 * dot02 - dot01 * dot12) * inverDeno;
if (u < 0 || u > 1) //如果u超出范围，直接返回
{
return false;
}
let v = (dot00 * dot12 - dot01 * dot02) * inverDeno;
if (v < 0 || v > 1) // 如果v超出范围，直接返回
{
return false;
}
return u + v <= 1
}
-----------------------------------------2D---------------------------------------
文章转载：http://www.cnblogs.com/TenosDoIt/p/4024413.html
原作者：tenos
注明：我只是为了自己学习照搬
二维平面上判断点是否在三角形内
已知三角形的三个顶点坐标，判断某个点是否在三角形中（在三角形的边上，我们也视作在三角形中），本文给出了三种方法。
算法1
面积法，如上图所示，如果点P在三角形ABC的内部，则三个小三角形PAB, PBC, PAC的面积之和 = ABC的面积，反之则不相等。三角形的三个顶点坐标求其面积，可以根据向量的叉乘，参考链接地址
该算法详见后面代码中的函数：IsPointInTriangle1
算法2
首先看一下这个问题，如何判断某两个点在某条直线的同一侧（代码中函数：IsPointAtSameSideOfLine）
根据向量的叉乘以及右手螺旋定则，AB^AM （表示叉乘，这里向量省略了字母上面的箭头符号）的方向为向外指出屏幕，ABAN也是向外指出屏幕，但AB^AO的方向是向内指向屏幕，因此M,N在直线AB的同侧，M ,O在直线AB的两侧。实际计算时，只需要考虑叉积的数值正负
假设以上各点坐标为A(0,0), B(4,0), M(1,2), N(3,4), O(3,-4)， 则：
AB^AM = (4,0)^(1,2) = 42 - 01 = 8
AB^AN = (4，0)^(3，4) = 44 – 03 = 16
AB^AO = (4,0)^(3,-4) = 4-4 – 03 = –16
由上面的数值可知，可以根据数值的正负判断叉乘后向量的方向。即，如果叉积AB^AM 和 ABAN的结果同号，那么M,N两点就在直线的同侧，否则不在同一侧。特殊地，如果点M在直线AB上，则ABAM的值为0。（如果是在三维坐标系中，求出的叉积是一个向量，可以根据两个向量的点积结果正负来判断两个向量的是否指向同一侧）
以上的问题解决了，就很容易的用来判断某个点是否在三角形内，如果P在三角形ABC内部，则满足以下三个条件：P,A在BC的同侧、P,B在AC的同侧、PC在AB的同侧。某一个不满足则表示P不在三角形内部。
该算法详见后面代码中的函数：IsPointInTriangle2
算法3
该方法也用到了向量。对于三角形ABC和一点P，可以有如下的向量表示：
p点在三角形内部的充分必要条件是：1 >= u >= 0, 1 >= v >= 0, u+v <= 1。
已知A,B,C,P四个点的坐标，可以求出u，v，把上面的式子分别点乘向量AC和向量AB
解方程得到：
解出u，v后只需要看他们是否满足“1 >= u >= 0, 1 >= v >= 0, u+v <= 1”，如满足，则，p 在三角形内。
（u = 0时，p在AB上， v = 0时，p在AC上，两者均为0时，p和A重合）
该算法详见后面代码中的函数：IsPointInTriangle3
算法4
该算法和算法2类似，可以看作是对算法2的简化，也是用到向量的叉乘。假设三角形的三个点按照顺时针（或者逆时针）顺序是A,B,C。对于某一点P，求出三个向量PA,PB,PC, 然后计算以下三个叉乘（^表示叉乘符号）：
t1 = PA^PB,
t2 = PB^PC,
t3 = PC^PA,
如果t1，t2，t3同号（同正或同负），那么P在三角形内部，否则在外部。
该算法详见后面代码中的函数：IsPointInTriangle4
原代码是C语言写的我转换成了TS
//经过测试，算法4最快，算法3次之，接着算法2，算法1最慢。直观的从计算量上来看，也是算法4的计算量最少。
//以下是代码，定义了两个类：二维向量类 和 三角形类
//类定义：二维向量
class V2 {
constructor(x: number, y: number) {
this.x_ = x;
this.y_ = y;
}
private x_: number = 0;
private y_: number = 0;
//二维向量叉乘, 叉乘的结果其实是向量，方向垂直于两个向量组成的平面，这里我们只需要其大小和方向
CrossProduct(vec: V2): number {
return this.x_ * vec.y_ - this.y_ * vec.x_;
}
//二维向量点积
DotProduct(vec: V2): number {
return this.x_ * vec.x_ + this.y_ * vec.y_;
}
//二维向量减法
Minus(vec: V2): V2 {
return new V2(this.x_ - vec.x_, this.y_ - vec.y_);
}
//判断点M,N是否在直线AB的同一侧
static IsPointAtSameSideOfLine(pointM: V2, pointN: V2, pointA: V2, pointB: V2): boolean {
let AB = pointB.Minus(pointA);
let AM = pointM.Minus(pointA);
let AN = pointN.Minus(pointA);
//等于0时表示某个点在直线上
return AB.CrossProduct(AM) * AB.CrossProduct(AN) >= 0;
}
}
//三角形类
class Triangle {
private pointA_: V2;
private pointB_: V2;
private pointC_: V2;
constructor(point1: V2, point2: V2, point3: V2) {
this.pointA_ = point1;
this.pointB_ = point2;
this.pointC_ = point3;
}
//计算三角形面积
ComputeTriangleArea() {
//依据两个向量的叉乘来计算，可参考http://blog.csdn.net/zxj1988/article/details/6260576
let AB: V2 = this.pointB_.Minus(this.pointA_);
let BC: V2 = this.pointC_.Minus(this.pointB_);
// 原文： fabs(AB.CrossProduct(BC) / 2.0);
return Math.abs(AB.CrossProduct(BC) / 2.0);
}
//算法1
IsPointInTriangle1(pointP: V2) {
let area_ABC = this.ComputeTriangleArea();
let area_PAB = new Triangle(pointP, this.pointA_, this.pointB_).ComputeTriangleArea();
let area_PAC = new Triangle(pointP, this.pointA_, this.pointC_).ComputeTriangleArea();
let area_PBC = new Triangle(pointP, this.pointB_, this.pointC_).ComputeTriangleArea();
// 原文： if (fabs(area_PAB + area_PBC + area_PAC - area_ABC) < 0.000001)
if (Math.abs(area_PAB + area_PBC + area_PAC - area_ABC) < 0.000001)
return true;
else return false;
}
//算法2
IsPointInTriangle2(pointP: V2) {
return V2.IsPointAtSameSideOfLine(pointP, this.pointA_, this.pointB_, this.pointC_) &&
V2.IsPointAtSameSideOfLine(pointP, this.pointB_, this.pointA_, this.pointC_) &&
V2.IsPointAtSameSideOfLine(pointP, this.pointC_, this.pointA_, this.pointB_);
}
//算法3
IsPointInTriangle3(pointP: V2) {
let AB = this.pointB_.Minus(this.pointA_);
let AC = this.pointC_.Minus(this.pointA_);
let AP = pointP.Minus(this.pointA_);
let dot_ac_ac = AC.DotProduct(AC);
let dot_ac_ab = AC.DotProduct(AB);
let dot_ac_ap = AC.DotProduct(AP);
let dot_ab_ab = AB.DotProduct(AB);
let dot_ab_ap = AB.DotProduct(AP);
let tmp = 1.0 / (dot_ac_ac * dot_ab_ab - dot_ac_ab * dot_ac_ab);
let u = (dot_ab_ab * dot_ac_ap - dot_ac_ab * dot_ab_ap) * tmp;
if (u < 0 || u > 1)
return false;
let v = (dot_ac_ac * dot_ab_ap - dot_ac_ab * dot_ac_ap) * tmp;
if (v < 0 || v > 1)
return false;
return u + v <= 1;
}
//算法4
IsPointInTriangle4(pointP: V2) {
let PA = this.pointA_.Minus(pointP);
let PB = this.pointB_.Minus(pointP);
let PC = this.pointC_.Minus(pointP);
let t1 = PA.CrossProduct(PB);
let t2 = PB.CrossProduct(PC);
let t3 = PC.CrossProduct(PA);
// return t1 * t2 >= 0 && t1 * t3 >= 0;
return t1 * t2 >= 0 && t1 * t3 >= 0 && t2 * t3 >= 0;
}
}