Problemática del sector y alternativas al uso del tapón de corcho

Higher-order surfaces, such as parametric surfaces, implicit surfaces, and CSG, are critical to computer graphics because they represent exact mathematical represen- tations of the 3D model and can be described with less data input (thus using less memory) than the many vertices for polygonal meshes. There are multiple ways to render higher-order surfaces: the most popular among them use numerical it- eration (Section 3.2.1) or rely on a form of polygonization (Section 3.2.2). There are also a few variants that use shadow volumes to directly generate shadows (Sec- tion 3.2.3).

Before proceeding, we provide a few words on what these higher-order sur- faces are:

● Parametric surface, also known as a spline surface, which is a particular and popular form of a polynomial parametric surface. A parametric surface in 3D is defined by a function of two parameters, usually denoted by(u, v). The surface is defined by a set of user-input control 3D points and the interpola- tion function for those points (seeFigure 3.1). The most common example of parametric surface is the cubic NURBS.

● Implicit surface, also known as a level-set or isosurface. An implicit surface is defined by a mathematical function F, where F(x, y, z) ≤ c. For example, a unit sphere located at (0,0,0) is defined by F(x, y, z) = x2_{+ y}2_{+ z}2_{. A} variation of an implicit function is known as algebraic surface, metaballs, or blobbies, with the definition that_∑iFi(x, y, z) ≤ c. An example of blobbies can be seen inFigure 3.2,where the water is composed of blobbies and they are rendered using numerical iteration techniques.

● Subdivision surface, which starts from an initial polygonal mesh that is recur- sively refined by inserting more vertices and faces to replace the ones from

Figure 3.1. Control points on the left, with the piecewise polynomial definition, result in the surface generated on the right.

Figure 3.2.Blobbies and their corresponding shadows, by Duncan Brinsmead. Image cour- tesy of Autodesk, Inc. © 2007. All rights reserved.

the previous iteration. The refinement schemes compute new vertex posi- tions within a given neighborhood; they are interpolating when the original vertices are matched with the subdivision, and otherwise approximating. ● Constructive solid geometry (CSG), procedural modeling technique that uses

Boolean operators (such as union, intersection, difference) to combine ob- jects.

Oddly enough, we found little to no literature on shadow algorithms for bound- ary representation (B-rep) surfaces. We suspect this is because the rendering of those surfaces is almost always done through polygonization. Further, B-reps are usually applied in CAD situations where shadows are not as critical. Thus, we have no coverage of B-rep surfaces as higher-order surfaces in the upcoming discussion.

3.2.1

Numerical Iteration

Rendering of higher-order surfaces can be achieved through direct rendering that applies numerical iteration techniques. Such techniques compute the intersection of a 3D ray with the surface, and the closest intersection point with the ray is deter- mined. Numerical iteration techniques require a starting guess where the closest point might be; then, iterations of the guesses hopefully result in the convergence of the solution. The quest for all numerical iteration techniques is to bound the intersection point’s range sufficiently to allow both fast and correct convergence.

Example numerical iteration techniques for implicit surfaces can be found us- ing Newton’s iteration and regula falsi [55], deriving analytic solutions to low- order polynomials [224], and using interval arithmetic [285, 411]. To achieve faster performance, the following papers use GPU to directly render implicit sur- faces [363, 588, 287, 532].

Example numerical iteration techniques for parametric surfaces can be found in the following: using Laguerre’s root-finding algorithms [281, 432], multivariate Newton’s method [572], interval arithmetic [591], subdividing polygonal approxi- mation [644], B´ezier clipping [432], and Chebyshev polynomials [180]. To achieve faster performance, the following papers use GPU to directly render parametric surfaces [216, 448, 286, 318].

Although the above numerical iteration techniques hint at a ray tracing ap- proach for shadowing, and while it is definitely the case, the intersection tests can be done as a preprocess to fill up depth information for shadow depth maps as well. Initial guesses can then rely on neighboring shadow depth map pixels.

The numerical robustness to guarantee closest intersection hits with the earlier approaches can be difficult to achieve, resulting in potential holes in the rendered images. However, robustness has been increasing. Further, rendering speed may be slow due to poor convergence rate to evaluate a single point visibility but signif- icantly improved due to GPU-based algorithms. The quest remains high for direct rendering of higher-order surfaces due to the small amount of memory needed and exact intersections achieved, as compared to polygonization of the surfaces, which will be discussed next.

3.2.2

Polygonization

Instead of numerical techniques to deal with the same parametric surfaces and implicit surfaces, polygonization (tessellation of the higher-order surface into a polygonal mesh) is another approach. However, polygonization has its costs, in- cluding the need for larger amounts of memory to deal with the polygonal mesh, the need to approximate a smooth surface with a sufficient number of polygons, and the need to deal with the terminator problem (as described in Section 1.4.1, although this problem can be reduced with finer tessellation).

There is a variant of polygonization that avoids some of the above concerns. In the Renderman implementation [110], fine tessellation (micropolygons) occurs on a per-tile basis, where each tile is a small region of the entire Z-buffer. The tessella- tion is thrown away once that tile has completed rendering. In such a case, neither memory nor terminator problems are of concern. However, this only works for a Z-buffer rendering approach, and care must be taken to account for the differing levels of detail of the tessellation between the Z-buffer render and the shadow depth map render, resulting in improper self-shadows (this is discussed in Section 2.3.2). Example references on polygonization from implicit surfaces [59, 58] and para- metric surfaces [607, 523] are available. Many other geometry types also employ

polygonization for the final rendering and shadowing steps due to some subset of the above reasons, such as Marching Cubes [367] to convert voxel data to poly- gons, and techniques to convert point-cloud data to polygons [594, 552]. Direct shadow rendering algorithms for those other geometry types are discussed in sec- tions starting with Section 3.6.

Note again that if the implementation employs polygonization, then the algo- rithms inChapter 2are more than relevant to the reader, and the graph of Fig- ure 2.33 to determine which algorithms to use applies.

3.2.3

Shadow Volumes

Jansen and van der Zalm [266] use shadow volumes to calculate shadows for CSG objects. Shadow volumes are first calculated for the shadow-generating parts of the silhouette (from the viewpoint of the light source) of each CSG object. A very large shadow CSG tree per object is formed. They consider only the front-facing parts of the CSG object to simplify the complexity of the shadow CSG tree. The shadow trees tend to be quite large and are needed on a per-object and per-light basis.

Heflin and Elber [235] extend the shadow volume approach to support free- form surfaces. Once the silhouette from the viewpoint of the light source is identi- fied, a set of trimmed surfaces are created to represent the shadow polygons of the shadow volume. The shadow count computations intersecting from these trimmed surfaces can be slow.

Tang et al. [580, 579] use the GPU to accelerate silhouette extraction in geom- etry images (Section 3.4) from subdivision surface-based models.

3.2.4

Trends and Analysis

Polygonization remains the more popular technique in industry (offline or real- time). Since it can apply any of the rendering and shadowing algorithms described in this book, the rendering can be fast because the polygonal mesh can be acceler- ated on the GPU, and most importantly, polygonization allows code maintenance to be much simpler since the rendering algorithm essentially only deals with one type of primitive (polygon) and the tessellation components for handling the dif- ferent higher-order surfaces can be self-contained. The latter point is especially key for some software which offers multiple surface types, e.g., Maya supports model- ing of NURBS, subdivision surfaces, and polygons.

However, with direct rendering solutions on the GPU, and the advantages of less memory usage plus avoidance of the terminator problem, direct rendering so- lutions should become more viable. The decreased memory factor makes native support ideal for current tablets, but the GPU capabilities of these devices may not be powerful enough. Further, the exact rendering of surface detail (through direct rendering solutions) is also ideal for certain domains that require such accuracy,

such as CAD or scientific applications/simulations. Also, direct rendering is most efficient when using blobbies to represent particles (such as water), due to the large data set complexity.

Another scenario that is becoming more common is the need to deal with dis- tributed learning scenarios (distributed over the internet), where the 3D files need to be quickly downloaded (via the internet) in order to visualize the content. With certain higher-order surfaces (e.g., NURBS), the geometry representation can be very compact and thus quite suitable for fast network transmission. As a result, being able to render the geometry natively, without the need to wait for the poly- gonization would be a significant advantage, i.e., perceived wait of download plus polygonization may be long and hurt the user experience.