An exact general remeshing scheme applied to physically conservative voxelization

We present an exact general remeshing scheme to compute analytic integrals of polynomial functions over the intersections between convex polyhedral cells of old and new meshes. In physics applications this allows one to ensure global mass, momentum, and energy conservation while applying higher-order polynomial interpolation. We elaborate on applications of our algorithm arising in the analysis of cosmological N-body data, computer graphics, and continuum mechanics problems. We focus on the particular case of remeshing tetrahedral cells onto a Cartesian grid such that the volume integral of the polynomial density function given on the input mesh is guaranteed to equal the corresponding integral over the output mesh. We refer to this as "physically conservative voxelization". At the core of our method is an algorithm for intersecting two convex polyhedra by successively clipping one against the faces of the other. This algorithm is an implementation of the ideas presented abstractly by Sugihara (1994), who suggests using the planar graph representations of convex polyhedra to ensure topological consistency of the output. This makes our implementation robust to geometric degeneracy in the input. We employ a simplicial decomposition to calculate moment integrals up to quadratic order over the resulting intersection domain. We also address practical issues arising in a software implementation, including numerical stability in geometric calculations, management of cancellation errors, and extension to two dimensions. In a comparison to recent work, we show substantial performance gains. We provide a C implementation intended to be a fast, accurate, and robust tool for geometric calculations on polyhedral mesh elements.Comment: Code implementation available at https://github.com/devonmpowell/r3

OpenFab: A programmable pipeline for multimaterial fabrication

Figure 1: Three rhinos, defined and printed using OpenFab. For each print, the same geometry was paired with a different fablet—a shaderlike program which procedurally defines surface detail and material composition throughout the object volume. This produces three unique prints by using displacements, texture mapping, and continuous volumetric material variation as a function of distance from the surface. 3D printing hardware is rapidly scaling up to output continuous mixtures of multiple materials at increasing resolution over ever larger print volumes. This poses an enormous computational challenge: large high-resolution prints comprise trillions of voxels and petabytes of data and simply modeling and describing the input with spatially varying material mixtures at this scale is challenging. Existing 3D printing software is insufficient; in particular, most software is designed to support only a few million primitives, with discrete material choices per object. We present OpenFab, a programmable pipeline for synthesis of multi-material 3D printed objects that is inspired by RenderMan and modern GPU pipelines. The pipeline supports procedural evaluation of geometric detail and material composition, using shader-like fablets, allowing models to be specified easily and efficiently. We describe a streaming architecture for OpenFab; only a small fraction of the final volume is stored in memory and output is fed to the printer with little startup delay. We demonstrate it on a variety of multi-material objects

Subdivision Surface based One-Piece Representation

Subdivision surfaces are capable of modeling and representing complex shapes of arbi-trary topology. However, methods on how to build the control mesh of a complex surfaceare not studied much. Currently, most meshes of complicated objects come from trian-gulation and simplification of raster scanned data points, like the Stanford 3D ScanningRepository. This approach is costly and leads to very dense meshes.Subdivision surface based one-piece representation means to represent the final objectin a design process with only one subdivision surface, no matter how complicated theobject\u27s topology or shape. Hence the number of parts in the final representation isalways one.In this dissertation we present necessary mathematical theories and geometric algo-rithms to support subdivision surface based one-piece representation. First, an explicitparametrization method is presented for exact evaluation of Catmull-Clark subdivisionsurfaces. Based on it, two approaches are proposed for constructing the one-piece rep-resentation of a given object with arbitrary topology. One approach is to construct theone-piece representation by using the interpolation technique. Interpolation is a naturalway to build models, but the fairness of the interpolating surface is a big concern inprevious methods. With similarity based interpolation technique, we can obtain bet-ter modeling results with less undesired artifacts and undulations. Another approachis through performing Boolean operations. Up to this point, accurate Boolean oper-ations over subdivision surfaces are not approached yet in the literature. We presenta robust and error controllable Boolean operation method which results in a one-piecerepresentation. Because one-piece representations resulting from the above two methodsare usually dense, error controllable simplification of one-piece representations is needed.Two methods are presented for this purpose: adaptive tessellation and multiresolutionanalysis. Both methods can significantly reduce the complexity of a one-piece represen-tation and while having accurate error estimation.A system that performs subdivision surface based one-piece representation was im-plemented and a lot of examples have been tested. All the examples show that our ap-proaches can obtain very good subdivision based one-piece representation results. Eventhough our methods are based on Catmull-Clark subdivision scheme, we believe they canbe adapted to other subdivision schemes as well with small modifications

Sparse Volumetric Deformation

Volume rendering is becoming increasingly popular as applications require realistic solid shape representations with seamless texture mapping and accurate filtering. However rendering sparse volumetric data is difficult because of the limited memory and processing capabilities of current hardware. To address these limitations, the volumetric information can be stored at progressive resolutions in the hierarchical branches of a tree structure, and sampled according to the region of interest. This means that only a partial region of the full dataset is processed, and therefore massive volumetric scenes can be rendered efficiently. The problem with this approach is that it currently only supports static scenes. This is because it is difficult to accurately deform massive amounts of volume elements and reconstruct the scene hierarchy in real-time. Another problem is that deformation operations distort the shape where more than one volume element tries to occupy the same location, and similarly gaps occur where deformation stretches the elements further than one discrete location. It is also challenging to efficiently support sophisticated deformations at hierarchical resolutions, such as character skinning or physically based animation. These types of deformation are expensive and require a control structure (for example a cage or skeleton) that maps to a set of features to accelerate the deformation process. The problems with this technique are that the varying volume hierarchy reflects different feature sizes, and manipulating the features at the original resolution is too expensive; therefore the control structure must also hierarchically capture features according to the varying volumetric resolution. This thesis investigates the area of deforming and rendering massive amounts of dynamic volumetric content. The proposed approach efficiently deforms hierarchical volume elements without introducing artifacts and supports both ray casting and rasterization renderers. This enables light transport to be modeled both accurately and efficiently with applications in the fields of real-time rendering and computer animation. Sophisticated volumetric deformation, including character animation, is also supported in real-time. This is achieved by automatically generating a control skeleton which is mapped to the varying feature resolution of the volume hierarchy. The output deformations are demonstrated in massive dynamic volumetric scenes

Tessellated Voxelization for Global Illumination using Voxel Cone Tracing

Modeling believable lighting is a crucial component of computer graphics applications, including games and modeling programs. Physically accurate lighting is complex and is not currently feasible to compute in real-time situations. Therefore, much research is focused on investigating efficient ways to approximate light behavior within these real-time constraints. In this thesis, we implement a general purpose algorithm for real-time applications to approximate indirect lighting. Based on voxel cone tracing, we use a filtered representation of a scene to efficiently sample ambient light at each point in the scene. We present an approach to scene voxelization using hardware tessellation and compare it with an approach utilizing hardware rasterization. We also investigate possible methods of warped voxelization. Our contributions include a complete and open-source implementation of voxel cone tracing along with both voxelization algorithms. We find similar performance and quality with both voxelization algorithms