Dynamic Creation of Multi-resolution Triangulated Irregular Network

(1)

Thesis no: MECS-2015-18

Dynamic Creation of Multi-resolution Triangulated Irregular Network

Emil Bertilsson

Dept. Computer Science & Engineering Blekinge Institute of Technology

SE371 79 Karlskrona, Sweden

(2)

This thesis is submitted to the Department of Computer Science & Engineering at Blekinge Institute of Technology in partial fulllment of the requirements for the degree of Master of Science in Computer Science. The thesis is equivalent to 20 weeks of full-time studies.

Contact Information:

Author:

Emil Bertilsson

E-mail: emil.bertilsson91@gmail.com

University advisor:

Prof. Prashant Goswami Dept. Creative Technologies

Dept. Computer Science & Engineering Internet : www.bth.se/didd Blekinge Institute of Technology Phone : +46 455 38 50 00 SE371 79 Karlskrona, Sweden Fax : +46 455 38 50 57

(3)

Abstract

Context. Triangulated irregular network (TIN) can produce terrain meshes with a reduced triangle count compared to a regular grid. At the same time, TIN meshes are more challenging to optimize in real- time in comparison to other approaches.

Objectives. This thesis explores ecient generation of view-dependent, adaptive TIN meshes for terrain during runtime with no or minimal preprocessing.

Methods. Since the workings of the proposed technique is a novel approach, an empirical strategy was employed to present the ndings instead of partial comparisons to related techniques.

Results. To determine the result of the technique, run-time performance is measured and presented to provide incentives for implementation and improvements on the proposed algorithm. Several problem sizes are tested with varying terrain features to determine the eec- tiveness as a result of the features in the mesh.

Conclusions. We conclude that reducing the problem of mesh simplication to that of 2D Delaunay triangulation on sampled points spanning terrains is valid approach for triangulating on-the-y. More- over, this approach opens up for further improvements which may soon allow real-time triangulation of TINs.

Keywords: Triangulated Irregular Network, View dependent terrain generation, Level of detail.

i

(4)

List of Figures

1.1 Cracks and t-junctions . . . 2

3.1 Preview of technique . . . 8

3.2 Problems with gradual ascent . . . 9

3.3 Consistent triangulation . . . 11

3.4 Conicting triangles . . . 11

3.5 Ignoring patches that are out of sight . . . 14

3.6 Improved lighting using pixel shader . . . 16

3.7 Variable resolution . . . 17

4.1 Approximation for 256 x 256 dataset . . . 20

4.4 Time consumption for patches (256 x 256) . . . 22

ii

(5)

List of Tables

4.1 Runtime performance . . . 19

4.2 Overhead during runtime . . . 19

4.3 Average approximation . . . 21

4.4 Average frames per second . . . 22

4.5 Startup performance . . . 24

4.6 Overhead during startup . . . 24

iii

(6)

List of Algorithms

1 Point selection . . . 10 2 Delaunay triangulation . . . 12 3 Multi-resolution TIN system . . . 15

iv

(7)

Chapter 1 Introduction

Terrain rendering can be found in a variety of applications and the detail of these terrain meshes has vastly increased over the years. It has become a major part of many applications and has subsequently seen much research and improvement over the years. Computer games and simulators often have heavy requirements on the visualization of the terrain, as well as to obtain a good resolution that can be presented without overwhelming the other parts of the application. Whether the focus lies on preprocessing level-of-detail (LOD) data or generating during startup or in real-time, many dierent techniques have been developed to address the problem of representing and visualizing large quantities of terrain data. Using LOD can provide the mesh it is applied on with both ner and more coarsened regions so that the overall triangle count can be reduced.

These techniques can be divided into three major groups: regular meshes, semi-regular meshes and fully irregular meshes [31]. A regular mesh or digital elevation model (DEM) contains points sampled at equal distance and therefore same sized triangles. Though simple and easy to implement, the main disad- vantage of purely regular triangulated meshes is the limited dierentiation of the terrain features in triangulation. While there is data redundancy in areas of uniform terrain, the mesh can simultaneously be under-represented in regions carrying high complexity. To avoid cracks and T-junctions, adjoining LODs are often constrained to dier in the tree by at most one level even if the features change drastically [3].

A crack in the terrain is an irregularity in which inconsistent triangles leave a hole in the terrain. These cracks might appear in areas where dierent LODs meet due to non-matching points on either side of the LODs. This is what is known as a t-junction, where a point is located in between corresponding points, giving it the characteristic form of a T-junction that can be seen in Fig. 1.1.

In theory, fully irregular and semi-regular approaches dier in their capabil- ity of producing a minimal complexity mesh representation for any given error measurement. They utilize splitting, merging and subdivision to produce a triangle count closer to what is required to present the terrain features. While the technique can furnish view-dependent, optimized mesh, its eciency is limited due to the overhead incurred by per-frame triangulations. Fully irregular meshes

1

(9)

Chapter 1. Introduction 2

Figure 1.1: Visualization of a t-junction that results in a crack in the mesh.

are theoretically very powerful, as the entire mesh can be simplied signicantly to contain close to optimal number of points needed to represent the features of the mesh. Drawbacks of fully irregular approaches are the expensive calculations and the increased complexity of the mesh. Processing the mesh is a time con- suming operation and could impose severe limitations to the interactivity of the application.

When computing multi-resolution meshes, there are a number of dierent angle of approaches to satisfy the needs of the techniques. Many techniques operate on a per-frame basis [32, 10, 30, 6, 29, 28] and builds the mesh for each frame by utilizing tree structures, predened triangulated patches and tessellation. Other techniques [23, 11] allows meshes to be valid over the course of multiple frames before an update request is made. The work presented here is more in line with the latter, where the mesh will remain in the same state for as long as the view- point remains similar. On top of the state of the mesh, view dependent culling and view dependent updates to out of core sections of the mesh is used to further reduce the number triangles rendered per frame. Once updated, only parts of the mesh will undergo new triangulation, as parts of the mesh will not receive a new pixel error.

When computing multi-resolution terrain meshes, visual artefacts can arise along the edges where areas of dierent resolutions meet. A denser triangulated region that meets a region of less density may require stitching [13, 24], as a denser triangulation allows an increased curvature, thereby resulting in two distinct approximations for the same curvature. Rather than stitching together the two distinct areas, the regions can be made to share the vertices along the edge [4]

or other forms of LOD managing [33, 19], thus providing a homogeneous base for triangulation. The approach chosen for this work was to have the regions share the vertices dening the borders with adjacent regions.

The novel approach presented in here creates a view-dependent multi-resolution TIN mesh on large terrain meshes, based on user specied tolerance and is updated throughout the execution of the application. To this end, the concept of

(10)

Chapter 1. Introduction 3 dividing the terrain into larger regions called patches is adopted, which are individually triangulated. The concept of patches is not new and has been explored in [6, 24, 26], among others. The main contributions and advantages of this method are:

1. Runtime generation of fully irregular multi-resolution meshes with no or minimal preprocessing.

2. Fast triangulation of a 3D view-dependent point selection by reducing it to a 2D Delaunay triangulation problem.

3. Independent patch processing without any mutual dependencies on the neighbouring patches.

The system perform asynchronous LOD updating and supports GPU-based rendering. Delaunay triangulation was chosen as the basis due to its properties [27] and simplicity, that allows for independent triangulation of points. Although the triangulation is independent, the possible candidates to fulll the triangles may in many cases be forced to processes a large number of points due to inept restrictions. Given the theoretical lower bound time consumption of Delaunay triangulation to be O(n log n) [5], the amount of processed data residing within the same computation block should therefore be kept to a minimum. Subsequently, the demand for structural changes in order to employ runtime triangulation is increased, as is addressed by employing patches. The properties of Delaunay triangulation makes for a good basis for further parallelism in general, or delegation of the triangulation to the GPU.

In order to dene whether or not the presented algorithm bridges the aforementioned gap, a research question was used as the underlying basis for the work.

The research question, which is specied below, will be discussed more in depth in Sec. 5.

Is it possible to triangulate an irregular mesh asynchronously with set update steps, thus providing dynamic updates to better approximate a dataset?

(11)

Chapter 2 Related Work

Terrain rendering with adaptive resolutions has been studied extensively, with dierent aims and angles. The earlier approaches and studies [12, 22, 15, 7, 37, 9] have since been followed by more complex algorithms and more recently algorithms that utilize the GPU to dierent extents. LOD techniques and multi- resolution meshes have received plentiful research and as such, many relevant papers have been published. Thus, a selection of papers will be covered here.

The amount of redundant triangles created by these techniques vary on dif- ferent circumstances and settings. For instance, a regular mesh would be more suited to represent a terrain with similar features [20], while vast optimizations are possible where the mesh displays variations making irregular mesh a more suited candidate. A semi-regular mesh performs well but struggles where dierent terrain features meet. The transition from that of a low elevation area to that of a higher area causes extra complexity because of the edge following and the approximation made by suboptimal division [6]. Fully irregular meshes struggle with the same kind of optimizations as semi-regular approaches mainly due to the arbitrary neighbours [31] inherent to the connection of nodes in a fully irregular mesh.

In this chapter, the discussion on techniques will be more focused towards techniques that, to a higher extent, is comparable to what is being presented here. The main areas of which will be covered includes techniques that generates multi-resolution meshes, applies Delaunay triangulation [34] and TIN meshes. A full coverage would however exceed the scope of a thesis.

Many high performance techniques [6, 21, 32, 3] utilize oine computed LODs which are then combined at runtime to render the scene during each frame. The strategy behind runtime combination is to achieve a mesh with close to an optimal amount of triangles, by performing splitting, merging and subdivision on the mesh. The focus of the thesis lies on TIN meshes and generating view dependent meshes valid for a few frames up to potentially thousands of frames. The reader may refer to [10, 31, 32, 14] for more in-depth analysis for other ways of achieving a multi-resolution terrain mesh.

TIN meshes are subjected to a number of drawbacks, as additional connectiv- ity information must be stored and operations on these meshes must in certain

4

(12)

Chapter 2. Related Work 5 areas handle implicit information. It is not yet viable to triangulate a TIN mesh in real-time, often resulting in a static mesh that was preprocessed in an oine tool. Combining dierent segments of a TIN mesh may also result in artefacts like cracks, increasing the overhead of using TIN meshes to alleviate these artefacts.

One of the more minimalistic approaches to multi-resolution terrain meshes can be found in [23], where only a few dozen lines of code is needed to achieve the presented view dependent renement. The authors present a number of promis- ing features and results, including computational eciency and cache ecient behaviour. The technique is applied to regular triangle strip terrain grids with subdivision to manage multi-resolution and the per frame view dependent re-

nement. Rening or coarsening the terrain mesh is performed asynchronously whenever the camera view is changed, based on the screen space pixel error.

Furthermore, the technique is top-down oriented and handles cracks and inconsistencies pre-emptively by nesting the terms used in their view culling renement.

Whether or not the strategy is applicable to TIN grids and how suited the technique would be remains unclear.

In [26] geometric clipmapping for view dependent LOD is discussed and presented as a means to create a pyramid structure to hold the cached nested regions.

It operates on regular triangle grids on the y without any preprocessing, using a renement scheme of power-of-two to tessellate the terrain. Unlike the proposed algorithm that is presented in this thesis, their algorithm generates intermediate areas to stitch together regions of dierent resolution, resembling [8] to ensure continuity. The technique has a number of advantages over similar algorithms, such that it can more eciently compress and store the triangle pyramid during runtime. Comparing the technique described here and the technique described in [26] shows that the two dierent algorithms both aim towards usage of dynam- ically changing view dependent regions, however the aim was towards solving dierent problems using two distinct methods.

Right handed triangulations for TINs is used in [11] where the developed technique is aimed towards a framework of multiple approximations for a given surface, rather than a single one. Dierent approximations are suited to dierent types of habitat and the presented technique explores dierent ways of appropri- ately approximating data. Furthermore, the approximation is location based so that high resolution areas are located around the camera. Varying renements strategies are employed to decide the appropriate approximation based on location and terrain features, while maintaining continuous transitions between areas of diverse LODs. The accuracy and memory requirements of right handed TINs are measured and deduced to be inferior to that of a TIN, but the authors discuss the possibility of other memory storage schemes to deal with the issue.

Several papers discuss optimizing TIN meshes and dierent techniques to reduce the triangle count. One of the more interesting ones is BDAM [6] which deals with small triangle patches of a few hundreds of triangles as primitives rather than single triangles. These patches, which are optimized TINs, are pre-

(13)

Chapter 2. Related Work 6 computed oine and are stored in a bintree, similar to [10]. To render the scene, a hierarchical view frustum culling is performed and the batches that are visible are then assembled. Doing so is highly advantageous compared to other techniques that operate on a per frame basis in terms of the time spent generating the scene. However, this approach does require a lot more memory storage, and can only operate on static terrain meshes that has been preprocessed into small patches.

Another technique that utilizes tree structure is QuadTIN [30], where a quadtree hierarchy is generated over any TIN surface oine and an adaptive LOD is stored along with the quadtree. Even though the algorithm can operate on any TIN surface, the mesh must be predened so that the preprocessing pass can generate and store the quadtree. Although relevant, as preprocessing is kept to a minimum, the operation of restructuring the tree must be kept low before being applicable to the algorithm presented here. In [2], indexing the vertices in the TIN mesh is discussed in such a way that multi-resolution is achieved. By searching the mesh and dening an ordered index list in which consecutive triangles share an edge or a vertex, the mesh can be coarsened using a space-lling curve. The usage of space-lling curves is continuous and is oriented so that the highest index and the lowest index in adjacent triangles coincide.

[25, 18] aimed at using point insertions to triangulate randomly generated spatial points with slightly dierent approaches. The algorithm presented in [25]

groups points together into cells of roughly equal sizes and triangulates the cells in parallel, without any data dependency between them. It uses tetrahedrons and circumspheres to perform the three dimensional triangulation. On the other hand, [18] does not utilize cells or tetrahedrons (and operates on two dimensions rather than three), but instead performs recursive checks after each insertion.

But since the points used in the algorithm presented in this thesis constitute a terrain, the points have properties that random points do not. Subsequently, simplications can be made that render the more complex algorithms in [18] and especially [25] less t.

Using hierarchical Delaunay triangulation is discussed in [16] where multi- resolution TINs are generated based on a xed error metric. Regions of the mesh are generated in a tree structure with decreasing error metrics until a predened level is reached. It does however struggle with increased memory consumption, static renement thresholds and a time consumption which does not enable runtime performance. The quality of the approximation is good, but requires performance orientated modications before it can be compared with the dynamic TIN generation presented here.

While the modern techniques operate at the level of meta units for more GPU- oriented rendering, simplication can still benet with improved methods that are capable of reducing triangle counts at runtime without incurring signicant overhead. The presented method works in this direction and aims at bridging the aforementioned gap.

(14)

Chapter 3 Method

When determining the scientic method for the thesis, related papers were examined in order to nd a suitable paper to compare the performance. However, as discovered in Chap. 2 there are no algorithm that triangulate irregular meshes during runtime. Furthermore, as the mesh cannot be triangulated during each frame, higher pixel errors will give a bigger dierence between update steps and the same pixel error can therefore give a dierent visual result from techniques that builds the mesh per frame. By taking these circumstances into consideration, an empirical approach was deemed to best present the ndings. The performance is subsequently presented without comparisons with only raw data and graphs to quantify the ndings.

Starting with the individual subsystems, the step by step algorithm will be explained in the upcoming subsections. Following the sub-chapters description, the overall system and how the dierent parts are combined will be described in detail.

The developed technique incorporates the standard rendering features like view-dependent pixel error and frustum culling. However, one big dierence from earlier works is the absence of the quadtree like hierarchical data structure. The terrain is divided into square regions called patches and each patch is handled for triangulation individually in parallel. The absence of a tree structure to store the patches implies that all patches belong to the same level in the tree and have the same dimensions. However, a hierarchical tree structure could additionally be imposed on top of the existing patches leading to further simplication of the mesh. This is recommended in cases where terrain size is very large. On the other hand, the tree structure constructs LODs for internal nodes and hence the preprocessing step would be necessary, should it be imposed on the algorithm.

In what follows, the process selecting both interior and border points will be explained, keeping in consideration the user dened error metric. After that, the implementation of Delaunay triangulation will be touched upon before continuing with the developed system. A preview showing the result of the algorithm in action is displayed in Fig. 3.1.

7

(15)

Chapter 3. Method 8

Figure 3.1: Terrain mesh simplication achieved using the proposed algorithm in real time, where the left image displays the triangulation for the rendered scene in wireframe and the right image displays the rendered scene.

3.0.1 Patch point selection

In order to achieve a more coarsened patch, fewer points are selected than what is available in the original data. Likewise, renement is done by adding more points than what was present before rening the patch. The function that coarsens the points belonging to a patch examines neighbouring points in relation to the previously selected points, and compares the height dierence in screen space with the projected pixel error. The pixel error is specied by the user and dictates to what extent the mesh can be simplied. The design of the selection process was oriented towards fast processing, approximating the mesh at a reasonable quality during runtime. More carefully developed approximations can be found in [30, 38, 2, 11, 35, 1, 17].

The further the algorithm gets from the last added point, the more likely it is to include the next one. Using a reduction factor solves the problem shown in Fig. 3.2, where low resolution areas could be simplied to a much greater extent than what is often desirable. The reduction factor increases the error factor by an empirically tested factor (_0.85¹ )ⁿ, where n is the number of points skipped since the previous inclusion.

To improve the quality of the triangles, an additional constraint was added so that the middle point of any border was always included, thereby eliminating some of the long and thin triangles. Moreover, a constraint limiting the possible length and width of the triangles were imposed to improve the quality further.

The selection process operates on patches independent of one another and only requires the error metrics from neighbouring patches to select identical border points as the adjacent patches.

(16)

Chapter 3. Method 9

Figure 3.2: Problem visualization of selecting points where the ascent is gradual.

The exact same area is approximated a) without any reduction factor and b) with a reduction factor.

3.0.2 Border point selection

In many cases, not all patches will require new triangulation when navigating across the mesh, especially patches whose relative position towards the camera remains close to its previous relative position. Since the border points are shared between adjacent patches, the logic for selecting borders was separated from the internal selection process.

Unlike the points located inside the patches, the border points only test their height dierences with other border points along the same edge. This is required so as to produce identical selection for two patches sharing a border. The previous screen space error metric for a patch is stored to avoid updating patches that would be given the same, or very near the same triangulation as it consists of in its current state. Subsequently, the border points may instead use the previous error metric so that the border to adjacent patches that are excluded from the update state is kept identical. The border will keep the same error metric until both patches receive an update request. The border always consists of the corner points in addition to any points included by the border calculation. The entire procedure of point selection is given in Alg. 1.

For determining what indices to include in Alg. 1, the height dierences in screen space for points and nearby points are examined. The immediate neighbours are compared along with the closest points on both the same row as the current index and previous rows. Points that surpass the given pixel error, with or without the reduction factor introduced in Chap. 3.0.1, are included. The point selection algorithm operates on single patches and computes the same border points multiple times to achieve fully independent computation. Considering that a dierence value lies in the range of 0 ≤ ∆ ≤ ∞, patches with the highest level of renement will in many cases still become coarsened in relation to the original dataset. Yet, such renement will still be an exact approximation of the terrain features.

(17)

Chapter 3. Method 10 Algorithm 1 Point selection

1: procedure MakePatch(patch p, pixelError e)

2: /* Set of interior points included in the patch */

3: P := ∅

4: /* Set of border points included in the patch */

5: B := ∅

6: for all indices i ∈ p do

7: if i is a corner index then

8: B.insert(i)

9: else if i is a border index then

10: if di(i 1, i) > e k di(i, B.back()) > e then

11: B.insert(i)

12: else if di(i 1, i) > e k di(i width, i) > e

13: kdi(i, P.back()) > e k di(i, x) > e then

14: /* x: index to the closest point located on previous lines */

15: P.insert(i)

16: return P ∪ B

3.0.3 Delaunay triangulation

A Delaunay triangulation operates by selecting triangles such that the minimum angle is maximized, so as to avoid creating thin triangles. The triangulation is applicable to points with and without internal structure, enabling triangulation for any form of point input data. A Delaunay triangulation has a circle associated with each triangle, such that no circle contains points from another triangle.

Once the points in the patch are obtained from Alg. 1, the next step is to triangulate them. To this end, techniques such as 3D Delaunay triangulation could be applied. However, observations were made that the terrain datasets are in fact 2.5D and running the expensive 3D Delaunay triangulation could be avoided. Even more so given the large execution times as demonstrated in [25], it would no longer allow real-time mesh simplication. Furthermore, observing that points in a patch are originally picked from DEM and hence no two points have identical 2D coordinates. This implies that the selected points of a patch can be projected on the x − z plane dropping their height values, triangulate them using 2D Delaunay method, nally giving the points back their y values.

With this, the problem was simplied to two dimensions which reduces the complexity of the algorithm while still achieving a good triangulation, see also Fig. 3.3. The implementation strategy allowed calculation with 2D lines and circles, rather than 3D lines and spheres. Delaunay triangulation for each patch is carried out in parallel using multi-core resources, thereby further reducing the overhead.

A slight downside to the structure of points when creating TINs collected from

(18)

Chapter 3. Method 11

Figure 3.3: Consistent triangulation at the border of patches, using the described method (no artefact, cracks or T-junctions).

Figure 3.4: Identical angles between points that can cause the algorithm to create conicting triangles.

a DEM was observed in instances where four points formed a square. The angles between the triangles that the triangulation process would calculate would then be identical. Depending on the order of which these points were processed, an overlap could occur which is illustrated in Fig. 3.4. This problem was mitigated by randomly osetting the 2D points sent to the triangulation, thereby eliminating these identical angles.

The implemented Delaunay triangulation function is given in Alg. 2 and

(19)

Chapter 3. Method 12 Algorithm 2 Delaunay triangulation

1: procedure Triangulate(point p0, vertexList V, triangleList T, patch p)

2: p1 := closestPoint(p0 ), neighbour1 := p1

3: while true do

4: for all triangles (t 3 p1 ) ∈ T do

5: if angle(V [p0 ], V [p1 ], V [t.x]) < PI then

6: p2 := t.x

7: break

8: while p2 not found do

9: circle := Circle(V [p0 ], V [p1 ], radius++)

10: for all indices i ∈ p do

11: if i is right of Line(V [p0 ], V [p1 ]) & i is inside circle then

12: if angle(V [p0 ], V [p1 ], p2 ) >= biggest angle then

13: p2 := i

14: if new triangle then

15: T.insert(p0, p1, p2 )

16: if p2 = neighbour1 then

17: break

18: if rst iteration then

19: neighbour2 := p2

20: p1 := p2

is quite straight forward, hardly deviating from standard implementations. It starts o by nding the closest point, p1, and examines all triangles in which p1 is an element and investigates if these triangles also include p0. In such cases an identical triangle already exists (unless the angle between the points exceed π). If the combination of p0 and p1 does not already exist in the triangle list, the nal point is calculated by dening a circle whose circumference grows throughout the iterations. The points that are processed towards the circle is further reduced by dening a line from p0 to p1 and testing the location of the points in relation to the calculated line. The points that are to the right of this line, in a vague sense, are disregarded. Essentially, the purpose of the line is to process all points to determine whether or not a point can theoretically be engulfed in the circumference of the circle or not. A separate list of indices stores these so that the loop wherein the circle grows reviews only relevant points.

Although all of the points can be included, it is at times very unlikely the points furthest away will ever be processed, but any generalization of that condition was not investigated further. The function exits once p2 receives the same value as the original p1, meaning that all triangles has been created based on the received starting index.

In order to obtain a smoother representation at coarse LODs, the unselected neighbours could be used to interpolate the height data of a selected point. Doing

(20)

Chapter 3. Method 13 so would however require updating to the vertex buer during the update step, rather than keeping it static with changes localized to the index buer.

3.0.4 System

While the entire pipeline could be carried out in the main thread, multi-threading is employed to make use of the multi-core architecture. The main thread is responsible for visibility checks, handling user input and rendering. A concurrent asynchronous thread is launched that takes care of storing screen space error metric for each patch, selecting the points required to approximate the mesh in its current state, Delaunay triangulation and updating the index buer. With this architecture, the main thread can be kept unblocked and the frame rates more consistent.

The asynchronous thread starts o by calculating the new screen space error values for all visible patches as well as comparing it to the previous value. These values will remain constant until at least the next update step. The error metrics for the patches are only relevant to the selection process and are hence handled by the asynchronous thread. As touched upon in Chap. 3.0.2, not all patches need to undergo each update step. Patches that are out of sight may never become visible before the next update, and any resources spent on that patch would therefore be misused. Patches that were excluded during previous updates may receive new triangulation whenever they become visible again. A patch can become visible during camera rotation or movement and is subsequently managed by the culling procedure. A thread is launched from the culling process so that the patch is not forced to wait until the next update step and to minimize the chance that the user will notice the our of core patch. Consider the scene in Fig. 3.5, where the camera (portrayed by the arrow) is positioned. Assuming movement along the current angle, any processing on patches not currently drawn would be futile as neither would come into view.

The system implemented to address these optimizations sets and maintains

ags during the culling step to distinguish the patches. It is by using these ags that the triangulation knows which patches to exclude. The ags are as follows:

1. Visible and updated, or previously out of sight but now visible and updated (frame-to-frame basis).

2. Visible but not updated.

3. Previous frame visible but now out of sight (frame-to-frame basis).

4. Not visible and not updated.

In cases where patches are no longer visible, the triangulation for those patches will remain in its previous state. The visual implications of this design can man-

(21)

Figure 3.5: A rendered scene from a separate perspective, illustrating the importance of selective updates. During continuous movement along the current orientation and only viewing ahead, processing power should not be used on areas out of sight.

ifest themselves in instances where a patch was given a very coarsened triangulation and the patch remains out of sight until the camera comes very close.

Then the dierence between the previous and current renement can result in a noticeable popping eect. However, that is highly dependent on a considerable fraction of the patch becoming visible and the extent of terrain features as well as their impact on the patch in question. When the circumstances are reversed and a patch retain its rened triangulation, the eect is not noticeable. Given that details are lost as objects move further away from the camera, a patch with a higher renement only serves in using more space in the buers bound on the GPU. As will be discussed more in depth in the coming paragraph, the buers have predened areas allocated to each patch, so no space is wasted in these instances.

As shown in Alg. 3, the asynchronous thread launches the selection process and then feeds the result into the triangulation. By rearranging the order of which the patches are processed, the areas closer to the camera are computed rst to maintain the nest approximation in close proximity to the camera. Moreover, the function responsible for updating the error metrics also determines patches to be excluded, should the error be similar enough to last iteration. The function inputs into the same list used for sorting the patches, in order simplify the load balance between the threads calculating the Delaunay triangulation. The triangulation

(22)

Chapter 3. Method 15 Algorithm 3 Multi-resolution TIN system

1: procedure UpdateMesh( )

2: /* The position of the eye when the update request was sent */

3: updatePixelError(camPos)

4: /* Set of vertex indices */

5: P := ∅

6: for all patches p ∈ mesh do

7: P.append(pointSelection(p, patchInfo[p]))

8: /* Set of 2D vertices used in the Delaunay step */

9: V := ∅

10: for all indices i ∈ P do

11: V.append(vertices[i])

12: sortByDistance()

13: for all patches p ∈ sortedList do

14: /* Triangle list */

15: T := ∅

16: for all vertices v ∈ p do

17: Triangulate(v, V, T )

18: mapToIndexBuer(T )

uses the selected 2D points and computes the patches both independently and in parallel. Once the triangulation has been completed for a patch, it is mapped into the corresponding area in the index buer. The index buer has a certain amount of elements allocated for each patch to ensure no data is overwritten and that no additional information is required to determine where to write the data.

This does however mean that memory is allocated to manage a fully rened patch for every single area, thereby utilizing an abundant allocation scheme which in most cases wastes memory. It does however simplify culling, data retrieval and data management in general, although allocating more memory than otherwise required.

Since only selected vertices are rendered, pixels present in coarsened areas can be given a normal that is interpolated between two vertices that are not adjacent in the original dataset. The light intensity that a pixel is given in the pixel shader can therefore change from one frame to the next, resulting in a popping behaviour. In addition to the increased visibility of the new triangulation, the resolution of the terrain texture could be reduced as the intermediate normals are lost to the normals of the surrounding vertices. To overcome the poor lighting result, the light calculations were done in the pixel shader with sampled normals from a texture. In Fig. 3.6 the dierence between the two approaches is shown in a zoomed in view of patches at a considerable distance from the camera, yet the lighting dierences are clearly noticeable. By creating a texture holding normals

(23)

Figure 3.6: Zoomed in view on coarsened region showing the resulting light calculations with normals applied to each vertex and automatic interpolation (left) and normals interpolated manually for each pixel (right). Bottom images shows the normals used to calculate lighting for the scenes.

for each vertex in the original dataset and sending it to the pixel shader, the result was vastly improved. Instead, applying the light to the surface was done according to the original surface rather than the approximation. This behaviour is similar to normal mapping [36] but since all vertices have world space coordinates, these coordinates can be utilized to sample the appropriate normal from the texture without needing tangent plane to convert the coordinates to model space.

The nal piece of the system is the screen space error metric, which is the area that an object takes up on the screen. The number of pixels occupied on the screen is then used as the renement factor for the selection process, described in Chap. 3.0.1. The error metric is the system that determines the resolution for patches as well as dictates when patches are updated, which creates the noticeable wireframe dierences in triangulation that can be observed in Fig. 3.7. The error metric is calculated for each patch by determining the maximum height dierence between adjacent points in the height dataset and projecting it onto the screen.

The user is given control over the error metric used to rene the mesh, which is specied outside of runtime.

The result of the triangulation is cached, since the mesh is often valid for multiple frames (ranging from a few to thousands of frames) depending on the camera movement. No tree structure for the patches was implemented, thereby forcing frustum checks against each patch. This could be improved by keeping

(24)

Figure 3.7: The system manages patches of dierent resolution based on the specied screen space error metric.

a hierarchical data structure, that performs top-down visibility check. On the other hand, the current arrangement enables the algorithm to eliminate preprocessing completely, wherein the patches are adaptively triangulated on-the-y.

This works quite eciently for small to moderately large datasets and even for larger datasets where the entire terrain is not visible at any point.

(25)

Chapter 4 Results

The proposed algorithm was implemented in C++ using DirectX 11 and its pro- grammable shader language HLSL. The tests were conducted on a 3.20GHz Intel Xeon processor with a NVIDIA Quadro 4000 graphics card.

In terms of required preprocessing before the technique can be utilized, the presented algorithm requires very little. Comparing with other TIN algorithms [2, 6, 16, 30] that processes up to the entire mesh outside of runtime, what is needed before the algorithm presented here can be launched is creating a vertex buer from the height data. The height data can be read from a height map or generated procedurally. Furthermore, no visual artefacts or inconsistencies are produced between dierent LODs. For each dataset, the presented tests below are all based on the same conditions and use the same predened movement across the terrain, from the perspective of a character running across the world. Of the measurements presented in this chapter, only Tab. 4.5 and Tab. 4.6 applies to the startup time, whereas the data presented in the other tables all concerns runtime.

The number of triangles produced per second for dierent height datasets are presented in Tab. 4.1, in which identical settings were provided for the dierent patch dimensions for a given dataset. The measurements for the dierent patch dimensions are relatable to a high extent and the main reason why there is such an observable deviation between them is the precision of the given error metric.

As can be seen by observing Fig. 4.1, Fig. 4.2 and Fig. 4.3, the extent of the approximation favours the dierent settings in Tab 4.1. For the two smaller datasets, the 8 x 8 patches maintains a more even triangle count while the 16 x 16 patches achieve the best performance in terms of the average number of triangles per second. Due to its high versatility and strong overall performance, 32 x 32 became the default patch dimension. Throughout the tests, 32 x 32 achieved the highest triangles per second value for all datasets and was unrivalled for the largest dataset tested. Finally, 64 x 64 proved to be a dimension unt for any of the datasets that were measured. However as 32 x 32 would produce a large number of patches for datasets larger than the ones measured here, 64 x 64 might then out perform the smaller dimensions.

18

(26)

Chapter 4. Results 19

Patch size 8 x 8

Size of dataset Avg (triangles / s) Min (triangles / s) Max (triangles / s)

256 x 256 236436 199771 529273

512 x 512 255317 146041 422409

1024 x 1024 179399 94798 487382

Patch size 16 x 16

256 x 256 278666 199771 529273

512 x 512 317548 138855 596180

1024 x 1024 242445 56462 376502

Patch size 32 x 32

256 x 256 258499 79003 567195

512 x 512 305929 88948 697792

1024 x 1024 394325 94866 750503

Patch size 64 x 64

256 x 256 70599 22405 141996

512 x 512 155965 33287 317697

1024 x 1024 207597 63078 639024

Table 4.1: The average, minimum and maximum number of triangles created during runtime.

Size of dataset

Patch dimension 256 x 256 512 x 512 1024 x 1024

8 x 8 91.0% 89.0% 66.0%

16 x 16 92.2% 93.6% 91.5%

32 x 32 91.4% 93.2% 89.8%

64 x 64 97.2% 94.8% 91.7%

Table 4.2: Data showing what portion of the time is spent on triangulation during the runtime of the algorithm.

(27)

10%0%

20%30%

40%

50%60%

70%80%

90%

100%

256 x 256

8 x 8 16 x 16 32 x 32 64 x 64 Iteration

Approximation

Figure 4.1: The approximation for dataset of size 256x256, with four dierent patch dimensions.

10%0%

20%30%

40%50%

60%

70%80%

100%90%

512 x 512

8 x 8 16 x 16 32 x 32 64 x 64 Iteration

Approximation

Continuing with the measurements of patch dimensions, Tab. 4.2 further jus- ties choosing patches with higher dimension, as a relatively large portion of the

(28)

0%

10%20%

30%40%

50%60%

70%

80%90%

100%

1024 x 1024

8 x 8 16 x 16 32 x 32 64 x 64 Iteration

Approximation

Size of dataset

Patch dimensions 256 x 256 512 x 512 1024 x 1024

8 x 8 56.19% 39.06% 30.82%

16 x 16 63.83% 41.54% 30.20%

32 x 32 76.49% 46.54% 31.17%

64 x 64 93.05% 52.47% 33.37%

Table 4.3: Average approximation over the tested datasets.

runtime of the algorithm is spent processing the data required to triangulate. A value as close to 1.0 as possible is what is desired so that the triangulation can commence as quickly as possible to update the area close to the user. Here, larger patch dimensions typically have an edge as the selection process is less limited by the border selection. Yet, 16 x 16 shows good performance throughout the conducted tests and manages a more eective update step when focusing on eective time spent triangulating. The overhead refers to all calculations required before the Delaunay triangulation can be launched and includes calculating error metrics, determining the new indices and sorting the lists to triangulate the patches close to the camera while ensuring load balance between threads. However, a higher fraction of the time spent on triangulation does not translate into a more time ecient triangulation, as demonstrated in Fig. 4.4, Fig. 4.5 and Fig. 4.6.

When determining the resolution for any given patch, the triangle occupying the largest area on the screen is used as the stored error metric for the patches.

(29)

Chapter 4. Results 22 Size of dataset

8 x 8 3569 1707 674

16 x 16 3659 1977 1172

32 x 32 3581 2099 1201

64 x 64 3421 1791 1225

Table 4.4: Average frames per second over the tested datasets.

Larger patch sizes will subsequently process a larger amount of points which may lead to triangles from high resolution areas being stored in patches that holds both high and low resolution areas. Subsequently, these patches may be excluded from the update step even when the lower resolution areas would need new triangulation. The approximation was therefore worsened for the larger patch dimensions when applied to smaller datasets, as shown in Tab. 4.3. The most optimal approximation can therefore be found in the smallest patch sizes.

Smaller datasets therefore has a tradeo between approximation and processing the patches between update steps. The average performance is presented in Tab.

4.4.

0,01 0,1 1

256 x 256

8 x 8 16 x 16 32 x 32 64 x 64

Iteration

Time (s)

Figure 4.4: The time consumption for dataset of size 256 x 256, showing the range of the runtime simulation.

During startup, the algorithm is able to triangulate many more triangles per second than during runtime, Tab. 4.1 versus Tab. 4.5. The triangulation is threaded and is launched from the asynchronous thread, but during startup the

(30)

0,01 0,1 1

512 x 512

8 x 8 16 x 16 32 x 32 64 x 64 Iteration

Time (s)

0,01 0,1 1

1024 x 1024

8 x 8 16 x 16 32 x 32 64 x 64 Iteration

Time (s)

main thread is launching the triangulation process. Furthermore, no other calculations or processing is done during the startup, thereby giving the main thread more resources to complete the triangulation faster. However, the portion of the

(31)

Chapter 4. Results 24 Size of dataset

8 x 8 1.068 0.8602 0.273

16 x 16 3.453 2.033 0.954

32 x 32 3.005 2.901 1.974

64 x 64 6.127 2.214 1.320

Table 4.5: Performance during startup, measured in million triangles per second.

Size of dataset

8 x 8 7.2% 3.9% 15.8%

16 x 16 27.9% 7.6% 43.5%

32 x 32 59.7% 50.6% 40.0%

64 x 64 8.9% 51.1% 51.4%

Table 4.6: Data showing what portion of the time is spent on triangulation during startup of the algorithm.

time spent on triangulating is much lower, as demonstrated in Tab. 4.6. Contrary to the runtime measurements in Tab. 4.2, the time consumption of the selection process dominates the one measured in Tab. 4.6, in all the measured cases. The selection process is also threaded and the reason to the overwhelming processing time remains to some extent unexplained. A possible candidate to the result is that the triangulation step can be parallelized very eectively with a very even load balance during startup, while the selection process cannot. The implications of these results are irrelevant for the algorithm, as the low startup time should not impose any restrictions on the application.

(32)

Chapter 5 Analysis

The aim of this thesis was to develop and implement a novel technique that utilizes view dependent renement on TIN surfaces, allowing runtime calculations and meshes valid for more than one frame. To this end, optimizations and the usage of data oriented structures were applied to the triangulation process in order to accommodate the desired performance. Considering the initial research question, what has been developed and presented here is a technique that does indeed operate on irregular grids which is made possibly by updating the mesh asynchronously. Again, this is in line with the research question and in order to answer whether or not the question conrmed, the measurements presented in Sec. 4 are used. Following the presented measurements, the conclusions that can be drawn are that it is in fact possible to triangulate an irregular mesh with good approximation and performance.

Several implementation strategies were imposed to ensure a fully disjointed triangulation process, while simultaneously targeting an overall reduction of complexity. The balance between reducing the number of points processed, and thereby the number of potential candidates for triangulation, and reducing the number of patches has been investigated. Following that outcome, there are two main aspects that are aected by the number of patches:

1. State of the mesh while not updated. Patches consists of forcefully selected vertices along the borders, as presented in Chap. 3.0.2, resulting in an increased triangle count when patch dimension is reduced. The dimension of patches also has an immediate eect on the time spent processing the patches in the culling process.

2. Operations on the mesh during updates. As presented in Chap. 4, the medium sized patch dimensions achieved the lowest execution time when updating the mesh. In terms of approximation, the smallest patch dimension achieved the best overall approximation, but could not compete with the execution time of the medium sized patch dimensions.

The overall architecture was built to support multi-core resources and to en- hance future parallelism improvements. The developed subsystems that generate

25

(33)

Chapter 5. Analysis 26 the list of vertices for triangulation, triangulates and culls the scenes all depend on the same basis that is patches. If another approximation replaces the one developed here, the system is likely to be modular enough to allow an easy re- placement. Such technique is required to produce either a list of indices to map the vertex list, or alternatively the complete vertex list. Assuming that another triangulation is developed to replace the one described in Chap. 3.0.3, it will not necessarily be as simple as for the other subsystems. The triangulation is more coherent and would require more time invested to be properly incorporated into the system.

As the dimensions of height maps are commonly based on power of two, the dierent resolutions used as a basis to measure presented in tables and gures, including Tab. 4.1 and Fig. 4.6, shows that the optimal patch dimension for the technique lies around 32 x 32. When determining the patch dimension most suited for the current terrain dataset, the update radius must be considered in conjunction with the size of the terrain. The larger the dataset is, the more impactful this decision will be. What pixel error is most suited to a dataset is more dicult to answer, as it is aected by the terrain features in the mesh as well the size of the dataset. Generally, a lower pixel error than what is used in other terrain LOD papers is required as the camera position changes a lot more between updates of the mesh when compared to other techniques.

During runtime, patches will be coarsened and rened depending on the movement of the camera. Since the improvement of applying the normals on pixels rather than the vertices, the ability to witness the progressive renement unfold in front of the camera was substantially reduced. The issue has not been fully mitigated, as the approximation technique is somewhat inept and the benets of simplicity and time consumption are decreased. Furthermore, the approximation and update mechanics can cause ripples that may appear when two adjacent patches are mapped to the index buer at dierent times. By imposing some form of ruleset negating the possibility of observing it happen, this issue could be fully mitigated. Solutions include selective updates whereas patches are evaluated to see whether or not a crack between two patches would occur as well as writing multiple patches into the index buer at once. In the following chapter (Chap.

6) there is a discussion concerning delegating the triangulation to the GPU which would in theory increase the performance and allow replacing the entire index buer at once.

Lastly, the culling procedure manages and updates the patches on a per-frame basis to notify the update step which patches to include during the next iteration.

Currently, the system stores a local copy of the visible patches once the triangulation system is launched. Although ensuring coherent data, changes during the execution of the system will be neglected. A possible solution is to use a sec- ondary camera view frustum that is located further away along the same angle, to force the selection process to consider the patches directly around the primary view. Given the small portion of the execution time that is spent on the selection

(34)

Chapter 5. Analysis 27 process, as shown in Tab. 4.2, this additional processing of patches can be jus- tied. With additional tweaking, it would enable dynamic adaptation to camera movement throughout the execution of the update step. Managing the load balance between threads would in many cases become more dicult if allowing this dynamic adaptation scheme. Although it would enable all new triangulation that occurs during the update step to be processed by the same thread, the culling procedure currently launches a new thread to triangulate patches that becomes visible during the update step. The importance of implementing this is thereby substantially reduced. Moreover, there are arguments for implementing a tree structure, where the processing time is reduced by the hierarchical structure but goes against the minimal preprocessing architecture that is a central part of the presented algorithm. Minimal preprocessing is important as it is what dictates the time passing before the user is within the virtual world. The importance of minimal preprocessing is most prominent in applications where the terrain is an integrated part in the system, such as a game or a simulator. Keeping the user waiting is something many applications seek to minimize.

The dierent settings that allows for customizations are specied outside of the executable le, in a settings le in which changes to the overall structure of the patches can be done. Settings that aect the way the algorithm operates are the user dened pixel error and the dimensions of the patches. For what duration the mesh remains valid is also specied in the settings le by setting the radius value that dictates the size of the area in which the mesh is still valid.

The resulting system built by the predened subsystems successfully creates view dependent TIN meshes and bridges the gap identied in Chap. 1, as in- tended. By allowing the mesh to remain in the same state and caching the patches, the technique is more suited to applications utilizing events or other means of retaining the user to the close proximity. With the advent of the subsystems that manage the patches much closer to reduce the processing in each step, the algorithm is much closer to a functional state.

To conclude this chapter, the limitations of the algorithm will be discussed as there are a few areas that does impose restrictions. To begin with, the triangulation cannot be applied per frame as many of the techniques discussed in Chap. 2 and therefore the mesh is valid over multiple frames. As such, the same pixel error used for many of the other techniques that builds the mesh per frame can give notable dierences between updates. The quality of triangulation is limited by the fact that no post-processing is applied to the mesh to merge or split triangles. The time it would take to process the patch after triangulating it might then impose an increased radius which in turn could further demand a lower pixel error. Although imposing an increased time consumption, the quality of the approximation would be improved. Another issue that can be observed occurs when patches are mapped into the index buer between dierent frames, as the updates are done fully independent of the main thread. This would manifest itself in a crack between adjacent patches as the border points would be updated

(35)

Chapter 5. Analysis 28 for both patches but not simultaneously.

(36)

Chapter 6 Conclusions and Future Work

In this thesis we have presented a novel LOD-based approach for TIN simplication that is capable of generating and stitching various resolutions at runtime.

By observing that terrain datasets are 2.5D, it was possible to derive that no combination of x and z coordinates can be identical. Our approach can therefore employ simplication from 3D Delaunay triangulation down to 2D without impacting the result, while simultaneously reducing triangle count by examining the features based on a user dened error metric. The technique uses multi-core resources to process what vertices are required to represent the terrain and to triangulate these vertices. Further, the algorithm distinguishes between patches so that patches that are unaected by the new circumstances or not visible are not given any new triangulation.

In terms of future work, there are two main aspects of which to focus on:

delegating the entire triangulation to the GPU, as well as implementing another approximation technique. The architecture of the algorithm has been developed with the focus of supporting parallelism in future works. The selection process contains all information necessary to feed the required data directly into the triangulation process, which is without sequential parts. The importance of moving the selection process to the GPU is only to reduce the information sent from the CPU to the GPU, the execution time is low enough to be disregarded. Moreover, a more complex approximation technique can replace the more simple strategy that was presented here. The focus on such approximation should still reect the fast processing architecture that is the basis for what has been of high importance for this thesis. This more complex approximation should more closely resemble the original terrain features while not imposing an unreasonable execution time increase. By depicting the terrain more closely, dierences between the triangulation from one update to another would be substantially reduced.

To increase the eciency when applying the technique to larger terrain datasets, a tree structure for managing the patches should be implemented. Although increasing the startup overhead, a tree structure would enable variable patch sizes and more ecient culling. Another detail that should be addressed is the waste- ful memory scheme that allocates equal amounts of memory for all patches, even though only a few patches could ever require the allocated amount at any given

29

(37)

Chapter 6. Conclusions and Future Work 30 update step. The very coarsened patches far away from the camera are subsequently given access to much more than they would require. A more intelligent storage system and memory distribution system should therefore be employed in circumstances where memory management has higher importance. Finally, the quality of triangulation can be improved by applying optimization techniques such as merges and splits to the TIN grid. This would impose an increased processing time and whether or not this can be implemented while still triangulating the mesh before in time before it is out of date again.

(38)

References

[1] Kevin Amaratunga and Jingsong Wu. Wavelet triangulated irregular networks. International Journal of Geographical Information Science, 17(3):273

289, 2003.

[2] III Bartholdi, J. J. and P. Goldsman. Multiresolution indexing of triangulated irregular networks. IEEE Transactions on Visualization and Computer Graphics, 10(4):484 495, 2004.

[3] Jonas Bösch, Prashant Goswami, and Renato Pajarola. RASTeR: Simple and ecient terrain rendering on the GPU. In Proceedings EUROGRAPHICS Areas Papers, Scientic Visulization, pages 35 42, 2009.

[4] J. D. Bruguera, M. Amor, J. Döllner, E. G. Paredes, and M. Bóo. Extended hybrid meshing algorithm for multiresolution terrain models. International Journal of Geographical Information Science, 26(5):771, 2012.

[5] Chazelle, Devillers, Hurtado, Mora, Sacristan, and Teillaud. Splitting a delaunay triangulation in linear time. Algorithmica, 34(1):39 46, 2002.

[6] P. Cignoni, F. Ganovelli, E. Gobbetti, F. Marton, F. Ponchio, and R. Scopigno. Bdam - batched dynamic adaptive meshes for high performance terrain visualization. Computer Graphics Forum, 22(3):505 514, 2003.

[7] P. Cignoni, E. Puppo, and R. Scopigno. Representation and visualization of terrain surfaces at variable resolution. The Visual Computer, 13(5):199 217, 1997.

[8] D. Cohen-Or and Y. Levanoni. Temporal continuity of levels of detail in delaunay triangulated terrain. pages 37 42, 1996.

[9] Leila De Floriani and Enrico Puppo. Hierarchical triangulation for multiresolution surface description. ACM Transactions on Graphics (TOG), 14(4):363

411, 1995.

[10] Mark Duchaineau, Murray Wolinsky, David Sigeti, Mark Miller, Charles Aldrich, and Mark Mineev-Weinstein. Roaming terrain: real-time optimally adapting meshes. pages 81 88. IEEE Computer Society Press, 1997.

31

(39)

References 32 [11] W. Evans, D. Kirkpatrick, and G. Townsend. Right-triangulated irregular

networks. Algorithmica, 30(2):264 286, 2001.

[12] M. H. Gross, R. Gatti, and O. Staadt. Fast multiresolution surface meshing.

pages 135 142, 1995.

[13] A. Gueziec, G. Taubin, F. Lazarus, and B. Hom. Cutting and stitching:

converting sets of polygons to manifold surfaces. IEEE Transactions on Visualization and Computer Graphics, 7(2):136 151, 2001.

[14] Stefan Gumhold and Tobias Hüttner. Multiresolution rendering with dis- placement mapping. pages 55 66. ACM, 1999.

[15] Hugues Hoppe. Smooth view-dependent level-of-detail control and its application to terrain rendering. pages 35 42. IEEE Computer Society Press, 1998.

[16] Shu-Jeng Huang and Din-Chang Tseng. Construction of multi-resolution terrain models using hierarchical delaunay triangulated irregular networks.

volume 4, pages 1999 2001 vol.4, 1997.

[17] Shu-Jeng Huang and Din-Chang Tseng. Construction of multi-resolution terrain models using hierarchical delaunay triangulated irregular networks.

volume 4, pages 1999 2001 vol.4, 1997.

[18] Ivana Kolingerová and Josef Kohout. Optimistic parallel delaunay triangulation. The Visual Computer, 18(8):511 529, 2002.

[19] Joshua Levenberg. Fast view-dependent level-of-detail rendering using cached geometry. pages 259 266. IEEE Computer Society, 2002.

[20] Q. Li, W. Shi, and B. Yang. An integrated tin and grid method for constructing multi-resolution digital terrain models. International Journal of Geographical Information Science, 19(10):1019 1038, 2005.

[21] P. Lindstrom and V. Pascucci. Terrain simplication simplied: a general framework for view-dependent out-of-core visualization. IEEE Transactions on Visualization and Computer Graphics, 8(3):239 254, 2002.

[22] Peter Lindstrom, David Koller, William Ribarsky, Larry Hodges, Nick Faust, and Gregory Turner. Real-time, continuous level of detail rendering of height

elds. pages 109 118. ACM, 1996.

[23] Peter Lindstrom and Valerio Pascucci. Visualization of large terrains made easy. pages 363 371. IEEE Computer Society, 2001.

(40)

References 33 [24] Yotam Livny, Zvi Kogan, and Jihad El-Sana. Seamless patches for gpu-based

terrain rendering. The Visual Computer, 25(3):197 208, 2009.

[25] S. H. Lo. Parallel delaunay triangulation in three dimensions. Computer Methods in Applied Mechanics and Engineering, 237-240:88 106, 2012.

[26] Frank Losasso and Hugues Hoppe. Geometry clipmaps: terrain rendering using nested regular grids. ACM Transactions on Graphics (TOG), 23(3):769

776, 2004.

[27] Oleg Musin. Properties of the delaunay triangulation. pages 424 426. ACM, 1997.

[28] R. Pajarola and C. DeCoro. Ecient implementation of real-time view- dependent multiresolution meshing. IEEE Transactions on Visualization and Computer Graphics, 10(3):353 368, 2004.

[29] Renato Pajarola. Large scale terrain visualization using the restricted quadtree triangulation. pages 19 26. IEEE Computer Society Press, 1998.

[30] Renato Pajarola, Marc Antonijuan, and Roberto Lario. Quadtin: quadtree based triangulated irregular networks. pages 395 402. IEEE Computer Society, 2002.

[31] Renato Pajarola and Enrico Gobbetti. Survey of semi-regular multiresolution models for interactive terrain rendering. The Visual Computer, 23(8):583 605, 2007.

[32] Michael Schwarz and Marc Stamminger. Fast gpu-based adaptive tessellation with cuda. Computer Graphics Forum, 28(2):365 374, 2009.

[33] Filip Strugar. Continuous distance-dependent level of detail for rendering heightmaps. Journal of Graphics, GPU, and Game Tools, 14(4):57 74, 2009.

[34] Peter Su and Robert L. Scot Drysdale. A comparison of sequential delaunay triangulation algorithms. Computational Geometry: Theory and Applica- tions, 7(5):361 385, 1997.

[35] Tao Tang, Huili Gong, Ying Mo, Fushou Duan, and Wenji Zhao. Dynamic data retrieval and distance decay of triangulated irregular network(tin) in three dimensional visualizations. Geographic Information Sciences, 12(1):21, 2006.

[36] Tolga Tasdizen, Ross Whitaker, Paul Burchard, and Stanley Osher. Geo- metric surface processing via normal maps. ACM Transactions on Graphics (TOG), 22(4):1012 1033, 2003.

(41)

References 34 [37] J. C. Xia and A. Varshney. Dynamic view-dependent simplication for polyg-

onal models. pages 327 334, 1996.

[38] Bisheng Yang, Qingquan Li, and Wenzhong Shi. Constructing multi- resolution triangulated irregular network model for visualization. Computers and Geosciences, 31(1):77 86, 2005.

Dynamic Creation of Multi-resolution Triangulated Irregular Network