Figure 9 - uploaded by Nigel Stewart
Content may be subject to copyright.
Source publication
We present an improved z-buffer based CSG rendering algorithm, based on previous techniques using z-buffer parity based surface clipping. We show that while this type of algorithm has been re-ported as requiring O(n^2)), (where n is the number of primitives), an O(kn) (where k is depth complexity) algorithm may be substituted. For cases where k is...
Context in source publication
Context 1
... result of this operation depends on the viewing direction, as illustrated in Figure 9. Five spheres are viewed from different directions and the counts in the stencil buffer visualised via different shades. The first scenario where no primitives overlap is ideal for clipping, since all five spheres may be clipped at once. The third scenario is the worst possible case, since all five spheres overlap at least one pixel. For this viewing direction, clipping primitives as a sequence of five layers, rather than five primitives offers no speedup over the standard algorithm. A stencil test may be employed to draw only the ’th layer of a set of primitives. The following OpenGL code fragment increments a count in the stencil buffer for each pixel covered by each prim- itve. The primitive is only drawn to the z-buffer if the stencil count equals the number of the desired layer. It should be noted that the particular surfaces in each layer are determined by the order in which primitives are presented to OpenGL. The first layer will consist of surface from the first primitive, and portions of the second primitive not overlapping the first, and so on. The Goldfeather CSG rendering algorithm implicitly avoids clipping z-buffer surfaces against the corresponding primitive. Clipping on a per-layer basis however, requires a clipping algorithm which will behave in this situation sensibly. Specifically, the front facing surface of an intersecting primitive should be classified as ‘inside’ the primitive. Similarly, the back facing surface of a subtracted primitive should be classified as ‘outside’. Configuring the parity test to utilise the ‘z-less-or-equal’ z-test satisfies these constraints, although they do depend on triangles being rasterised to precisely the same z-buffer values on different passes. The new algorithm is summarised below. Two z-buffers are utilised in a similar manner to the Goldfeather algorithm. The surface z- buffer is used to extract and clip each layer of surfaces in the product. The output z-buffer accumulates the final result, taking the closest pixel from each instance of the surface z-buffer. Like the Goldfeather algorithm, a final pass over all primitives draws the correct colour into the frame buffer, using a ‘z-equal-test’ on the final z-buffer. The Goldfeather algorithm performs one clipping operation per primitive. The time required for each clipping operation is ! #" , where is related to polygon rasterisation speed, and " is related to z-buffer copy speed. The time required to draw the product is: £% " . The modified CSG rendering algorithm requires rendering primitives to extract a layer, rendering primitives to clip the layer, and one z-buffer copy operation per layer. Multiplying this cost by ' the number of layers & , the time required to draw a product is: & ( " & . The important difference between this and the standard algorithm is the behavior of & . The depth complexity of a scene is determined by the viewing direction and the particular configuration of primitives in the product. The usefulness of this approach is therefore limitied to those applications where 01 . For situations where !3 , the performance is expected to be similar to that of the standard algorithm — O( $ ). It should be noted that since layer extraction doubles the polygon rasterisation load, the standard algorithm should be faster when . It is expected that this improvement to the Goldfeather CSG rendering algorithm will be of particular use in the simulation of manu- facturing processes. Our observation is that this application domain has the characteristic that & tends to be significantly less than . A systematic investigation would be required to quantify this relationship. The constants referred to as and " could be also be quantified. These correspond to rasterisation and z-buffer copying performance respectively. Our observation is that z-buffer copy rate is the bottle- neck on platforms we have experimented with. An investigation to quantify these characteristics would be useful in predicting the usefulness of z-buffer CSG algorithms for different problem domains. This would also aid the identification of suitable platforms for hardware implementation of the algorithm. Implementation of the algorithm could include a decision mak- ing policy to choose the best clipping strategy, given and . In certain circumstances, clipping on a primitive basis is optimal, whil 5 in other circumstances, layer clipping would be more effi- cient. We have described an image-space CSG subtraction algorithm which performs better in many useful cases. Modifying the Goldfeather CSG rendering algorithm to exploit depth complexity offers O( 6 7 ) performance rather than O( £8 ). The algorithmic implication of this modification is to increase the cost of the inner loop, while potentially reducing the number of iterations of the outer loop. A significant implication of this result, given current graphics hardware architectures, is the reduced z-buffer copy bandwidth and z-comparison requirement. This is reduced from to . The following people are acknowledged for their suggestions, guid- ance and contributions to this research: Dr. Mike Simakov and the software development team at ANCA Pty. Ltd. This research is supported by the Co-operative Research Center for Intelligent Manufacturing Systems & Technologies, their industry partner ANCA Pty. Ltd., and their academic partner RMIT ...
Similar publications
A modified type of Hybrid ARQ system with erasures correction and parity bits retransmission is considered. Performance of the system is analyzed under assumption that the forward channel suffers from Nakagami common fading and additive white Gaussian noise. A good agreement between theoretical results and simu-lation is achieved. The proposed ARQ...
Differential cross-section measurements are presented for the electroweak production of two jets in association with a Z boson. These measurements are sensitive to the vector-boson fusion production mechanism and provide a fundamental test of the gauge structure of the Standard Model. The analysis is performed using proton–proton collision data col...
Lifetimes of states in the lowest lying positive parity band in 106Cd have been measured using the Doppler shift attenuation method. The deduced B(E2) transition rates show a marked decrease with increasing spin. Cranking and semiclassical model calculations suggest that the structure has the character of a shears-type band resulting from the coupl...
![FIG. 4: Energy staggering [S(I)] between the α = ±1/2 partners of νh...](profile/Saikat-Chakraborty-8/publication/356683201/figure/fig2/AS:1098197942435840@1638842201843/Energy-staggering-SI-between-the-a-1-2-partners-of-nh-11-2-band-in-127-131-Xe_Q320.jpg)
Citations
... Our prototype implementation uses a simple screen-space CSG implementation [11] for previewing; for final export we use CGAL's Nef-polyhedra library [1], which supports accurate Boolean operations. ...
With the current state of video games growing in scale, manual content creation may no longer be feasible in the future. Split grammars are a promising technology for large-scale procedural generation of urban structures, which are very common in video games. Buildings with curved parts, however, can currently only be approximated by static pre-modelled assets, and rules apply only to planar surface parts. We present an extension to split grammar systems that allow the creation of curved architecture through integration of free-form deformations at any level in a grammar. Further split rules can then proceed in two different ways. They can either adapt to these deformations so that repetitions can adjust to more or less space, while maintaining length constraints, or they can split the deformed geometry with straight planes to introduce straight structures on deformed geometry.
... Using graphics hardware to speed up the evaluation of Boolean operations in image space has a long history (ref. [4], [27], [29], [31]–[33], [49], [66], [67], [74]). The purpose of these algorithms is to provide a quick feedback in rendering rather than boundary evaluation, which indeed is our mission. ...
We present a new approach to compute the approximate Boolean operations of two freeform polygonal mesh solids efficiently with the help of Layered Depth Images (LDI). After applying the LDI sampling based membership classification, the most challenging part, a trimmed adaptive contouring algorithm, is developed to reconstruct the mesh surface from the LDI samples near the intersected regions and stitch it to the boundary of the retained surfaces. Our method of approximate Boolean operations holds the advantage of numerical robustness as the approach uses volumetric representation. However, unlike other methods based on volumetric representation, we do not damage the facets in non-intersected regions, thus preserving geometric details much better and speeding up the computation as well. We show that the proposed method can successfully compute the Boolean operations of freeform solids with a massive number of polygons in a few seconds.
... CSG defers evaluation of the boolean expression until the last possible moment, such as the time of ray intersection. A similar effect can be achieved with polygon rasterization and z-buffer clipping, though performance scales badly with expression size [10,11]. Recently, Rossignac et al. used modern graphics processing units to dramatically improve the performance of this approach through the use of B-Lists [12]. ...
This paper presents a new method for evaluating boolean set operations between Binary Space Partition (BSP) trees. Our algorithm has many desirable features, including both numerical robustness and O(n) output sensitive time complexity, while simultaneously admitting a straightforward implementation. To achieve these properties, we present two key algorithmic improvements. The first is a method for eliminating null regions within a BSP tree using linear programming. This replaces previous techniques based on polygon cutting and tree splitting. The second is an improved method for compressing BSP trees based on a similar approach within binary decision diagrams. The performance of the new method is analyzed both theoretically and experimentally. Given the importance of boolean set operations, our algorithms can be directly applied to many problems in graphics, CAD and computational geometry.
... Rappoport and Spitz [12] converted the CSG representation to a Convex Differences Aggregate (CDA) representation and then used the stencil buffer to render at interactive rates. Stewart [15] improved upon Goldfeather's algorithm and then introduced the Sequenced Convex Subtraction (SCS) algorithm [17], and later refined it [18]. Erhart and Tobbler [3], Guha et al. [6], and Kirsch and Dollner [9] implemented optimizations over either the SCS, the Goldfeather or the layered Goldfeather algorithms to better use newer graphics hardware. ...
Existing methods that are able to interactively render complex CSG objects with the aid of GPUs are both image based and severely bandwidth limited. In this paper we present a new approach to this problem whose main advantage is its capability to efficiently scale the dependency on CPU instruction throughput, memory bandwidth and GPU instruction throughput. Here, we render CSG objects composed of convex primitives by combining spatial subdivision of the CSG object and GPU ray-tracing methods: the object is subdivided until it is locally ''simple enough'' to be rendered effectively on the GPU. Our results indicate that our method is able to share the load between the CPU and the GPU more evenly than previous methods, in a way that depends less on memory bandwidth and more on GPU instruction throughput for up to moderately sized CSG models. Even though the same results indicate that the present method is eventually becoming more bus bandwidth and CPU limited with the current state of the art GPUs, especially for extremely complex models, our method presents a solid recipe for escaping this problem in the future by a rescale of the dependency on CPU/memory bandwidth vs. GPU instruction throughput. With this, greater increases in performance are to be expected by adapting our method for newer generation of graphics hardware, as instruction throughput has historically increased at a greater pace than both bus bandwidth and internal GPU bandwidth.
... Choosing second, third or fourth degree surfaces sections enables to produce non polygonal, volumic, exact graphic rendering for display purposes, for instance using real-time ray-tracing rendering [3], stencil buffers [8], or better, Buffers Arithmetic, which is the native rendering system for AF. ...
This article defines principles for a new generation of geometric simulator, able to unify volumic data representation and processing for real time applications in urban simulation. The proposed simulator unifies in particular geometric and graphic pipelines, replacing polygonal surfaces with descriptive polynomials for generalized algebraic surfaces. Such algebraic surfaces are combined with an arithmetical superset of constructive solid geometry system. This approach virtually enables interoperability between CAD/CAM, GIS, AEC, and photogrammetry, through an universal solid 3D data format, designed for high performance computing.
... Image-based VH (IBVH) technique [5] suffices to generate the VH looking from a desired view. Hardware-based acceleration of IBVH was proposed through texture mapping-based visual cone trimming [9] or direct Constructive Solid Geometry (CSG) rendering [6,7,8] to speed up the processing. Applications such as object modeling and 3D digital archiving require a full reconstruction of the object's shape. ...
In this paper, we describe a new method for shape re- construction from a set of silhouette images. We propose a method for traversing the depth layers of the projected viewing cones from all viewpoints based on the principle of the Constructive Solid Geometry (CSG). Taking advan- tage of the modern Graphics Processing Units (GPU), the proposed CSG-like method achieves a fast full reconstruc- tion of VH, rather than rendering a looking of the VH from a virtual viewpoint, in an interactive frame rate. For each viewpoint, the viewing edges are computed separately in a parallel manner. Subsequently, the edges are merged to- gether to generate the final surface-based Visual Hull (VH). The method was tested on several datasets including real data and the results will be presented in this paper.
... Rappoport [10] converts the CSG representation to a CDA representation and then uses the stencil buffer to render at interactive rates. Stewart et al. [13] improved upon Goldfeather's algorithm and then introduced the SCS algorithm [14], an improvement upon [13] and later refined it [15]. Erhart and Tobbler [3], Guha et al. [6] and Kirsch and Dollner [9] implemented optimizations over either the SCS, the Goldfeather or the layered Goldfeather algorithms to better use newer graphics hardware . ...
... Rappoport [10] converts the CSG representation to a CDA representation and then uses the stencil buffer to render at interactive rates. Stewart et al. [13] improved upon Goldfeather's algorithm and then introduced the SCS algorithm [14], an improvement upon [13] and later refined it [15]. Erhart and Tobbler [3], Guha et al. [6] and Kirsch and Dollner [9] implemented optimizations over either the SCS, the Goldfeather or the layered Goldfeather algorithms to better use newer graphics hardware . ...
Current methods that interactively render reasonably complex CSG objects are image based and are severely bandwidth limited. This paper presents a new approach to ray-tracing CSG objects composed of convex primitives that combines spatial subdivision and ray-tracing methods. By performing spatial subdivision on the CSG object until locally it is simple enough to be rendered effectively and efficiently on a GPU, we are able to share the load more evenly between the CPU and the GPU and depend less on bandwidth and more on GPU instruction throughput than current methods, hence obtaining better scalability with newer hardware
... For larger CSG trees and noninteractive modeling B-rep algorithms calculate the resulting polygons for a view-independent representation, but are too slow for real-time calculation. A good overview of the different approaches to CSG is given in [2], which also was the motivation for our work. Image-based methods like the Goldfeather algorithm have the disadvantage that the resulting CSG objects cannot be used inside a complex virtual environment (VE), without adding the whole environment to the CSG tree. ...
... The basic Goldfeather algorithm has O(n²) run-time complexity, where n is the number of primitives in a CSG product. For large CSG products , it is often better to test the visibility of a complete depth layer at once [8] . This leads to a run-time complexity of O(n·k), where k is the depth complexity of the CSG product. ...
We present the design and implementation of a real-time D graphics library for image-based Constructive Solid Geometry (CSG). This major approach of 3D modeling has not been supported by real-time computer graphics until recently. We explain two essential image-based CSG rendering algorithms, and we introduce an API that provides a compact access to their complex functionality and implementation. As an important feature, the CSG library seam- lessly integrates application-defined 3D shapes as primitives of CSG operations to ensure high adaptability and openness. We also outline optimization techniques to improve the performance in the case of complex CSG models. A number of use cases demonstrate potential applications of the library.
... The problems arising when rendering objects created by CSG operations have been intensively studied. For polygonal models, references include, but are not limited to [4, 5, 7, 9, 10, 11]. Recently, there has been significant work on pointsampled objects as a modeling primitive [12] . ...
This paper presents an algorithm for rendering of point-sampled CSG models. The approach works with arbitrary CSG trees of surfel models with arbitrary sampling densities. Edges and corners are rendered by reconstructing the involved surfaces separately. The reconstructed surfaces are clipped at intersections. This way, blurring at any magnification is avoided. As opposed to existing methods, which resample surfaces close to object intersections, the proposed approach preserves the original object representation. Since no resampling is needed, dynamic scenes can be handled very flexible. Complex intersections involving any number of objects can be rendered.
