From 3D Models to 3D Prints: an Overview of the Processing Pipeline <s> Contouring of ray-representations <s> The A-buffer (anti-aliased, area-averaged, accumulation buffer) is a general hidden surface mechanism suited to medium scale virtual memory computers. It resolves visibility among an arbitrary collection of opaque, transparent, and intersecting objects. Using an easy to compute Fourier window (box filter), it increases the effective image resolution many times over the Z-buffer, with a moderate increase in cost. The A-buffer is incorporated into the REYES 3-D rendering system at Lucasfilm and was used successfully in the “Genesis Demo” sequence in Star Trek II. <s> BIB001 </s> From 3D Models to 3D Prints: an Overview of the Processing Pipeline <s> Contouring of ray-representations <s> The real-time shaded display of a solid model being milled by a cutting tool following an NC path is attained by the image-space Boolean subtraction of solid objects. The technique is suitable for implementation in microcode in a raster graphic display processor. Update rates of 10 cutting operations per second are typical. <s> BIB002 </s> From 3D Models to 3D Prints: an Overview of the Processing Pipeline <s> Contouring of ray-representations <s> In this paper we present a set of efficient image based rendering methods capable of rendering multiple frames per second on a PC. The first method warps Sprites with Depth representing smooth surfaces without the gaps found in other techniques. A second method for more general scenes performs warping from an intermediate representation called a Layered Depth Image (LDI). An LDI is a view of the scene from a single input camera view, but with multiple pixels along each line of sight. The size of the representation grows only linearly with the observed depth complexity in the scene. Moreover, because the LDI data are represented in a single image coordinate system, McMillan’s warp ordering algorithm can be successfully adapted. As a result, pixels are drawn in the output image in back-to-front order. No z-buffer is required, so alphacompositing can be done efficiently without depth sorting. This makes splatting an efficient solution to the resampling problem. <s> BIB003 </s> From 3D Models to 3D Prints: an Overview of the Processing Pipeline <s> Contouring of ray-representations <s> The layered depth-normal images (LDNIs) is an implicit representation of solid models that sparsely encodes the shape boundary in three orthogonal directions. We present a LDNI-based geometric modeling method for applications with high accuracy requirements. In our method, we first construct LDNIs models from input polygonal models. The accuracy of the generated LDNIs models can be controlled by setting pixel width during the construction process. Even for very complex geometries and high accuracy requirements, the construction process is fast with the aid of graphics hardware. Based on the LDNIs models, we then perform geometric modeling operations. Two types of operations are presented including regularizing and Boolean operations. The geometric modeling operations are straightforward and easy to be implemented robustly. From the processed LDNIs model, an adaptive sampling method is presented to construct a cell representation that includes both uniform and octree cells. Finally 2-manifold polygonal mesh surfaces are constructed from the cell representation. For high accuracy requirements that are typical in CAD/CAM applications, we present a volume tiling technique and a parallel implementation to accelerate the computation. Our method achieves a good balance between the accuracy and computational resources. We report experimental results on a variety of CAD models. The results demonstrate the effectiveness and efficiency of our approach especially for modeling complex geometries.© 2008 ASME <s> BIB004 </s> From 3D Models to 3D Prints: an Overview of the Processing Pipeline <s> Contouring of ray-representations <s> We present a novel framework which can efficiently evaluate approximate Boolean set operations for B-rep models by highly parallel algorithms. This is achieved by taking axis-aligned surfels of Layered Depth Images (LDI) as a bridge and performing Boolean operations on the structured points. As compared with prior surfel-based approaches, this paper has much improvement. Firstly, we adopt key-data pairs to store LDI more compactly. Secondly, robust depth peeling is investigated to overcome the bottleneck of layer-complexity. Thirdly, an out-of-core tiling technique is presented to overcome the limitation of memory. Real-time feedback is provided by streaming the proposed pipeline on the many-core graphics hardware. <s> BIB005 </s> From 3D Models to 3D Prints: an Overview of the Processing Pipeline <s> Contouring of ray-representations <s> We present a robust and efficient approach to directly slicing implicit solids. Different from prior slicing techniques that reconstruct contours on the slicing plane by tracing the topology of intersected line segments, which is actually not robust, we generate contours through a topology guaranteed contour extraction on binary images sampled from given solids and a subsequent contour simplification algorithm which has the topology preserved and the geometric error controlled. The resultant contours are free of self-intersection, topologically faithful to the given r-regular solids and with shape error bounded; therefore, correct objects can be fabricated from them by rapid prototyping. Moreover, since we do not need to generate the tessellated B-rep of given solids, our approach is memory efficient — only the binary image and the finest contours on one particular slicing plane need to be stored in-core. Our method is general and can be applied to any implicit representations of solids.Copyright © 2011 by ASME <s> BIB006 </s> From 3D Models to 3D Prints: an Overview of the Processing Pipeline <s> Contouring of ray-representations <s> Conservative sampling samples boundary-representation (B-rep) solid models into layered depth images (LDIs). The resulting models have a closed boundary and are guaranteed to bound the input B-rep models on the rays of LDIs. This approach can be fully implemented by shader programs supported by various graphics hardware. Experimental results demonstrate this approach's efficiency; applications of it to evaluating intersecting volumes and computing Minkowski sums show its versatility. <s> BIB007 </s> From 3D Models to 3D Prints: an Overview of the Processing Pipeline <s> Contouring of ray-representations <s> AbstractThe trade-off between accuracy and efficiency is of major concern in rapid prototyping (RP), where STL is the most commonly used format to present a CAD model. A STL model needs to be sliced into layered contours before it is used to build a RP object. The challenge to achieve the accuracy/efficiency trade-off becomes critical when a STL model contains a large number of triangles. Previous work by Zeng et al. [19] proposed an efficient slicing method that speeded up the layer decomposition of the STL model by adopting a one-dimensional LDNI sampling, which is independent of geometric complexity. However, the accuracy of the generated contours is not entirely satisfactory for the model with sharp features, even by adopting a high sampling resolution. Therefore, the objective of this work focuses on achieving accurate layer contours in a more effective manner without scarifying the high efficiency. In this paper, a grid-structured point representation with neighborhood information embedded, Surfel-G... <s> BIB008 </s> From 3D Models to 3D Prints: an Overview of the Processing Pipeline <s> Contouring of ray-representations <s> Purpose – Most layer‐based rapid prototyping systems use polygonal models as input. In addition, the input polygonal models need to be manifold and water‐tight; otherwise the built objects may have defects or the building process may fail in some cases. This paper aims to present a regulation method of an arbitrarily complex polygonal model for rapid prototyping and manufacturing applications.Design/methodology/approach – The method is based on a semi‐implicit representation of a solid model named the layered depth‐normal images (LDNI), which sparsely encodes the shape boundary of a polygonal model in three orthogonal directions. In the method, input polygonal models or parametric equations are first converted into LDNI models. A regulation operator based on the computed LDNI models is presented. A volume tiling technique is developed for very complex geometries and high accuracy requirements. From the processed LDNI model, an adaptive contouring method is presented to construct a cell representation that... <s> BIB009 </s> From 3D Models to 3D Prints: an Overview of the Processing Pipeline <s> Contouring of ray-representations <s> In this chapter we introduce and compare four different techniques to build andrender from an A-buffer in real-time. One of these techniques, called PostLinin this chapter, is well known and has been discussed in details in recentworks.The other techniques are, to the best of our knowledge, novel in the contextof A-buffer rendering. We focus on scenes with moderate or sparse depth complexity;the techniques presented here will not scale well on extreme transparencyscenarios. In exchange their implementation is simple and they integratedirectly in the graphics API; a compute API is not necessary. All ourtechniques build the A-buffer in a single geometry pass: the scene geometry israsterized once per frame. <s> BIB010
Ray-reps are techniques were the geometry is captured by solid/empty intervals along a set of rays. This technique was pioneered by Hook BIB002 who proposed the dexel-buffer. This data-structure is built by intersecting axis-aligned rays along one direction with the geometry. Given a closed geometry, the number of intersections is even and each interval can be classified as inside (solid) or outside (empty). The dexel-buffer is closely related to the A-buffer BIB001 . There are therefore interesting similarities between ray-reps and A-buffer techniques for order independent transparency  . For instance, dexel-buffers can be constructed by rasterization, recording all fragments drawn in every pixel BIB010 . Other efficient approaches are based on Layered depth images (LDI) BIB003 , which capture the geometry as a set of depth images each storing a surface sheet in space (a depth peel). This data structure has been extended to solid modelling for additive manufacturing by Chen et al. BIB004 BIB004 , adding normal information along with depth information (layer depth normal images, or LDNI). Fast construction methods have been proposed, e.g. using single pass voxelization BIB007 and compaction for increase memory efficiency BIB005 . Most ray-reps used multiple directions to better reproduce geometries  . Once obtained, ray-reps may be directly rendered BIB002 WLC10,  or converted into meshes through efficient procedures [ZL09, WLC10, Wan11]. However, they may also be directly contoured to extract slices. Different strategies have been used: single set of rays from the object side [ZY01,ZLQ * 11], rays from two sides BIB008 , and rays from the object bottom  . Contouring is then performed by marching along the rays, forming polygonal loops   . A key issue when using ray-reps for contouring is to decide upon the resolution required to properly capture the geometry and its topology BIB006 (see Figure 12) . The contours extracted from ray-reps have typically many small segments -each slice is an image and contours are extracted as the outline of the solid pixels. Huang et al. BIB006 describe a topology preserving contour simplification, and a full image based pipeline for additive manufacturing  . Another difficulty is the large memory requirements, which is roughly proportional to the surface area. To avoid saturating memory, tiling schemes may be used BIB009 . Ray-reps have other significant advantages for additive manufacturing, for instance to perform CSG between complex geometries [BM97, WLC10, Lef13], for regulating solids having selfintersections BIB009 or for computing offset surface for hollowing parts (detailed in Section 3.3.2.1).