碰撞检测算法

请向我看齐

于 2024-11-30 11:17:18 发布

阅读量1.1k

点赞数 16

分类专栏：算法文章标签：算法

本文链接：https://blog.csdn.net/qq_40844444/article/details/144151341

版权

算法专栏收录该内容

121 篇文章

订阅专栏

以下是关于碰撞检测中空间划分（以八叉树、KD树为例）以及碰撞响应的详细内容：

空间划分 - 八叉树（Octree）

原理

八叉树是一种用于对三维空间进行划分的数据结构。它基于递归细分的思想，将一个三维空间区域不断地等分成八个子区域（八叉体），直到满足特定的终止条件，如每个子区域内包含的物体数量小于某个阈值或者子区域的大小小于设定值等。通过这种方式，能够有效地组织和管理三维空间中的物体，方便后续的碰撞检测等操作。

概念

八叉树是一种树形数据结构，每个节点代表一个三维空间区域，根节点表示整个三维空间，非根节点的每个节点都有八个子节点，分别对应将父节点空间等分成的八个子空间。

过程

1. 初始化： 创建八叉树的根节点，其表示整个要处理的三维空间区域，设定该区域的边界范围（如最小坐标和最大坐标）。

2. 插入物体： 对于要放入八叉树中的每个物体，从根节点开始，判断物体与当前节点所代表的空间区域的关系。如果物体完全在该区域内，则继续判断是否需要进一步细分该节点（根据上述终止条件）。如果需要细分，就将物体依次与细分后的八个子节点进行上述判断，直到找到合适的叶子节点放入物体。

3. 细分操作： 当一个节点需要细分时，按照空间的八个方向将其等分成八个子节点，更新每个子节点的空间边界范围，并将原节点中的物体重新分配到合适的子节点中。

4. 查询操作： 例如在碰撞检测时，要查询与某个物体可能发生碰撞的其他物体，从八叉树的根节点开始，遍历相关的节点，通过判断节点所代表的空间区域与查询物体的关系，快速定位到可能包含碰撞物体的子区域，缩小搜索范围。

分类

• 静态八叉树： 在初始化后，八叉树的结构不再改变，适用于场景中物体相对固定的情况，如静态的建筑场景模型。

• 动态八叉树： 可以根据物体的运动、添加或删除等情况实时更新八叉树的结构，更适合于动态场景，如游戏中的角色和道具在场景中移动的情况。

用途

• 在三维游戏开发中，用于快速检测游戏场景中不同物体之间的碰撞可能性，减少不必要的两两物体之间的直接碰撞检测计算量，提高游戏性能。

• 在计算机图形学的渲染中，可辅助进行场景的优化渲染，比如只渲染当前视角可见的八叉树子区域内的物体，提高渲染效率。

• 在机器人运动规划领域，帮助机器人快速判断其运动路径上是否存在障碍物，通过八叉树对空间的划分和物体的组织，能更高效地进行路径搜索和碰撞避免。

C语言代码实现示例（简化示意，实际应用可能更复杂）

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

// 定义三维点结构体
typedef struct Point3D {
    double x;
    double y;
    double z;
} Point3D;

// 定义八叉树节点结构体
typedef struct OctreeNode {
    Point3D min; // 节点所代表空间区域的最小坐标
    Point3D max; // 节点所代表空间区域的最大坐标
    struct OctreeNode *children[8]; // 八个子节点指针
    int numObjects; // 当前节点内包含的物体数量
    void **objects; // 指向物体的指针数组，存储当前节点内的物体
} OctreeNode;

// 创建八叉树节点函数
// 参数注释：
// min：节点所代表空间区域的最小坐标
// max：节点所代表空间区域的最大坐标
OctreeNode *createOctreeNode(Point3D min, Point3D max) {
    OctreeNode *node = (OctreeNode *)malloc(sizeof(OctreeNode));
    node->min = min;
    node->max = max;
    for (int i = 0; i < 8; i++) {
        node->children[i] = NULL;
    }
    node->numObjects = 0;
    node->objects = NULL;
    return node;
}

// 判断点是否在节点空间内函数
// 参数注释：
// point：要判断的三维点
// node：八叉树节点
int isPointInNode(Point3D point, OctreeNode *node) {
    return (point.x >= node->min.x && point.x <= node->max.x &&
            point.y >= node->min.y && point.y <= node->max.y &&
            point.y >= node->min.z && point.y <= node->max.z);
}

// 将物体插入八叉树函数
// 参数注释：
// object：要插入的物体指针
// node：当前八叉树节点
// threshold：细分阈值，当节点内物体数量超过该值时考虑细分
void insertObjectIntoOctree(void *object, OctreeNode *node, int threshold) {
    if (!isPointInNode(*((Point3D *)object), node)) {
        return;
    }

    if (node->numObjects < threshold) {
        node->numObjects++;
        node->objects = (void **)realloc(node->objects, node->numObjects * sizeof(void *));
        node->objects[node->numObjects - 1] = object;
        return;
    }

    if (node->children[0] == NULL) {
        // 细分节点
        Point3D center;
        center.x = (node->min.x + node->max.x) / 2;
        center.y = (node->min.y + node->max.y) / 2;
        center.z = (node->min.z + node->max.z) / 2;

        // 创建八个子节点
        node->children[0] = createOctreeNode(node->min, center);
        node->children[1] = createOctreeNode({center.x, node->min.y, node->min.z}, {node->max.x, center.y, center.z});
        node->children[2] = createOctreeNode({center.x, center.y, node->min.z}, {node->max.x, node->max.y, center.z});
        node->children[3] = createOctreeNode({node->min.x, center.y, node->min.z}, {center.x, node->max.y, center.z});
        node->children[4] = createOctreeNode({node->min.x, node->min.y, center.z}, {center.x, center.y, node->max.z});
        node->children[5] = createOctreeNode({center.x, node->min.y, center.z}, {node->max.x, center.y, node->max.z});
        node->children[6] = createOctreeNode({center.x, center.y, center.z}, {node->max.x, node->max.y, node->max.z});
        node->children[7] = createOctreeNode({node->min.x, center.y, center.z}, {center.x, node->max.y, node->max.z});
    }

    // 将物体插入到合适的子节点中
    for (int i = 0; i < 8; i++) {
        insertObjectIntoOctree(object, node->children[i], threshold);
    }
}

// 释放八叉树内存函数
// 参数注释：
// node：要释放的八叉树节点
void freeOctree(OctreeNode *node) {
    if (node == NULL) {
        return;
    }

    for (int i = 0; i < 8; i++) {
        freeOctree(node->children[i]);
    }

    if (node->objects!= NULL) {
        free(node->objects);
    }

    free(node);
}

空间划分 - KD树（K-Dimensional Tree）

原理

KD树是对高维数据空间进行划分的数据结构，这里以二维或三维情况常见应用为例说明。它通过选择一个维度（如在三维空间中可以依次选择x、y、z维度等），按照该维度上数据的中位数将空间分成两部分（在二维时是左右两部分，在三维时是前后、上下、左右等类似的两部分），然后在每个子空间内继续按照上述方式递归划分，直到满足终止条件，如子空间内的数据点数量小于某个阈值或者子空间的大小小于设定值等。

概念

KD树是一种二叉树结构，每个节点代表一个高维空间区域（这里以二维或三维为例），根节点表示整个高维空间，非根节点的每个节点都有两个子节点，分别对应将父节点空间按照选定维度划分后的两个子空间。

过程

1. 初始化： 创建KD树的根节点，其表示整个要处理的高维空间区域，设定该区域的边界范围（如二维时的最小x、y坐标和最大x、y坐标，三维时的最小x、y、z坐标和最大x、y、z坐标）。

2. 插入数据点： 对于要放入KD树中的每个数据点，从根节点开始，根据当前节点选择的划分维度，判断数据点在该维度上与节点划分值（如中位数）的关系，从而确定将数据点放入左子节点还是右子节点对应的空间区域。如果需要进一步细分子节点，就按照上述方式在子节点内继续递归插入数据点，直到找到合适的叶子节点放入数据点。

3. 划分操作： 当插入数据点时需要对节点进行划分，首先选择一个划分维度（按照一定规则，如轮流选择不同维度等），然后计算该维度上所有数据点的中位数，根据中位数将节点空间分成两个子空间，更新每个子节点的空间边界范围，并将原节点中的数据点重新分配到合适的子节点中。

4. 查询操作： 例如在碰撞检测时，要查询与某个数据点可能发生碰撞的其他数据点，从KD树的根节点开始，遍历相关的节点，通过判断节点所代表的空间区域与查询数据点的关系，快速定位到可能包含碰撞数据点的子区域，缩小搜索范围。

分类

• 平衡KD树： 通过一些调整手段，尽量使KD树的左右子树高度相对平衡，这样在查询操作时能够保证较好的时间复杂度，通常采用一些重平衡算法来实现，适用于对查询效率要求较高的场景。

• 非平衡KD树： 不特意去保证树的平衡，构建过程相对简单，但在查询时可能会出现性能不稳定的情况，适用于数据点分布相对均匀且对查询效率要求不是特别高的场景。

用途

• 在计算机视觉中，用于图像特征匹配等操作，通过KD树对图像特征点的高维数据进行组织和划分，能够快速找到与给定特征点相似的其他特征点，提高匹配效率。

• 在地理信息系统（GIS）中，对地理坐标等高维数据进行管理和查询，比如快速定位到与某个地点坐标相近的其他地点，通过KD树的空间划分可以缩小搜索范围，提高查询速度。

• 在三维游戏开发中，类似于八叉树，也可用于碰撞检测等操作，通过对游戏场景中的物体位置等数据进行KD树划分，减少不必要的碰撞检测计算量，提高游戏性能。

C语言代码实现示例（简化示意，实际应用可能更复杂）

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

// 定义三维点结构体
typedef struct Point3D {
    double x;
    double y;
    double z;
} Point3D;

// 定义KD树节点结构体
typedef struct KDTreeNode {
    Point3D min; // 节点所代表空间区域的最小坐标
    Point3D max; // 节点所代表空间区域的最大坐标
    struct KDTreeNode *left; // 左子节点指针
    struct KDTreeNode *left; // 右子节点指针
    int depth; // 当前节点在树中的深度
    Point3D point; // 该节点对应的划分数据点（如中位数点）
} KDTreeNode;

// 创建KD树节点函数
// 参数注释：
// min：节点所代表空间区域的最小坐标
// max：节点所代表空间区域的最大坐标
// depth：节点在树中的深度
KDTreeNode *createKDTreeNode(Point3D min, Point3D max, int depth) {
    KDTreeNode *node = (KDTreeNode *)malloc(sizeof(KDTreeNode));
    node->min = min;
    node->max = max;
    node->left = NULL;
    node->right = NULL;
    node->depth = depth;
    node->point = {0};
    return node;
}

// 判断点是否在节点空间内函数
// 参数注释：
// point：要判断的三维点
// node：KD树节点
int isPointInNode(Point3D point, KDTreeNode *node) {
    return (point.x >= node->min.x && point.x <= node->max.x &&
            point.y >= node->min.y && point.y <= node->max.y &&
            point.y >= node->min.z && point.y <= node->max.z);
}

// 选择划分维度函数
// 参数注释：
// depth：当前节点在树中的深度
// k：空间维度（这里以三维为例，k = 3）
int chooseDimension(int depth, int k) {
    return depth % k;
}

// 计算中位数函数
// 参数注释：
// points：要计算中位数的点数组
// numPoints：点数组中的点数
// dimension：要计算中位数的维度
double calculateMedian(double *points, int numPoints, int dimension) {
    double *sortedPoints = (double *)malloc(numPoints * sizeof(double));
    for (int i = 0; i < numPoints; i++) {
        sortedPoints[i] = points[i * k + dimension];
    }
    qsort(sortedPoints, numPoints, sizeof(double), compareDoubles);
    double median;
    if (numPoints % 2 == 0) {
        median = (sortedPoints[numPoints / 2 - 1] + sortedPoints[numPoints / 2]) / 2;
    } else {
        median = sortedPoints[(numPoints - 1) / 2];
    }
    free(sortedPoints);
    return median;
}

// 插入数据点到KD树函数
// 参数注释：
// point：要插入的三维点
// node：当前KD树节点
// k：空间维度（这里以三维为例，k = 3）
void insertPointIntoKDTree(Point3D point, KDTreeNode *node, int k) {
    int dimension = chooseDimension(node->depth, k);
    double median = calculateMedian(point, 1, dimension);

    if (point.x <= median) {
        if (node->left == NULL) {
            node->left = createKDTreeNode(node->min, {median, node->max.y, node->max.z}, node->depth + 1);
        }
        insertPointIntoKDTree(point, node->left, k);
    } else {
        if (node->right == NULL) {
            node->right = createKDTreeNode({median, node->min.y, node->min.z}, node->max, node->depth + 1);
        }
        insertPointIntoKDTree(point, node->right, k);
    }
}

// 释放KD树内存函数
// 参数注释：
// node：要释放的KD树节点
void freeKDTree(KDTreeNode *node) {
    if (node == NULL) {
        return;
    }

    freeKDTree(node->left);
    freeKDTree(node->right);
    free(node);
}

碰撞响应

原理

碰撞响应基于物理定律和预先设定的规则，当检测到两个物体发生碰撞后，根据物体的属性（如质量、速度、弹性系数等）以及碰撞的具体情况（如碰撞点、碰撞角度等）来确定物体在碰撞后的运动状态变化，包括速度、位置等方面的改变。这通常涉及到动量守恒定律、能量守恒定律等物理原理的应用，以模拟真实世界中物体碰撞后的实际效果。

概念

碰撞响应是指在碰撞检测到两个物体发生碰撞事件后，对碰撞物体采取的一系列处理动作，目的是模拟真实世界中物体碰撞后的物理现象，使物体在虚拟环境中的行为更加符合现实情况。

过程

1. 碰撞检测确认： 首先通过碰撞检测算法（如基于空间划分等方法）确定两个物体是否发生了碰撞，获取碰撞的相关信息，如碰撞点坐标（通常用三维坐标表示，例如 x、y、z 坐标）、碰撞时间、碰撞角度等。

2. 属性获取： 获取参与碰撞的两个物体的相关属性，包括质量（单位通常为千克，如 mass1、mass2）、速度（三维速度向量，例如 velocity1 包含 vx1、vy1、vz1 等分量，velocity2 同理）、弹性系数（表示物体碰撞后的弹性恢复程度，如 elasticityCoefficient1、elasticityCoefficient2）、摩擦系数（用于考虑碰撞过程中的摩擦影响，如 frictionCoefficient1、frictionCoefficient2）等。这些属性通常是预先设定好的或者根据物体在场景中的状态动态获取的。

3. 计算响应： 根据物理定律（如动量守恒定律、能量守恒定律等）以及设定的碰撞规则（如完全弹性碰撞、非完全弹性碰撞等规则），结合碰撞的相关信息和物体的属性，计算出每个物体在碰撞后的速度、位置等运动状态的变化量。

• 对于完全弹性碰撞，根据动量守恒定律（m1 * v1 + m2 * v2 = m1 * v1’ + m2 * v2’，其中 m1、m2 是两物体质量，v1、v2 是碰撞前速度，v1’、v2’ 是碰撞后速度）和机械能守恒定律（0.5 * m1 * (v1)^2 + 0.5 * m2 * (v2)^2 = 0.5 * m1 * (v1’)^2 + 0.5 * m2 * (v2’)^2）联立方程求解碰撞后速度。

• 对于非完全弹性碰撞，除了依据动量守恒定律外，还会根据设定的能量损失系数（如摩擦系数等）来计算碰撞后速度，通常碰撞后总动能会小于碰撞前总动能。

4. 更新物体状态： 将计算得到的运动状态变化量应用到相应的物体上，更新物体的速度（如 velocity1、velocity2）、位置（通过速度和时间步长等计算新位置，假设时间步长为 dt，新位置 newPosition1 = oldPosition1 + velocity1 * dt，newPosition2 同理）等属性，从而实现碰撞后物体状态的模拟。

分类

• 完全弹性碰撞响应： 在这种碰撞响应类型中，假设物体在碰撞过程中机械能守恒，即碰撞前后物体的总动能不变。根据动量守恒定律和机械能守恒定律来计算碰撞后物体的速度等状态变化，通常适用于模拟一些理想情况下的弹性物体碰撞，如台球之间的碰撞。

• 非完全弹性碰撞响应： 考虑到实际情况中物体碰撞时会有能量损失，在这种类型的碰撞响应中，除了依据动量守恒定律外，还会根据设定的能量损失系数（如摩擦系数等）来计算碰撞后速度，通常碰撞后总动能会小于碰撞前总动能。此类型更贴近现实生活中大多数物体的碰撞情况，如汽车碰撞、球类碰撞在有能量损耗场景下的模拟。

用途

• 在游戏开发中，用于模拟游戏角色、道具、场景物体等之间的碰撞效果，使游戏场景更加真实，增强玩家的游戏体验。例如，模拟角色跳跃后落地与地面的碰撞，或者子弹与目标物体的碰撞等。

• 在计算机动画制作中，通过准确的碰撞响应模拟，可以让动画中的物体运动更加自然合理，如模拟动画角色之间的肢体碰撞、物体在场景中的碰撞运动等，提高动画质量。

• 在虚拟现实（VR）和增强现实（AR）应用中，真实地模拟碰撞响应能让用户在虚拟环境中与物体交互时感受到更逼真的效果，提升沉浸感。例如，用户在VR环境中用虚拟球棒击打虚拟棒球时，能感受到类似真实世界的碰撞反馈。

C语言代码实现示例（简化示意，假设二维情况，仅考虑动量守恒的非完全弹性碰撞，且质量、速度等属性已预先设定）

#include <stdio.h>
#include <math.h>

// 定义结构体表示物体
typedef struct Object {
    double mass;      // 物体质量
    double velocity_x; // x方向速度
    double velocity_y; // y方向速度
} Object;

// 碰撞响应函数，处理两个物体的碰撞
// 参数注释：
// object1：参与碰撞的第一个物体结构体指针
// object2：参与碰撞的第二个物体结构体指针
// restitutionCoefficient：恢复系数，用于模拟非完全弹性碰撞的能量损失情况
void collisionResponse(Object *object1, Object *object2, double restitutionCoefficient) {
    // 计算碰撞前两物体在x和y方向的总动量
    double totalMomentumXBefore = object1->mass * object1->velocity_x + object2->mass * object2->velocity_x;
    double totalMomentumYBefore = object1->mass * object1->velocity_y + object2->mass * object2->velocity_y;

    // 根据动量守恒定律，碰撞后两物体在x和y方向的总动量不变
    double totalMomentumXAfter = totalMomentumXBefore;
    double totalMomentumYAfter = totalMomentumYBefore;

    // 计算碰撞后两物体的总质量
    double totalMass = object1->mass + object2->mass;

    // 计算碰撞后两物体的相对速度在x和y方向的分量
    double relativeVelocityX = object2->velocity_x - object1->velocity_x;
    double relativeVelocityY = object2->velocity_y - object1->velocity_y;

    // 根据恢复系数和相对速度计算碰撞后两物体在x和y方向的速度变化量
    double velocityChangeX = (restitutionCoefficient * relativeVelocityX) / totalMass;
    double velocityChangeY = (restitutionCoefficient * relativeVelocityY) / totalMass;

    // 计算碰撞后物体1的速度
    object1->velocity_x += velocityChangeX * object2->mass;
    object1->velocity_y += velocityChangeY * object2->mass;

    // 计算碰撞后物体2的速度
    object2->velocity_x -= velocityChangeX * object1->mass;
    object2->velocity_y -= velocityChangeY * object1->mass;
}

int main() {
    // 创建两个物体并初始化它们的质量和速度
    Object object1 = {2.0, 3.0, 0.0};
    Object object2 = {3.0, -1.0, 0.0};

    // 设置恢复系数，这里假设为0.8，表示非完全弹性碰撞有一定能量损失
    double restitutionCoefficient = 0.8;

    // 调用碰撞响应函数处理两物体的碰撞
    collisionResponse(&object1, &object2, restitutionCoefficient);

    // 输出碰撞后两物体的速度
    printf("物体1碰撞后的速度：x方向 %.2f，y方向 %.2f\n", object1->velocity_x, object1->velocity_y);
    printf("物体2碰撞后的速度：x方向 %.2f，y方向 %.2f\n", object2->velocity_x, object2->velocity_y);

    return 0;
}

代码注释：

• 在 collisionResponse 函数中：

• double totalMomentumXBefore = object1->mass * object1->velocity_x + object2->mass * object2->velocity_x;：计算碰撞前两物体在 x 方向的总动量，通过每个物体的质量乘以其在 x 方向的速度并求和得到。

• double totalMomentumYBefore = object1->mass * object1->velocity_y + object2->mass * object2->velocity_y;：计算碰撞前两物体在 y 方向的总动量，原理同 x 方向。

• double totalMomentumXAfter = totalMomentumXBefore;：根据动量守恒定律，碰撞后两物体在 x 方向的总动量不变，所以直接赋值。

• double totalMomentumYAfter = totalMomentumYBefore;：同理，碰撞后两物体在 y 方向的总动量也不变。

• double totalMass = object1->mass + object2->mass;：计算碰撞后两物体的总质量，即两物体质量之和。

• double relativeVelocityX = object2->velocity_x - object1->velocity_x;：计算两物体碰撞前的相对速度在 x 方向的分量，通过物体2在 x 方向的速度减去物体1在 x 方向的速度得到。

• double relativeVelocityY = object2->velocity_y - object1->velocity_y;：计算两物体碰撞前的相对速度在 y 方向的分量，原理同 x 方向。

• double velocityChangeX = (restitutionCoefficient * relativeVelocityX) / totalMass;：根据恢复系数和相对速度计算碰撞后两物体在 x 方向的速度变化量，先将恢复系数乘以相对速度在 x 方向的分量，再除以总质量。

• double velocityChangeY = (restitutionCoefficient * relativeVelocityY) / totalMass;：计算碰撞后两物体在 y 方向的速度变化量，原理同 x 方向。

• object1->velocity_x += velocityChangeX * object2->mass;：计算碰撞后物体1在 x 方向的速度，将碰撞前物体1在 x 方向的速度加上根据碰撞后速度变化量计算得到的增量，增量通过速度变化量乘以物体2的质量得到。

• object1->velocity_y += velocityChangeY * object2->mass;：计算碰撞后物体1在 y 方向的速度，原理同 x 方向。

• object2->velocity_x -= velocityChangeX * object1->mass;：计算碰撞后物体2在 x 方向的速度，将碰撞前物体2在 x 方向的速度减去根据碰撞后速度变化量计算得到的减量，减量通过速度变化量乘以物体1的质量得到。

• object2->velocity_y -= velocityChangeY * object1->mass;：计算碰撞后物体2在 y 方向的速度，原理同 x 方向。

• 在 main 函数中：

• Object object1 = {2.0, 3.0, 0.0};：创建第一个物体结构体并初始化其质量为2.0千克，在 x 方向速度为3.0米/秒，在 y 方向速度为0.0米/秒。

• Object object2 = {3.0, -1.0, 0.0};：创建第二个物体结构体并初始化其质量为3.0千克，在 x 方向速度为-1.0米/秒，在 y 方向速度为0.0米/秒。

• double restitutionCoefficient = 0.8;：设置恢复系数为0.8，表示非完全弹性碰撞有一定能量损失。

• collisionResponse(&object1, &object2, restitutionCoefficient);：调用碰撞响应函数处理两物体的碰撞，传入两个物体结构体的指针以及恢复系数。

• printf(“物体1碰撞后的速度：x方向 %.2f，y方向 %.2f\n”, object1->velocity_x, object1->velocity_y);：输出碰撞后物体1在 x 方向和 y 方向的速度，保留两位小数。

• printf(“物体2碰撞后的速度：x方向 %.2f，y方向 %.2f\n”, object2->velocity_x, object2->latitude_y);：输出碰撞后物体2在 x 方向和 y 方向的速度，保留两位小数。不过这里代码有误，应该是 printf(“物体2碰撞后的速度：x方向 %.2f，y方向 %.2f\n”, object2->velocity_x, object2->velocity_y); 用于正确输出物体2碰撞后的速度情况。