** Next:** 4 Question 4
**Up:** 3 Question 3
** Previous:** 3.3 Benefits

##

3.4 Pitfalls

As Marching Cubes is an object-order algorithm, and not image-order, it can
be inefficient, specifically, slow in computation and large in storage requirements.
Each voxel may contribute up to four facets to the final geometry, and so even
a modest sized dataset of 100 slices at 256 by 256 resolution may produce between
500,000 and 2,000,000 triangles[6]. This can have excessive processing
and storage requirements, especially during the rendering stage.

Further, the as the facets generated are sub-voxel, many triangles end up being
smaller than a single pixel after rendering. This is inefficient, and reveals
the algorithms object-order nature. The Dividing Cubes algorithm [5, Reference 2]
attempts to avoid this problem. It is similar to Marching Cubes except that
it projects voxels that intersect the surface into the image plane. If these
map to a single pixel or smaller, they are rendered as single points, otherwise
they are subdivided into facets as with Marching Cubes.

Void data is not gracefully handled by the algorithm. If it is anticipated in
the dataset it requires special cases to be added to the implementation if it
is even treated at all. Also, not all datasets are well suited to the conceptual
side of Marching Cubes. For example, amorphous data often doesn't contain thin
surfaces suitable for isosurface visualisation, care must be exercised if it
is attempted.

However, by far the largest problem with the Marching Cubes algorithm is that
of ambiguity in the surface. This occurs when the wrong decision is made about
whether a vertex is contained by the surface (such as when the assumption of
one edge-surface intersection per voxel edge breaks down), or if the triangles
chosen at adjacent voxels don't fit together properly. The result is a hole
in the constructed surface, usually of the order of a voxel's face. One such
example is illustrated in [2], which also refers to a similar algorithm
by Wyvill *et al* in [2, References 2,3,4], which correctly handles
these cases. In addition, Dividing Cubes [5, Reference 2],
Marching Tetrahedra [5, Reference 14] and Asymptotic Decider
[3], are all algorithms based on Marching Cubes which attempt to
solve this problem.

** Next:** 4 Question 4
**Up:** 3 Question 3
** Previous:** 3.3 Benefits
*Kevin Pulo*

2000-08-22