3D空间包围球(Bounding Sphere)的求法

引言

在3D碰撞检測中，为了加快碰撞检測的效率，降低不必要的碰撞检測，会使用基本几何体作为物体的包围体(Bounding Volume, BV)进行測试。基本包围体的碰撞检測相对来说廉价也easy的多，所以假设在基本包围体的碰撞检測中都没有通过的话，那么就没有必要进行更加复杂的碰撞检測了。

而对于不同性质，不同形状的模型，须要依据情况选择不同的包围体，一般来说，包围体分为例如以下的几种：

Sphere， AABB， OBB， 8-DOP， Convex Hull这几种常见的。

接下来将向大家讲述怎样使用Sphere包围体。

表示方法

想要使用包围体，我们就要知道，怎样的表示一个包围球体。对于球体来说，表示它非常easy，例如以下所看到的：

struct Sphere
{
     VECTOR3 center ;
     float radious ;
};

这样，在有了中点和半径之后，我们就能唯一的确定一个包围球体了。

包围球之间的碰撞检測

对于包围球之间的碰撞检測，十分的简单，仅仅要推断两个包围球心之间的距离是否小于他们两个的半径之和就能够了。假设小于，那么这两个包围球发生了交叉，没有的话，就相互分离。下面是进行碰撞检測的代码：

int TestSphereSphere(Sphere a, Sphere b)

{

       VECTOR3 d = a.center - b.center ;

       float dist2 = Dot(d, d);

       float radisum = a.radious + b.radious ;

       if(dist2 < radisum * radisum)

             return 1 ;

       else

            return 0 ;

}

非常easy不是嘛！因为进行开平方计算要消耗大量的CPU，所以，我们直接对球心之间距离的平方和他们半径之和的平方进行比較，结果与进行距离和半径之和的比較一致。

包围球体的计算

球形包围体的计算有非常多的算法，在本篇文章中将讲述两种常见的计算方法。假设你使用DirectX，就会知道，DirectX内置了一个D3DXComputBoundingSphere的函数。这里将不会使用这个函数，而是使用我们自己创建的计算方法来进行包围球体的计算。

首先来介绍第一种包围球体的计算方法。

均值法

我们知道，在3D模型的表示中，一般都是用一系列的顶点来描写叙述一个模型。所以，要求一个包围球体，我们就必须确定这个包围球体的球心，然后计算每个顶点与球心的距离，选取最长的距离作为包围球体的半径。这个简单的算法就行确定一个包围球体了。那么，有一个问题，假设的确定这个模型的球心了？

我们通过例如以下的简答方法来计算出这个模型的球心。我们将全部的顶点相加，然后除以顶点数，这样就能得到一个球心的位置了。

到这里，这种方法的理论就介绍完成了，非常easy不是吗？？？以下来看看这种方法的代码部分：

void Sphere::computeBoundingSphereAverage(VECTOR3* vertices, unsigned int vertex_num)
{
	//Compute the center point
	VECTOR3 total ;
	total.x = 0 ;
	total.y = 0 ;
	total.z = 0 ;
	for(int i = 0 ; i < vertex_num ; i ++)
	{
		total.x += vertices[i].x ;
		total.y += vertices[i].y ;
		total.z += vertices[i].z ;
	}// end for

	total.x /= vertex_num ;
	total.y /= vertex_num ;
	total.z /= vertex_num ;
	center = total ;

	//Compute the radious
	float r = 0 ;
	for(int i = 0 ; i < vertex_num ; i ++)
	{
		VECTOR3 temp ;
		Vec3Sub(temp, total, vertices[i]);
		float length = 0 ;
		length = Vec3Length(length, temp);
		if(length > r)
			r = length ;
	}// end for

	radious = r ;
}// end for computeBoundingSphereAverage

代码非常清晰，也非常easy明确，所以这里将不再进行解释了。

看看使用这种方法计算出来的包围球的效果怎样：

Ritter方法

Ritter，Jack提出了一种新的近似的计算包围球体的方法。它的思路是这种：

首先我们分别找到这个模型在x，y，z正负六个方向上的最远距离的6个点。然后我们分别计算出这三对点之间的长度，也就是x轴向上两个点之间的长度，y轴向上两个点之间的长度，z轴向上两个点之间的长度。我们选取长度最长的那一个作为包围球的直径，以这个长度的两个点的中点作为包围球的球心。

通过上面的方法，我们能近似的求出这个包围球，可是并不能保证模型中的每个顶点都在这个包围球里面，所以我们还须要对此进行修正。

我们遍历全部的顶点，推断顶点是否在球体里面，假设在里面，则忽略它，假设不在里面，我们依照以下的算法来对球体进行修正，以使的新的球体可以包括这个点。

请看下图：

我们如果当前的球心为O，半径为r。如今我们发如今这个球体之外有一个点P。所以，我们须要对这个包围球体进行修正，以便于将这个点包围在球体里面。为了最紧凑的包围住这个点，我们将点P与球心O连线，交圆与T点。这时，你就会发现，TP就是我们要求的包围球的新直径了，那么球心也就是他们之间的中点了。

求出T的计算比較庞大，所以我们计算新的半径使用以下的方法：

因为P点和O点都是已知的，所以求他们之间的距离比較easy。也就是说新的半径为： (r + OP) * 0.5

有了新的半径之后，我们须要做的就是平移球心点，平移的向量大小刚好就是SP的长度，方向是从O点指向P点，当中S点为PR的中点。

所以有了上面的算法，我们依次的遍历全部的点，我们就行确定一个近似的包围球了。

这个理论也非常easy，以下是实现的代码：

void Sphere::computeBoundingSphereRitter(VECTOR3* vertices, unsigned int vertex_num)
{
	unsigned int maxX = 0 , maxY = 0, maxZ = 0 , minX = -1, minY = -1, minZ = -1 ;

	//Find the max and min along the x-axie, y-axie, z-axie
	for(int i = 0 ; i < vertex_num ; i ++)
	{
		if(vertices[i].x > maxX) maxX = i ;
		if(vertices[i].x < minX) minX = i ;
		if(vertices[i].y > maxY) maxY = i ;
		if(vertices[i].y < minY) minY = i ;
		if(vertices[i].z > maxZ) maxZ = i ;
		if(vertices[i].z < minZ) minZ = i ;
	}// end for

	float x = 0;
	VECTOR3 sub1 , sub2 ;
	sub1.x = vertices[maxX].x ; sub1.y = vertices[maxX].y ; sub1.z = vertices[maxX].z ;
	sub2.x = vertices[minX].x ; sub2.y = vertices[minX].y ; sub2.z = vertices[minX].z ;
	Vec3Sub(sub1, sub1, sub2);
	Vec3Dot(x, sub1, sub1);

	float y = 0 ;
	sub1.x = vertices[maxY].x ; sub1.y = vertices[maxY].y ; sub1.z = vertices[maxY].z ;
	sub2.x = vertices[minY].x ; sub2.y = vertices[minY].y ; sub2.z = vertices[minY].z ;
	Vec3Sub(sub1, sub1, sub2);
	Vec3Dot(y, sub1, sub1);

	float z = 0 ;
	sub1.x = vertices[maxZ].x ; sub1.y = vertices[maxZ].y ; sub1.z = vertices[maxZ].z ;
	sub2.x = vertices[minZ].x ; sub2.y = vertices[minZ].y ; sub2.z = vertices[minZ].z ;
	Vec3Sub(sub1, sub1, sub2);
	Vec3Dot(z, sub1, sub1);

	float dia = 0 ;
	int max = maxX , min = minX ;
	if( z > x && z > y)
	{
		max = maxZ ;
		min = minZ ;
		dia = z ;
	}else if(y > x && y > z)
	{
		max = maxY ;
		min = minY ;
		dia = y ;
	}

	//Compute the center point
	center.x = 0.5 * (vertices[max].x + vertices[min].x) ;
	center.y = 0.5 * (vertices[max].y + vertices[min].y) ;
	center.z = 0.5 * (vertices[max].z + vertices[min].z) ;

	//Compute the radious
	radious = 0.5 * sqrt(dia);

	//Fix it
	for(int i = 0 ; i < vertex_num ; i ++)
	{
		VECTOR3 d ;
		Vec3Sub(d, vertices[i], center);
		float dist2 = 0 ;
		Vec3Dot(dist2, d, d);

		if(dist2 > radious * radious)
		{
			float dist = sqrt(dist2);
			float newRadious = (dist + radious) * 0.5 ;
			float k = (newRadious - radious) / dist ;
			radious = newRadious ;
			VECTOR3 temp ;
			Vec3Mul(temp, d, k);
			Vec3Add(center, center, temp);
		}// end if
	}// end for vertex_num
}// end for computeBoundingSphereRitter

上面的代码应该非常清楚了，所以不须要在进行解释，假设有疑问能够在博客中留言。看下这个算法的效果怎样：

两种方法的对照

上面两种方法，尽管第一种最简单，可是相同的他的效果不如另外一种的好，假设你不能直观的看出来，那么请看以下两种对照图：

第一种算法：

另外一种算法：

非常明显的看出，另外一种算法它的包围球体更加的紧凑点。

包围球类

以下，我将这个包围球的类的全部代码列出来（唯独包围球的类，关于DirectX的操作部分，不属于这个类）

//---------------------------------------------------------------------------------
// declaration	: Copyright (c), by XJ , 2014 . All right reserved .
// brief		: This file will define the bounding sphere in collision system
// author		: XJ
// date			: 2014 / 6 / 20
// file			: Sphere.h
// version		: 1.0
//---------------------------------------------------------------------------------
#pragma once
#include"XJMath.h"
namespace XJCollision
{
	class Sphere
	{
	public:
		Sphere();
		Sphere(VECTOR3 c, float r);
		~Sphere();

	public:
		/**
		* This method will use the average method to compute the bounding sphere of the
		* input vertices array
		*/
		void computeBoundingSphereAverage(VECTOR3* vertices, unsigned int vertex_num);

		/**
		* This method will use the Ritter's method to compute the bounding sphere
		*/
		void computeBoundingSphereRitter(VECTOR3* vertices, unsigned int vertex_num);
	public:
		VECTOR3 center ;
		float radious ;
	};
};

#include"Sphere.h"
#include<cmath>
using namespace std ;
using namespace XJCollision ;

Sphere::Sphere()
	:center(),
	radious(0.0f)
{

}

Sphere::Sphere(VECTOR3 c, float r)
	:center(c),
	radious(r)
{

}

Sphere::~Sphere()
{

}

void Sphere::computeBoundingSphereAverage(VECTOR3* vertices, unsigned int vertex_num)
{
	//Compute the center point
	VECTOR3 total ;
	total.x = 0 ;
	total.y = 0 ;
	total.z = 0 ;
	for(int i = 0 ; i < vertex_num ; i ++)
	{
		total.x += vertices[i].x ;
		total.y += vertices[i].y ;
		total.z += vertices[i].z ;
	}// end for

	total.x /= vertex_num ;
	total.y /= vertex_num ;
	total.z /= vertex_num ;
	center = total ;

	//Compute the radious
	float r = 0 ;
	for(int i = 0 ; i < vertex_num ; i ++)
	{
		VECTOR3 temp ;
		Vec3Sub(temp, total, vertices[i]);
		float length = 0 ;
		length = Vec3Length(length, temp);
		if(length > r)
			r = length ;
	}// end for

	radious = r ;
}// end for computeBoundingSphereAverage

void Sphere::computeBoundingSphereRitter(VECTOR3* vertices, unsigned int vertex_num)
{
	unsigned int maxX = 0 , maxY = 0, maxZ = 0 , minX = -1, minY = -1, minZ = -1 ;

	//Find the max and min along the x-axie, y-axie, z-axie
	for(int i = 0 ; i < vertex_num ; i ++)
	{
		if(vertices[i].x > maxX) maxX = i ;
		if(vertices[i].x < minX) minX = i ;
		if(vertices[i].y > maxY) maxY = i ;
		if(vertices[i].y < minY) minY = i ;
		if(vertices[i].z > maxZ) maxZ = i ;
		if(vertices[i].z < minZ) minZ = i ;
	}// end for

	float x = 0;
	VECTOR3 sub1 , sub2 ;
	sub1.x = vertices[maxX].x ; sub1.y = vertices[maxX].y ; sub1.z = vertices[maxX].z ;
	sub2.x = vertices[minX].x ; sub2.y = vertices[minX].y ; sub2.z = vertices[minX].z ;
	Vec3Sub(sub1, sub1, sub2);
	Vec3Dot(x, sub1, sub1);

	float y = 0 ;
	sub1.x = vertices[maxY].x ; sub1.y = vertices[maxY].y ; sub1.z = vertices[maxY].z ;
	sub2.x = vertices[minY].x ; sub2.y = vertices[minY].y ; sub2.z = vertices[minY].z ;
	Vec3Sub(sub1, sub1, sub2);
	Vec3Dot(y, sub1, sub1);

	float z = 0 ;
	sub1.x = vertices[maxZ].x ; sub1.y = vertices[maxZ].y ; sub1.z = vertices[maxZ].z ;
	sub2.x = vertices[minZ].x ; sub2.y = vertices[minZ].y ; sub2.z = vertices[minZ].z ;
	Vec3Sub(sub1, sub1, sub2);
	Vec3Dot(z, sub1, sub1);

	float dia = 0 ;
	int max = maxX , min = minX ;
	if( z > x && z > y)
	{
		max = maxZ ;
		min = minZ ;
		dia = z ;
	}else if(y > x && y > z)
	{
		max = maxY ;
		min = minY ;
		dia = y ;
	}

	//Compute the center point
	center.x = 0.5 * (vertices[max].x + vertices[min].x) ;
	center.y = 0.5 * (vertices[max].y + vertices[min].y) ;
	center.z = 0.5 * (vertices[max].z + vertices[min].z) ;

	//Compute the radious
	radious = 0.5 * sqrt(dia);

	//Fix it
	for(int i = 0 ; i < vertex_num ; i ++)
	{
		VECTOR3 d ;
		Vec3Sub(d, vertices[i], center);
		float dist2 = 0 ;
		Vec3Dot(dist2, d, d);

		if(dist2 > radious * radious)
		{
			float dist = sqrt(dist2);
			float newRadious = (dist + radious) * 0.5 ;
			float k = (newRadious - radious) / dist ;
			radious = newRadious ;
			VECTOR3 temp ;
			Vec3Mul(temp, d, k);
			Vec3Add(center, center, temp);
		}// end if
	}// end for vertex_num
}// end for computeBoundingSphereRitter

好了，今天到这里就结束了。以后会陆陆续续的解说其它的包围体的用法，希望大家喜欢！！！！

3D空间包围球(Bounding Sphere)的求法,布布扣,bubuko.com

时间： 2024-10-26 07:13:00

3D空间包围球(Bounding Sphere)的求法的相关文章

3D空间中的AABB(轴向平行包围盒, Aixe align bounding box)的求法

引言 在前面的一篇文章中讲述了如何通过模型的顶点来求的模型的包围球,并且还讲述了基本包围体除了包围球之外,还有AABB包围盒.在这一章,将讲述如何根据模型的坐标求得它的AABB盒. 表示方法 AABB盒的表示方法有很多,总结起来有如下的三种情况: Max-min表示法:使用一个右上角和左下角的点来唯一的定义一个包围体 Center-radious表示法:我们用center点来表示中点,radious是一个数组,保存了包围盒在x方向,y方向,z方向上的半径. Min-Width表示方法:我们用mi

WebGL简易教程(十二)：包围球与投影

目录 1. 概述 2. 实现详解 3. 具体代码 4. 参考 1. 概述 在之前的教程中,都是通过物体的包围盒来设置模型视图投影矩阵(MVP矩阵),来确定物体合适的位置的.但是在很多情况下,使用包围盒并不方便计算,可以利用包围盒再生成一个包围球,利用包围球来设置MVP矩阵. 在<WebGL简易教程(十):光照>中,给地形赋予了固定方向的平行光.这篇教程的例子就是想模拟在平行光的视角下地形的情况.对于点光源光,可以用透视投影来实现渲染的效果:而平行光就需要通过正射投影来模拟.并且,这种正射并不是

3D空间中射线与轴向包围盒AABB的交叉检测算法

引言 在上一节中,我讲述了如何实现射线与三角形的交叉检测算法.但是,我们应该知道,在游戏开发中,一个模型有很多的三角形构成,如果要对所有的物体,所有的三角形进行这种检测,就算现在的计算机运算能力,也是无法高效的完成.所以,我们需要通过其他的手段来提早剔除一些不可能发生交叉的物体,这种早退的思想,大量的运用在3D游戏技术中.在本篇文章中,我将像大家讲述如何实现射线与轴向包围盒AABB的交叉检测.如果读者不明白什么是轴向包围盒,请看这篇文章. Ray-AABB交叉检测算法 现如今,有很多的Ray-A

AABB包围盒、OBB包围盒、包围球的比較

1) AABB 包围盒: AABB 包围盒是与坐标轴对齐的包围盒, 简单性好, 紧密性较差(尤其对斜对角方向放置的瘦长形对象, 採用AABB, 将留下非常大的边角空隙, 导致大量不是必需的包围盒相交測试).当物体旋转之后需对AABB 进行相同的旋转并更新; 当物体变形之后仅仅需对变形了的基本几何元素相应的包围盒又一次计算; 然后能够自下向上由子结点的AABB 合成父结点的AABB, 最后进行包围盒树的更新. 2) OBB 包围盒: OBB 碰撞检測方法紧密性是较好的, 可以大大降低參与相交測试的

NeHe OpenGL教程 第五课：3D空间

转自[翻译]NeHe OpenGL 教程 前言 声明,此 NeHe OpenGL教程系列文章由51博客yarin翻译(2010-08-19),本博客为转载并稍加整理与修改.对NeHe的OpenGL管线教程的编写,以及yarn的翻译整理表示感谢. 第五课:3D空间 3D空间: 我们使用多边形和四边形创建3D物体,在这一课里,我们把三角形变为立体的金子塔形状,把四边形变为立方体. 在上节课的内容上作些扩展,我们现在开始生成真正的3D对象,而不是象前两节课中那样3D世界中的2D对象.我们给三角形增加一

第05课 OpenGL 3D空间

3D空间: 我们使用多边形和四边形创建3D物体,在这一课里,我们把三角形变为立体的金子塔形状,把四边形变为立方体. 在上节课的内容上作些扩展,我们现在开始生成真正的3D对象,而不是象前两节课中那样3D世界中的2D对象.我们给三角形增加一个左侧面,一个右侧面,一个后侧面来生成一个金字塔(四棱锥).给正方形增加左.右.上.下及背面生成一个立方体. 我们混合金字塔上的颜色,创建一个平滑着色的对象.给立方体的每一面则来个不同的颜色. int DrawGLScene(GLvoid) // 此过程中包括所有

Qt_OpenGL：3D空间中移动图像

Qt_OpenGL:3D空间中移动图像 //.h #ifndef GLWIDGET_H #define GLWIDGET_H #include <QGLWidget> #include <QtOpenGL> class QGLWidget; class QTimer; typedef struct Stars{ public: int r, g, b; GLfloat dist, angle; }Stars; class GLWidget : public QGLWidget {

OpenGl学习进程（9）在3D空间的绘制实例

    本节将演示在3D空间中绘制图形的几个简单实例:     (1)在3D空间内绘制圆锥体: #include <GL/glut.h> #include <math.h> #pragma comment(linker,"/subsystem:\"windows\" /entry:\"mainCRTStartup\"") #define PI 3.1416 GLfloat xRot = 0; GLfloat yRot =

3D空间管理系统 Vantage.Plant.Design.Management.System.v12.1.SP2-ISO 1DVD

完全以数据为中心的3D空间管理系统,VANTAGE Plant Design 以独立于下部CAD系统.多训练接口.整洁的管理.自动绘图为特征.■□■□■□■□■□■□■□■□■□■□■□■□■□■□■□■□■□■□ + 诚信合作,保证质量!!!长期有效: + 电话TEL:18980583122 客服 QQ:1140988741 邮件(Email):[email protected] ■□■□■□■□■□■□■□■□■□■□■□■□■□■□■□■□■□■□工厂设计管理系统:全局工程操作.模式管理.