平面内两条线段的位置关系(相交)判定与交点求解

admin

概念
平面内两条线段位置关系的判定在很多领域都有着广泛的应用，比如游戏、CAD、图形处理等，而两线段交点的求解又是该算法中重要的一环。本文将尽可能用通俗的语言详细的描述一种主流且性能较高的判定算法。

外积，又称叉积，是向量代数（解析几何）中的一个概念。两个二维向量v1(x1, y1)和v2(x2, y2)的外积v1×v2=x1y2-y1x2。如果由v1到v2是顺时针转动，外积为负，反之为正，为0表示二者方向相同（平行）。此外，文中涉及行例式和方程组的概念，请参阅线性代数的相关内容。

为方便计算，对坐标点的大小比较作如下定义：x坐标较大的点为大，x坐标相等但y坐标较大的为大，x与y都相等的点相等。一条线段中较小的一端为起点，较大的一端为终点。



问题
给定两条线段的端点坐标，求其位置关系，并求出交点（如果存在）。



分析
两条线段的位置关系大体上可以分为三类：有重合部分、无重合部分但有交点（相交）、无交点。为避免精度问题，首先要将所有存在重合的情况排除。

重合可分为：完全重合、一端重合、部分重合三种情况。显然，两条线段的起止点都相同即为完全重合；只有起点相同或只有终点相同的为一端重合（注意：坐标较小的一条线段的终点与坐标较大的一条线段的起点相同时应判定为相交）。要判断是否部分重合，必须先判断是否平行。设线段L1(p1->p2)和L2(p3->p4)，其中p1(x1, y1)为第一条线段的起点，p2(x2, y2)为第一条线段的终点，p3(x3, y3)为第二条线段的起点，p4(x4, y4)为第二段线段的终点，由此可构造两个向量：

v1(x2-x1, y2-y1)，v2(x4-x3, y4-y3)
若v1与v2的外积v1×v2为0，则两条线段平行，有可能存在部分重合。再判断两条平行线段是否共线，方法是用L1的一端和L2的一端构成向量vs并与v2作外积，如果vs与v2也平行则两线段共线（三点共线）。在共线的前提下，若起点较小的线段终点大于起点较大的线段起点，则判定为部分重合。

没有重合，就要判定两条线是否相交，主要的算法还是依靠外积。然而外积的计算开销比较大，如果不相交的情况比较多，可先做快速排斥实验：将两条线段视为两个矩形的对角线，并构造出这两个矩形。如果这两个矩形没有重叠部分（x坐标相离或y坐标相离）即可判定为不相交。

然后执行跨立试验。两条相交的线段必然相互跨立，简单的讲就是p1和p2两点位于L2的两侧且p3和p4两点位于L1的两侧，这样就可利用外积做出判断了。分别构造向量s1(p3, p1), s2(p3, p2)，如果s1×v2与s2×v2异号(s1->v2与s2->v2转动的方向相反），则说明p1和p2位于L2的两侧。同理可判定p3和p4是否跨立L1。如果上述四个叉积中任何一个等于0，则说明一条线段的端点在另一条线上。

当判定两条线段相交后，就可以进行交点的求解了。当然，求交点可以用平面几何方法，列点斜式方程来完成。但这样作会难以处理斜率为0的特殊情况，且运算中会出现多次除法，很难保证精度。这里将使用向量法求解。

设交点为(x0, y0)，则下列方程组必然成立：

x0-x1=k1(x2-x1)
y0-y1=k1(y2-y1)
x0-x3=k2(x4-x3)
y0-y3=k2(y4-y3)
其中k1和k2为任意不为0的常数（若为0，则说明有重合的端点，这种情况在上面已经被排除了）。1式与2式联系，3式与4式联立，消去k1和k2可得：

x0(y2-y1)-x1(y2-y1)=y0(x2-x1)-y1(x2-x1)
x0(y4-y3)-x3(y4-y3)=y0(x4-x3)-y3(x4-x3)
将含有未知数x0和y0的项移到左边，常数项移动到右边，得：

(y2-y1)x0+(x1-x2)y0=(y2-y1)x1+(x1-x2)y1
(y4-y3)x0+(x3-x4)y0=(y4-y3)x3+(x3-x4)y3
设两个常数项分别为b1和b2：

b1=(y2-y1)x1+(x1-x2)y1
b2=(y4-y3)x3+(x3-x4)y3
系数行列式为D，用b1和b2替换x0的系数所得系数行列式为D1，替换y0的系数所得系数行列式为D2，则有：

|D|=(x2-x1)(y4-y3)-(x4-x3)(y2-y1)
|D1|=b2(x2-x1)-b1(x4-x3)
|D2|=b2(y2-y1)-b1(y4-y3)
由此，可求得交点坐标为：

x0=|D1|/|D|, y0=|D2|/|D|
解毕。



C++/STL实现

1. #include <iostream>
2. #include <cmath>
3. using namespace std;
4. struct POINTF {float x; float y;};
5. bool Equal(float f1, float f2) {
6.     return (abs(f1 - f2) < 1e-4f);
7. }
8. //判断两点是否相等
9. bool operator==(const POINTF &p1, const POINTF &p2) {
10.     return (Equal(p1.x, p2.x) && Equal(p1.y, p2.y));
11. }
12. //比较两点坐标大小，先比较x坐标，若相同则比较y坐标
13. bool operator>(const POINTF &p1, const POINTF &p2) {
14.     return (p1.x > p2.x || (Equal(p1.x, p2.x) && p1.y > p2.y));
15. }
16. //计算两向量外积
17. float operator^(const POINTF &p1, const POINTF &p2) {
18.     return (p1.x * p2.y - p1.y * p2.x);
19. }
20. //判定两线段位置关系，并求出交点(如果存在)。返回值列举如下：
21. //[有重合] 完全重合(6)，1个端点重合且共线(5)，部分重合(4)
22. //[无重合] 两端点相交(3)，交于线上(2)，正交(1)，无交(0)，参数错误(-1)
23. int Intersection(POINTF p1, POINTF p2, POINTF p3, POINTF p4, POINTF &Int) {
24.     //保证参数p1!=p2，p3!=p4
25.     if (p1 == p2 || p3 == p4) {
26.         return -1; //返回-1代表至少有一条线段首尾重合，不能构成线段
27.     }
28.     //为方便运算，保证各线段的起点在前，终点在后。
29.     if (p1 > p2) {
30.         swap(p1, p2);
31.     }
32.     if (p3 > p4) {
33.         swap(p3, p4);
34.     }
35.     //判定两线段是否完全重合
36.     if (p1 == p3 && p2 == p4) {
37.         return 6;
38.     }
39.     //求出两线段构成的向量
40.     POINTF v1 = {p2.x - p1.x, p2.y - p1.y}, v2 = {p4.x - p3.x, p4.y - p3.y};
41.     //求两向量外积，平行时外积为0
42.     float Corss = v1 ^ v2;
43.     //如果起点重合
44.     if (p1 == p3) {
45.         Int = p1;
46.         //起点重合且共线(平行)返回5；不平行则交于端点，返回3
47.         return (Equal(Corss, 0) ? 5 : 3);
48.     }
49.     //如果终点重合
50.     if (p2 == p4) {
51.         Int = p2;
52.         //终点重合且共线(平行)返回5；不平行则交于端点，返回3
53.         return (Equal(Corss, 0) ? 5 : 3);
54.     }
55.     //如果两线端首尾相连
56.     if (p1 == p4) {
57.         Int = p1;
58.         return 3;
59.     }
60.     if (p2 == p3) {
61.         Int = p2;
62.         return 3;
63.     }//经过以上判断，首尾点相重的情况都被排除了
64.     //将线段按起点坐标排序。若线段1的起点较大，则将两线段交换
65.     if (p1 > p3) {
66.         swap(p1, p3);
67.         swap(p2, p4);
68.         //更新原先计算的向量及其外积
69.         swap(v1, v2);
70.         Corss = v1 ^ v2;
71.     }
72.     //处理两线段平行的情况
73.     if (Equal(Corss, 0)) {
74.         //做向量v1(p1, p2)和vs(p1,p3)的外积，判定是否共线
75.         POINTF vs = {p3.x - p1.x, p3.y - p1.y};
76.         //外积为0则两平行线段共线，下面判定是否有重合部分
77.         if (Equal(v1 ^ vs, 0)) {
78.             //前一条线的终点大于后一条线的起点，则判定存在重合
79.             if (p2 > p3) {
80.                 Int = p3;
81.                 return 4; //返回值4代表线段部分重合
82.             }
83.         }//若三点不共线，则这两条平行线段必不共线。
84.         //不共线或共线但无重合的平行线均无交点
85.         return 0;
86.     } //以下为不平行的情况，先进行快速排斥试验
87.     //x坐标已有序，可直接比较。y坐标要先求两线段的最大和最小值
88.     float ymax1 = p1.y, ymin1 = p2.y, ymax2 = p3.y, ymin2 = p4.y;
89.     if (ymax1 < ymin1) {
90.         swap(ymax1, ymin1);
91.     }
92.     if (ymax2 < ymin2) {
93.         swap(ymax2, ymin2);
94.     }
95.     //如果以两线段为对角线的矩形不相交，则无交点
96.     if (p1.x > p4.x || p2.x < p3.x || ymax1 < ymin2 || ymin1 > ymax2) {
97.         return 0;
98.     }//下面进行跨立试验
99.     POINTF vs1 = {p1.x - p3.x, p1.y - p3.y}, vs2 = {p2.x - p3.x, p2.y - p3.y};
100.     POINTF vt1 = {p3.x - p1.x, p3.y - p1.y}, vt2 = {p4.x - p1.x, p4.y - p1.y};
101.     float s1v2, s2v2, t1v1, t2v1;
102.     //根据外积结果判定否交于线上
103.     if (Equal(s1v2 = vs1 ^ v2, 0) && p4 > p1 && p1 > p3) {
104.         Int = p1;
105.         return 2;
106.     }
107.     if (Equal(s2v2 = vs2 ^ v2, 0) && p4 > p2 && p2 > p3) {
108.         Int = p2;
109.         return 2;
110.     }
111.     if (Equal(t1v1 = vt1 ^ v1, 0) && p2 > p3 && p3 > p1) {
112.         Int = p3;
113.         return 2;
114.     }
115.     if (Equal(t2v1 = vt2 ^ v1, 0) && p2 > p4 && p4 > p1) {
116.         Int = p4;
117.         return 2;
118.     } //未交于线上，则判定是否相交
119.     if(s1v2 * s2v2 > 0 || t1v1 * t2v1 > 0) {
120.         return 0;
121.     } //以下为相交的情况，算法详见文档
122.     //计算二阶行列式的两个常数项
123.     float ConA = p1.x * v1.y - p1.y * v1.x;
124.     float ConB = p3.x * v2.y - p3.y * v2.x;
125.     //计算行列式D1和D2的值，除以系数行列式的值，得到交点坐标
126.     Int.x = (ConB * v1.x - ConA * v2.x) / Corss;
127.     Int.y = (ConB * v1.y - ConA * v2.y) / Corss;
128.     //正交返回1
129.     return 1;
130. }
131. //主函数
132. int main(void) {
133.     //随机生成100个测试数据
134.     for (int i = 0; i < 100; ++i) {
135.         POINTF p1, p2, p3, p4, Int;
136.         p1.x = (float)(rand() % 10); p1.y = (float)(rand() % 10);
137.         p2.x = (float)(rand() % 10); p2.y = (float)(rand() % 10);
138.         p3.x = (float)(rand() % 10); p3.y = (float)(rand() % 10);
139.         p4.x = (float)(rand() % 10); p4.y = (float)(rand() % 10);
140.         int nr = Intersection(p1, p2, p3, p4, Int);
141.         cout << "[(";
142.         cout << (int)p1.x << ',' << (int)p1.y << "),(";
143.         cout << (int)p2.x << ',' << (int)p2.y << ")]--[(";
144.         cout << (int)p3.x << ',' << (int)p3.y << "),(";
145.         cout << (int)p4.x << ',' << (int)p4.y << ")]: ";
146.         cout << nr;
147.         if (nr > 0) {
148.             cout << '(' << Int.x << ',' << Int.y << ')';
149.         }
150.         cout << endl;
151.     }
152.     return 0;
153. }
155. https://www.cnblogs.com/devymex/archive/2010/08/19/1803885.html

复制代码