检测立方体和圆锥体是否相互交叉？

时间：2014-02-25 19:16:43

标签： python c++ math 3d collision-detection

考虑3D中的两个几何对象：

  • 与轴对齐并由其中心位置及其范围（边长）
    • 定义的立方体
  • 一个不与轴对齐的圆锥体，由其顶点的位置，底部中心的位置和顶点的半角定义

这是一个用C ++定义这些对象的小代码：

// Preprocessor
#include <iostream>
#include <cmath>
#include <array>

// 3D cube from the position of its center and the side extent
class cube
{ 
    public:
        cube(const std::array<double, 3>& pos, const double ext)
        : _position(pos), _extent(ext) 
        {;}
        double center(const unsigned int idim) 
            {return _position[idim];}
        double min(const unsigned int idim)
            {return _position[idim]-_extent/2;}
        double max(const unsigned int idim)
            {return _position[idim]+_extent/2;}
        double extent()
            {return _extent;}
        double volume()
            {return std::pow(_extent, 3);}
    protected:
        std::array<double, 3> _position;
        double _extent;
};

// 3d cone from the position of its vertex, the base center, and the angle
class cone
{
    public:
        cone(const std::array<double, 3>& vert, 
             const std::array<double, 3>& bas, 
             const double ang)
        : _vertex(vert), _base(bas), _angle(ang)
        {;}
        double vertex(const unsigned int idim)
            {return _vertex[idim];}
        double base(const unsigned int idim)
            {return _base[idim];}
        double angle()
            {return _angle;}
        double height()
            {return std::sqrt(std::pow(_vertex[0]-_base[0], 2)+std::pow(
            _vertex[1]-_base[1], 2)+std::pow(_vertex[2]-_base[2], 2));}
        double radius()
            {return std::tan(_angle)*height();}
        double circle()
            {return 4*std::atan(1)*std::pow(radius(), 2);}
        double volume()
            {return circle()*height()/3;}
    protected:
        std::array<double, 3> _vertex;
        std::array<double, 3> _base;
        double _angle;
};

我想编写一个函数来检测立方体和圆锥的交点是否为空：

// Detect whether the intersection between a 3d cube and a 3d cone is not null
bool intersection(const cube& x, const cone& y)
{
    // Function that returns false if the intersection of x and y is empty
    // and true otherwise
}

以下是问题的说明（插图是2D，但我的问题是3D）： Cube and cone intersection

如何有效地执行此操作（我正在搜索算法，因此答案可以是C，C ++或Python）？

注意：此处交点定义为：它存在一个位于立方体和圆锥内的非零三维体积（如果立方体位于圆锥内，或者如果圆锥位于立方体内，则它们相交）。

4 个答案:

答案 0 :(得分：5)

  1. 想象2个无限行

    • 圆锥轴
    • 线穿过与{{li>>垂直的点P（起点的立方体中心）。

    锥形轴对您而言很容易知道，第二行定义为

    P+t*(perpendicular vector to cone axis)

    该矢量可以通过锥轴矢量和垂直于图像的矢量（假设Z轴）的叉积获得。 t是标量值参数...

  2. 计算这两条线/轴的交点

    如果您不知道方程式派生他们或google他们。设交点为Q

  3. 如果交叉点Q不在锥体内

    （在顶点和底点之间）然后点P不与锥相交。从交叉方程式中，您将获得参数t1和t2

    • 让t1成为P轴线
    • 和t2用于锥轴线

    如果您的轴线方向向量也是锥长，那么如果t2 = <0,1>

    4. ，则交叉点在锥内。

  4. 如果P不在三角形内部（由这两个轴生成的切割圆锥到平面）

    这也很容易你知道Q在锥体（t2）内的位置，所以你知道锥体在P - 从Q轴到距离R*t2其中R是圆锥的基本半径。因此，您可以计算|P-Q|并检查它是<=R*t2还是直接使用t1（如果P轴方向向量是单位）。

    如果距离较大，则R*t2点P不会与圆锥相交。

  5. 如果＃3和＃4为正数，则P与圆锥相交

    cone

    • 希望你不介意这里是你的形象，为了清晰起见，增加了一些东西

    6. <强> [注释]

    现在，当没有立方体的顶点与锥体相交但是立方体本身与锥体相交时，存在边缘情况。 ||P-Q|-R*t2| = <0,half cube size>在这种情况下，您应检查更多点，然后沿最近的立方体面立方体顶点。

    另一种方法是：

    1. 为圆锥

      创建变换矩阵

      其中：

      • 其顶点为原点
      • 其轴为+Z轴
      • 和XY平面与其基础平行

      所以任何一点都在锥内，如果

      • Z = <0,h>
      • X*X + Y*Y <= (R*Z/h)^2或X*X + Y*Y <= (R*Z*tan(angle))^2

    2. 将立方体顶点转换为圆锥空间

      并检查是否有任何顶点在锥内也可以检查所有立方体边缘线的条件来自＃1（代数）或沿着立方体面使用更多的点，如前面的方法。

      3. 聊天讨论：http://chat.stackoverflow.com/rooms/48756/discussion-between-spektre-and-joojaa

答案 1 :(得分：5)

代码

这个答案会比你的问题略胜一筹（例如我认为是一个方框而不是一个方块）。适应你的情况应该非常简单。

一些定义

/*
    Here is the cone in cone space:

            +        ^
           /|\       |
          /*| \      | H
         /  |  \     |
        /       \    |
       +---------+   v

    * = alpha (angle from edge to axis)
*/
struct Cone // In cone space (important)
{
    double H;
    double alpha;
};

/*
    A 3d plane
      v
      ^----------+
      |          |
      |          |
      +----------> u
      P
*/
struct Plane
{
    double u;
    double v;
    Vector3D P;
};

// Now, a box.
// It is assumed that the values are coherent (that's only for this answer).
// On each plane, the coordinates are between 0 and 1 to be inside the face.
struct Box
{
    Plane faces[6];
};

线 - 锥交点

现在，让我们计算一个段和我们的锥体之间的交集。请注意，我将在锥形空间中进行计算。另请注意，我将Z轴作为垂直轴。把它改成Y一个留给读者练习。假设该线在锥形空间中。分段方向未规范化;相反，该段具有方向向量的长度，并从点P开始：

/*
    The segment is points M where PM = P + t * dir, and 0 <= t <= 1
    For the cone, we have 0 <= Z <= cone.H
*/
bool intersect(Cone cone, Vector3D dir, Vector3D P)
{
    // Beware, indigest formulaes !
    double sqTA = tan(cone.alpha) * tan(cone.alpha);
    double A = dir.X * dir.X + dir.Y * dir.Y - dir.Z * dir.Z * sqTA;
    double B = 2 * P.X * dir.X +2 * P.Y * dir.Y - 2 * (cone.H - P.Z) * dir.Z * sqTA;
    double C = P.X * P.X + P.Y * P.Y - (cone.H - P.Z) * (cone.H - P.Z) * sqTA;

    // Now, we solve the polynom At² + Bt + C = 0
    double delta = B * B - 4 * A * C;
    if(delta < 0)
        return false; // No intersection between the cone and the line
    else if(A != 0)
    {
        // Check the two solutions (there might be only one, but that does not change a lot of things)
        double t1 = (-B + sqrt(delta)) / (2 * A);
        double z1 = P.Z + t1 * dir.Z;
        bool t1_intersect = (t1 >= 0 && t1 <= 1 && z1 >= 0 && z1 <= cone.H);

        double t2 = (-B - sqrt(delta)) / (2 * A);
        double z2 = P.Z + t2 * dir.Z;
        bool t2_intersect = (t2 >= 0 && t2 <= 1 && z2 >= 0 && z2 <= cone.H);

        return t1_intersect || t2_intersect;
    }
    else if(B != 0)
    {
        double t = -C / B;
        double z = P.Z + t * dir.Z;
        return t >= 0 && t <= 1 && z >= 0 && z <= cone.H;
    }
    else return C == 0;
}

直 - 圆锥交点

现在，我们可以检查平面的矩形部分是否与圆锥相交（这将用于检查立方体的面是否与圆锥相交）。仍然在锥形空间。该计划以一种有助于我们的方式传递：2个向量和一个点。矢量未标准化，以简化计算。

/*
    A point M in the plan 'rect' is defined by:
        M = rect.P + a * rect.u + b * rect.v, where (a, b) are in [0;1]²
*/
bool intersect(Cone cone, Plane rect)
{
    bool intersection = intersect(cone, rect.u, rect.P)
                     || intersect(cone, rect.u, rect.P + rect.v)
                     || intersect(cone, rect.v, rect.P)
                     || intersect(cone, rect.v, rect.P + rect.u);

    if(!intersection)
    {
        // It is possible that either the part of the plan lie
        // entirely in the cone, or the inverse. We need to check.
        Vector3D center = P + (u + v) / 2;

        // Is the face inside the cone (<=> center is inside the cone) ?
        if(center.Z >= 0 && center.Z <= cone.H)
        {
            double r = (H - center.Z) * tan(cone.alpha);
            if(center.X * center.X + center.Y * center.Y <= r)
                intersection = true;
        }

        // Is the cone inside the face (this one is more tricky) ?
        // It can be resolved by finding whether the axis of the cone crosses the face.
        // First, find the plane coefficient (descartes equation)
        Vector3D n = rect.u.crossProduct(rect.v);
        double d = -(rect.P.X * n.X + rect.P.Y * n.Y + rect.P.Z * n.Z);

        // Now, being in the face (ie, coordinates in (u, v) are between 0 and 1)
        // can be verified through scalar product
        if(n.Z != 0)
        {
            Vector3D M(0, 0, -d/n.Z);
            Vector3D MP = M - rect.P;
            if(MP.scalar(rect.u) >= 0
               || MP.scalar(rect.u) <= 1
               || MP.scalar(rect.v) >= 0
               || MP.scalar(rect.v) <= 1)
                intersection = true;
        }
    }
    return intersection;
}

箱 - 锥交叉口

现在，最后一部分：整个立方体：

bool intersect(Cone cone, Box box)
{
    return intersect(cone, box.faces[0])
        || intersect(cone, box.faces[1])
        || intersect(cone, box.faces[2])
        || intersect(cone, box.faces[3])
        || intersect(cone, box.faces[4])
        || intersect(cone, box.faces[5]);
}

对于数学

仍然在锥形空间中，锥方程是：

// 0 is the base, the vertex is at z = H
x² + y² = (H - z)² * tan²(alpha)
0 <= z <= H

现在，3D中一条线的参数方程是：

x = u + at
y = v + bt
z = w + ct

方向向量是（a，b，c），点（u，v，w）位于该行上。

现在，让我们把方程式放在一起：

(u + at)² + (v + bt)² = (H - w - ct)² * tan²(alpha)

然后，在对这个等式进行开发和重新分解之后，我们得到以下结论：

At² + Bt + C = 0

其中A，B和C显示在第一个交叉函数中。只需解决此问题并检查z和t上的边界条件。

答案 2 :(得分：2)

信息：我不知道这个想法是否已经是一个专利的知识产权（在您所在的地区），或者没有，或者如何找出，或者其他任何意义。我这样做是为了好玩。 ：）

但是，这是牛肉：

  • 步骤1：近似：为了提高效率，请将两个对象视为球体（使用外球体）。计算它们的 distance （在它们的两个中心点之间），以确定它们是否足够接近相交。如果它们不可能相交，则快速返回false（因为它们的距离大于两个球体的半径之和）。

  • 第2步：精确计算：这是一种简单的方法：将锥形解释为一批名为 voxels的三维像素（或legos）：选择您认为可接受的分辨率（粒度）（可能为0.01）。创建一个从（0,0,0）指向锥体体积内任意体素点的矢量（从您已命名为“顶点”的点开始）。如果该体素的坐标存在于给定的多维数据集内，则返回true。根据所选的粒度，为您可以为圆锥体对象计算的每个体素重复此操作。

  • 第3步：如果没有匹配，则返回false。

优化：通过考虑立方体的内部球体，确定任何给定的3-D点是否在立方体内部的函数可以是可优化的。意思是，任何给定的三维点都在立方体内，如果它足够接近立方体内部球体的中心在该球体内。有趣的是，当你开始用额外的球体填充空的立方角以进行更多优化时（这完全是可选的）。

我确信第2步可以进一步优化。但是，这种方法的好处在于你可以自由调整粒度，在计算时间和计算精度之间进行微调。

您还可以创建一个自动缩小多次迭代粒度的解算器。意味着精度随着时间的推移而增加（为了更好的分辨率

答案 3 :(得分：1)

几年前，我制作了一个有效的算法来测试锥体和aabb之间的交叉，以获得一些渲染代码。我最近需要对我现在正在处理的事情进行测试，所以我重新审视它并使其更加高效。我花了更多的时间来承认解决这个问题，因此我决定免除你的痛苦并发布代码。因此，这是AFAIK一个完全独特的解决方案，并且不会在教科书中找到（即David Eberly的解决方案）。

大编辑：我之前的算法处理了大多数情况，我没有注意到任何问题 - 直到我得到足够大的时间来严格测试所有情况。它在一种情况下具有小的误差范围，并且在针对蛮力6平面方法进行测试时在另一种情况下具有相当大的误差范围。我最后做的分段测试无法解释所有可能的奇怪情况，即扩展锥体会穿透盒子。它在我的2D和绘制得很差的3D测试用例上看起来很不错，但在实践中失败了。我的新想法略贵一些，但它是防弹的。

新版本的步骤如下：

1。）如果顶点位于边界框内，请提前退出。

2。）识别锥体可能触摸的面（最多3个）并将它们的顶点添加到数组中。

3.）将数组中的所有顶点投影到＆＃34; cone-space＆＃34;。

4。）如果投影顶点在锥体内

，请提前退出

5.）对顶点数组和圆锥半径进行圆形多边形测试，以捕捉与圆锥边界上的多边形的边缘交点

bool Intersect(const Cone& pCone) const {
    Vector3 pFaceVerts[12];
    U32 uVertCount;
    int piClipSigns[3];
    U32 uClipCount = GetClipInfo(pCone.GetApex(), piClipSigns);

    switch (uClipCount) {
        // If the clip count is zero, the apex is fully contained in the box
        xcase 0: {
            return true;
        }
        // 1) Clips single face, 4 vertices, guaranteed to not touch any other faces
        xcase 1: {
            int iFacet = piClipSigns[0] != 0 ? 0 : (piClipSigns[1] != 0 ? 1 : 2);
            GetFacetVertices(iFacet, piClipSigns[iFacet], pFaceVerts);
            uVertCount = 4;
        }
        // 2) Clips an edge joining two candidate faces, 6 vertices
        // 3) Clips a vertex joining three candidate faces, 7 vertices
        xcase 2:
        acase 3: {
            uVertCount = 0;
            for (U32 iFacet = 0; iFacet < 3; iFacet++) {
                if (piClipSigns[iFacet] != 0) {
                    GetFacetVertices(iFacet, piClipSigns[iFacet], pFaceVerts + uVertCount);
                    uVertCount += 4;
                }
            }
            FixVertices(pFaceVerts, uVertCount);
        }
    }

    // Project vertices into cone-space
    F32 fConeRadiusSquared = Square(pCone.GetRadius());
    F32 pfLengthAlongAxis[6];
    bool bOutside = true;
    for (U32 i = 0; i < uVertCount; i++) {
        pfLengthAlongAxis[i] = Dot(pCone.GetAxis(), pFaceVerts[i] - pCone.GetApex());
        bOutside &= Clamp1(pfLengthAlongAxis[i], LargeEpsilon, pCone.GetHeight() - LargeEpsilon);
    }
    // Outside the cone axis length-wise
    if (bOutside) {
        return false;
    }
    for (U32 i = 0; i < uVertCount; i++) {
        Vector3 vPosOnAxis = pCone.GetApex() + pCone.GetAxis() * pfLengthAlongAxis[i];
        Vector3 vDirFromAxis = pFaceVerts[i] - vPosOnAxis;

        F32 fScale = (pCone.GetHeight() / pfLengthAlongAxis[i]);
        F32 x = fScale * Dot(vDirFromAxis, pCone.GetBaseRight());
        F32 y = fScale * Dot(vDirFromAxis, pCone.GetBaseUp());
        // Intersects if any projected points are inside the cone
        if (Square(x) + Square(y) <= fConeRadiusSquared) {
            return true;
        }
        pFaceVerts[i] = Vector2(x, y);
    }
    // Finally do a polygon circle intersection with circle center at origin
    return PolygonCircleIntersect(pFaceVerts, uVertCount, pCone.GetRadius());
}

GetClipInfo：

inline U32 GetClipInfo(const Vector3& P, int piClipSigns[3]) const {
    U32 N = 0;
    for (U32 i = 0; i < 3; i++) {
        if (P[i] < m_vMin[i]) {
            piClipSigns[i] = -1;
            N++;
        } else if (P[i] > m_vMax[i]) {
            piClipSigns[i] = +1;
            N++;
        } else {
            piClipSigns[i] = 0;
        }
    }
    return N;
}

GetFacetVertices和FixVertices目前略显苛刻，但是他们分别获得了面上的顶点并将顶点固定为凸面和ccw排序。

另一种方法是将所有顶点投影到锥形空间而不需要任何奇特的逻辑，但我需要尽可能快地将其分解为几种情况。

我尝试了各种其他方法，特别是锥轴和盒子之间的分离轴测试，并使用最大的分离轴来获得最接近的面以使用PolygonCircleIntersect进行测试，但我确定了一个失败案例，因此将其抛出。 / p>

相关问题
最新问题