Question

我正在寻找一种找到两条线的交点的解决方案。我知道可以通过找到其向量积来实现。

我在这里偶然发现了这个例子：

def get_intersect(a1, a2, b1, b2):
    s = np.vstack([a1,a2,b1,b2])        # s for stacked
    h = np.hstack((s, np.ones((4, 1)))) # h for homogeneous
    l1 = np.cross(h[0], h[1])           # get first line
    l2 = np.cross(h[2], h[3])           # get second line
    x, y, z = np.cross(l1, l2)          # point of intersection
    if z == 0:                          # lines are parallel
        return (float('inf'), float('inf'))
    return (x/z, y/z)

我仔细阅读了该示例，并在一些场景中使用了该示例，它似乎运行得很好。但是，有三件事我还不太了解：

为什么矢量需要是同质的（我们用一列填充那一部分）？
同质溶液与非同质溶液（如果有的话）相比有何不同？
为什么我们只检查结果在Z轴上的平行度，而不是X和Y？

我觉得我缺少一些非常明显的东西，但是我无法确定它到底是什么。

Answer 1

作为参考，来自维基百科的等式：

$[]$

让a1 = (x1, y1), a2 = (x2, y2), b1 = (x3, y3), b2 = (x4, y4)。

计算解释

观察链接答案中的前两个叉积：

l1 = np.cross(h[0], h[1]) = (x1, y1, 1) ^ (x2, y2, 1)
   = (y1 - y2, x2 - x1, x1*y2 - x2*y1)

l2 = np.cross(h[2], h[3]) = (x3, y3, 1) ^ (x4, y4, 1)
   = (y3 - y4, x4 - x3, x3*y4 - x4*y3)

这两行是计算上面方程式中的6个不同项的全部。最后一个交叉产品：

x, y, z = np.cross(l1, l2)
      x = (x2 - x1) * (x3*y4 - x4*y3) - (x4 - x3) * (x1*y2 - x2*y1)
-->   y = (y3 - y4) * (x1*y2 - x2*y1) - (y1 - x2) * (x3*y4 - x4*y3)
      z = (y1 - y2) * (x4 - y3) - (y3 - y4) * (x2 - x1)

这些数字完全等于Wikipedia方程中的分子和分母。

像这样的相当复杂的表达式将需要数十条FPU指令来逐项计算。

向量的均质化允许这种叉积方法，可以将其优化为仅使用少量SIMD指令，效率更高。

几何解释

假设您将均匀化的向量视为3D空间中的点，并将每对向量与原点相连以形成两个三角形：

所有4个点均位于平面 Z = 1（灰色）上。

线 L （绿色）是两个三角形（蓝色+红色）的平面之间的交点，并且穿过原点 O 和目标点 P （黄色）。

三角形的法线由其边矢量的叉积给出。在这种情况下，侧面矢量仅由4个点给出，因为另一个点是原点。在代码中，法线由l1和l2给出。

一个平面的定义是，平面中的所有线都必须垂直于其法线。由于线 L 位于两个三角形的平面中，因此它必须垂直于l1和l2，即其方向由np.cross(l1, l2)给出。

均质化允许一个聪明的最终步骤，该步骤使用个相似的三角形来计算 P ：

if z == 0:                          # lines are parallel
    return (float('inf'), float('inf'))
return (x/z, y/z)                   # Px = x / z, Py = y / z

Answer 2

作为对以上答案的略微修正，使用3D叉积计算2D线相交几乎是效率最低的。跨产品根本不会对SIMD进行优化（除非您竭尽全力使用SOA数据结构，但这甚至是非常浪费的方法）。最好的方法是使用良好的旧联立方程。

从定义线的输入点开始：

line1: [(x1, y1), (x2, y2)]
line2: [(x3, y3), (x4, y4)]

计算一些方向向量：

// 1st direction
u1 = x2 - x1
v1 = y2 - y1
D1 = [u1, v1]

// 2nd direction
u2 = x4 - x3
v2 = y4 - y3
D2 = [u2, v2]

现在，我们将线方程重新表示为射线，并针对沿射线的任何点提出方程：

// coords of a point 'd1' distance along the 1st ray
Px = x1 + d1*u1
Py = y1 + d1*v1

// coords of a point 'd2' distance along the 2nd ray
Px = x3 + d2*u2
Py = y3 + d2*v2

让我们假设线条相交，这意味着两个P都相同，从而允许我们声明：

x1 + d1*u1 = x3 + d2*u2
y1 + d1*v1 = y3 + d2*v2

我不会完成每个步骤，而是将两个等式重新排列为d1，我们得到：

 d1 = x3 + d2*u2 - x1
      ---------------
            u1

 d1 = y3 + d2*v2 - y1
      ---------------
            v1

现在我们有两个d1方程，让我们做另一个联立方程来获得d2值：

x3 + d2*u2 - x1     y3 + d2*v2 - y1
---------------  =  ---------------
      u1                  v1

重新排列以隔离d2：

 d2 = u1(y3 - y1) - v1(x3 - x1)
      -------------------------
           v1*u2 - u1*v2

如果（v1 * u2-u1 * v2）恰好为零，则此方程式无解（叫行列式，因为它就是它！）。如果行列式不为零，则只需使用以上方程式计算d2，然后抽回到我们的较早方程式中即可找到点值：

Px = x3 + d2*u2
Py = y3 + d2*v2

一些未经测试的C ++代码：

bool computeIntersectPoint(
  float x1, float y1,
  float x2, float y2,
  float x3, float y3,
  float x4, float y4,
  float outPoint[2])
{
  // compute direction vectors
  // in some cases, it can be worth 
  // storing the lines as rays as an 
  // optimisation. (avoids 4 subs)
  const float u1 = x2 - x1;
  const float v1 = y2 - x1;
  const float u2 = x4 - x3;
  const float v2 = y4 - x3;

  // check to see if we have a solution
  // 1 mul, 1 fmsub
  float determinant = v1*u2 - u1*v1; 
  if(determinant == 0)
    return false;

  // 2 sub, 1 mul, 1 fmsub
  float temp = u1 * (y3 - y1) - v1 * (x3 - x1);

  // 1 div
  float intersectDistance = temp / determinant;

  // 2 fma
  outPoint[0] = intersectDistance * u2 + x3;
  outPoint[1] = intersectDistance * v2 + y3;

  return true;
}

快速证明：https://www.desmos.com/calculator/gtlmnmzn6l

在此处比较这两种方法之间的指令计数是值得的。 3d叉积需要3个mult和3个fmsub指令（如果没有FMA，则需要6 mul + 3 sub）。既然我们有3个，我们最多可以做到：9 mul和9 fmsub ops。将2个分区相加，我们得到：

9 mul
9 fmsub
2 div

我发布的方法需要：

1 div
6 sub
4 fma
2 mul

尽管您可以省去将这些线存储为射线的麻烦，但您可以保存其中的4个。

为什么我们需要使这些向量同质化？

2 个答案:

计算解释

几何解释