碰撞检测之OBB-OBB检测

最新推荐文章于 2024-09-04 18:28:39 发布
最新推荐文章于 2024-09-04 18:28:39 发布
阅读量2.1k 收藏 3
点赞数
分类专栏： obb
碰撞检测之OBB-OBB检测
2016年03月07日 02:20:14
阅读数：3732

2D情况

首先回顾一下SAP



两个凸包多边形，当且仅当存在一条线，这两个多边形在这条线上的投影不相交，则这两个多边形也不相交.


这条线称为Separating Axis.垂直Separating Axis存在一条Separating Line将两个多边形分开。


这里还有一个要确定的，就是如果两个矩形之间存在Separating Line，则一定存在一条和两个矩形中的一条边平行。每个矩形对边平行，则我们只需要检查四个方向是否存在Separating Line，如下图



找Separating Line 就是找Separating Axis, Separating Axis也只有四个方向，所以将矩形在四个轴上投影就可以了，如下图









下面来看具体的计算


定义下面几个变量

PA = coordinate position of the center of rectangle A
Ax = unit vector representing the local x-axis of A
Ay = unit vector representing the local y-axis of A
WA = half width of A (corresponds with the local x-axis of A)
HA = half height of A (corresponds with the local y-axis of A)


PB = coordinate position of the center of rectangle B

Bx = unit vector representing the local x-axis of B
By = unit vector representing the local y-axis of B
WB = half width of B (corresponds with the local x-axis of B)
HB = half height of B (corresponds with the local y-axis of B)


T= PB - PA

轴L是Seprating Axis的条件是

|Proj ( T )| > 0.5 * |Proj ( RectangleA )| + 0.5 *|Proj ( RectangleB )|


Proj是投影计算， 展开

| T • L | > | ( WA*Ax ) • L | + | ( HA*Ay ) • L | + | ( WB*Bx ) • L | + |( HB*By ) • L |

L只有四种情况，AX, AY, BX, BY

CASE 1:
// L = Ax
| T • Ax | > | ( WA*Ax ) • Ax | + | ( HA*Ay ) • Ax | + | ( WB*Bx ) • Ax | + |( HB*By ) • Ax |
| T • Ax | > WA + 0 + | ( WB*Bx ) • Ax | + |( HB*By ) • Ax |
| T • Ax | > WA + | ( WB*Bx ) • Ax | + |( HB*By ) • Ax |

如果成立，存在Separating Axis平行Ax。


CASE 2:
// L = Ay
| T • Ay | > HA + | ( WB*Bx ) • Ay | + |( HB*By ) • Ay |

如果成立，存在Separating Axis平行Ay。


CASE 3:
// L = Bx
| T • Bx | > | ( WA* Ax ) • Bx | + | ( HA*Ay ) • Bx | + WB

如果成立，存在Separating Axis平行Bx。


CASE 4:
// L = By
| T • By | > | ( WA* Ax ) • By | + | ( HA*Ay ) • By | + HB

如果成立，存在Separating Axis平行By。



三维情况

在三维情况下的，之前的Separating Line就变成了Separating Plane，如下图



每个Box都有三组面，每组面都是平行的，Separating Plane都是平行其中的一个面。则两个box的SAT（Separating AxisTheorem）中可能的Separating Axis有六个




下图中Separating Plane就平行于右边Box的一个面



然而还有一种情况，如下



这种情况，两个Box并不相交，但是他们并没有发生碰撞，这种情况，Separating Plane的法线是两条红线的叉乘



所以在三维情况下Box和Box的碰撞检测需要判定的情况有6+9种

CASE 1:L = Ax  CASE 2:L = Ay  CASE 3:L = Az   CASE 4:L = Bx   CASE 5:L = By  CASE 6:L = Bz

CASE 7:L = Ax Bx  CASE 8:L = Ax By  CASE 9:L = Ax Bz  CASE 10:L = Ay Bx  

CASE 11:L = Ay By  CASE 12:L = Ay Bz  CASE 13:L = Az Bx  CASE 14:L = Az By  CASE 15:L = Az Bz


判断条件还是

| T • L | > | ( WA*Ax ) • L | + | ( HA*Ay ) • L | + |( DA*Az ) • L |+ | ( WB*Bx ) • L | + |( HB*By ) • L | + |( DB*Bz ) • L |

一点优化，关于T • L 

T • (Ax * Bx) =(T •  Az)(Ay •  Bx) - (T•  Ay)(Az •  Bx)

这里将有叉乘的地方进行了转化，要看证明的请看参考资料。


好，可以上代码了

[csharp] view plain copy
  1. public static bool IntersectBoxBox(Box box0, Box box1)  
  2.       {  
  3.           Vector3 v = box1.center - box0.center;  
  4.   
  5.           //Compute A's basis  
  6.           Vector3 VAx = box0.rotation * new Vector3(1, 0, 0);  
  7.           Vector3 VAy = box0.rotation * new Vector3(0, 1, 0);  
  8.           Vector3 VAz = box0.rotation * new Vector3(0, 0, 1);  
  9.   
  10.           Vector3[] VA = new Vector3[3];  
  11.           VA[0] = VAx;  
  12.           VA[1] = VAy;  
  13.           VA[2] = VAz;  
  14.   
  15.           //Compute B's basis  
  16.           Vector3 VBx = box1.rotation * new Vector3(1, 0, 0);  
  17.           Vector3 VBy = box1.rotation * new Vector3(0, 1, 0);  
  18.           Vector3 VBz = box1.rotation * new Vector3(0, 0, 1);  
  19.   
  20.           Vector3[] VB = new Vector3[3];  
  21.           VB[0] = VBx;  
  22.           VB[1] = VBy;  
  23.           VB[2] = VBz;  
  24.   
  25.           Vector3 T = new Vector3(Vector3.Dot(v, VAx), Vector3.Dot(v, VAy), Vector3.Dot(v, VAz));  
  26.   
  27.           float[,] R = new float[3, 3];  
  28.           float[,] FR = new float[3, 3];  
  29.           float ra, rb, t;  
  30.   
  31.           for (int i = 0; i < 3; i++)  
  32.           {  
  33.               for (int k = 0; k < 3; k++)  
  34.               {  
  35.                   R[i, k] = Vector3.Dot(VA[i], VB[k]);  
  36.                   FR[i, k] = 1e-6f + Mathf.Abs(R[i, k]);  
  37.               }  
  38.           }  
  39.   
  40.           // A's basis vectors  
  41.           for (int i = 0; i < 3; i++)  
  42.           {  
  43.               ra = box0.extents[i];  
  44.               rb = box1.extents[0] * FR[i, 0] + box1.extents[1] * FR[i, 1] + box1.extents[2] * FR[i, 2];  
  45.               t = Mathf.Abs(T[i]);  
  46.               if (t > ra + rb) return false;  
  47.           }  
  48.   
  49.           // B's basis vectors  
  50.           for (int k = 0; k < 3; k++)  
  51.           {  
  52.               ra = box0.extents[0] * FR[0, k] + box0.extents[1] * FR[1, k] + box0.extents[2] * FR[2, k];  
  53.               rb = box1.extents[k];  
  54.               t = Mathf.Abs(T[0] * R[0, k] + T[1] * R[1, k] + T[2] * R[2, k]);  
  55.               if (t > ra + rb) return false;  
  56.           }  
  57.   
  58.           //9 cross products  
  59.   
  60.           //L = A0 x B0  
  61.           ra = box0.extents[1] * FR[2, 0] + box0.extents[2] * FR[1, 0];  
  62.           rb = box1.extents[1] * FR[0, 2] + box1.extents[2] * FR[0, 1];  
  63.           t = Mathf.Abs(T[2] * R[1, 0] - T[1] * R[2, 0]);  
  64.           if (t > ra + rb) return false;  
  65.   
  66.           //L = A0 x B1  
  67.           ra = box0.extents[1] * FR[2, 1] + box0.extents[2] * FR[1, 1];  
  68.           rb = box1.extents[0] * FR[0, 2] + box1.extents[2] * FR[0, 0];  
  69.           t = Mathf.Abs(T[2] * R[1, 1] - T[1] * R[2, 1]);  
  70.           if (t > ra + rb) return false;  
  71.   
  72.           //L = A0 x B2  
  73.           ra = box0.extents[1] * FR[2, 2] + box0.extents[2] * FR[1, 2];  
  74.           rb = box1.extents[0] * FR[0, 1] + box1.extents[1] * FR[0, 0];  
  75.           t = Mathf.Abs(T[2] * R[1, 2] - T[1] * R[2, 2]);  
  76.           if (t > ra + rb) return false;  
  77.   
  78.           //L = A1 x B0  
  79.           ra = box0.extents[0] * FR[2, 0] + box0.extents[2] * FR[0, 0];  
  80.           rb = box1.extents[1] * FR[1, 2] + box1.extents[2] * FR[1, 1];  
  81.           t = Mathf.Abs(T[0] * R[2, 0] - T[2] * R[0, 0]);  
  82.           if (t > ra + rb) return false;  
  83.   
  84.           //L = A1 x B1  
  85.           ra = box0.extents[0] * FR[2, 1] + box0.extents[2] * FR[0, 1];  
  86.           rb = box1.extents[0] * FR[1, 2] + box1.extents[2] * FR[1, 0];  
  87.           t = Mathf.Abs(T[0] * R[2, 1] - T[2] * R[0, 1]);  
  88.           if (t > ra + rb) return false;  
  89.   
  90.           //L = A1 x B2  
  91.           ra = box0.extents[0] * FR[2, 2] + box0.extents[2] * FR[0, 2];  
  92.           rb = box1.extents[0] * FR[1, 1] + box1.extents[1] * FR[1, 0];  
  93.           t = Mathf.Abs(T[0] * R[2, 2] - T[2] * R[0, 2]);  
  94.           if (t > ra + rb) return false;  
  95.   
  96.           //L = A2 x B0  
  97.           ra = box0.extents[0] * FR[1, 0] + box0.extents[1] * FR[0, 0];  
  98.           rb = box1.extents[1] * FR[2, 2] + box1.extents[2] * FR[2, 1];  
  99.           t = Mathf.Abs(T[1] * R[0, 0] - T[0] * R[1, 0]);  
  100.           if (t > ra + rb) return false;  
  101.   
  102.           //L = A2 x B1  
  103.           ra = box0.extents[0] * FR[1, 1] + box0.extents[1] * FR[0, 1];  
  104.           rb = box1.extents[0] * FR[2, 2] + box1.extents[2] * FR[2, 0];  
  105.           t = Mathf.Abs(T[1] * R[0, 1] - T[0] * R[1, 1]);  
  106.           if (t > ra + rb) return false;  
  107.   
  108.           //L = A2 x B2  
  109.           ra = box0.extents[0] * FR[1, 2] + box0.extents[1] * FR[0, 2];  
  110.           rb = box1.extents[0] * FR[2, 1] + box1.extents[1] * FR[2, 0];  
  111.           t = Mathf.Abs(T[1] * R[0, 2] - T[0] * R[1, 2]);  
  112.           if (t > ra + rb) return false;  
  113.   
  114.           return true;  
  115.       }  

测试代码
[csharp] view plain copy
  1. public class BoxBoxTester : MonoBehaviour {  
  2.     public GameObject box;  
  3.     public GameObject box1;  
  4.     Box _box;  
  5.     Box _box1;  
  6.     // Use this for initialization  
  7.     void Start()  
  8.     {  
  9.         _box = new Box();  
  10.         _box1 = new Box();  
  11.     }  
  12.   
  13.     // Update is called once per frame  
  14.     void Update()  
  15.     {  
  16.         _box.center = box.transform.position;  
  17.         _box.rotation = box.transform.rotation;  
  18.         _box.extents = 0.5f * box.transform.localScale;  
  19.   
  20.         _box1.center = box1.transform.position;  
  21.         _box1.rotation = box1.transform.rotation;  
  22.         _box1.extents = 0.5f * box1.transform.localScale;  
  23.   
  24.         if (NIntersectTests.IntersectBoxBox(_box, _box1))  
  25.         {  
  26.             box.GetComponent<MeshRenderer>().materials[0].SetColor("_Color", new Color(1, 0, 0));  
  27.         }  
  28.         else  
  29.         {  
  30.             box.GetComponent<MeshRenderer>().materials[0].SetColor("_Color", new Color(1, 1, 1));  
  31.         }  
  32.     }  
  33. }  


运行结果




参考

Separating Axis Theorem for Oriented Bounding Boxes
linuxheik
关注
专栏目录
旋转目标检测：Gaussian Synthesis for High-Precision Location in Oriented Object Detection【方法解析】
sinat_39783664的博客
07-24 60
旋转目标检测G-OBB方法部分详细解读
Apollo9.0 PNC源码学习之Planning模块—— 碰撞检测 AABB、OBB(C++ 代码实现)
BigDavid123的博客
08-25 208
本文详解了常见的碰撞检测算法AABB和OBB
基于cocos2d-x的2D空间中的OBB(Orient Bounding Box)碰撞检测算法
热门推荐
i_dovelemon的专栏
06-16 1万+
使用OBB来进行碰撞检测，避免使用传统AABB进行碰撞检测的不精确性。
OBB碰撞检测算法
计算机技术交流
03-19 1万+
1 OBB包围盒 OBB(Oriented Bounding Box)包围盒也被称作有向包围盒或定向包围盒，它会随着物体的移动、缩放、旋转。简单来说，它就是一个能够旋转的AABB包围盒。在Cocos2d-x中使用过物理引擎的开发者一定见过当我们在物理世界中创建一个物体并开启调试模式时，这个物体会被红色的矩形包围，当物体做平移或旋转时，这个红色矩形也会做同样的操作，这个红色矩形正是该物体的OBB包
OBB盒构建方法
weixin_61464913的博客
02-26 1336
OBB包围盒生成与碰撞检测
OBB 碰撞检测和碰撞反应示例
03-25
使用OBB算法展示立方体碰撞和碰撞后的反应
三维包围盒碰撞检测算法-Python（OBB-SAT）
王小石的博客
09-07 3025
想实现一个检测三维包围盒是否发生碰撞的功能，因为目标是任意方向的三维包围盒，即没有和坐标轴对齐的旋转包围盒，所以考虑采用检测OBB碰撞的SAT算法，但找了很久没找到现成的python代码，就比着别人写的C++版的自己写了python的版本。 1.原理 参考该博客 2.代码实现 import numpy as np class OBB: def __init__(self,point_set:np.ndarray): self.pos=(point_set[0]+point_set[
碰撞检测 | 详解矩形AABB与OBB碰撞检测算法(附ROS C++可视化)
最新发布
loveting99的博客
09-04 3011
AABB由两个对角点的坐标定义：一个是左下角的最小点（minPoint），另一个是右上角的最大点（maxPoint）。这两个点共同确定了一个轴对齐的矩形边界框。为了判断两个AABB是否发生碰撞，算法会检查它们在各个轴上的投影是否重叠。A由minPointA(minX_A, minY_A)和maxPointA(maxX_A, maxY_A)定义。B由minPointB(minX_B, minY_B)和maxPointB(maxX_B, maxY_B)定义。
OBB-box.zip_OBB包围盒_OBB包围盒PCA_OSG 包围盒_osg_包围盒
07-15
这样，OBB就能更好地适应物体的形状，提高碰撞检测、可见性判断等计算的效率和准确性。 **osg图形引擎与OBB** osg（OpenSceneGraph）是一个开源的高性能3D图形库，广泛应用于科学可视化、虚拟现实和游戏开发等领域...
用c语言写的OBB旋转及碰撞检测示例源代码
03-25
用c语言写的旋转及碰撞检测示例源代码。在VC6.0环境中编写，使用了grahics 库。使用了二维OBB矩形投影半径算法。
基于八叉树的OBB包围盒碰撞检测
09-20
碰撞检测技术是大规模复杂场景渲染的关键技术之一 ,它可以有效地提高虚拟环境的真实感和沉浸感 。碰撞检测的研 究目标是如何在很高的实时交互要求下完成大量复杂物体的相交检测 。提出一种将场景图中的 OBB包围盒以八叉树的形式划分 , 并利用八叉树的层次结构实现有效碰撞检测的方法 ,该方法从宏观到微观的搜索方式可以快速确定需要进行相交检测的对象列表 , 有效地避免所有几何节点与运动节点的相交检测 ,提高了碰撞检测的效率 ,并且采用 OBB包围盒来描述几何模型 ,有效地提高碰撞 检测的精度 。
碰撞检测
WADE
05-06 1万+
1.矩形与矩形碰撞 一般规则的物体碰撞都可以处理成矩形碰撞，实现的原理就是检测两个矩形是否重叠。 矩形1的参数是：左上角的坐标是(x1,y1)，宽度是w1，高度是h1; 矩形2的参数是：左上角的坐标是(x2,y2)，宽度是w2，高度是h2。 在检测时，数学上可以处理成比较中心点的坐标在x和y方向上的距离和宽度的关系。 即两个矩形中心点在x方向的距离的绝对值小于等于矩形宽度和的二分之一，同...
碰撞检测之OBB-OBB的SweepTest
爱冒险的技术宅
04-12 5375
提要当物体在运动的时候，普通的每帧进行碰撞检测已经无法满足要求，比如子弹的运动两帧的位置已经直接将中间的板子穿过了，所以 t 时刻和 t +1 时刻的检测都是失效的。这时候需要用到的就是sweep检测了。今天要处理的就是AABB的Sweep检测。2D情况如下图，当前位置是蓝色Box所在位置，目的位置是绿色框所在位置。2D情况只用处理x,y方向的，利用SAP理论，分别在各个轴向计算可以移动的距离。代
C语言实现OBB矩形旋转与碰撞检测算法
"这篇资源提供了一个使用C语言编写的OBB(轴对齐边界框)旋转及碰撞检测的示例源代码。代码适用于VC6.0环境，利用了graphics库，并且基于二维OBB矩形投影半径算法进行碰撞检测。" 在游戏开发和物理模拟中，碰撞检测是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值