一种城市道路网络的随机生成方式（Unity中可视化）
一种城市道路网络的随机生成方式（Unity中可视化）
- 1. 说在开头
- 2. 有限元网格划分
-
- 2.1. 什么是有限元
- 2.2. 前沿推进法/波前推进法（Advancing Front Technique）
- 3. 实现
-
- 3.1. 数据的定义
- 3.2. 边界的分类
- 3.3. 生成一个小网格
- 3.4. 生成桥边
- 4. 完整代码
-
- 4.1. 一些定义或辅助
- 4.2. AFT算法
- 4.3. 可视化
参考：
[1]王元,刘华,李航.基于有限元网格划分的城市道路网建模[J].图学学报,2016,37(03):377-385.
[2]李任君. 关于四边形有限元网格生成算法的研究[D].吉林大学,2008.
1. 说在开头
做毕设的时候，第一步就需要城市道路网络的生成。翻了一些文献，感觉王元等人1所提到的利用有限元网格生成的方式进行的路网生成效果挺不错的，于是打算用这种方式实现。但是论文中并没有过多的提算法本身，所以实现算法的时候主要还是参考李任君2的那篇文献。
写这篇博客的时候，我已经大体上把生成路网的初步功能给实现了。当然实现的非常粗糙，而且自身算法能力非常有限，很多地方写的也很暴力。还会有一定几率会生成出质量很差的网格、甚至还有一些BUG没有解决。后续继续做下去的时候应该还是会进一步完善的。现在先写一篇博客，记录一下阶段性的成果。顺便当作是给最后写毕业设计说明书打个草稿。
目前为止可以实现的是，通过给定一个多边形的顶点数据作为路网的边缘，然后自动的生成路网的数据，也可以实现不同区域的路网密度不同。
先放一下演示视频，视频播放有问题或者不对的话，可以跳转到原网页查看。
路网生成效果
稍微讲解一下，目前是在Unity中，简单的通过输入顶点的方式给定路网边缘，然后可以设置的参数有单元格长度（每一小段道路长度会尽可能的贴近单元格的长度），随机种子（用于随机一些长度和角度，种子一样且其他参数一样的情况下每次的结果也会一样），然后就是一些可视化调试用的选项。以及在世界坐标靠近原点的位置那一区块道路密度更高（以后会改成专门制定密度的形式，这个靠近原点密度更高只是暂时用来测试密度变化功能用的）。
当前也存在着一些比较明显的问题，比如有的网格质量非常差，所划分的区域很小很窄，道路也靠的很近，效果不好。有的时候生成会出现死循环的情况（检测到死循环就自动跳出），无法继续向下划分（视频中出现过一次，一般换一个随机种子就有很大几率解决，当然这也是治标不治本），目前认为主要还是网格密度变化导致的一些缺陷，有待优化。
2. 有限元网格划分
2.1. 什么是有限元
百度百科：
在数学中，有限元法（FEM，Finite Element Method）是一种为求解偏微分方程边值问题近似解的数值技术。求解时对整个问题区域进行分解，每个子区域都成为简单的部分，这种简单部分就称作有限元。
它通过变分方法，使得误差函数达到最小值并产生稳定解。类比于连接多段微小直线逼近圆的思想，有限元法包含了一切可能的方法，这些方法将许多被称为有限元的小区域上的简单方程联系起来，并用其去估计更大区域上的复杂方程。它将求解域看成是由许多称为有限元的小的互连子域组成，对每一单元假定一个合适的（较简单的）近似解，然后推导求解这个域总的满足条件（如结构的平衡条件），从而得到问题的解。这个解不是准确解，而是近似解，因为实际问题被较简单的问题所代替。由于大多数实际问题难以得到准确解，而有限元不仅计算精度高，而且能适应各种复杂形状，因而成为行之有效的工程分析手段。
定义还是有点难懂。根据我的一些浅显的了解（可能不太准确），大概就是在工业上，对一些模型进行某些力学分析等处理的时候，需要将模型细分为很多的小块。用到的是有限元分析。
查资料的时候搜到的也基本是对三维模型，特别是CAD等的处理。
然后一个平面有限元网格划分的结果，的确是有一点像路网的意思，再给他加上一些调整就更像了。
2.2. 前沿推进法/波前推进法（Advancing Front Technique）
进行有限元网格划分的方法并不止一种，比较常见的有Delaunay法、映射法、AFT法等。通常也都是生成三角形，但是也有生成四边形的。
我这里用到的就是AFT法。下面先大概讲一下这个算法的思路，主要参考的是李任君的论文。
- 首先是有一个边界的多边形数据（一般别人的边界可以是曲线也可以是直线，我这就不搞那么复杂了。只有直线），如下图。
- 然后把根据设置的单元格长度把一条长的边离散开来，如下图。
- 这一圈蓝色的边就称作当前的前沿，然后开始遍历前沿上的每一个点，判断该点适合往里面生成一个怎样的网格单元。生成一个网格单元就记录起来，并且更新前沿，实其不包括已经生成出去的网格单元。然后一直重复直到整个前沿剩下最后一个小的网格单元，即生成完毕。如下图的蓝色边界是一个已经生成了四个网格单元之后的前沿。
下图蓝色边界是生成了更多网格单元之后的前沿。
下图是生成完之后，已经没有了前沿。
3. 实现
3.1. 数据的定义
首先是节点和道路的定义。非常的简单明了，稍微提一下就是，每一个节点和道路都需要一个唯一的ID，然后AftNode中的angle，其实是可以不用的，因为后面实际用到角度的时候我都是用一次当场计算一次的，这里存起来只是当时还在调试算法的时候，可视化角度用的。
public class AftNode
{
// ID
public readonly uint ID;
// 位置
public Vector3 Coord {
get; }
// 该点内角角度
public float Angle;
/// 上面还有一个概念——标准单元。所谓的标准单元就是一个矩形，如下图一个灰色的框框就是一个标准单元。
为什么需要引入标准单元这个概念呢？是因为在后面算法的计算中，需要进行非常多次的线段碰撞判断等操作，如果直接与所有的线段边界都比较一次，那显然开销特别大。而且做了很多无用功，因为100条线段中，也许90条都根本不可能发生碰撞，因为他们相隔实在太远了。
标准单元，记录自身所包含的线段，每一个线段也记录着他所相关的所有单元。比如上图中绿色的一条线段，他所在的标准单元就是黄色的三个单元。当他要进行比较的时候只需要与这三个标准单元中所包含的线段比较即可。
下面是标准单元的定义。(X、Y其实不需要，因为后续算法中是用一个二维数组存储所有的标准单元，直接通过计算索引就可以找到标准单元，这里只是我在将他可视化出来成黄色框框的时候，需要用到而已)
/// 这就是标准网格的存储方式。
// 标准网格（由标准单元组成）
public static StandardUnit[,] StandardNet {
get; private set; }
然后在生成一个小网格的时候，需要把它作为结果存起来。需要存下来的数据有顶点的位置，道路（包含两个顶点），街区（包含多个道路）。我使用字典的方式存储，用他们的ID作为key。
public static readonly Dictionary<uint, Block> ResultBlocks = new Dictionary<uint, Block>();
public static readonly Dictionary<uint, Node> ResultNodes = new Dictionary<uint, Node>();
public static readonly Dictionary<uint, Road> ResultRoads = new Dictionary<uint, Road>();
这是结果类的定义。
/// 然后整个前沿是以一个类对象的形式存在的，类为AdvancingFrontTechnique，部分定义如下图所示，后面还有很多函数就不展示了，最后会放上完整的代码。(IsDone可以忽视掉，在之前不完善的算法中是用到这一个变量的，后面改进之后就不需要了，只是遗留在这里没有删除。)
3.2. 边界的分类
在前沿每一次往内推进的过程中，是需要生成新的边界的。论文中是把边界分成了三类，我这里根据我自己的想法稍微改了一下，分成了四类。
首先先说明一下，如上图所示。图中是整个前沿中截出来的一下段，假设现在正在处理第i个顶点（红色是顶点，蓝色是边和角），此时其他点的名称即分别为点i-1、点i+1、点i+2、点i+3。边为边i-1、边i、边i+1、边i+3（边i为点i与点i+1的连线）。然后点i+1和点i+2所在的角度分别为a1、a2。
然后就是四种分类：
- 添加一条边的情况（1）
如果此时a1<65°，且a2>90°，则将点i与点i+2相连作为新的边，然后边i、边i+1、黄色的新边就作为一个新的小网格存到结果中去，以及所包含的点和边也是。并且把边i、边i+1从前沿中去掉，在该位置插入黄色的新边，同时也去掉点i+1。 - 添加一条边的情况（2）
当65°<=a1<115°，且160°<=a1+a2<240°时，将点i与点i+3相连作为新的边，与上面的情况一样，删除点i+1、点i+2、边i、边i+1、边i+2，并把边i、边i+1、边i+2、黄色新边所构成的网格作为新的结果存起来。 - 添加两条边的情况
当65°<=a1<115°，200°<=a1+a2时。创建一个新顶点点t1，然后连接点i和点t1作为边e1，以此类推，将边e1、边e2加入到前沿中，点t1也加入到前沿中，其他的该删除删除，该存结果存结果。 - 添加三条边的情况
和前面三种一个套路，话不多说，懂得都懂。
写了个简单的demo，大概效果就如下，有时候各种情况都不符合的，基本上当i到下一个的时候，或者下一轮生成的时候也就都生成了。
边界分类
3.3. 生成一个小网格
生成一个网格主要是有一个private void GenerateABlock(int i)来搞定，这个也是整个算法中最核心的一个函数，半数代码都在这（当让也是因为我写的比较烂，感觉挺乱的）。
前面的public List和public List就是按照逆时针的顺序存着当前的前沿中，所有的点和边 （这里我用的List来存这个数据，其实是不妥当的。因为更新前沿时会经常的在中间进行插入和删除的操作，而且需要不断地循环，并且处理顶点的时候也是一个接着一个的处理，几乎不怎么需要随机读取任意位置的数据。所以改用双向循环链表来存前沿的数据才是最合适的。 但是我写到后期才意识到这个问题，而且可能是因为数据量的确不算大，即便用List的时候生成路网也是蛮快的，反正这个速度我可以接受，就懒得改了。不过为了处理跨越结尾的增删操作等等，我还是写了好多函数和求余操作去处理，的确实制造了挺多的麻烦） 。
然后GenerateABlock中的参数i的意思就是处理第i个节点的时候。就是根据前面提到的边界分类，进行判断然后处理。我就挑生成三条边的情况稍微讲一下，其他的情况也是按照思路写就是了。
- 首先第一步判断当前前沿中顶点的个数是否是6以下，即小于等于5。如果是的话，直接把剩下的所有顶点作为一个街区，然后清空前沿。结束。（其实论文中是以生成四边形网格为目标，迫不得已就生成一个三角形，但是我觉得我的需求其实无所谓，5边形我觉得也是可以接受的，所以我就这样写了）
// 当节点剩下的已经足够少,直接组成Block
if (Nodes.Count < 6)
{
// 标记已执行
_executed = true;
// 添加街区
AddToResultBlock(Edges.ToArray());
// 清空
Nodes.Clear();
Edges.Clear();
// 标记结束
IsDone = true;
return;
}
- 然后就是按照边界分类那部分讲的一样，计算
a1和a2的角度，这个AngleOf(int n)函数是我自己写的，返回的是前沿中第n个顶点所在的角度。求余是因为处理正好+1、+2之后跨越边界饶了一圈的情况。
// 不需要比较的边的ID
var noCompareIDs = new List<uint>();
// 求得下两个顶点的角度之和
var angle1 = AngleOf((i + 1) % Nodes.Count);
var angle2 = AngleOf((i + 2) % Nodes.Count);
// 新加的边界是否与已存在的边界碰撞
var isCollide = false;
- 然后判断当符合生成三条边的时候，
if (angle1 >= 115 && angle1 < 220 && angle2 >= 115 && angle2 < 220)，继续执行下面对应的函数。 - 然后就是要生成出新的两个点和三个边。边好说，只要有这几个点，按顺序直接连起来就好了。可是点要怎么求呢？我这里用到的方法就是定义
向量dir是一个从点i+1到点i+2的向量旋转90度之后的向量，那么点i+1加上向量dir就是点t1的位置，点t2同理。当然这个向量dir需要先单位话然后再乘上单元格的长度，这样就可以时得生成的网格中，每一个小段道路都是贴近单元格长度。不过我再此还加上了一个随机数（可以指定随机种子），让路网不至于太规规矩矩。这个时候生成出来的两条边都还是垂直于边i+1的，因为是按照90度旋转的，要是喜欢在这也可以加上一定的随机。代码里面用node1、node2存了以下就是不想后面每次用都写Nodes[(i + 1) % Nodes.Count]这么麻烦，其实node1就是图中的点i+1，node2就是点i+2。这里可以留意一下，我是写了一个IdManger来管理ID，确保每一个ID都是唯一的。以及里面的WeightUnitLength函数，这里本来应该是直接写的单元格长度。但是后来我加了一个控制密度的功能。就是我可以指定某一个区域的路网更稀疏或者更密集。我就可以通过这个函数获取当前位置的长度应该是多少。当然目前这个函数背后只是很简单的根据位置判断了以下长度返回回来，还处于测试阶段。
// 记录一下node1 node2
AftNode node1 = Nodes[(i + 1) % Nodes.Count], node2 = Nodes[(i + 2) % Nodes.Count];
// 计算第一个点到第二个点的方向
var dir = node2.Coord - node1.Coord;
// 计算旋转矩阵
var roateMat = Matrix4x4.Rotate(Quaternion.Euler(0, -90, 0));
// 计算并创建出第一个要添加的点
var testScale = RandomRange(0.9f, 1.1f);
Vector3 newDir = (roateMat * dir).normalized * (WeightUnitLength(node1.Coord.x,node1.Coord.z) * testScale);
var tempNode1 = new AftNode(node1.Coord + newDir, IdManager.GetNodeID());
// 计算第二个点到底一个点的方向（反转即可）
dir *= -1;
// 计算旋转矩阵
roateMat = Matrix4x4.Rotate(Quaternion.Euler(0, 90, 0));
// 计算并创建出第二个要添加的点
newDir = (roateMat * dir).normalized * (WeightUnitLength(node1.Coord.x,node1.Coord.z) * testScale);
var tempNode2 = new AftNode(node2.Coord + newDir, IdManager.GetNodeID());
// 计算新的三条边
var tempEdge1 = new AftEdge(node1, tempNode1, IdManager.GetRoadID());
var tempEdge2 = new AftEdge(tempNode1, tempNode2, IdManager.GetRoadID());
var tempEdge3 = new AftEdge(tempNode2, node2, IdManager.GetRoadID());
- 然后就是给新加的这三条边设置与标准单元的关系，用于等会计算碰撞。函数实现可以看最后放的完整代码，反正这里就是设置了关系。
// 设置关系
SetUnitRelation(tempEdge1);
SetUnitRelation(tempEdge2);
SetUnitRelation(tempEdge3);
- 判断新加入的边是否与其他边相互碰撞，如果有碰撞的话就说明无法按这个方式生成。首先我们可以知道，新加的边本身，和相邻的边是不需要判断碰撞的，而且因为他们是点对点的接在一起，甚至真有可能判断为碰撞，所以先把不需要碰撞的边的ID存一下，待会检测的时候只要是这些ID就不需要比较。结合着上面的图片看就会比较容易理解了。然后就是遍历当前边每一个有关系的单元中，所有有关系的边。虽然这里是双重循环，但是一般来说一条边最多只会和三个标准单元有关系（因为一条边的长度就是按照标准单元的长度生成的）。然后比较的时候，除非真的有碰撞，否则大多数情况除了不需要比较的ID，其他也没多少需要比较的，一旦找到一个也直接跳出所有的判断了。所以这里效率其实还算可以。但也不是没法优化了，还是可能会出现再两个单元格内都出现同一条边，然后重复比较的情况，可以记录一下比较过的边的ID。但是这种情况感觉也不多，就算了。
// 判断碰撞
// 设置不需要比较碰撞的ID(新加的边以及几个边是不需要比较的)
noCompareIDs.Clear();
noCompareIDs.Add(tempEdge1.ID);
noCompareIDs.Add(tempEdge2.ID);
noCompareIDs.Add(tempEdge3.ID);
noCompareIDs.Add(Edges[(i + 1) % Edges.Count].ID);
// 遍历新边所在的所有标准单元
foreach (var unit in tempEdge2.Units)
// 遍历每一个标准单元中的其他边
foreach (var edge in unit.Edges)
// 如果发生碰撞，就记录并跳出（不比较某些边）
if (!noCompareIDs.Contains(edge.ID) && IsCollide(edge, tempEdge2))
{
isCollide = true;
// 跳出这个双重循环
goto outLoop;
}
noCompareIDs.Add(Edges[i].ID);
foreach (var unit in tempEdge1.Units)
// 遍历每一个标准单元中的其他边
foreach (var edge in unit.Edges)
// 如果发生碰撞，就记录并跳出（不比较某些边）
if (!noCompareIDs.Contains(edge.ID) && IsCollide(edge, tempEdge1))
{
isCollide = true;
// 跳出这个双重循环
goto outLoop;
}
noCompareIDs.Remove(Edges[i].ID);
noCompareIDs.Add(Edges[(i + 2) % Edges.Count].ID);
foreach (var unit in tempEdge3.Units)
// 遍历每一个标准单元中的其他边
foreach (var edge in unit.Edges)
// 如果发生碰撞，就记录并跳出（不比较某些边）
if (!noCompareIDs.Contains(edge.ID) && IsCollide(edge, tempEdge3))
{
isCollide = true;
// 跳出这个双重循环
goto outLoop;
}
outLoop:
- 如果检测到碰撞
isCollide就会为true。那么说明这三条边这样生成是不行的，所以首先要解除他们与标准单元的关系。因为如果他们的信息还存在里面，以后判断别的边的时候，很可能会将明明不碰撞的判断为了碰撞。所以要把残留的关系清除。同时因为刚才都给新增的顶点和边界分配了唯一ID，如果不将ID收回的话，将会浪费很多ID。（不过说实在的，我大概只需要几千个，顶多上万个街区就已经足够了，uint这么多ID其实根本分配不完，但是能省则省吧）所以还需要跟IdManager说明移除这些分配过的ID，待会就还可以继续分配。
// 清除关系
tempEdge1.DeleteRelateUit();
tempEdge2.DeleteRelateUit();
tempEdge3.DeleteRelateUit();
// 移除ID
IdManager.RemoveNodeID(tempNode1.ID);
IdManager.RemoveNodeID(tempNode2.ID);
IdManager.RemoveRoadID(tempEdge1.ID);
IdManager.RemoveRoadID(tempEdge2.ID);
IdManager.RemoveRoadID(tempEdge3.ID);
- 如果没有碰撞，说明这样的生成方法可行，那么就把该存到结果的存到结果。然后把新的边和顶点加入到前沿中，同时把已经不属于前沿的顶点和边从前沿中删去。
// 添加新Node到结果中
AddToResultNode(tempNode1);
AddToResultNode(tempNode2);
// 添加新Road到结果中
AddToResultRoad(tempEdge1);
AddToResultRoad(tempEdge2);
AddToResultRoad(tempEdge3);
// 添加新Block到结果中
AddToResultBlock(Edges[(i + 1) % Edges.Count], tempEdge3, tempEdge2, tempEdge1);
// 清除掉无用边界与其标准单元的关系
Edges[(i + 1) % Edges.Count].DeleteRelateUit();
// 添加新顶点到前沿中
var tempNodeList = new List<AftNode>()
{
tempNode1,
tempNode2
};
Nodes.InsertRange((i + 2) % Nodes.Count, tempNodeList);
// 添加新边界到前沿中
var tempEdgeList = new List<AftEdge>()
{
tempEdge1,
tempEdge2,
tempEdge3
};
Edges.InsertRange((i + 1) % Edges.Count, tempEdgeList);
// 删除无用边界
RemoveEdgesInList((i + 4) % Edges.Count, 1);
至此，如果没有问题的话，第i个顶点位置的一个小的网格就生成好了，有问题的话就不会生成。如果是因为碰撞导致的不生成，后面会直接用桥边的方式解决，如果是不满足四类的任何一种情况导致的不生成，那么要么就会在下一个点的时候生成，要么在下一轮的时候生成。很少会出现卡死的情况（目前还是有一定记录出现到某些情况的时候会卡住，无法继续往下生成，观察后感觉主要是因为加入了密度改变的功能之后，当有时候一个小前沿中，怎么生成都会碰撞，但有的边有太长而不符合桥边的规则的时候会出现，这个后续有待优化。但是更换以下随机种子还是很大程度上的暂时的解决这个问题）。
3.4. 生成桥边
当前沿两边靠的足够近的时候，很容易就会出现，并且总是会出现怎么生成都会碰撞的情况。如下图红色圈起来的部分，到这里按照前面的分类生成肯定会碰撞，如果没有生成桥边的功能。那么算法到这里将会卡死无法继续生成。
当一个顶点可以找到一个足够近的其他顶点的时候，可以将两点连接起来，分为两个前沿，然后再分别生成。
比如上图中，C和H两点已经足够近了，可以直接连接生成桥边，然后再分成左边的前沿和右边的前沿继续生成。
只要遍历一下一个点所在的标准单元以及附近的一圈的标准单元中，最近的那个点是否满足足够近的这个原则，就可以找到连接点。（为啥还需要判断附近一圈的标准单元呢？因为很可能出现两个点很近但是又处于相邻的标准单元的情况）。
但是还有一个要考虑的问题就是。假设当前的前沿如下图所示，此时正在寻找第i个顶点适合连接桥边的另一个顶点。如果单纯按距离来算，很可能会找到紫色圈起来的顶点。很明显这不是我们想要的桥边。
我们想要的是如下图黄色区域所示，这一区域中，最近的且满足距离要求的点。
我这里是利用向量的计算，判断这个顶点是否属于黄色一边的区域。这是在检测线段碰撞的方法中得到启发所改写的。
/// 然后就是在处理完第i个顶点所生成的网格之后，顺带如下面代码一样，判断一下是否有可以生成桥边的情况。如果有则生成桥边，并且将当前前沿根据桥边划分为两部分，一部分继续生成，另一部分存到_edgesLinkedList和_nodesLinkedList链表中，直到当前前沿生成结束，节生成链表中的下一个前沿。
// 判断有没有距离该节点很近的其他非邻边节点
noCompareIDs.Clear();
noCompareIDs.Add(Edges[i > 0 ? i - 1 : Edges.Count - 1].ID);
noCompareIDs.Add(Edges[i].ID);
noCompareIDs.Add(Edges[(i + 1) % Edges.Count].ID);
noCompareIDs.Add(Edges[(i + 2) % Edges.Count].ID);
// 找到一个最近的，并且位于左侧的一个符合距离的顶点
var closestIndex = FindClosestNodeIndex((i + 1) % Nodes.Count, noCompareIDs,
Nodes[i].Coord,
Nodes[(i + 1) % Nodes.Count].Coord,
Nodes[(i + 2) % Nodes.Count].Coord);
// 如果找到
if (closestIndex >= 0)
{
// 标记已执行
_executed = true;
// 【注意】此ID由两个方向的边用，但实际是一条边，任意一条边加入结果即可
var brigeEdgeID = IdManager.GetRoadID();
// 创建桥边
var brigeEdge = new AftEdge(Nodes[closestIndex], Nodes[(i + 1)%Nodes.Count], brigeEdgeID);
// 添加到结果中
AddToResultRoad(brigeEdge);
// 创建桥边分割开来的另一半的顶点和边
var newNodes = CopyRangeInNodes((i + 1) % Nodes.Count, closestIndex);
var newEdges = CopyRangeInEdges((i + 1) % Edges.Count, closestIndex > 0 ? closestIndex - 1 : Edges.Count - 1);
newEdges.Add(brigeEdge);
// 将新的边界和顶点存到链表后，用于以后继续生成，代替递归
_edgesLinkedList.AddLast(newEdges);
_nodesLinkedList.AddLast(newNodes);
// 删除掉已经划分的边和顶点
// 计算需要删掉几个边
var deleteEdgeCount = (Edges.Count + closestIndex - i - 1) % Edges.Count;
// 添加桥边
Edges.Insert((i + 1) % Edges.Count, new AftEdge(Nodes[(i + 1) % Nodes.Count], Nodes[closestIndex], brigeEdgeID));
// 删除多余边
RemoveEdgesInList((i + 2) % Edges.Count, deleteEdgeCount);
// 删除多余顶点
RemoveNodesInList((i + 2) % Nodes.Count, deleteEdgeCount - 1);
}
这一部分的时候我遇到一个坑。一开始我不是这样写的，一开始我是生成桥边之后，用划分出来的另一半生成一个新的AdvancingFrontTechnique对象，然后让他继续划分，直到所有结束。是一种递归的思想。当然这种方法没问题，是对的，实验出来的结果也OK。（那个IsDone也是这个地方用的，当IsDone为true就说明这个前沿生成完毕，就返回到刚才的前沿接着生成）
但是当我单元网格长度越挑调小，也就是密度越来越高，数据越来越大的时候。Unity闪退了。真的是突然就闪退，也没有崩溃日志。就像有一个临界值，只要密度超过那个他就闪退。我被这个问题难了几乎整整一天。也和群里的同学讨论了很久。一开始认为是unity的问题，后来又感觉不是，觉得是不是内存爆了（但是任务管理器看内存是好好的，占用很少，啥都没爆），并且单步调试看到闪退前的数据量也不大，也就几千。真是百思不得其解。甚至当晚我下单了一条8G内存第二天到货（虽然后来在内存到之前我就把问题解决了），企图的解决这个问题。
然后第二天早上我就尝试着把这个算法直接粘到vs的项目里面运行，看看是不是unity的问题。不过由于我还是用了不少uinity给的数学运算，不在unity里面都没法用，好在github上有这一部分源码，我就照着拿了一些过来用。改了以下终于能跑了。然后测试了和在unity中运行时会闪退的数据。VS终于给了我一个结果。
堆栈溢出。
好家伙终于把问题找到了，原来是堆栈溢出。Unity要早报这个错我早解决了。下图是用Rider调试的时候，闪退前的堆栈情况，左边那个长到令人发指的就是不停的划分桥边生成新对象并且调用函数用到的堆栈。简单的上网查了以下，貌似是c#一个进程的堆栈大小就只给你1m，也没法改，像我这样整肯定就溢出了。
然后我才把这段代码改成前面那样用链表存着划分出来的另一个前沿。然后用下面这种形式来控制所有的前沿来生成。
public void GenOnce()
{
while (_edgesLinkedList.Count > 0 && _nodesLinkedList.Count > 0)
{
_executed = false;
if(Nodes != null && Edges != null){
if (Nodes.Count == 0 && Edges.Count == 0)
{
_nodesLinkedList.RemoveFirst();
_edgesLinkedList.RemoveFirst();
if (_nodesLinkedList.Count > 0 && _edgesLinkedList.Count > 0)
{
Nodes = _nodesLinkedList.First.Value;
Edges = _edgesLinkedList.First.Value;
}
}
if(Nodes != null && Edges!= null)
for (var i = 0; i < Nodes.Count; i++)
GenerateABlock(i);
}
if (!_executed && _edgesLinkedList.Count > 0 && _nodesLinkedList.Count > 0)
{
Debug.LogWarning("检测到死循环，跳出！");
return;
}
}
}
4. 完整代码
基本的思想就在前面讲了一遍，下面是完整的代码。多很多函数的实现，也多了一些细节。注释也很充足。(同时也有很多没用的代码在里面，不用太在意)
当然现在我这个东西其实也还是个半成品，不少东西还不完善，也还处于测试的状态。说不定还会有BUG存在。
有什么问题也欢迎交流。
4.1. 一些定义或辅助
using System.Collections.Generic;
using UnityEngine;
namespace RoadNetwork
{
/// using System.Collections.Generic;
namespace RoadNetwork
{
public static class IdManager
{
// 当前的最大ID（已分配）
// 0不会被分配
public static uint currentNodeID {
get; private set; }
public static uint currentRoadID {
get; private set; }
public static uint currentBlcokID {
get; private set; }
// 被移除掉的ID，获取ID时会优先分配这些ID，以免浪费ID
private static Queue<uint> _removedNodeID = new Queue<uint>();
private static Queue<uint> _removedRoadID = new Queue<uint>();
private static Queue<uint> _removedBlockID = new Queue<uint>();
/// 4.2. AFT算法
using System;
using System.Collections.Generic;
using UnityEngine;
namespace RoadNetwork
{
public class AdvancingFrontTechnique
{
// 该前沿是否生成完成
public bool IsDone {
get; private set; }
// 当前多边形边界的所有顶点
private readonly LinkedList<List<AftNode>> _nodesLinkedList = new LinkedList<List<AftNode>>();
public List<AftNode> Nodes = new List<AftNode>();
// 当前多边形边界的所有边界线段
private readonly LinkedList<List<AftEdge>> _edgesLinkedList = new LinkedList<List<AftEdge>>();
public List<AftEdge> Edges = new List<AftEdge>();
// 单个标准单元的长度
public float StandardUintLength {
get; }
// 标准网格（由标准单元组成）
public static StandardUnit[,] StandardNet {
get; private set; }
// 网格起始点
public Vector3 StartCoordinate {
get; private set; }
// 生成的结果
public static readonly Dictionary<uint, Block> ResultBlocks = new Dictionary<uint, Block>();
public static readonly Dictionary<uint, Node> ResultNodes = new Dictionary<uint, Node>();
public static readonly Dictionary<uint, Road> ResultRoads = new Dictionary<uint, Road>();
// 随机数
private static System.Random _random;
// TODO 构造函数
public AdvancingFrontTechnique(IEnumerable<Vector3> coords, float unitLength = 1,int randomSeed = 0)
{
// 初始化
IsDone = false;
ResultBlocks.Clear();
ResultNodes.Clear();
ResultRoads.Clear();
// TODO
_nodesLinkedList.AddLast(Nodes);
_edgesLinkedList.AddLast(Edges);
_random = new System.Random(randomSeed);
// 创建节点
foreach (var point in coords)
Nodes.Add(new AftNode(point, IdManager.GetNodeID()));
// 参数传递
StandardUintLength = unitLength;
// 离散边界
DisperseNodes(ref Nodes);
// 生成边
for (var i = 0; i < Nodes.Count - 1; i++)
Edges.Add(new AftEdge(Nodes[i], Nodes[i + 1], IdManager.GetRoadID()));
// 最后一条边
Edges.Add(new AftEdge(Nodes[Nodes.Count - 1], Nodes[0], IdManager.GetRoadID()));
// 生成标准网格
GenerateStandardNet(Nodes);
// TEST 计算所有顶点的角度
for (var i = 0; i < Nodes.Count; i++)
Nodes[i].Angle = AngleOf(i);
// 把最初的边界和顶点加入到结果中
foreach (var node in Nodes)
AddToResultNode(node);
foreach (var edge in Edges)
AddToResultRoad(edge);
}
/// 角度
private float AngleOf(int n)
{
// 计算该点的两个向量
var vec1 = Nodes[n > 0 ? n - 1 : Nodes.Count - 1].Coord - Nodes[n].Coord;
var vec2 = Nodes[(n + 1) % Nodes.Count].Coord - Nodes[n].Coord;
// 计算角度
var angle = Vector3.SignedAngle(vec1, vec2, Vector3.up);
// 将负的角度改成正数
if (angle < 0) angle = 360 + angle;
return angle;
}
/// 矩形数据（2维，只有对角的坐标）
private Vector3[] RectOf(int x, int y)
{
var res = new Vector3[2];
res[0].x = StartCoordinate.x + x * StandardUintLength;
res[0].z = StartCoordinate.z + y * StandardUintLength;
res[1].x = res[0].x + StandardUintLength;
res[1].z = res[0].z + StandardUintLength;
return res;
}
/// 4.3. 可视化
using System;
using System.Collections.Generic;
using UnityEngine;
using RoadNetwork;
using System.Threading;
namespace Test
{
public class TestAFT : MonoBehaviour
{
public List<Transform> polygon = new List<Transform>();
public float unitLength = 1.5f;
public float nodeShpereSize = 0.2f;
public int randomSeed = 0;
public enum ShowType
{
Input,
Front,
Result,
FrontAndResult
}
public enum LableType
{
NodeAndRoad,
Node,
Road
}
public LableType idType;
public int genType;
public ShowType showType;
private List<Vector3> polygonCoords = new List<Vector3>();
public AdvancingFrontTechnique _boundary;
// TEST 可视化选择边界用到
[Range(1,100)]
public int edgeIndex = 1;
public void Creat()
{
// 获取多边形顶点位置
polygonCoords.Clear();
foreach (var point in polygon)
polygonCoords.Add(point.position);
Generate();
}
public void GenAndGen()
{
Generate();
_boundary.GenOnce();
Debug.Log("Done");
Debug.Log(AdvancingFrontTechnique.ResultNodes.Count);
}
private void OnDrawGizmos()
{
// 画出标准网格
if (_boundary != null)
{
// 显示起始点
Gizmos.color = Color.red;
Gizmos.DrawSphere(_boundary.StartCoordinate,0.4f);
// 显示标砖网格
Gizmos.color = Color.gray;
for (int i = 0; i < AdvancingFrontTechnique.StandardNet.GetLength(0); i++)
{
for (int j = 0; j < AdvancingFrontTechnique.StandardNet.GetLength(1); j++)
{
Vector3 p1 = _boundary.StartCoordinate, p2 = _boundary.StartCoordinate;
p1.x += i * _boundary.StandardUintLength;
p1.z += j * _boundary.StandardUintLength;
p2.x = p1.x + _boundary.StandardUintLength;
p2.z = p1.z + _boundary.StandardUintLength;
DrawRect(p1,p2);
}
}
}
switch (showType)
{
case ShowType.Input:
// 画出所构建的多边形
if (polygon.Count > 0)
{
Gizmos.color = Color.blue;
for (var i = 0; i < polygon.Count; i++)
{
Gizmos.DrawLine(polygon[i].position, polygon[(i + 1) % polygon.Count].position);
}
}
break;
case ShowType.Front:
if (_boundary != null)
{
// 显示离散之后的各个顶点
Gizmos.color = Color.magenta;
foreach (var node in _boundary.Nodes)
Gizmos.DrawSphere(node.Coord,nodeShpereSize);
// 显示前沿
Gizmos.color = Color.blue;
foreach (var edge in _boundary.Edges)
{
Gizmos.DrawLine(edge.Begin.Coord, edge.End.Coord);
}
// 显示一个边以及对应的单元格
// 线条
Gizmos.color = Color.green;
edgeIndex %= _boundary.Edges.Count;
Gizmos.DrawLine(_boundary.Edges[edgeIndex].Begin.Coord,_boundary.Edges[edgeIndex].End.Coord);
// 单元格
Gizmos.color = Color.yellow;
foreach (var unit in _boundary.Edges[edgeIndex].Units)
{
Vector3 p1 = _boundary.StartCoordinate, p2 = _boundary.StartCoordinate;
p1.x += unit.X * _boundary.StandardUintLength;
p1.z += unit.Y * _boundary.StandardUintLength;
p2.x = p1.x + _boundary.StandardUintLength;
p2.z = p1.z + _boundary.StandardUintLength;
DrawRect(p1,p2);
}
}
break;
case ShowType.Result:
if (_boundary != null && _boundary.IsDone)
{
// 绘制结果顶点
Gizmos.color = Color.magenta;
foreach (var node in AdvancingFrontTechnique.ResultNodes)
Gizmos.DrawSphere(node.Value.Coord,nodeShpereSize);
// 绘制结果边界
Gizmos.color = Color.green;
foreach (var road in AdvancingFrontTechnique.ResultRoads)
{
Gizmos.DrawLine(road.Value.Begin.Coord,road.Value.End.Coord);
}
}
break;
case ShowType.FrontAndResult:
if (_boundary != null)
{
// 绘制结果边界
Gizmos.color = Color.green;
foreach (var road in AdvancingFrontTechnique.ResultRoads)
{
Gizmos.DrawLine(road.Value.Begin.Coord,road.Value.End.Coord);
}
// 显示前沿
Gizmos.color = Color.blue;
foreach (var edge in _boundary.Edges)
{
Gizmos.DrawLine(edge.Begin.Coord, edge.End.Coord);
}
// 绘制结果顶点
Gizmos.color = Color.white;
foreach (var node in AdvancingFrontTechnique.ResultNodes)
Gizmos.DrawSphere(node.Value.Coord,nodeShpereSize);
// 显示离散之后的各个顶点
Gizmos.color = Color.red;
foreach (var node in _boundary.Nodes)
Gizmos.DrawSphere(node.Coord,nodeShpereSize);
}
break;
}
}
// 画四边形
private void DrawRect(Vector3 p1, Vector3 p3)
{
Vector3 p2 = new Vector3(p1.x,0,p3.z), p4 = new Vector3(p3.x,0,p1.z);
Gizmos.DrawLine(p1,p2);
Gizmos.DrawLine(p2,p3);
Gizmos.DrawLine(p3,p4);
Gizmos.DrawLine(p4,p1);
}
public void Generate()
{
// 初始化IDManager
IdManager.Initialization();
_boundary = new AdvancingFrontTechnique(polygonCoords, unitLength, randomSeed);
}
// TEST 测试用的函数
private Thread _thread;
public void TEST()
{
// 获取多边形顶点位置
polygonCoords.Clear();
foreach (var point in polygon)
polygonCoords.Add(point.position);
_thread = new Thread(new ThreadStart(GenAndGen));
_thread.Start();
}
public void StopThread()
{
_thread.Abort();
}
private static float CrossVec2(Vector3 a, Vector3 b)
{
return (a.x * b.z) - (b.x * a.z);
}
}
}
using System.Collections.Generic;
using RoadNetwork;
using UnityEditor;
using UnityEngine;
namespace Test.Editor
{
[CustomEditor(typeof(TestAFT))]
public class TestAftEditor : UnityEditor.Editor
{
private bool showLable;
public override void OnInspectorGUI()
{
base.OnInspectorGUI();
showLable = GUILayout.Toggle(showLable, "ShowLable");
TestAFT script = target as TestAFT;
if (GUILayout.Button("生成"))
{
script.Creat();
SceneView.RepaintAll();
}
if (script._boundary!=null && GUILayout.Button("生成一次网格"))
{
script._boundary.GenOnce();
Debug.Log(AdvancingFrontTechnique.ResultBlocks.Count);
SceneView.RepaintAll();
}
if (GUILayout.Button("TEST"))
{
script.TEST();
}
if (GUILayout.Button("STOP"))
{
script.StopThread();
}
}
private void OnSceneGUI()
{
TestAFT script = target as TestAFT;
if (showLable && script._boundary != null)
{
switch (script.showType)
{
case TestAFT.ShowType.Front:
// TEST 可视化角度 (更新过前沿之后这个角度就不对了，因为每次用角度都是重新计算的，并没有更新这个角度)
foreach (var node in script._boundary.Nodes)
Handles.Label(node.Coord,"Node: " + node.ID.ToString());
foreach (var road in script._boundary.Edges)
Handles.Label(Vector3.Lerp(road.Begin.Coord,road.End.Coord,0.5f),"Road: "+road.ID.ToString());
break;
case TestAFT.ShowType.Result:
// 可视化ID
Handles.color = Color.white;
foreach (var node in AdvancingFrontTechnique.ResultNodes)
Handles.Label(node.Value.Coord,"Node: " + node.Value.ID.ToString());
Handles.color = Color.black;
foreach (var road in AdvancingFrontTechnique.ResultRoads)
Handles.Label(Vector3.Lerp(road.Value.Begin.Coord,road.Value.End.Coord,0.5f),"Road: "+road.Value.ID.ToString());
break;
case TestAFT.ShowType.FrontAndResult:
// 可视化ID
Handles.color = Color.white;
if(script.idType == TestAFT.LableType.NodeAndRoad || script.idType == TestAFT.LableType.Node)
foreach (var node in AdvancingFrontTechnique.ResultNodes)
Handles.Label(node.Value.Coord,"Node: " + node.Value.ID.ToString());
Handles.color = Color.black;
if(script.idType == TestAFT.LableType.NodeAndRoad || script.idType == TestAFT.LableType.Road)
foreach (var road in AdvancingFrontTechnique.ResultRoads)
Handles.Label(Vector3.Lerp(road.Value.Begin.Coord,road.Value.End.Coord,0.5f),"Road: "+road.Value.ID.ToString());
break;
}
}
}
private void TestLinkedList()
{
var linkedList = new LinkedList<MyClass>();
linkedList.AddLast(new MyClass("1",1));
linkedList.AddLast(new MyClass("2",2));
linkedList.AddLast(new MyClass("3",3));
linkedList.AddLast(new MyClass("4",4));
linkedList.AddLast(new MyClass("5",5));
linkedList.AddLast(new MyClass("6",6));
linkedList.AddLast(new MyClass("7",7));
linkedList.AddLast(new MyClass("8",8));
MyClass temp = linkedList.First.Value;
temp.str = "liu";
ShowLinked(linkedList);
}
private void RemoveRange(ref LinkedList<MyClass> link, LinkedList<MyClass>.Enumerator begin, LinkedList<MyClass>.Enumerator end)
{
var i = begin;
link.Remove(i.Current);
}
private void ShowLinked(LinkedList<MyClass> targetList)
{
foreach (var node in targetList)
{
Debug.Log(node);
}
}
public class MyClass
{
public string str;
public int inter;
public MyClass(string str, int inter)
{
this.inter = inter;
this.str = str;
}
public override string ToString()
{
return str;
}
}
}
}
王元,刘华,李航.基于有限元网格划分的城市道路网建模[J].图学学报,2016,37(03):377-385. ↩︎
李任君. 关于四边形有限元网格生成算法的研究[D].吉林大学,2008. ↩︎