Results 1  10
of
39
Gigavoxels: rayguided streaming for efficient and detailed voxel rendering
 In Proc. I3D ’09
, 2009
"... Figure 1: Images show volume data that consist of billions of voxels rendered with our dynamic sparse octree approach. Our algorithm achieves realtime to interactive rates on volumes exceeding the GPU memory capacities by far, tanks to an efficient streaming based on a raycasting solution. Basical ..."
Abstract

Cited by 27 (2 self)
 Add to MetaCart
Figure 1: Images show volume data that consist of billions of voxels rendered with our dynamic sparse octree approach. Our algorithm achieves realtime to interactive rates on volumes exceeding the GPU memory capacities by far, tanks to an efficient streaming based on a raycasting solution. Basically, the volume is only used at the resolution that is needed to produce the final image. Besides the gain in memory and speed, our rendering is inherently antialiased. We propose a new approach to efficiently render large volumetric data sets. The system achieves interactive to realtime rendering performance for several billion voxels. Our solution is based on an adaptive data representation depending on the current view and occlusion information, coupled to an efficient raycasting rendering algorithm. One key element of our method is to guide data production and streaming directly based on information extracted during rendering. Our data structure exploits the fact that in CG scenes, details are often concentrated on the interface between free space and clusters of density and shows that volumetric models might become a valuable alternative as a rendering primitive for realtime applications. In this spirit, we allow a quality/performance tradeoff and exploit temporal coherence. We also introduce a mipmappinglike process that allows for an increased display rate and better quality through high quality filtering. To further enrich the data set, we create additional details through a variety of procedural methods. We demonstrate our approach in several scenarios, like the exploration of a 3D scan (8192 3 resolution), of hypertextured meshes (16384 3 virtual resolution), or of a fractal (theoretically infinite resolution). All examples are rendered on current generation hardware at 2090 fps and respect the limited GPU memory budget. This is the author’s version of the paper. The ultimate version has been published in the I3D 2009 conference proceedings. 1
Realtime parallel hashing on the gpu
 In ACM SIGGRAPH Asia 2009 papers, SIGGRAPH ’09
, 2009
"... Figure 1: Overview of our construction for a voxelized Lucy model, colored by mapping x, y, and z coordinates to red, green, and blue respectively (far left). The 3.5 million voxels (left) are input as 32bit keys and placed into buckets of ≤ 512 items, averaging 409 each (center). Each bucket then ..."
Abstract

Cited by 16 (4 self)
 Add to MetaCart
Figure 1: Overview of our construction for a voxelized Lucy model, colored by mapping x, y, and z coordinates to red, green, and blue respectively (far left). The 3.5 million voxels (left) are input as 32bit keys and placed into buckets of ≤ 512 items, averaging 409 each (center). Each bucket then builds a cuckoo hash with three subtables and stores them in a larger structure with 5 million entries (right). Closeups follow the progress of a single bucket, showing the keys allocated to it (center; the bucket is linear and wraps around left to right) and each of its completed cuckoo subtables (right). Finding any key requires checking only three possible locations. We demonstrate an efficient dataparallel algorithm for building large hash tables of millions of elements in realtime. We consider two parallel algorithms for the construction: a classical sparse perfect hashing approach, and cuckoo hashing, which packs elements densely by allowing an element to be stored in one of multiple possible locations. Our construction is a hybrid approach that uses both algorithms. We measure the construction time, access time, and memory usage of our implementations and demonstrate realtime performance on large datasets: for 5 million keyvalue pairs, we construct a hash table in 35.7 ms using 1.42 times as much memory as the input data itself, and we can access all the elements in that hash table in 15.3 ms. For comparison, sorting the same data requires 36.6 ms, but accessing all the elements via binary search requires 79.5 ms. Furthermore, we show how our hashing methods can be applied to two graphics applications: 3D surface intersection for moving data and geometric hashing for image matching.
External perfect hashing for very large key sets
 In Proceedings of the 16th ACM Conference on Information and Knowledge Management (CIKM’07
, 2007
"... A perfect hash function (PHF) h: S → [0, m − 1] for a key set S ⊆ U of size n, where m ≥ n and U is a key universe, is an injective function that maps the keys of S to unique values. A minimal perfect hash function (MPHF) is a PHF with m = n, the smallest possible range. Minimal perfect hash functio ..."
Abstract

Cited by 14 (2 self)
 Add to MetaCart
A perfect hash function (PHF) h: S → [0, m − 1] for a key set S ⊆ U of size n, where m ≥ n and U is a key universe, is an injective function that maps the keys of S to unique values. A minimal perfect hash function (MPHF) is a PHF with m = n, the smallest possible range. Minimal perfect hash functions are widely used for memory efficient storage and fast retrieval of items from static sets. In this paper we present a distributed and parallel version of a simple, highly scalable and nearspace optimal perfect hashing algorithm for very large key sets, recently presented in [4]. The sequential implementation of the algorithm constructs a MPHF for a set of 1.024 billion URLs of average length 64 bytes collected from the Web in approximately 50 minutes using a commodity PC. The parallel implementation proposed here presents the following performance using 14 commodity PCs: (i) it constructs a MPHF for the same set of 1.024 billion URLs in approximately 4 minutes; (ii) it constructs a MPHF for a set of 14.336 billion 16byte random integers in approximately 50 minutes with a performance degradation of 20%; (iii) one version of the parallel algorithm distributes the description of the MPHF among the participating machines and its evaluation is done in a distributed way, faster than the centralized function.
Simple and spaceefficient minimal perfect hash functions
 In Proc. of the 10th Intl. Workshop on Data Structures and Algorithms
, 2007
"... Abstract. A perfect hash function (PHF) h: U → [0, m − 1] for a key set S is a function that maps the keys of S to unique values. The minimum amount of space to represent a PHF for a given set S is known to be approximately 1.44n 2 /m bits, where n = S. In this paper we present new algorithms for ..."
Abstract

Cited by 14 (7 self)
 Add to MetaCart
Abstract. A perfect hash function (PHF) h: U → [0, m − 1] for a key set S is a function that maps the keys of S to unique values. The minimum amount of space to represent a PHF for a given set S is known to be approximately 1.44n 2 /m bits, where n = S. In this paper we present new algorithms for construction and evaluation of PHFs of a given set (for m = n and m = 1.23n), with the following properties: 1. Evaluation of a PHF requires constant time. 2. The algorithms are simple to describe and implement, and run in linear time. 3. The amount of space needed to represent the PHFs is around a factor 2 from the information theoretical minimum. No previously known algorithm has these properties. To our knowledge, any algorithm in the literature with the third property either: – Requires exponential time for construction and evaluation, or – Uses nearoptimal space only asymptotically, for extremely large n.
Realtime smoke rendering using compensated ray marching
 ACM Trans. Graph
"... We present a realtime algorithm called compensated ray marching for rendering of smoke under dynamic lowfrequency environment lighting. Our approach is based on a decomposition of the input smoke animation, represented as a sequence of volumetric density fields, into a set of radial basis function ..."
Abstract

Cited by 13 (2 self)
 Add to MetaCart
We present a realtime algorithm called compensated ray marching for rendering of smoke under dynamic lowfrequency environment lighting. Our approach is based on a decomposition of the input smoke animation, represented as a sequence of volumetric density fields, into a set of radial basis functions (RBFs) and a sequence of residual fields. From this lowfrequency RBF approximation of density fields, an efficient technique is proposed for computing source radiance distributions throughout the volume. Source radiances from single and multiple scattering are directly computed at only the RBF centers and then approximated at other points in the volume using an RBFbased interpolation. With the computed source radiances, a slicebased integration of radiance along each viewing ray is performed to render the final image. During this ray marching process, the residual fields are compensated back into the radiance integral to generate images of high detail. The runtime algorithm, which includes both light transfer simulation and ray marching, can be easily implemented on the GPU, and thus allows for realtime manipulation of viewpoint and lighting, as well as interactive editing of smoke attributes such as extinction cross section, scattering albedo, and phase function. With only moderate preprocessing time and storage, this technique generates rendering results that are comparable to those from offline rendering algorithms like ray tracing.
C.: Precise vector textures for realtime 3d rendering
 In SI3D ’08: Proc. of the 2008 symposium on Interactive 3D graphics and games (2008), ACM
"... Figure 1: A scene using several vector textures with some closeups showing embossing and transparency. Vector graphics representations of images are resolution independent. Direct use of vector images for realtime texture mapping would be desirable to avoid sampling artifacts such as blurring commo ..."
Abstract

Cited by 11 (0 self)
 Add to MetaCart
Figure 1: A scene using several vector textures with some closeups showing embossing and transparency. Vector graphics representations of images are resolution independent. Direct use of vector images for realtime texture mapping would be desirable to avoid sampling artifacts such as blurring common with raster images. Scalable Vector Graphics (SVG) files are typical of vector graphics image representations. Such representations composite images from layers of paths and strokes defined with lines, elliptical arcs, and quadratic and cubic parametric splines. Highquality texture mapping requires both random access and anisotropic antialiasing. For vector images, these goals can be achieved by computing the distance to the closest primitives from a sample point and then mapping this distance through a soft threshold function. Representing transparency masks in this way is especially useful, since vector mattes can be used to render complex curvilinear geometry as textures on simple geometric primitives. Unfortunately, computing the exact minimum distance to the parametric curves used in vector images is difficult. Previous work has used approximations, but an accurate minimum distance is desirable in order to enable wide strokes and special effects such as embossing. In this paper, a simple algorithm is presented that can efficiently and accurately compute the minimum distance to a parametric curve when the sample point is within its radius of curvature and the curve can be segmented into monotonic regions. This technique can be used in a GPU shader to render antialiased vector images exactly as defined by SVG files.
QueryDriven Visualization of TimeVarying Adaptive Mesh Refinement Data
"... Abstract—The visualization and analysis of AMRbased simulations is integral to the process of obtaining new insight in scientific research. We present a new method for performing querydriven visualization and analysis on AMR data, with specific emphasis on timevarying AMR data. Our work introduce ..."
Abstract

Cited by 9 (2 self)
 Add to MetaCart
Abstract—The visualization and analysis of AMRbased simulations is integral to the process of obtaining new insight in scientific research. We present a new method for performing querydriven visualization and analysis on AMR data, with specific emphasis on timevarying AMR data. Our work introduces a new method that directly addresses the dynamic spatial and temporal properties of AMR grids that challenge many existing visualization techniques. Further, we present the first implementation of querydriven visualization on the GPU that uses a GPUbased indexing structure to both answer queries and efficiently utilize GPU memory. We apply our method to two different science domains to demonstrate its broad applicability. Index Terms—AMR, QueryDriven Visualization, Multitemporal Visualization 1
Mesh Colors
"... Figure 1: A head model textured using mesh colors. The image in the middle shows color samples on the low resolution mesh and the image on the right shows the result after final filtering operations. (Modelled and painted by Murat Afsar) The coloring of three dimensional models using two or three di ..."
Abstract

Cited by 8 (0 self)
 Add to MetaCart
Figure 1: A head model textured using mesh colors. The image in the middle shows color samples on the low resolution mesh and the image on the right shows the result after final filtering operations. (Modelled and painted by Murat Afsar) The coloring of three dimensional models using two or three dimensional texture mapping has well known intrinsic problems, such as mapping discontinuities and limitations to model editing after coloring. Workarounds for these problems often require adopting very complex approaches. Here we propose a new technique, called mesh colors, for associating color data directly with a polygonal mesh. The approach eliminates all problems deriving from using a map from texture space to model space. Mesh colors is an extension of vertex colors where, in addition to keeping color values on each vertex, color values are also kept on edges and faces. Like texture mapping, the approach allows higher texture resolution than model resolution, but at the same time it guarantees onetoone correspondence between the model surface and the color data, and eliminates discontinuities. We show that mesh colors integrate well with the current graphics pipeline and can be used to generate very high quality textures.
Realtime Reduced LargeDeformation Models and Distributed Contact for Computer Graphics and Haptics
, 2007
"... not be interpreted as representing the official policies, either expressed or implied, of any sponsoring institution, the U.S. government or any other entity. Keywords: realtime, deformations, model reduction, finite element method, subspace integration, ..."
Abstract

Cited by 5 (1 self)
 Add to MetaCart
not be interpreted as representing the official policies, either expressed or implied, of any sponsoring institution, the U.S. government or any other entity. Keywords: realtime, deformations, model reduction, finite element method, subspace integration,
Supercubes: A highlevel primitive for diamond hierarchies
 IEEE TRANSACTIONS ON VISUALIZATION AND COMPUTER GRAPHICS
, 2009
"... Volumetric datasets are often modeled using a multiresolution approach based on a nested decomposition of the domain into a polyhedral mesh. Nested tetrahedral meshes generated through the longest edge bisection rule are commonly used to decompose regular volumetric datasets since they produce highl ..."
Abstract

Cited by 5 (5 self)
 Add to MetaCart
Volumetric datasets are often modeled using a multiresolution approach based on a nested decomposition of the domain into a polyhedral mesh. Nested tetrahedral meshes generated through the longest edge bisection rule are commonly used to decompose regular volumetric datasets since they produce highly adaptive crackfree representations. Efficient representations for such models have been achieved by clustering the set of tetrahedra sharing a common longest edge into a structure called a diamond. The alignment and orientation of the longest edge can be used to implicitly determine the geometry of a diamond and its relations to the other diamonds within the hierarchy. We introduce the supercube as a highlevel primitive within such meshes that encompasses all unique types of diamonds. A supercube is a coherent set of edges corresponding to three consecutive levels of subdivision. Diamonds are uniquely characterized by the longest edge of the tetrahedra forming them and are clustered in supercubes through the association of the longest edge of a diamond with a unique edge in a supercube. Supercubes are thus a compact and highly efficient means of associating information with a subset of the vertices, edges and tetrahedra of the meshes generated through longest edge bisection. We demonstrate the effectiveness of the supercube representation when encoding multiresolution diamond hierarchies built on a subset of the points of a regular grid. We also show how supercubes can be used to efficiently extract meshes from diamond hierarchies and to reduce the storage requirements of such variableresolution meshes.