The development of Piecewise Continuation on Marching Cubes Kieran Ghataora MENG Computer Science 2012/2013

Transcription

1 The development of Piecewise Continuation on Marching Cubes Kieran Ghataora MENG Computer Science 2012/2013 The candidate confirms that the work submitted is their own and the appropriate credit has been given where reference has been made to the work of others. I understand that failure to attribute material which is obtained from another source may be considered as plagiarism. (Signature of student) I

2 Summary This project attempts to address the issue of the interactiveness of the marching cubes algorithm. I aim to have piecewise isosurface extraction for any interactive use of the marching cubes algorithm. II

3 Acknowledgements I would primarily like to thank my project supervisor for allowing me the opportunity of doing such an interesting project and for his continued support during my project. He taught me some extremely valuable lessons about myself and about working and I am extremely grateful. I would also like to thank my parents for their support during my degree and especially during the weeks up to the deadline for putting up with my lack of contact. I was busy, was most definitely not just ignoring you! III

4 Contents 1 Introduction Minimum Requirements Mid-Way Points Final Goals Relevance to my Degree Programme Data Visualization An Introduction to Marching Cubes Marching Cubes: A High Resolution 3D Surface Construction Algorithm Uses for Marching Cubes How does the algorithm decide what to place in each cube? Rendering the triangles Implications of the algorithm Background Reading A survey of the marching cubes algorithm Generating the marching cubes lookup table Mirror Symmetry Rotation only How should one generate a marching cubes table? Other types of Data Multi-resolution rectilinear data Higher Dimensional Data Non-rectangular Data Speed-Ups Octree-Based Methods Interval-Based Methods Span Space-Based Methods Propagation-Based Methods Parallel and distributed IV

5 Dynamic vs Static Load-Balancing Summary of Speed ups Octree-based decimation of marching cubes surfaces Surface Tracking Merging of the Cells Crack Patching Strategy Triangulation Conclusions Quality Isosurface Mesh Generation Using an Extended Marching Cubes Lookup Table Classification of vertices Skinny Triangles Results Conclusions Additional Reference to Marching Cubes Ambiguity in Marching Cubes Casing the problem Separated faces Re-sampling Modified look-up tables Extended boolean disambiguations Simple metric disambiguations Facial averaging Trilinear Approaches Run-Time The Asymptotic Decider: Resolving the Ambiguity in Marching Cubes Case Case Case Case Case Case Conclusions A modified look-up table for implicit disambiguation of Marching Cubes Overall conclusions from my background reading Efficiency at run time Surface Coherency Degenerate Vertices and skinny triangles Propagation Methods V

6 4.5 Marching Cubes Table generation Methodology Software choices Stages of the Project Marching Cubes Generating the Marching Cubes Table Piecewise Continuation Generating my own marching cubes tables Acquiring the base cases Rotation Octahedral Symmetry Computing these rotations Decomposing the rotations around non-coordinate axes Complements Indexing Piecewise Continuation Surface Tracking Repeat Vertices Implementation Choices Referencing cubes Referencing edges Seed Points Edge continuations to other cubes Which edge belongs to which surface? Continuation of surfaces per configuration Modified lookup Table Overview of the PC algorithm Project Management How did my project progress? Stages of the Project Discuss and Outline Project Original MC Implementation Mid-Project Report Generate MC Lookup Table Second Background Reading phase Create Piecewise Linear Continuation algorithm VI

7 Implement Piecewise Linear Continuation Final Project Report Development of my understanding of the marching cubes algorithm Evaluation Tests and Results Implications of the results Explanation of the custom data sets Trends and Analysis Slightly more in-depth analysis of Surface Tracking Project Reflection Requirements Generate isosurfaces using the marching cubes algorithm Render these isosurfaces Generate my own marching cubes table Develop a Piecewise Continuation algorithm Generate a modified marching cubes table Implement piecewise continuation Overview Potential Extensions Surface Coherency issue Implementing the newer classification methodology Improve the surface tracking algorithm Conclusion Bibliography Personal Reflection Materials used that weren t my own Ethical Issues 54 VII

8 Chapter 1 Introduction Piecewise continuation, at it s core, is an extension that provides an improvement to the marching cubes algorithm, and tries to tailor it for an interactive purpose. There are various core elements to it, however interactivity is the key here. These interactive purposes could be anything, but my idea centres around the selection and manipulation of individual isosurfaces and therefore there are certain aspects that I shall be looking to improve. Extracting the disconnected surfaces individually is important to this interactive process as it leads to the potential of individual manipulation and selection of the isosurfaces. Memory usage is another concern that I shall look at, it directly affects the frames per second of the output and therefore is important to an interactive purpose due to responsiveness. Speed and efficiency is another concern, extracting the isosurfaces quickly is relevant but not the most important thing. 1.1 Minimum Requirements 1. Generate isosurfaces using the marching cubes algorithm 2. Render these isosurfaces 1.2 Mid-Way Points 1. Generate my own marching cubes table 1

9 1.3 Final Goals 1. Develop a Piecewise Continuation algorithm 2. Generate a modified marching cubes table 3. Devise the piecewise continuation algorithm 4. Implement piecewise continuation 1.4 Relevance to my Degree Programme This project directly builds on certain modules and uses the skills learnt in level 3 modules. I originally learnt briefly about the marching cubes algorithm in level 2 module X. At level 3 I was taught in the Computer Graphics module how to render 3D graphics with the C++ language with the QT framework. I will be using the experience gained in the level 3 module to program the implementations of the algorithm and will be directly building off material in my level 2 module X. 1.5 Data Visualization Visualisation is a field of computer graphics that attempts to render 3d data on screen. There are multiple ways of achieving this feat and I will be looking solely at the marching cubes algorithm. The other techniques out there include such principles as volume rendering and contouring. Whilst these are relevant within the field I am looking at marching cubes as it is still very much in use and despite it s age due to it s robust nature and the potential for extensions for tailoring the algorithm to any specific purpose. 2

10 Chapter 2 An Introduction to Marching Cubes This section is an overview of the original marching cubes paper and the algorithm 2.1 Marching Cubes: A High Resolution 3D Surface Construction Algorithm Marching Cubes is a divide and conquer algorithm that constructs a surface from a 3D scalar field and an isovalue. The algorithm looks at subsections of the scalar field in sets of 8 neighbouring vertices (a cube) in a scanline manner, decides if there is a part of the surface within this subsection and then moves onto the next subsection until it has reached the end of the field Uses for Marching Cubes Marching Cubes is a surface reconstruction algorithm, it s applications are far and wide. Medical scans are a popular area for marching cubes to be associated with however it is a relevant technique in graphics in general, terrain is another popular use for this algorithm How does the algorithm decide what to place in each cube? In every cube the algorithm looks at the vertices and compares the values with the isovalue provided as an input. The results of this comparison are then used to create an index, where every result is treated as a bit in an 8-bit integer. If the value at the vertex is higher than the isovalue, the appropriate bit is set to one, otherwise it is zero. As is shown in the diagram and stated above, the vertices each correspond to a bit in the 8 bit number. This forms an index with a possibility of 2 8 entries. You use this as the index for the march- 3

11 Figure 2.1: Vertex numbers and Edge numbers ing cubes lookup table, which contains every possible combination of vertices above and below the isovalue. Luckily, these actually can be reduced down to 15 base cases. Figure 2.2: Original 15 marching cubes cases The marching cubes table is every rotation of these base cases possible and their complements, each indexed individually by the configuration of vertices above and below the value. The entries in the table contain the triangles that intersect the queried cube for the surface defined by it s isovalue and the scalar field Rendering the triangles Currently, we have which triangles are in which cube of the field and which edges they intersect. For rendering purposes we require the exact location of the vertices. To get this we use simple interpo- 4

12 lation. Let E be and edge with points V 1 and V 2 who s values are i and j and an isovalue z and the interpolated position is I. I = V 1(x,y,z) + z i j i (V 1 (x,y,z) V 2(x,y,z) ) The other requirement for rendering is that we have the unit normal vector for each vertex. The way we do this is to look at the gradient of the surface in all 3 dimensions from the location of the imaginary cube vertex. You then interpolate from the cube vertices to the triangle vertices. If you then divide it by it s length, you get the unit vector for the normal of that vertex Implications of the algorithm The algorithm makes no effort to logically differentiate between any disconnected surface within the same isosurface. It uses it s exhaustive search to seek out the triangle configurations and render them. The marching cubes algorithm is O(n), meaning the algorithm scales with the input size of the data set and not the output size. Apart from reusing the interpolation there is nothing that dictates reusing vertices in triangle calculations. This has the potential to have multiple vertices from one cube in the exact same point, with some cases being worse than others and then again, since 4 cubes share any single edge, if the isosurface continues to all 4 cubes that s potentially a lot of vertices on one spot. 5

13 Chapter 3 Background Reading This section shall be an overview of the previous work within the context of marching cubes.summarised here will be the survey paper, influential marching cubes papers and papers potentially directly related to the development of the piecewise continuation algorithm. 3.1 A survey of the marching cubes algorithm This paper is an overview of marching cubes and alterations to the algorithm Generating the marching cubes lookup table The standard marching cubes algorithm uses rotation and reflection to reduce it to 15 base cases (14 patterns and one with no triangles) for the generation of the table. [4] Mirror Symmetry Abusing the use of mirror symmetry, certain algorithms have reduced the number of base cases to 14 total. [5, 6, 7]. It is also worth noting that case 14 is a mirror of case 11. Combining all 3 types, rotation, mirror and reflection, you can reduce it to 14 total cases Rotation only Abusing rotation only will allow you to reduce it to 23 cases. Whilst this gives you more cases, it overcomes the problem of surface coherency without any other alteration. [8, 9, 10] 6

14 How should one generate a marching cubes table? The best choice here is to exploit only rotational symmetry. The process of rotation is not overly complex and, as will be stated later in the project, the issue of surface coherency is a problem Other types of Data There are various other types of input data that could be considered for use in marching cubes. Whilst they are still variants of marching cubes, some of the variants do not actually involve cubes. They are however, based off the same exhaustive divide and conquer strategy with a lookup table that is at marching cube s core Multi-resolution rectilinear data This term refers to data is not uniformly laid out and that the data is contained within rectangles only. Simply put, the data must be sectioned into rectangular splices that are not restricted to being identical width or height. cubes. The multi-resolute nature of this data type allows for a solution to two issues that plague marching The first refers to the issue of every portion of the isosurface being the same resolution despite not every portion of the isosurface being the same relevance for any specific purpose. Having multiresolution data means that the areas that are of more interest can get more focus due to this restriction being lifted. The other issue that this addresses is the holes within the marching cubes output, if these holes appear you can re-evaluate the position and number of the nearby polygons by increasing the number of cells within this area. Weber et. al claims that this method also fixes the problem of non-fully continuous surfaces without fully continuous surface interpolation. Whilst it is not mathematically perfect, it generates a better representation of the data than interpolating between certain data points. [11] An example of the use of multi-resolution data in real life that is extremely relevant to marching cubes is the models used in a lot of game engines. Due to the polygon restriction on games due to processing power restrictions the models and textures need to highlight features in different resolutions depending on what is important. Whilst models for characters are probably not best produced by the marching cubes, terrain is a perfect opportunity for marching cubes to be used. 7

15 Higher Dimensional Data True visual 4D representation of data is extremely difficult as we live and are only working in a 3D space. Roberts and Steve Hill (1999) 12 proposed the concept of rendering any n-dimensional data as splices of n-1 dimensional data. For 4D grids, this means you generate splices of the 4D data as 3D grids and run them through the original marching cubes algorithm. Time-varying data lends itself well to this exact model of representation. [13] A great problem if you do not take this approach is the intersection topology lookup table is difficult to approach. Bhaniramka P et al [15,16] has created an algorithm that generates a table using convex-hull theory. This does however produce a large data set that grows with dimensions Non-rectangular Data There have been quite a lot of attempts to extend the marching cubes algorithm in this way to make it fit for different purposes The first method discussed is a cylindrical and spherical data set. The motivation for this direction come from the needs of certain other fields, such as geology, to reconstruct data about naturally more spherical objects. It is always better to visualise data within the original image s own restrictions. If the original data is spherical, mapping it to a cube is not necessarily the best representation of it due to the fact that interpolation can only do so much with curved surfaces. The more resolution you apply the better, however certain methods prefer to take a more direct approach to the problem of representing non-rectangular data than just converting it as it is claimed it produces less cracks and distortion. [14] Tetrahedra shaped cells (now known as marching tetrahedra [15], a natural extension to marching triangles) is another consideration. It does not have the ambiguity problem that cubes have due to the fact that they are tetrahedra and as explained later, the issue of ambiguity comes from the separation problem. It works on the same principle that marching cubes works on, however equally spacing data into triangular-spaced cells is something that is uncommonly done and potentially awkward. It is worth nothing however, that a cube can be divided into six tetrahedra. The look-up table is much smaller than the marching cubes one as there are only 2 3 variations 8

16 Octahedral and Hexahedral [18] are also cell shapes that have been delved into and analysed Speed-Ups The speed-up of the isosurface extraction is an issue with solutions that can be broken down into a few areas. I will talk about various methods that attempt to avoid non-empty cells and parallel and distributed methods Octree-Based Methods Octree based methods break down the scalar fields into nodes of an octree where the root note is the entire field and the leaf nodes are particular subsections of the data, with the smallest subsection being eight cells adjacent to each other. The original octree usage was proposed by Wilhelms and van Gelder [20] Creating this octree requires the traversal of the entire data set, however proceeding extractions will not visit empty cells. In general isosurface extraction using this method is worth using, apart from in certain data sets, in one shot extractions because the time saved by not visiting empty cells is more than the octree generation, which can also be sped up itself by standard parallel processing, even multi-threaded environments. [19] There extensions available for this basic principle, some of which can include such specific purposes like isosurfaces extracted based on current viewing angle [21,22] or more standard extensions where the octree is more efficient, a good example of which is [23] Interval-Based Methods Interval-based approaches are based on grouping the cubes / cells simply on intervals. This is intended to be vague as it reflects the flexible nature of the principle. The first iteration of which was by Giles and Haimes. [ 24] The idea behind it is to group spaces by isovalue level, above and below and then the list of cubes / cells that are potentially non-empty are the ones with a minima under the isovalue a but also greater than the a - x where x is the largest change in minima and maxima between the cells / cubes. This however, does have the possibility of running through the entire dataset as it only orders the dataset for an increased likelihood of faster isosurface extraction. This technique, however, can be used on both structured and unstructed data, regular and non-regular and is therefore extremely versatile 9

17 Span Space-Based Methods Originally proposed by Livnat et al [26]. this method works by creating a 2D representation of the data, where a mapping for each cell is present and placed based on their minimum and maximum values, and then this 2D space is scanned for cells with a minima and maxima where the isovalue is between it. The first proper implementation of this method used a k-dimensional binary tree to organise this 2D space, but generating and searching this table is very expensive. An advancement to this idea was using regions instead of individual cells, but obviously this requires potentially searching non-active cells, even though overall it is a speed increase ISSUE [27] span space is represented as a square lattice of a specified size where each lattice element is one of 5 things: 1. Outside the active area 2. Inside the active area 3. On a vertical boundary 4. On a horizontal boundary 5. On both boundaries This is extremely fast active cell detection, however it is very space intensive and bound by I/O performance Propagation-Based Methods Propagation-based methods are akin to my piecewise continuation principle. They attempt to avoid the empty cells by not traversing the scalar field cube by cube. There are not a great deal of these methods, the closest of which appears to be the Octree-Based Decimation of Marching Cubes Surfaces (1996). Seed point generation is also a concern for these algorithms, the simplest of these being traversing the entire field, much like marching cubes would do, and picking seed points out there. The more advanced methods involve various graph theory techniques to search out differences between adjacent cells [28,29] 10

18 Parallel and distributed These methods are almost the most obvious speed up of the marching cubes algorithm. It is a standard divide and conquer algorithm where each of the individual cubes and be independently solved. Cubes that share edges and faces should most likely be processed together however due to the ability to reuse previously interpolated values Dynamic vs Static Load-Balancing Static load-balancing is splitting up the work beforehand and then never altering it and dynamic is an allocation of work that varies based on certain variables during execution. A concern going into this comparison however, is related directly to the innate potential for parallelism of marching cubes and the potential overhead of a dynamic-load balancing whilst it s static partner has a formidable speed up without the communication and processing overhead of the dynamic method. A particularly early dynamic strategy was developed by Miguet and Nicod [42] wherein they traverse the field layer by later and use interpolation to decide where the extensions to the isosurface potentially are, and then split on the layer based on this interpolation. Where dynamic load balancing comes into it s own in comparison to static is when we are dealing with multi-resolution data. There are two potential approaches to this, the pre-processing angle and the dynamic one. Taking a look at the pre-processing idea, the principle behind this is to map where the clusters of data are and then allocate evenly between the cores. There are a few approaches to the dynamic way of thinking with respect to this problem. One approach [43] is to split the multi-resolution into a tree structure (potentially an octree) and recursively solve the tree, providing the largest unsolved subtree to the processor that goes idle first. The simplest static load-balancing technique is to simply divide the cells up evenly between all the cpus and then letting them have at it. The other approaches deal with certain sections or layers of the field. An extremely interesting implementation [44] of static-load balancing relating to propagation based methods involves splitting up the active cells within an octree based decimation of the field between each of the CPUs. Each CPU extracts the part of the isosurface within their section. It is an interesting addition to current propagation techniques. As with most parallel and load-balancing problems it is entirely dependant on your needs. 11

19 Summary of Speed ups Most of these methods attempt to use heavy pre-processing to improve the speed (somewhat including the parallel and distrusted approaches because they have to process these allocations). They all have their own benefits, however the ones that are particularly interesting is the propagation ones that use surface tracking I will now go into more detail with respect to certain, more influential or relevant papers 3.2 Octree-based decimation of marching cubes surfaces This paper addresses the problem of propagation of isosurfaces with respect to irregular shaped cells as opposed to cubes. This means that their crack patching strategies will be of a completely irrelevant nature. They also attempt to extract every surface possible at once, and if a surface intersects with another surface of a similar isovalue, both surfaces will be extracted. Piecewise continuation requires the extraction of the surfaces individually for potential manipulation and selection process.// There are 4 major steps within this algorithm Surface Tracking The algorithm uses a modified lookup table to store every extension of the each of the configurations. Provided with a seed point, this algorithm will extract all isosurfaces given a particular isovalue connected to the seed point provided. It uses the standard MC table to look up the configuration and then the extension provides the list of new potential extensions to the surface which are then added to the queue and processed in order, using flags to make sure that the same cubes are not visited again Merging of the Cells This attempts to merge all of the adjacent cells into a single parent node and note whether the boundary intersects the node Crack Patching Strategy The cracks in this algorithm are primarily due to the fact that the cells are not cubes, not necessarily relevant to the ambiguous cases internal or external. The way they do this is by extending the high resolution edges to cover the low resolution ones, which is similar to re-sampling the data. Patching is then done on a case by-case basis if conditions are met, if the current node in the octree requires patching, then children nodes are also added to be checked. 12

20 3.2.4 Triangulation This is the simpler of the steps, and simply involves rendering the surface Conclusions Whilst this paper bears resemblance to my project as they are both propagation-based methods the implementation is very different and as is the aim. I will most likely use the principle behind the surface tracking part of the algorithm whilst changing some of it to adapt it to my problem. The crack-patching and merging of the cells portion of the algorithm is however not so useful to me, it solves a similar problem of holes within the marching cubes output, however, it is generated from a different set of conditions and reasons. It uses some of the same principles the original marching cubes 13

21 3.3 Quality Isosurface Mesh Generation Using an Extended Marching Cubes Lookup Table This paper vastly extends the way marching cubes works. Whilst it stays true to it s core of exhaustive divide and conquer strategy based around lookup tables and isovalues Classification of vertices The first major change this paper makes to the algorithm is how it classifies vertices. Whilst it still classifies vertices as being above and below, the paper introduces a third classification, equal to. This does large things to the algorithm, the first of which increases the lookup table size to 38, 6561 entries. This means that the marching cubes algorithm can be more accurate than ever with different triangles formed to tackle the problem of degenerate triangles and allows for different triangles to be rendered if they are close to the actual grid points, which is what creates the skinny triangles Skinny Triangles This is primarily what this extension is actually trying to fix. With the usage of the new classification, fixing cases where the isovalue is too close to the actual grid point, generating triangles that have extremely acute angles and not giving a good representation of the surface Results This paper states that they reduced the amount of triangles by percent, which is a significant reduction in terms of memory usage. This reduction in triangles also did not come at the cost of processing time. The paper states that the difference in isosurface generation time was negligible and since the new table does not count as a preprocessing step as it is simply a table with values Conclusions Whilst this is an extremely interesting development for marching cubes, I do not think I shall be using this iteration of 3 vertex classifications in my project purely because it would increase the complexity of it. This could be a very good future point to aim towards though after the project. 14

22 3.4 Additional Reference to Marching Cubes This is the first paper to notify the community about the ambiguous surfaces and holes contained within the surfaces generated. This is the start of a long series of attempted solutions and discussions on the subject. 3.5 Ambiguity in Marching Cubes The very first notice of this issue was brought up by Durst [31] where he noticed that some of the topologies could be envisioned in multiple ways, some of which creating holes and problems. Various other papers identified the ambiguous cases that caused holes and confusion. At most 5.6% and on average 3% of all faces suffer from ambiguous surfaces. [41] This is highly relevant because if the method employed has a very high overhead it could greatly impact the speed of the Marching Cubes algorithm Casing the problem It has been eluded to prior, but never fully explained why some of the marching cubes cases are broken. When the scalar values get too high or too low in certain cases, some of the triangles can either intersect, creating artefacts or simply not join up at all, creating holes. The picture used in this paper illustrates it perfectly. Figure 3.1: Illustration of the issues with marching cubes As you can see in both cases, the configurations are wrong due to the intersections of blatant holes within the examples Separated faces The paper defines an ambiguous face as one where the vertices above the isovalue are diagonally opposite. These cases can then produce two different configurations. This is one of the main issues with some of the configurations. The way you decide between these two is the position of the interpolation of the isovalue ends up being.and whichever is more appropriate 15

23 3.6 Re-sampling A very simple fix to this issue is to simple re-sample the data. [11] If you break the data down enough and recursively solve the problem you will attain a higher resolution image with less ambiguousness. It will obviously increase the number of faces on the surface and therefore increase the rendering cost, but it is a way of dealing with the ambiguous nature. There is also an approach that involves decomposing the field into unambiguous sections and then resolving the ambiguous edges between these sections, eventually finding a section that contains the entire field. Simple boolean approaches decide which case is best by looking at the actual points of the configuration and compare them with adjacent ones to decide where the connections are. 3.7 Modified look-up tables This method fixes the look-up table so the standard MC algorithm can continue, however the cases are fixed so that there is no ambiguity within the isosurface produced. Montani et al. [32] used another facetization for the cases that have potential ambiguity and adding a few more cases in. However, there is an alternative method that uses rotation [33] to generate the cases in MC and rotation generates the correct configurations for certain cases naturally. For the cases that are not solved by rotation naturally, there are other configurations suggested. 3.8 Extended boolean disambiguations There seem to be two alternatives for this method. The first [34] is extremely simple conceptually and it involves checking for a hole based on a certain criteria and then inserting triangles that will bridge the gap between this hole. This potentially could create artefacts that should not be in the original 16

24 data, however depending on what the purpose is this may not be as relevant. The second [35] refers specifically to the marching tetrahedra variant and employs a tactic where you create a new tetrahedra that spans two cells and in the process plugs the holes in the isosurface. 3.9 Simple metric disambiguations One method [36] is to just check for the ambiguous cases when they arise and use a specific fix for the area Facial averaging This is the process of averaging the scalar value of each of the faces points so they align up with adjacent cubes. Asymptotic decider [40] is similar, but much more robust; it uses the curvature of the surface to interpolate to the expected position of the surface at the grid lines. The surface is then extended to where it intersects with a similar point on the adjacent cube. This will fix the face ambiguities but will not resolve any internal ones. This is actually the mathematical way you are supposed to generate the surfaces for marching cubes, I will go into detail over this later in the report Trilinear Approaches The principle behind this is an extension of simple and bilinear disambiguation techniques. They do a similar thing as the bilinear method, however this uses seven points in the interpolation process, one that is inside the surface. This means that it actually fixes the internal problems as well as the face problems. A good example of one of these approaches is [38], where they interpolate bezier patches to fit the holes, or the Asymptotic Decider method [39] Run-Time is hurt by checking for all potential ambiguities is not always the best idea when you are considering the need for speed in any implementation. Fujishiro and Takeshima [39] have developed a metric to determine potential ambiguity 17

25 3.9.4 The Asymptotic Decider: Resolving the Ambiguity in Marching Cubes This paper discusses a technique for mathematically fixing the ambiguous faces by making a formulation for deciding which vertices to use in the configuration. It uses bilinear interpolation to work out where the vertices of the face will be placed for ambiguous faces. I will be using graphics from the original paper as they convey the situation perfectly. There are some new configurations for each of the cases based on this work. I will discuss them in the order that they are listed in the paper, as they are ranked in order of complexity Case 3 The issue lies in one face and a new triangulation is supplied. Figure 3.2: Original Triangulation for Case 3 Figure 3.3: New Triangulation for Case 3 This new configuration eliminates the ambiguity in the face because the two new surfaces, when they approach each other, will not intersect Case 6 This is a similar problem to Case 3, one of the faces produces a hole or an intersection under certain conditions. There are however two proposed triangulations to fix this case. The reason there are two is because there needs to be a case for when the face is separated and not separated. 18

26 Figure 3.4: New Triangulations for Case Case 12 Within this configuration, there are two ambiguous faces. There are 4 potential triangulations that will fix it as there are 4 possible combinations of the two faces. Figure 3.5: New Triangulations for Case Case 10 This is a slightly more complicated configuration. There are once again two ambiguous faces, however certain cases arise when certain combinations of separated and non-separated faces occur. The case where the two ambiguous faces are both separated or not separated result in triangulations that are possible and plausible (10A and 10C) yet where they are of alternate separation it is actually impossible for reasons explained in the paper to create a triangulation that is safe. Their solution to this is to create a vertex within the actual cube to use in the triangulation process, the location of which is dictated by the interpolation of the isovalue. A similar interpolation that is used to decide whether the face is ambiguous or not Case 7 Within this configuration, there are actually 3 ambiguous faces, some of which suffer similar problems to case 10, where the fix is to create a new vertex. 19

27 Figure 3.6: New Triangulations for Case 10 Figure 3.7: New Triangulations for Case 7 The new vertex is taken by interpolating between grid points v2 and v8 (under the standard marching cubes cube notation, figure of which is under chapter 2) Case 13 This is a particularly complicated case as every single face is ambiguous. With 64 possible cases this looks like a large amount of work, however, using a trick abused by marching cubes in the first place, using rotational symmetry the cases can be reduced to 9. Figure 3.8: New Triangulations for Case 13 13E, 13D and 13F require an additional vertex interpolating the line between v8 and v2 and 13H requires an interpolated vertex along the line between v3 and v5. 20

28 3.9.5 Conclusions This is the paper that mathematically solves the problem with marching cubes. It is however, an extremely complicated paper and to implement it it is computationally expensive. It does however lead to fixes that will most likely be less computationally expensive A modified look-up table for implicit disambiguation of Marching Cubes. This paper relates to solving the surface coherency problem caused by the original marching cubes and originally pointed out by Durst. This fix [32] is rather simple but elegant, we replace the complementary cases of 3, 6 and 7 with new configurations and to generate all other cases This is due to the relative configuration of the surface when the two diagonal vertices are of opposite polarity with respect to the isovalue. Figure 3.9: Replacement configurations As you can see in this figure, the cases with ambiguous faces have been replaced by other configurations. There were quite a few papers prior to this and is a result of a series of iterative improvements. 21

29 Overall, from all the fixes I have seen, I believe this is the best as it does not increase computation time and yet completely fixes the ambiguity problem. If I were to implement a fix this is most likely it. 22

30 Chapter 4 Overall conclusions from my background reading Marching Cubes suffers from three relatively large problems and a subsection of other applicable, intent specific problems. The first problem, and the specific problem I am attempting to solve incorporates but does not fully fit into any of these categories. 4.1 Efficiency at run time Efficiency at run time is a potential problem with marching cubes depending what you are doing. If we consider traversing any cube that does not intersect the isosurface wasted time, this leads to the conclusion that marching cubes is potentially extremely inefficient due to it s exhaustive nature. It is also worth noting that due to this exhaustive nature, the runtime scales with dataset size and not output size. The obvious solution to this inefficiency is to not traverse the empty cubes, however this requires a different take on the algorithm that I shall discuss in this report. Another efficiency issue is the vertex placements too. In most marching cubes implementations vertices are laid on top of each other and re interpolated. This is obviously a giant waste and something I shall be looking to solve too. 4.2 Surface Coherency This issue has been fully solved and I shall not be dealing with it in this project. The section above notes the series of papers and alternatives to fixing it. 23

31 4.3 Degenerate Vertices and skinny triangles This issue is caused by having vertices where the isovalue too close or on top of to the data grid points and produces a poor representation of the surface. This problem is not that abundant and has been fixed by certain algorithms [45], however within this project it is not a concern for me. Fixing this could be a future extension. 4.4 Propagation Methods Whilst it is not identical, I will most likely be using Shekhar et al s [1] principle for surface tracking to generate my own way of doing it. Edge continuation tables are a good idea and with tweaking I can adapt it to my own needs. 4.5 Marching Cubes Table generation There are many methods to do this, and exploiting rotation seems to be the best one. However, for simplicity s sake I will be using the original marching cubes table, so that I have a reference to check against. This means that I will be using rotation and reflection with 15 base cases. 24

32 Chapter 5 Methodology Within this chapter, I shall discuss my software choices for the project, the stages of the project and why they are the project steps 5.1 Software choices This project aims to develop an algorithm so the implementation is not overly relevant. However, there are some things to consider. In essence, this project is a graphics one and there are some certain unwritten standards. The majority of graphics work is programmed in C++ with a direct X or opengl library. C++ interfaces particularly well opengl and is therefore a solid choice for implementation language. 5.2 Stages of the Project In this section, I will provide a basic overview of the original 3 steps of my project. Later within this chapter I shall evaluate them in details when I have noted the steps they involved into Marching Cubes This first step is the most obvious, I will need it to perform the tests for my evaluation and it provides me a solid knowledge base. 25

33 I will be using the original algorithm, with a pre-generated modified [32] lookup table. The potential surface coherency issue that plagues the original marching cubes implementation has been fixed by a modified version of the marching cubes table which fixes the broken cases Generating the Marching Cubes Table I will need different lookup tables for this algorithm and therefore I shall need to know how to create my own basic table from rotation and so that I can apply that knowledge to creating my own modified version. The base cases are rotated and reflected to create the table and it is the same principle for creating any other modified version of the marching cubes lookup table. I will generate the original marching cubes table using the same cases, rotation and reflection. This is the most basic implementation Piecewise Continuation This is the final step of the project. I shall use the experience gathered from the other two steps to hopefully implement it well and come up with an algorithm that should work for the better. Later on in the project, we shall return to these steps and see whether I stuck to them or not. I also made a plan from this stage: Figure 5.1: First Plan 26

34 Chapter 6 Generating my own marching cubes tables Generating a basic marching cubes table involves four major steps. Acquiring the base cases, rotation, complements and indexing. 6.1 Acquiring the base cases As stated in chapter 2, where the original marching cubes paper is analysed, every single entry within the lookup table can be generated by enumerating through every rotation of the 15 base cases. There are multiple starting points for enumeration, however the approach I shall be taking is the standard 15 base cases. The base cases I will be using, I have obtained by extracting them from the table provided to me to use in my original marching cubes implementation provided by my supervisor Hamish Carr. 6.2 Rotation This section will explore how to rotate the cases and enumerate every entry in table. It will explain the rotation group of a cube and how to translate this into code. The images used in this section are from [3] as they perfectly fit the situation and explains it well Octahedral Symmetry A cube has a possible of 24 permutations and 13 axes that it can rotate about including the identity matrix rotation. 27

35 The first set of rotations is a group of 9 around the 3 coordinate axes, x, y and z of 90, 180 and 270 degrees. [3] Figure 6.1: 3 Coordinate Axes [3] This is the most simple of the rotation sets. The second set is a group of 6 rotations along 6 axes by 180 degrees [3] Figure 6.2: Second set of 6 axes [3] This is a slightly more complicated set as they are not rotations around coordinate axes. However these can be decomposed into a set of x, y and z rotations which are much easier to code The third set is a set of 4 axes that rotations by 120 and 240 degrees shall be performed. This gives us the final 8 rotations. [3] Figure 6.3: Third set of 4 axes [3] Computing these rotations A challenge with these rotations is that not all of them are around the coordinate axes. These rotations could be mapped directly however, mapping x, y and z rotations and then decomposing the non-coordinate axes rotations into a set of coordinate rotation axes is much easier to compute and to 28

36 program. The tables following are the mappings for vertex and edge rotations by 90 degrees around the respective coordinate axes Table 6.1: Edge Rotation Table Edge x y z -x -y -z Table 6.2: Vertex Rotation Table Edge x y z -x -y -z

37 Decomposing the rotations around non-coordinate axes The first set of rotations is simply working through the 9 permutations of x y and z rotations through 90 and 270 degrees The second set is where the decomposition starts happening. The axes will be defined by what edges it goes between. Axes Order of Rotations 3-5 +y +y +z 1-9 +z +y +y x +y +y y +y +x 4-2 +z +z +y 0-6 +x +x +y The third set is two rotations around axes that can be defined by the vertices it goes through Axes Order of Rotations 6-1 +z +y 2-5 +x +z 0-7 +x +y 4-3 +x -y 6.3 Complements This part of the generation involves taking the complement of every rotation we do. This means that we switch whether a vertex is above or below the isovalue in the representation and keep the same configuration. 6.4 Indexing The last section of the generation is storing all the permutations. This is the exact same process outlined as in the original marching cubes paper, but reversed as we are storing it instead of looking it up. 30

38 Chapter 7 Piecewise Continuation This section shall consist of an overview of the key elements of piecewise continuation and of the implementation choices used in the algorithm. 7.1 Surface Tracking This is the primary element of the Piecewise Continuation algorithm. As stated in the background reading section, there are many variations of surface tracking algorithms out there, classified under Propagation methods [1]. These methods are primarily used to speed up the isosurface extraction process and are not all necessarily interested in piecewise extraction of specific surfaces. However, my surface tracking will do a similar thing and hopefully have a great speed up for the algorithm. The method shall be similar to the one used in [1]. That algorithm, as stated above, holds all continuations for every cube, piecewise continuation requires extraction of specific surfaces individually and therefore the edge continuations shall all be surface based and not entirely configuration based. For piecewise continuation, a seed edge as opposed to a more common seed cube will be used. As an edge is specific to one disconnected surface, whereas a cube can have as many as 4 disconnected surfaces at once. From any edge you should be able to add 4 cubes that the edge is involved in, which shall be done with the seed edge to start with. The configuration is then lookup up with respect to the isovalue, much like the standard MC algorithm. Then the surface tracking begins, information on edge continuations and relevant triangles is to be extracted from the modified table and then the edge continuations processed until the cube queue is empty, never processing the same cube twice within one disconnected surface extraction. 31