survey of terrain generation and approximation algorithms · abstract terrain, in nature, is a...
TRANSCRIPT
Survey of Terrain Generation and Approximation Algorithms
Carleton University
School of Computer Science
COMP4905 - Honors Project
By: Po Kong Lai
Supervisor: Prosenjit. K. Bose
April 12, 2011
1
Abstract
Terrain, in nature, is a vertical and horizontal dimension of land. Terrain generation problem is
therefore the problem of how to generate terrain such that it meets certain criterion. For example,
we could want to generate realistic looking terrain, that resembles the terrain we see on Earth, or we
could want to generate terrain that is suited for other worlds like Mars or the worlds inside a video
game. A realistic or detailed terrain usually contains millions of data points and thus we may want to
approximate the terrain using fewer data points yet still have the terrain maintain its shape. In this
project we explore how terrain can be represented, how terrain can be generated, the applications for
such a generated terrain and finally we look at a way to approximate terrain.
2
Acknowledgments
Firstly I would like to thank Prosenjit. K. Bose for his patience, guidance and constant source of
inspiration. Secondly, I would like to thank the many people who created tutorials for Java3D which
allowed me to get started on 3D programming quickly despite having no prior experience. Lastly I would
like to thank Boaz Ben-Moshe for making his implementation of the Delaunay triangulation available
to use.
3
Contents
1 Introduction 6
2 Implementation of Terrain Generation 7
3 Random Fractal Terrain Generation 8
3.1 1D Case . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
3.2 Height Maps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3.3 2D Case - Diamond Square . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
3.4 Other Applications of Height Maps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
4 3D Model Creation 14
4.1 Tessellation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
4.2 Voronoi diagram and Delaunay triangulation . . . . . . . . . . . . . . . . . . . . . . . . 14
4.2.1 The Voronoi diagram . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
4.2.2 Duality . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
4.2.3 Delaunay triangulation and Terrain . . . . . . . . . . . . . . . . . . . . . . . . . 17
4.3 Java3D and Model Implementation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
5 Levels of Detail 22
5.1 Hierarchy Approach . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
5.1.1 Selecting Very Important Points . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
5.1.2 Hierarchy Construction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
6 Conclusions 27
4
List of Figures
1 Screenshots of the main program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2 Random fractal terrain in 1D with iterations i = 1→ 4. Note a rounded hill at iteration 4 9
3 Diamond Square at varying stages. (3a) shows the intial four corners. (3b) demonstrates
the first diamond step. If the terrain was rendered now we would see four diamonds
all converging at E. (3c) demonstrates the first square step. The computed midpoints
between the four corners are represented by blue dots. (3d) is the result of the first pass.
Now we have four squares so we repeat the diamond step for each square. (3e) shows the
result after applying the diamond step to all squares. Now we need to apply the square
step. The points for the first square are the blue points. The lines extend to K and L as
we need those points to wrap. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
4 Height maps at varying roughness levels . . . . . . . . . . . . . . . . . . . . . . . . . . 12
5 Fractal Clouds . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
6 Voronoi regions bound by solid lines. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
7 Delauny triangulation is in black while the Voronoi diagram is in red. Source: Wikipedia 16
8 A violation of Circumcircle Property . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
9 Empty Circle Property . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
10 Local Maximum Miniumum Angle Property. . . . . . . . . . . . . . . . . . . . . . . . . 18
11 Some triangulations created by TerrainGenerator using Boaz Ben-Moshes Delaunay
triangulation library. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
12 An example of a height map generated by TerrainGenerator using the Diamond
Square algorithm (iterations=6, roughness=0.5) and the accompanying 3D view of the
terrain. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
13 The 3D terrain when we add sunlight and Gouraud shading. . . . . . . . . . . . . . . . 21
14 Height map that will be used to generate the hierarchy of terrains in the next figure. . . 25
15 Example of terrain with a hierarchy of levels of detail. . . . . . . . . . . . . . . . . . . . 26
5
1 Introduction
Formally a terrain is the graph of a continuous function that assigns to every point on the plane an
elevation. Inituatively we can imagine terrain as a natural landscape which includes various features
like mountains, lakes and plains. Terrain in general is not limited to the natural Earth like landscapes
we are so accustomed to. It can also represent the landscapes of other planets with would thus bring
in different features unique to the chemical, and thus geograhical, structure of that world. Terrain
generation is a series of steps or an algorithm which may or may not take in parameters and the output
is a represetionation of a terrain. The main application for terrain generation would be anything in which
a terrain is needed. Thus the main application would be as geographic modelling as terrain generation
can create a random terrain which may include features that the user desires (such as mountains).
These generated terrains would then be used in aircraft simulations, video games and various other
applications such as Google Earth.
This report will start by describing several techniques to generate random fractal terrain and how
it was implemented in practice. For an object to be fractal it must display the self-similiar property on
all scales. In nature we can see many examples of fractal objects such as trees and thus fractal terrain
would represent natural looking terrian. To create a realistic looking terrain one would need millions of
points and triangles to recreate the level of detail needed. Hence once we examine how to create terrain
we will look at some techniques to approximate terrain so that it will retain it’s shape using less points
and triangles. This sort of approximation can be used to speed up terrain generation and rendering so
that it can be used for real-time applications or it can be used to allow zooming in and out of a terrain
to a more or less detailed terrain. The report will end with a summary of results obtained using the
different terrain generation and approximation algorithms along with what was learned in the process.
6
2 Implementation of Terrain Generation
A terrain generator program, which will henceforth be refered to as TerrainGenerator, was
written to help study terrain generation. TerrainGenerator was coded in Java and utilizes Java3D
to display 3D models of generated terrain. The algorithms used in the program are outlined in the next
section. An example of what the program looks like can be see in Figure 1.
(a) Each button launches a new frame with the respective
generation technique
(b) Height Map (c) Rendered 3D terrain using height map from (b)
Figure 1: Screenshots of the main program
7
3 Random Fractal Terrain Generation
A fractal is an object or quantity that displays self-similarity on all scales [1]. This self-similarity
property in the strictest sense does require that the object exhibit the exact same structure on all scales.
We can see this sort of self-similarity property all over nature in the trees, how the rivers are shaped
and even in our blood viens. Thus it is natural to use fractal generation technqiues to create terrain
which would serve as models for a given geographical world. However in nature the self-similiarity
property is more relaxed and allows for for small variations in the structure at different levels unlike
the purely mathematical fractals such as the Mandelbrot set. The main technique we will use to create
random fractal terrain utilizes midpoints and displacements the midpoints by a random factor. First
we will examine the 1D case and then we will look at the 2D case which will be the basis for a 3D
representation.
3.1 1D Case
Terrain in the one dimensional case would be a line which reaches from one end of the bounding
universe to the other. All we need to create a line are two points and thus any line can be considered
as terrain. Hence in general a terrain in one dimension can be seen as a set of lines such that the end
point of a line Li is the starting point for the next line Li+1. To generate a random fractal terrain in
1D we will use a midpoint displacement method. Thus if we let S be the set of all line segements which
represent the terrain and N be the number of steps we run the midpoint displacement method, the
algorithm to generate a fractal terrain in Algorithm 1.
While in essence a very simple algorithm the resulting terrain can be very complex. This is the
nature of fractals as a few simple instructions can create a rich and detailed terrain. The reduction in
the range of random numbers (line 7) is what gives the generated terrain is a measure of roughness.
That is to say if we reduce more with each pass of the loop we will have a smoother terrain and inversely
if we reduce less with each pass of the loop we have a rougher terrain. Examples of the generated 1D
fractal terrain can be see in Figure 2.
8
Algorithm 1 Random Fractal Terrain in One-dimension
1: Start with a single horizontal line segment L0 and add it to S.
2: for i = 1 to N do
3: for line L in S do
4: Find midpoint of L and let it be known as M .
5: Displace M by a random amount.
6: Let A and B be the start and end points of L, insert lines AM and MB in the place of L.
7: Reduce the range of the random numbers.
8: end for
9: end for
(a) Iteration 1 (b) Iteration 2 (c) Iteration 3 (d) Iteration 4
Figure 2: Random fractal terrain in 1D with iterations i = 1→ 4. Note a rounded hill at iteration 4
3.2 Height Maps
A common representation of a computer generated terrain is usually in the form of a height map. A
height map, in general, maps some indices to height values. Thus in the 1D case we can represent the
terrain as a one dimensonal height map which maps the x values to y values. Thus a height map in the
2D case would map the indices (x, z) to some height values y. This height map can be implemented
as a N × N array of values each of which represent an elevation given a particular position (i, j) in
the array. This is the main data structure which will hold the elevation values for the terrain in the
Diamond Square algorithm. Given a height map H and indices x and z, the elevation would have a
value of H[x][z]. Thus the indices of the height map provide us with the horizontal position in the
terrain where we would apply the elevation H[x][z]. Now that we know what a height map is. . . how
does one render it? A common way to render the height map is as an image and thus the N ×N array
which makes up the height map will produce an N × N image. We can color the values of highest
9
elevation the brigthest colors while the values of lower elevation darker colors. This height map will
also be useful later when we create 3D models of the generated terrain.
3.3 2D Case - Diamond Square
Now that we have a definition for the height map let us examine the Diamond Square algorithm
which will produce a height map. We start with a large empty N ×N 2D array, denoted as H, which
will be completely filled and thus be a height map once the algorithm is complete. The dimension of
the array should be a power of two plus one and thus we have N = 2m + 1 where m will be refered
to as the step size. If we take the four corners of H and set their elevation values equally we have a
square. This is the starting point for the algorithm which is a two-step subdivision routine which will
be refered to as the DiamondSquare routine. The two steps are aptly named diamond and square
and are outlined below:
Diamond Step
Take the square shape produced by four points and generate a random value at the square midpoint
where the two diagonals meet. This midpoint value is calcuated by averaging the four corner values
plus a random amount. This step produces diamond shapes in the grid we we have multiple
squares.
Square Step
Take each diamond shape produced by four points and generate a random value at the center of
the diamond. The mindpoint value is calculated by taking the average of the four points plus
a random amount. This random amount is in the same range as the diamond step. This step
produces squares which will be used in the next diamond step.
Suppose we take our starting square again, with each of the corners seeded with the same value,
and we make a single pass through the subdivision routine. The result would be four squares. Run the
subdivision routine again on this output and we would get 16 squares. Once more and we would have
64 squares and thus we can see that the number of squares genereated is exponentially proportional
to the number of times we run through the subdivision routine. Figure 3 illustrates how the Diamond
Square method works visually.
Initially looking at the DiamondSquare routine we may be inclined to implement it recursively.
However, there are advantages to implememting DiamondSquare iteratively. Algorithm 2 and algo-
10
(a) Initial square. (b) First diamond step. (c) First square step.
(d) Now we have four squares. (e) Extension for wrapping.
Figure 3: Diamond Square at varying stages. (3a) shows the intial four corners. (3b) demonstrates
the first diamond step. If the terrain was rendered now we would see four diamonds all converging
at E. (3c) demonstrates the first square step. The computed midpoints between the four corners are
represented by blue dots. (3d) is the result of the first pass. Now we have four squares so we repeat
the diamond step for each square. (3e) shows the result after applying the diamond step to all squares.
Now we need to apply the square step. The points for the first square are the blue points. The lines
extend to K and L as we need those points to wrap.
rithm 3 describes a recursive implementation and an iterative approach respectively. While algorithm
2 is a simple implementation it requires that some points be generated with insufficient data. This can
be seen after the first pass since we will need to do a square step before having all four corners of a
diamond. This problem can be avoided with an iterative approach such as the one below.
This iterative approach fixes the problems found in the recursive approach but the problem of
missing data will occur once again if we are generating a point on the edge of H. This is only an issue
in the square step and is solvable by taking into account that one of the four diamond points is wrapped
11
Algorithm 2 Recursive Diamond Square
1: Do diamond step.
2: Do square step.
3: Reduce random number range.
4: Call Recursive Diamond Square four times.
Algorithm 3 Iterative Diamond Square
1: while Length of the side of the squares > 0 do
2: Run through H and perform the diamond step for each square present.
3: Run through H and perform the square step for each diamond present.
4: Reduce random number range.
5: end while
around on the other side of H.
In line 5 of the Iterative Diamond Square we reduce the random number range and this reduction
can be encapuslated in constant which we denote as r. That is to say that r will determine how much
the random number range is reduced each time and thus will determine the roughness of the resulting
terrain. Hence, r is the roughness constant and at each iteration i of DiamondSquare we have the
following: −ri ≤ X ≤ rn where X is the random amount to be added. Thus as we add finer detail to
our height map H we reduce the scale of the changes we make. Hence small changes at a small scale
are similar to large changes at a larger scale. This is the self-similairy property mentioned eariler that
is found in fractals. Figure 4 displays a few height maps at different roughness levels.
(a) r = 0.25 (b) r = 0.50 (c) r = 0.75
Figure 4: Height maps at varying roughness levels
12
3.4 Other Applications of Height Maps
While it may be nice generating random fractal terrain sometimes we may want to have certain
features on the terrain such as mountains and lakes. This can be done by seeding the desired location
for the features with the appropriate value in the height map. Mountains would be seeded with their
peak value at the peak location and water basins can be accomplished by seeding as many key points
needed in order to create the desired size of water basin. A threshold height can then be defined so
that we can determine which parts of the terrain will be filled with water.
Given a height map H one can say that the values represent the elevation at a particularly point.
However, if one were to think of the values as representing not height but rather opacity, then we
have an opacity map. Such an opacity map can be used to create fractal clouds as each value in the
map would represent cloud opacity data. A rendering of this opacity map could have the lowest values
colored as blue and the highest values colored as white. This rendering of the opacity map would
produce a texture map which we can apply to the sky. Thus the height map generated with random
fractal techniques can be used to create an entire world with the terrain being the 3D mesh of a height
map and the sky a texture map generated from a height map that was converted to an opacity map.
Figure 5 shows an example of clouds generated by a height map.
Figure 5: Fractal Clouds
13
4 3D Model Creation
The goal of terrain generation is often to create a 3D model of the generated terrain. Java3D was used
as 3D rendering is not possible in standard Java without having to write your own 3D rendering engine.
Java3D provides a simple way to create a frame which contains an area to display 3D objects with their
SimpleUniverse class. All 3D objects must be contained within what is called a BranchGroup for
it to be rendered onto the screen. Java3D also provides a Shape3D class which allows for creation of
custom 3D shapes given some geometry data. This geometry data would specifiy the points of the shape
and how to build it. The geometry used for TerrainGenerator is a list of triangles which together
create the terrain. We will now look at a few ways to create the triangulation which will represent the
generated terrain.
4.1 Tessellation
A tessellation or tiling of a plane is a pattern of plane figures that fills the plane with no overlaps
and no gaps [2]. Given a height map H one could tessellate using squares which works naturally as the
indices of H would create a grid. We will use triangles however so each square in the grid would be
composed of two triangles. The use of triangles allows for better approximation of the actual terrain
when compared to squares. This is because squares are not flat in 3D space. If we were to consider
four random points in space there is a very low probablity that they will all be coplanar. In contrast
we can guarantee that any three points in space will be coplanar. Therefore we will use triangles for
basic tessellation.
Now that we have decided on what shapes to use in the tessellation of a height map, let us examine
an algorithm which will produce this tessellation. Such an algorithm is outlined in Algorithm 4. Looking
at algorithm 4 we can see it runs in O(k2) where k is the length of the side of the height map or in
O(n) where n is the number of points in the height map.
4.2 Voronoi diagram and Delaunay triangulation
In this section we first introduce the notion of a Voronoi diagram and then give the duality prop-
erties of the Delaunay triangulation. We will then see the Delaunay triangulation can be used with
triangulating terrains.
14
Algorithm 4 Height Map Tessellation
1: Let k be the side length of the generated height map H.
2: Let T be a list which will contain all the triangles.
3: for i = 0 to k − 1 do
4: for j = 0 to k − 1 do
5: T.append(Triangle[(i, j,H[i][j]), (i+ 1, j,H[i+ 1][j]), (i, j + 1, H[i][j + 1])])
6: T.append(Triangle[(i+ 1, j,H[i+ 1][j]), (i+ 1, j + 1, H[i+ 1][j + 1]), (i, j + 1, H[i][j + 1])])
7: end for
8: end for
4.2.1 The Voronoi diagram
Let P = {p1, p2, p3, . . . , pn} be a set of points in the plane. Each point is called a site and a region of
the plane is obtained by assigning every point to its nearest site pi. Such a region is called the Voronoi
cell or region and is denoted as V (pi). Formally we define V (pi) as the following:
V (pi) = {x ∈ R : d(x, pi) ≤ d(x, pj),∀i 6= j
To understand the above better consider the simplest case with two sites, a and b in the plane. If l is
the bisector of the two sites then l divides the plane into two halfplanes. Let H(a, b) be the halfplane
that contains a. Then we have that any point p in H(a, b) would have the site a as its nearest neighbor
and thus we have V (a) = H(a, b). Similiarly we would have V (b) = H(b, a). Thus the Voronoi diagram
V D of a set of sites P is defined as the partition of the plane induced by all the Vonoroni regions V (p)
where p ∈ P [3]. Figure 6 shows this example along with another example with three sites.
The Voronoi diagram has many applications with its innate geometric proximity properties. It can
be computed in O(nlogn) with a planer sweep algorithm [3] with n being the number of sites. The
Delaunay triangulation also arises naturally from a Voronoi diagram which we will describe in the next
section.
4.2.2 Duality
In 1934, Delaunay proved that the dual graph of the Vonroni diagram produces a triangulation of
the Voronoi sites P [4]. The trianglation is now better known as the Delaunay triangulation. The dual
of a planar graph G(V,E) is a graph where each face in G is represented by a vertex and for each edge
15
(a) P = (a, b) (b) P = (a, b, c)
Figure 6: Voronoi regions bound by solid lines.
e ∈ E we draw an edge between the verices that represent the faces which share e. Given a list of
sites P we denote V D(P ) as the Voronoi diagram of P and DT (P ) to be the Delaunay triangulation
of P . Listed below are the duality properties which links the Voronoi diagram and its dual graph the
Delaunay triangulation into a one to one correspondence between vertices, edges, and faces.
1. DT (P ) is the dual graph of V D(P )
2. Every vertex in V D(P ) is linked to a triangle in DT (P ).
3. Every edge of V D(P ) is linked to an edge in DT (P )
4. Every region of V D(P ) is linked to a vertex in DT (P )
5. The convex hull of P bounds DT (P )
6. No triangle of DT (P ) contains within it a site of P .
Figure 7: Delauny triangulation is in black while the Voronoi diagram is in red. Source: Wikipedia
16
4.2.3 Delaunay triangulation and Terrain
There are some interesting properties of the Delaunay triangulation which would be useful to dicuss
before looking at the applications to terrain. These properties are described below:
Circumcircle Property
Let (pa, pb) be an edge that is incident to triangles ∆papbpc and ∆papbpd as show in Figure 4.3.1.
The edge is considered illegal if pd lies in the interior of the circumcircle of ∆papbpc or pc in that
of ∆papbpd. No illegal edges are allowed in the triangulation and thus the circumcircle of any
triangle in the Delaunay triangulation is empty (contains no sites of P ).
Figure 8: A violation of Circumcircle Property
Empty Circle Property
If an empty circle can be formed in such a way that it passes through sites pa and pb, then the
edge (pa, pb) is in the triangulation DT (P ). This is true since if two sites pa and pb are incident in
the Delaunay triangulation, then their cells are incident in the triangulations dual graph. Thus,
given any point pi on the Voronoi edge between pa and pb, a circle centered at pi passing through
pa and pb cannot contain any other point (since they must be closest).
Figure 9: Empty Circle Property
17
Local Maximum Miniumum Angle Property
Suppose we have a triangulation T and let (pa, pb) be an edge in T such that it is shared by
triangles ∆papbpc and ∆papbpd. Let M be the quadrilateral formed by the two triangles and for
1 ≤ i ≤ 6 let θi be an the ith angle in M and αi be an the ith angle in M ′ where M ′ is formed by
flipping the diagonal of M . We say the edge (pa, pb) satisfies the local min-max angle property if
min(αi) ≤ min(θi)∀1≤i≤6.
(a) M (b) M ′
Figure 10: Local Maximum Miniumum Angle Property.
With respect to terrain, the Delaunay triangulation allows for a non-grid like triangulation of points.
Thus the terrain is not limited to a height map but rather a list of points (and from those points a
list of triangles which form the triangulation). The local maximum miniumum angle property works
well with terrain since it reduces robustness problems and aliasing problems when rendering [6]. The
triangulation can also be computed in O(nlogn) and some of these algorithms are described in the
lecture notes by David M. Mount [5]. In TerrainGenerator the main data structure is still the
height map for the highest level of detail even if the triangulation method is Delaunays. Varying levels
of detail is discussed in the next section. The Delaunay triangulation used in TerrainGenerator is
computed using the implementation by Boaz Ben-Moshe[7]. The reason for using an external library
is because many of the O(nlogn) algorithms are difficult to implement and require lots of code. The
implementation by Boaz Ben-Moshe also handles triangulations of size 105 vertices in a few seconds and
thus would be ideal for generating detailed terrain. Figure 11 shows two examples of triangulations.
18
(a)
(b)
Figure 11: Some triangulations created by TerrainGenerator using Boaz Ben-Moshes Delaunay
triangulation library.
19
4.3 Java3D and Model Implementation
Now that we have described regular triangular tessellation and the Delaunay triangulation we can
describe how the model was created in Java3D. As stated eariler, Java3D provides us with a Shape3D
class which allows us to build 3D shapes assuming have the right geometries. The N ×N height map is
built from algorithm 3 and is used to serve as the point set for tessellation and Delaunay triangulation.
Figure 12 shows an example height map and terrain in 3D built by TerrainGenerator.
(a) Height Map (b) 3D Terrain View
Figure 12: An example of a height map generated by TerrainGenerator using the Diamond Square
algorithm (iterations=6, roughness=0.5) and the accompanying 3D view of the terrain.
While the above is a nice representation of the terrain we are still missing something. Terrain in the
geographical sense is usually lit up by sunlight. The terrain in Figure 4.4.1 shows no such lighting as
there are no shadows. To light up a Shape3D in Java3D one needs to apply a material to the object. A
material describes how different types of light will bounce off the object and the material is set through
the Appearance of the object. One also sets the shading mode through the Appearance which is
used to determine the shading when light is present. Once the material is applied and the terrain is
re-rendered we are left with what appears to be a black blank screen. This is because we have not
added lights to our scene yet! Java3D provides a way to define different types of lights and the one
used in TerrainGenerator is the DirectionalLight which represents a sun ray from a window.
After all the set up we finally have our new terrain rendered with proper light and shading as seen in
Figure 13.
20
Figure 13: The 3D terrain when we add sunlight and Gouraud shading.
21
5 Levels of Detail
Many applications require not only a detailed and realistic terrain, but one that can also scale. This
need for scaling can be best seen in aircraft simuations where it would be ideal to use less triangles when
viewing terrain from afar (and thus needs less detail) and more triangles we the aircraft approaches the
ground. Detailed in the next section is an approach by Mark De Berg and Katrin T.G.Dobrind based
on a hierarchy of Delaunay triangulations [6].
5.1 Hierarchy Approach
Given a collection of n data points in the plane, each with its own elevation, we wish to automatically
compute a hierarchy of levels with the most detailed level corresponding to the triangulation of all n
data points and the least being a small subset of the points[6]. This hierarchy should have a small
approximation error between each level as we want the terrain to look roughly the same at all levels
of detail. Mark De Berg and Katrin T.G.Dobrind use the Delaunay triangulation for each level as
the triangulation has the local maximum miniumum angle property and the triangulation gives a good
approximation since it links points by proximity. The hierarchy can be represented as a directed acyclic
graph where each node in the graph correspond to the triangles in the hierary. An arc connects to
triangles at one level to the next if these triangles intersect. Figure 5.1 illustrates this. The data
structure used in TerrainGenerator to store the different levels of detail is a hash table with the
indices corresponding to the level of detail and the values being the triangulation of that level of detail.
While this means that more memory is used, the code is less complex and thus easier and quicker to
implement.
Now that we have described what the hierarchy is, we can look at how the hierarchy can be con-
structed. We start with an initial triangulation which will be the most detailed level of terrain and uses
all n data points. To go to the next most detailed level we remove a number of non-adjacent vertices
and the triangulation is retriangulated. By using non-adjacent vertices we can then combine different
levels of terrain into one representation. This can be done by selecting small groups of triangles from
different levels instead of individual triangles. To better help keep the shape of the terrain we can fix
certain vertices such that they are present throughout all levels of detail. Different methods could be
used but the one choosen for TerrainGenerator was the very important points (VIP) method[8].
This algorithm is outlined in section 5.1.1. The algorithm to actually construct the hierarchy is detailed
22
in section 5.1.2.
5.1.1 Selecting Very Important Points
Given a height map H we know that, without loss of generality, each cell has 8 neighbhor cells.
These 8 neighbouring cells form the 4 opposite pairs up-down, left-right, and the two diagonals. Given
a point a let us denote the set of 4 opposite pairs for a as M(a). Given this we can select some very
important points as outlined in algorithm 5.
Algorithm 5 Very Important Points Selection
1: Let α be a constant that will bound the number of points to be fixed.
2: Let β be a constant that will bound the significance limit.
3: for Each point p in H, examine the set M(p) do
4: Connect each pair in M(p) by a straight line and compute the perpendicular distance from the
central point to the line.
5: Average the four distances obtained from M(p) and label this as the significance for the point.
6: end for
7: while The number of points is < α or all points are < β in terms of significance. do
8: Remove points in order of increasing significance with the least significant first.
9: end while
5.1.2 Hierarchy Construction
A sequence of Delaunay triangulations DTk, . . . , DTi, . . . , DT0 can be considered a hierarchical rep-
resentation if each of the triangulations from level k → 0 progressivly get finer until we reach the finest
level of detail DT0. The bottom-up construction of the hierarchical representation starts with the finest
level DT0 which is the Delaunay triangulation of the given set of n points. Let Vi be the vertices of
DTi. To get the next level of detail we must first find a new vertex set Vi+1. The vertices of Vi+1 is
obtained by removing a maximal independent subset Ii of Vi where each vertex has degree of at most d
where d is a constant. The constant that Mark de Berg and Katrin T.G.Dobrindt use is d = 12 which
is the constant TerrainGenerator uses. The maximal independent subset Ii is the set of pairwise
non-adjacent vertices of Vi and if no other vertex of Vi can be added to it while keeping all vertices
pairwise non-adjacent. The set Ii thus contain vertices that, when removed, would leave ”holes” in the
23
original triangulation. Hence DTi+1 can be obtained by finding Ii, removing all v ∈ Ii from Vi. Then
the new Vi becomes Vi+1 and all we need to do to get DTi+1 is to re-triangulate DTi and thus fill in the
holes. We stop the recursive construction of the hierarchy when the set Vi is c times larger then the set
of fixed points. Thus we can see that there is a trade off between accuracy and vertex reduction - the
more vertices are fixed, the more accurate the representation and thus less vertices are removed.
Given a terrain T that is represented as a Delaunay triangulation of a set of vertices V and a set of
fixed vertices Vfixed ⊂ V , the hierarchy construction algorithm is described below [6].
Algorithm 6 Construct Terrain Hierarchy
1: Let i = 0, Vi = V and DTi = DT (V )
2: while |Vi| ≥ c× |Vfixed| do
3: Vi+1 = Vi
4: DTi+1 = DTi
5: Determine a maximal set Ii of non-adjacent vertices of Vi \ Vfixed such that each vertex has at
most degree d.
6: for all vertices v ∈ Ii do
7: Remove v from Vi+1.
8: Remove v and all its incident edges and triangles from DTi+1.
9: Retriangulate the surrounding polygon so that the Delaunay properties still hold.
10: Add new edges and triangles to DTi+1.
11: Create an arc of the hierarchy between a triangle of DTi incident to v and a new triangle if
their interiors intersect.
12: end for
13: i = i+ 1
14: end while
The algorithm used in TerrainGenerator is roughly the same but does not create arcs as the
data structure which stores the hierarchies is not a direct acyclic graph but a hash table HT where
HT [i] = DTi∀i>0 assuming there is a DTi constructed. The external package which computes the
Delaunay triangulation for TerrainGenerator does not contain with in it the possiblity of removing
vertices, triangles or edges from the triangulation. Thus the algorithm was adpated and triangulation
DTi+1 is not created by re-triangulating just the polygon but is created anew from the new set of vertices
24
Vi+1. This leads to a slower runtime but makes the algorithm easier to implementation. Examples of
different levels of detail for a terrain is show in Figure 15 along with the height map which was used to
produce the 3D model.
Figure 14: Height map that will be used to generate the hierarchy of terrains in the next figure.
25
(a) Triangulation of terrain (b) Initial Terrain (8190 triangles)
(c) Triangulation of Level 3 (d) Level 3 (5958 triangles)
(e) Triangulation of Level 5 (f) Level 5 (1852 triangles)
Figure 15: Example of terrain with a hierarchy of levels of detail.
26
6 Conclusions
This project has covered the main techniques used to create random fractal terrain that can scale
to various levels of detail. The terrain geneator program, TerrainGenerator, was writen for this
project to helps study the techniques and can serve as a learning tool for others who are interested.
While the code for TerrainGenerator is not optimal, it is sufficiently fast for a decently sized height
map. It was found that number of iterations for ”best” results in terms of speed and terrain detail is six.
This is because if we increase the number of iterations the number of cells in the height map increases
exponentially. Generating the height map itself is relatively fast even for iterations of 10 or more. It
is the computation of the triangulation and creating the 3D model which is the cause of performance
issues. This is because the triangulation takes O(nlogn) where n is the number of points. After 10
iterations we would have 210 + 1 as the side length of the height map and thus the number of points
is (210 + 1)2. This performance issue is especially noticable when one uses over 7 iterations for the
height map and then contructs the hierarchy of levels of detail. Since each level must re-triangulate
a sub-set of the entire point set as TerrainGenerator uses a slightly diferrent approach explained
in section 5.1.2. However once the model and hierarchy is created we have the hash table of all the
triangulations and switching levels of detail becomes O(1). Java3D handles the rendering well even
with a large number of triangles and so along with the hast table approach moving from one level of
detail to another is nearly seemless.
Overall this project was very enjoyable to work on and over time I look forward to improving
TerrainGenerator. Future work could include using a height map to generate fractal cloud texture
maps which we can apply to a polygon to give the apperance of a sky, adding a threshold limit so that
we can add water, wrapping the generated terrain around a sphere and thus we could generate planets
with random terrain (or if we so choose to we can fix a number of vertices to get the features we want).
27
References
[1] Weisstein, Eric W. ”Fractal.” From MathWorld–A Wolfram Web Resource.
http://mathworld.wolfram.com/Fractal.html, Retrived April 2011.
[2] Weisstein, Eric W. ”Tessellation.” From MathWorld–A Wolfram Web Resource.
http://mathworld.wolfram.com/Tessellation.html, Retrived April 2011.
[3] Smid, Michiel. ”Voronoi diagrams and their construction using plane sweep”, 21 October 2003.
[4] Wikipedia, ”Delaunay triangulation.” From Wikipedia Web Resource.
http://en.wikipedia.org/wiki/Delaunay triangulation, April 2011.
[5] Mount, David M., ”CMSC 754 - Computational Geometry” From Department of Computer Science,
University of Maryland, 2005.
[6] Mark de Berg, Katrin T.G.Dobrindt, ”On Levels of Detail in Terrain.”, 29 October 1997.
[7] Ben-Moshe, Boaz. ”Delaunay Triangulation in Java” Web Resource. http://www.cs.bgu.ac.il/ ben-
moshe/DT/Delaunay Triangulation in Java.htm, Retrived March 2011.
[8] Chen, Z., and J.A. Guevara, 1987. ”Systematic selection of very important points (VIP) from
digital terrain models for construction triangular irregular networks,” Proceedings, AutoCarto 8,
ASPRS/ACSM, Falls Church, VA, pp. 50-56. A description of ESRI’s VIP approach to constructing
a TIN.
28