什么是Quadtrees? 四叉树

原理：什么是Quadtrees?

由于3D图形卡消费市场的变革，现在3D游戏越来越流行了，他们中大部分是第一人称射击游戏，这 是一个很好的理由，这个理由是室内环境，当和室外环境相比它非常简单。对于室外环境，它没有方便 的通往下一关的楼梯，门，或墙来阻挡你的视线。室外环境都是连续的。对于传统的几何学来说这是非 常棘手的，请打入quadtrees来学习下面的知识。

注意：下面的图示都是从上到下看一个3D地形，方格显示了在X和Y轴上的地形，并看不见现 实中的物体高度，因为我们是顺着Y轴看的。

 
Figure 1

设想你的地形是一个非常大的方格，在一个X和Z的面上扩展，如图1。我们有一个摄象机在地形的右 下角，它的可视截面（蓝三角）扩展为在相同方向上的小单元，这样在优化前，绘制地形的程序代码看 起来象这样:

for(int ctr=0; ctr<num_of_cells; ctr++){  DrawCell();}      

注意：一个小单元就是一个包含一些三角形的正方形，它是地形的一部分），看起来非常好，但是本 来我们只是占用了16个单元，可是画了256个。这是非常大的浪费，在我们的可视截面里只有5个单元。 现在第一个优化：我们要测试所有的单元是否在可视截面里，如果在就画他，现在的代码如下：

for(int ctr=0; ctr<num_of_cells; ctr++){  if(cell is in frustum) DrawCell();}      

如果单元在我们的可视截面中，就画他，非常正确。现在我们只画了5个单元，而不是256个，我们只 是更改很少的代码。在上面，我们保存了我们没有绘出的251个单元，每次都是，这是非常的浪费，如下图：

 
Figure 2

我将一些单元变成了兰色，这样我们可以建立一个包围盒，如果兰色的单元不在截面内，我们可以安全 的说这个单元在区域A中，如果我们知道兰色的单元不在截面内，我们如何去测试区域A中的其他144个单元 呢，这由quadtrees 来工作

quadtrees 是从地形中获得的，把它分割成四个较小的部分，每一个部分继续分下去，直到一个分到 一个设定的大小，这看起来有点乱，让我结合图片解释一下，首先，从我们的网格出发，现在将他分为四份。

 
Figure 3

如图三，我们现在有四个子地形，继续分下去，知道一个部分只有一个单元，，在下图中，我们把第一个 小部分分成了四个更小的部分。

 
Figure 4

然后继续：

 
Figure 5

然后继续：

 
Figure 6

好了，现在第一个部件只有一个单元大小，我们告诉树停止分割第一个部件，分割下一个，直到 全部分割完毕。当然你也可以将树分割到合适的三角形数目停止，在我们的例子中为16个三角形，第 一，这个树是父子关系，每个子节点有一个父节点，每个父节点有四个子节点，叶节点例外，他只有 一个父节点没有子节点。叶节点是我们允许的最小的子节点，第二，每个树都有一个根节点，它没有 父节点，但有四个子节点。

再看一下图，暗红的边界就是根节点，在图3中，我们分割根节点，分配给他的子节点。蓝线描绘 的正方形是根节点的四个子。称为节点2，3，4，5。在图4 ，我们把节点2分为四份，这些正方形是 节点的子，称为节点6，7，8，9。继续由节点6分割出10，11，12，13，由节点10分割为14，15， 16，17。这是他们的叶节点。停止分割。分割节点11，分完后是12和13，然后是7，8，和9。然后是 3，4，5。完成。

quadtrees 使用一个节点的包围坐标工作，我们说我们的图形0-16在X轴上，0-16在Z轴上。由于 这个原因，我们整个地图的包围坐标为左上为（0，0，0）右上（16，0，0）左下（0，0，16）右下 （16，0，16）当我们分割父节点时，我们就分割他的包围坐标，于是节点2的包围坐标为：左上 （0，0，0）右上（8，0，0）左下（0，0，8）右下（8，0，8）如图7.

 
Figure 7

Test 1

方法如下：我们从根节点开始问“摄象机是否在根节点的包围坐标内？”我们说是。我们知道摄 象机在根节点的一个子节点内，于是测试他们，“摄象机在节点2的包围坐标内吗？”这里回答不， 于是我们离开节点2和它的子节点。这样我们就可以不用测试节点2的64个单元了，不坏，不坏。

 
Figure 8

Test 2

你可以看图8，我移出了节点2和它的子节点。继续测试，“摄象机在节点3的包围坐标内吗？” ，回答不，于是我们可以安全的离开节点3和它的子节点。

 
Figure 9

Test 3

继续“摄象机在节点4的包围坐标内吗？”回答不测试节点5。

 
Figure 10

Test 4

这时，摄象机在节点5的包围坐标内，我们测试它的子节点，我们给他的子节点命名为A，B，C，D， 测试第一个子节点“摄象机在节点A的包围坐标内吗？”如图10，不在，于是我们离开节点A和它的子节 点。

 
Figure 11

Test 5

现在测试节点5的第二个子节点，“摄象机在节点B的包围坐标内吗？”如图11。不在

 
Figure 12

Test 6

现在测试节点5的第三个子节点，“摄象机在节点C的包围坐标内吗？”如图12。不在

 
Figure 13

Test 7

OK，他一定在节点D中，“摄象机在节点D的包围坐标内吗？”，是的，太好了，我们将在这里停止。 考虑一下上面的测试，共有16次测试（节点D内），结果是有5个单元被看见，测试总数是7+16为23。 我们从256减少为23次。

A quadtree is used to dismiss large chunks of terrain at a time. If an apple is on a tree's leaf, chopping off the branches the apple is nowhere near saves you looking on every leaf.

编码

Before we go any further, I advise those who are unsure about Indexed Lists to read through my tutorial here.

我们需要:

• 一个保存我们QUADTREE数据的结构
• 一个建立树的函数
• 一个保存三角形数据的结构

typedef struct node{  int bType;  VERTEX vBoundingCoordinates[4];  unsigned int uiBranches[4];  unsigned int uiVertexStrip1[8];  unsigned int uiVertexStrip2[8];  unsigned int uiVertexStrip3[8];  unsigned int uiVertexStrip4[8];  unsigned int uiID;  unsigned int uiParentID;}NODE;      

变量bType告诉我们节点的类型，可以为NODE_TYPE or LEAF_TYPE，如果我们画树的话，他用 来作为一个标志告诉程序停止或画一些三角形（LEAF_TYPE），或继续向下解析树（NODE_TYPE）。 下一个变量是一个包含4个顶点的数组，他用来保存节点的包围坐标，VERTEX定义如下

typedef struct vertex{  float x,y,z;}VERTEX;      

我们还有一个叫做uiBranches的数组，他保存了四个索引值，代表了节点的四个子节点，如果本 节点类型是LEAF_TYPE，就不使用。

由于我们说每个叶节点保存16个多边形，这里有四个数组，名为uiVertexStrip1到uiVertexStrip4， 每个数组保存四个三角形。在本向导中，他们没被使用

变量uiID保存了QUADTREE的节点ID，在我解释他以前，QUADTREE就如同一个节点的数组，这个ID就是 数组的索引

T让我们看看最后一个变量，uiParentID，它是父节点的索引，让我们用自己的方法来遍历这棵树，对 于给定的节点，我们可以从它的父节点遍历到它的子节点，对于下面给定一个树，我们如何遍历他呢，

NODE *pNodeList;      

这是一个pNodeList的指针，它是一个QUADTREE，注意：我们使用数组pNodeList[0] 作为根节点。

 
Formula 1.

上面的公式给出了叶节点的数目，叶宽指的是每个叶的三角形数目，这里我们称叶节点为单元，也可以说每 个单元包含16个三角形，那么这里的叶宽为4个三角形，Grid Width 指的是格子的宽度，由于每个单元有4个 三角形，Grid Width 为16个单元乘以4是64，为了求出树中的节点数，使用下面的函数:

unsigned int CalcNodeNum(unsigned int max,unsigned int min){  int ctr=0;  int var = 0;  while(var==0)  {    ctr+=max;    max=max/min;    if(max==1)      {var=1;}  }  ctr++;  return ctr;}      

这里函数CalcNodeNum 有两个参数，叶节点的数目（MAX）和叶宽（MIN），在这里叶宽为4 个三角形，叶节点的数目包含在上面的公式中，为了更好的理解上面的函数，给出下面的代码:

unsigned int Temp =(GridWidth/4)*(GridWidth/4);unsigned int Temp2 = CalcNodeNum(Temp,4);pNodeList = (NODE*)malloc(sizeof(NODE)*Temp2);      

首先计算叶节点的总数，其次保存节点的总数到变量Temp2，第三行是为指针分配内存，现在 我们已经技术了节点的总数并分配了内存，接着调用QUADTREE的建立函数。

但是首先，让我们回忆一下递归的代码，如果我们想显示数目1到10，我们可以这样做：

void Count(int num){  cout<<num<<"\n";}void main(){  Count(0);  Count(1);  Count(2);  Count(3);  Count(4);  Count(5);  Count(6);  Count(7);  Count(8);  Count(9);  return;}      

这样做很乏味，可以这样

for(int ctr=0;ctr<10;ctr++){  Count(ctr);}      

虽然上面的代码没有任何错误，但在QUADTREE中使用他简直是噩梦，在上面我们调用了10次，如 果我们想调用20次，我们不得不告诉FOR循环使用20次，而递归只需要一次。他不需要FOR或WHILE结 构，正确的代码如下：

void Count(int num){  static int ctr = 0;  if(ctr>num)    {return;}  else  {    cout<<ctr<<"\n";    ctr++;    Count(num);  }}void main(){  Count(ctr);  return;}      

现在让我们看看函数CreateNode，象它的名字一样，他用来建立节点，实际他不仅可以建立一个 节点，还可以建立整个树，我们只要调用函数一次，

void CreateNode(unsigned int Bounding[4],unsigned int ParentID,unsigned int NodeID)      

< 使用的是顶点索引，因此我 是（0，0，0）（16，0，0）（0，0，16）（16，0，16），Bounding[4] 数需要初始化他，由于第一个节点是根节点，我们需要为根节点设置参数，包围坐标就是整个地形，这里>

在一个2D数组中扩展为高度为0的X和Z的面，为发现左上坐标，使用下面的公式

右上为:

左下?

右下?

数学并不困难，现在准备调用:

unsigned int uiBoundingCoordinates[] =  {0,GridWidth,(GridHeight*(GridWidth+1)),((GridHeight)*(GridWidth+1))+GridWidth};CreateNode(uiBoundingCoordinates,0,0);

父节点已经建立好了，我们可以通过CreateNode来工作了。.

void CreateNode(unsigned int Bounding[4],unsigned int ParentID,unsigned int NodeID){  static unsigned int TotalTreeID = 0;  unsigned int uiNodeType;  unsigned int uiWidth,uiHeight;

OK，静态变量TotalTreeID保存了当前的节点数目，我们最后使用他来将子节点与他们的ID联系起 来，uiNodeType保存节点的类型，uiWidth,uiHeight保存节点的宽和高，由于我们传送的是包围坐 标，实际上我们并不知道节点的大小，我们使用uiWidth,uiHeight来告诉节点是叶节点还是普通节点 ，现在需要从包围坐标中获得uiWidth,uiHeight:

  uiWidth = fVerts[(Bounding[1]*3)] - fVerts[(Bounding[0]*3)];  uiHeight = fVerts[(Bounding[2]*3)+2] - fVerts[(Bounding[0]*3)+2];

T这里假设fVerts是一个包含顶点列表的数组，每个顶点包含3个部件，X，Y，Z，如果我们有顶点的 索引，就可以获得指向这个顶点的指针，

 
Figure 14

如同你看见的一样，索引0指向element[0]，element[0]是顶点0的X部件，依次类推。 现在，我们说我们的叶节点是4*4的三角形，这意味着叶宽为4三角形，由于我们知道节点的宽度（存储 在uiWidth），如果我们分割宽度的结果为2，那么意味着这个宽度为4，这个节点就是一个叶节点，

  if(0.5*uiWidth==2)  {    uiNodeType = LEAF_TYPE;  }  else  {    uiNodeType = NODE_TYPE;  }

接着，我们想得到一个指向我们节点的指针，pNodeList包含所有我们的节点，我们需要选择一个。

  NODE *pNode = &pNodeList[NodeID];

向节点内填充内容

  pNodeList[NodeID].uID = Whatever;

我们可以简单的做:

  pNode->uiID = Whatever;

用我们得到的值填充

  pNode->uiID = NodeID;  pNode->uiParentID = ParentID;  pNode->vBoundingCoordinates[0].x = fVerts[(Bounding[0]*3)];  pNode->vBoundingCoordinates[0].y = fVerts[(Bounding[0]*3)+1];  pNode->vBoundingCoordinates[0].z = fVerts[(Bounding[0]*3)+2];  pNode->vBoundingCoordinates[1].x = fVerts[(Bounding[1]*3)];  pNode->vBoundingCoordinates[1].y = fVerts[(Bounding[1]*3)+1];  pNode->vBoundingCoordinates[1].z = fVerts[(Bounding[1]*3)+2];  pNode->vBoundingCoordinates[2].x = fVerts[(Bounding[2]*3)];  pNode->vBoundingCoordinates[2].y = fVerts[(Bounding[2]*3)+1];  pNode->vBoundingCoordinates[2].z = fVerts[(Bounding[2]*3)+2];  pNode->vBoundingCoordinates[3].x = fVerts[(Bounding[3]*3)];  pNode->vBoundingCoordinates[3].y = fVerts[(Bounding[3]*3)+1];  pNode->vBoundingCoordinates[3].z = fVerts[(Bounding[3]*3)+2];  pNode->bType = uiNodeType;

现在我们还没有处理叶节点，一旦我们分配了叶节点，我们将返回调用函数，在真实的世界里，你 或许希望得到一个指向数组或三角形的叶节点指针，如果你仔细看过NODE结构，你将注意变量 uiVertexStrip1...4，如果你愿意的话，可以在里面填充三角形，.

  if(uiNodeType == LEAF_TYPE)  {    return;  }  else  {

下面，我们需要处理节点的子节点

    unsigned int BoundingBox[4];    TotalTreeID++;    pNode->uiBranches[0] = TotalTreeID;    //Top-Left i.e. b[0]    BoundingBox[0] = Bounding[0];    //Between b[0] and b[1]    BoundingBox[1] = Bounding[0]+((Bounding[1]-Bounding[0])/2);    //[between b[0] and b[2]    BoundingBox[2] = Bounding[0]+((Bounding[2]-Bounding[0])/2);    //middle of node    BoundingBox[3] = Bounding[0]+((Bounding[2]-Bounding[0])/2)+((Bounding[1]-Bounding[0])/2);    CreateNode(BoundingBox,NodeID,TotalTreeID);

很简单，自己看吧，

    //******************************************************************************    TotalTreeID++;    pNode->uiBranches[1] = TotalTreeID;    // Between b[0] and b[1]    BoundingBox[0] = Bounding[0]+((Bounding[1]-Bounding[0])/2);    //Top-Right i.e. b[1]    BoundingBox[1] = Bounding[1];    //middle of node    BoundingBox[2] = Bounding[0]+((Bounding[2]-Bounding[0])/2)+((Bounding[1]-Bounding[0])/2);    //between b[1] & b[3]    BoundingBox[3] = Bounding[0]+((Bounding[2]-Bounding[0])/2)+((Bounding[1]-Bounding[0]));    CreateNode(BoundingBox,NodeID,TotalTreeID);    //******************************************************************************    TotalTreeID++;    pNode->uiBranches[2] = TotalTreeID;    //between b[0] and b[2]    BoundingBox[0] = Bounding[0]+((Bounding[2]-Bounding[0])/2);    //middle of node    BoundingBox[1] = Bounding[0]+((Bounding[2]-Bounding[0])/2)+((Bounding[1]-Bounding[0])/2);    //Bottom-Left i.e. b[2]    BoundingBox[2] = Bounding[2];    //between b[2] and b[3]    BoundingBox[3] = Bounding[2]+((Bounding[3]-Bounding[2])/2);    CreateNode(BoundingBox,NodeID,TotalTreeID);    //******************************************************************************    TotalTreeID++;    pNode->uiBranches[3] = TotalTreeID;    //middle of node    BoundingBox[0] = Bounding[0]+((Bounding[2]-Bounding[0])/2)+((Bounding[1]-Bounding[0])/2);    //between b[1] and b[3]    BoundingBox[1] = Bounding[0]+((Bounding[2]-Bounding[0])/2) + uiWidth;    //between b[2] and b[3]    BoundingBox[2] = Bounding[2]+((Bounding[3]-Bounding[2])/2);    //Bottom-Right i.e. b[3]    BoundingBox[3] = Bounding[3];    CreateNode(BoundingBox,NodeID,TotalTreeID);  }

All we need to do is return nothing and end CreateNode's curly brackets:

  return;}

And that's about it. You can download the fully annotated source and executable here.