二维中的OBB相交测试

最新推荐文章于 2024-05-20 16:22:54 发布

linuxheik

最新推荐文章于 2024-05-20 16:22:54 发布

阅读量921

点赞数

文章标签： obb

二维中的OBB相交测试

置顶 2013年10月23日 21:05:53

阅读数：2087

1. 背景知识

OBB全称oriented bounding box，比AABB（axis-aligned bounding box）多了一个方向性。

求交核心思想：向量点积的投影意义，unitX为(1,0)单位向量， A.dot( unitX ) 结果值为为A点的x分量，表示意义是A点在x轴上的投影。

1）一维求交

如图1，线段[t1, t2]和线段[t3, t4]相交当且仅当两个线段在T轴上是投影区间相交，即

[cpp] view plain copy

t3 < t4 && t1 < t2 && !(t3 >= t2 || t1 >= t4)

2）二维AABB相交

如图2，蓝色OBB在X轴投影区间为[x1, x3]，在Y轴投影区间为[y1, y3]；橙色矩形在X轴投影为[x2, x4]，在Y轴投影区间为[y2, y4]。二维的OBB求交通过投影，转化为两个一维的求交运算。 蓝色、红色矩形相交当且仅当它们在X、Y轴上的投影区间同时相交。即

[cpp] view plain copy

!(x2 >= x3 || x1 >= x4) && !(y2 >= y3 || y1 >= y4)

3）二维OBB求交

如图3，蓝色、橙色为任意朝向包围矩形。我们选橙色矩形相邻两条正交边为投影轴S和T轴，且橙色矩阵在S轴上投影区间为[s1, s2]，在T轴上投影区间为[t1, t2]；蓝色矩形在S轴投影区间为[s3, s4]，在T轴上投影为[t3, t4]。与AABB求交思路类似，OBB橙色矩形和蓝色矩形相交则一定得出他们在坐标系S-T轴上的投影区间分别相交，但不是充分必要件：

左图中，首先将蓝色、橙色矩形分别投影在橙色矩阵确定的S、T轴上，投影区间都相交，但是目测两个矩形其实并没有相交；再次将蓝色、橙色矩形分别投影到在蓝色矩形确定的S、T轴上，结果二者在S轴上的投影区间并不相交，从而得出蓝色、橙色矩形其实并不相交。

因此，OBB相交测试中需要投影到橙色的坐标系上做投影测试，如果通过则投影到蓝色矩形坐标系上做测试，只有两次都相交才可以。代码实际执行时，第一次相交测试已经能过滤至少50%的case，只有剩余的50%再次执行第二次相交测试。

2. 代码

google obb求交，第一个资料就是flipcode的教程：http://www.flipcode.com/archives/2D_OBB_Intersection.shtml

我实际测试发现flip code上的obb代码并不能正确运行。

下面是我修改后的程序： 2dobb.h

[cpp] view plain copy

class Vector2
{
public:
typedef float data_type;
Vector2() {
m_Data[0] = m_Data[1] = 0.0f;
}
Vector2(const Vector2& other) {
m_Data[0] = other.m_Data[0];
m_Data[1] = other.m_Data[1];
}
Vector2(data_type x, data_type y) {
m_Data[0] = x;
m_Data[1] = y;
}
double dot(const Vector2& other) const {
return other.m_Data[0] * m_Data[0] + other.m_Data[1] * m_Data[1];
}
double squaredLength() const {
return sqrtf(m_Data[0]*m_Data[0] + m_Data[1]*m_Data[1]);
}
Vector2& operator/(data_type factor) {
m_Data[0] /= factor;
m_Data[1] /= factor;
return *this;
}
Vector2& operator/=(data_type factor) {
m_Data[0] /= factor;
m_Data[1] /= factor;
return *this;
}
Vector2& operator*(data_type factor) {
m_Data[0] *= factor;
m_Data[1] *= factor;
return *this;
}
Vector2& operator*=(data_type factor) {
m_Data[0] *= factor;
m_Data[1] *= factor;
return *this;
}
Vector2& operator+=(const Vector2& other) {
m_Data[0] += other.m_Data[0];
m_Data[1] += other.m_Data[1];
return *this;
}
Vector2& operator=(const Vector2& other) {
if (this==&other) {
return *this;
}
m_Data[0] = other.m_Data[0];
m_Data[1] = other.m_Data[1];
return *this;
}
operator const data_type* () const {
return &(m_Data[0]);
}
const data_type* data() const {
return &(m_Data[0]);
}
friend static Vector2 operator-(const Vector2& first, const Vector2& second) {
data_type x = first.m_Data[0] - second.m_Data[0];
data_type y = first.m_Data[1] - second.m_Data[1];
return Vector2(x, y);
}
friend static Vector2 operator+(const Vector2& first, const Vector2& second) {
data_type x = first.m_Data[0] + second.m_Data[0];
data_type y = first.m_Data[1] + second.m_Data[1];
return Vector2(x, y);
}
private:
data_type m_Data[2];
};
class OBB2D {
private:
/** Corners of the box, where 0 is the lower left. */
Vector2 corner[4];
/** Two edges of the box extended away from corner[0]. */
Vector2 axis[2];
/** origin[a] = corner[0].dot(axis[a]); */
double minProjLength[2]; // 原点 0点在两个轴上的投影
double maxProjLength[2]; // 2点在两个轴上的投影
/** Returns true if other overlaps one dimension of this. */
bool overlaps1Way(const OBB2D& other) const {
for (int a = 0; a < 2; ++a) {
double t = other.corner[0].dot(axis[a]);
// Find the extent of box 2 on axis a
double tMin = t;
double tMax = t;
for (int c = 1; c < 4; ++c) {
t = other.corner[c].dot(axis[a]);
if (t < tMin) {
tMin = t;
} else if (t > tMax) {
tMax = t;
}
}
// We have to subtract off the origin
// See if [tMin, tMax] intersects [minProjLength, maxProjLength]
if (tMin > maxProjLength[a] || tMax < minProjLength[a]) {
// There was no intersection along this dimension;
// the boxes cannot possibly overlap.
return false;
}
}
// There was no dimension along which there is no intersection.
// Therefore the boxes overlap.
return true;
}
/** Updates the axes after the corners move. Assumes the
corners actually form a rectangle. */
void computeAxes() {
axis[0] = corner[1] - corner[0];
axis[1] = corner[3] - corner[0];
// Make the length of each axis 1/edge length so we know any
// dot product must be less than 1 to fall within the edge.
for (int a = 0; a < 2; ++a) {
axis[a] /= axis[a].squaredLength();
minProjLength[a] = corner[0].dot(axis[a]);
maxProjLength[a] = corner[2].dot(axis[a]);
}
}
public:
OBB2D(const Vector2& center, const double w, const double h, double angle)
{
Vector2 X( cos(angle), sin(angle));
Vector2 Y(-sin(angle), cos(angle));
X *= w / 2;
Y *= h / 2;
corner[0] = center - X - Y;
corner[1] = center + X - Y;
corner[2] = center + X + Y;
corner[3] = center - X + Y;
computeAxes();
}
void updateAngle(const Vector2& center, const double w, const double h, double angle) {
Vector2 X( cos(angle), sin(angle));
Vector2 Y(-sin(angle), cos(angle));
X *= w / 2;
Y *= h / 2;
corner[0] = center - X - Y;
corner[1] = center + X - Y;
corner[2] = center + X + Y;
corner[3] = center - X + Y;
computeAxes();
}
/** For testing purposes. */
void moveTo(const Vector2& center) {
Vector2 centroid = (corner[0] + corner[1] + corner[2] + corner[3]) / 4;
Vector2 translation = center - centroid;
for (int c = 0; c < 4; ++c) {
corner[c] += translation;
}
computeAxes();
}
/** Returns true if the intersection of the boxes is non-empty. */
bool overlaps(const OBB2D& other) const {
return overlaps1Way(other) && other.overlaps1Way(*this);
}
void render() const {
glBegin(GL_LINE_LOOP);
for (int c = 0; c < 5; ++c) {
glVertex2fv(corner[c & 3]);
}
glEnd();
}
};

相交时候用绿色绘制线框，不相交时候用红色绘制线框。

glut的测试框架：

[cpp] view plain copy

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include <time.h>
#include <math.h>
#include <gl/glut.h>
#include <iostream>
using namespace std;
#include "2dobb.h"
const int g_window_size = 512;
int g_window_width = g_window_size;
int g_window_height = g_window_size;
const char* g_app_string = "OBB2DDemo";
OBB2D* g_rotateObbPtr;
OBB2D* g_moveObbPtr;
float g_obbAngle = 10;
Vector2 g_moveObbCenter(50, 50);
GLenum checkForError(char *loc);
void Init(void)
{
g_rotateObbPtr = new OBB2D( Vector2(100, 100), 50,100, g_obbAngle );
g_moveObbPtr = new OBB2D( g_moveObbCenter, 50,100, 0 );
glEnable(GL_CULL_FACE);
}
void Render(void)
{
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClearDepth(0.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if (g_rotateObbPtr->overlaps(*g_moveObbPtr))
{
glColor3f(0, 1, 0);
} else
{
glColor3f(1, 0, 0);
}
g_rotateObbPtr->render();
g_moveObbPtr->render();
glutSwapBuffers();
checkForError("swap");
}
void Reshape(int width, int height)
{
g_window_width = width; g_window_height = height;
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0.0f, (GLfloat) g_window_width, 0.0f,
(GLfloat) g_window_height, -1.0f, 1.0f);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glViewport(0, 0, g_window_width, g_window_height);
}
void keyboard(unsigned char key, int x, int y) {
int state = -1;
switch (key)
{
case '1':
g_obbAngle += 0.1;
g_rotateObbPtr->updateAngle(Vector2(100, 100), 50, 100, g_obbAngle);
break;
case 'w': // move up
state = 0;
break;
case 's':
state = 1;
break;
case 'a':
state = 3;
break;
case 'd':
state = 2;
break;
case 'q':
delete g_rotateObbPtr;
delete g_moveObbPtr;
exit(0);
}
if (state >= 0) {
Vector2::data_type dx = 10 * (state < 2 ? 0 : (state==3 ? -1 : 1) );
Vector2::data_type dy = 10 * (state < 2 ? (state==0 ? 1 : -1) : 0 );
g_moveObbCenter += Vector2(dx, dy);
g_moveObbPtr->moveTo(g_moveObbCenter);
}
glutPostRedisplay();
}
int main(int argc, char *argv[])
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGB|GLUT_DOUBLE|GLUT_DEPTH);
glutInitWindowSize(g_window_width, g_window_height);
glutCreateWindow(g_app_string);
// set up world space to screen mapping
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0.0f, (GLfloat)g_window_size, 0.0f, (GLfloat)g_window_size, -1.0f, 1.0f);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glViewport(0, 0, g_window_size, g_window_size);
glutDisplayFunc(Render);
glutReshapeFunc(Reshape);
glutKeyboardFunc(keyboard);
Init();
glutMainLoop();
return 0;
}
GLenum checkForError(char *loc)
{
GLenum errCode;
const GLubyte *errString;
if ((errCode = glGetError()) != GL_NO_ERROR)
{
errString = gluErrorString(errCode);
printf("OpenGL error: %s",errString);
if (loc != NULL)
printf("(%s)",loc);
printf("\n");
}
return errCode;
}