Acceleration Digital Image Synthesis YungYu Chuang 10112007 with
- Slides: 108
Acceleration Digital Image Synthesis Yung-Yu Chuang 10/11/2007 with slides by Mario Costa Sousa, Gordon Stoll and Pat Hanrahan
Classes • Primitive (in core/primitive. *) – Geometric. Primitive – Instance. Primitive – Aggregate • Two types of accelerators are provided (in accelerators/*. cpp) – Grid. Accel – Kd. Tree. Accel
Hierarchy Primitive Geometric Primitive Instance Primitive T Material Shape Aggregate
Primitive class Primitive : public Reference. Counted { <Primitive interface> } class Instance. Primitive : public Primitive { … Reference<Primitive> instance; }
Interface BBox World. Bound(); geometry bool Can. Intersect(); // update maxt bool Intersect(const Ray &r, Intersection *in); bool Intersect. P(const Ray &r); void Refine(vector<Reference<Primitive>> &refined); void Fully. Refine(vector<Reference<Primitive>> &refined); Area. Light *Get. Area. Light(); material BSDF *Get. BSDF(const Differential. Geometry &dg, const Transform &World. To. Object);
Intersection • primitive stores the actual intersecting primitive, hence Primitive->Get. Area. Light and Get. BSDF can only be called for Geometric. Primitive More information than Differential. Geometry; also contains material information struct Intersection { <Intersection interface> Differential. Geometry dg; const Primitive *primitive; Transform World. To. Object; };
Geometric. Primitive • represents a single shape • holds a reference to a Shape and its Material, and a pointer to an Area. Light Reference<Shape> shape; Reference<Material> material; // BRDF Area. Light *area. Light; // emittance • Most operations are forwarded to shape
Object instancing 61 unique plant models, 1. 1 M triangles, 300 MB 4000 individual plants, 19. 5 M triangles
Instance. Primitive Reference<Primitive> instance; Transform Instance. To. World, World. To. Instance; Ray ray = World. To. Instance(r); if (!instance->Intersect(ray, isect)) return false; r. maxt = ray. maxt; isect->World. To. Object = isect->World. To. Object *World. To. Instance;
Aggregates • Acceleration is a heart component of a ray tracer because ray/scene intersection accounts for the majority of execution time • Goal: reduce the number of ray/primitive intersections by quick simultaneous rejection of groups of primitives and the fact that nearby intersections are likely to be found first • Two main approaches: spatial subdivision, object subdivision • No clear winner
Acceleration techniques
Bounding volume hierarchy
Bounding volume hierarchy 1) Find bounding box of objects
Bounding volume hierarchy 1) Find bounding box of objects 2) Split objects into two groups
Bounding volume hierarchy 1) Find bounding box of objects 2) Split objects into two groups 3) Recurse
Bounding volume hierarchy 1) Find bounding box of objects 2) Split objects into two groups 3) Recurse
Bounding volume hierarchy 1) Find bounding box of objects 2) Split objects into two groups 3) Recurse
Bounding volume hierarchy 1) Find bounding box of objects 2) Split objects into two groups 3) Recurse
Where to split? • At midpoint • Sort, and put half of the objects on each side • Use modeling hierarchy
BVH traversal • If hit parent, then check all children
BVH traversal • Don't return intersection immediately because the other subvolumes may have a closer intersection
Bounding volume hierarchy
Bounding volume hierarchy
Space subdivision approaches Unifrom grid Quadtree (2 D) Octree (3 D)
Space subdivision approaches KD tree BSP tree
Uniform grid
Uniform grid Preprocess scene 1. Find bounding box
Uniform grid Preprocess scene 1. Find bounding box 2. Determine grid resolution
Uniform grid Preprocess scene 1. Find bounding box 2. Determine grid resolution 3. Place object in cell if its bounding box overlaps the cell
Uniform grid Preprocess scene 1. Find bounding box 2. Determine grid resolution 3. Place object in cell if its bounding box overlaps the cell 4. Check that object overlaps cell (expensive!)
Uniform grid traversal Preprocess scene Traverse grid 3 D line = 3 D-DDA
octree Octree
K-d tree A A Leaf nodes correspond to unique regions in space
K-d tree A B A Leaf nodes correspond to unique regions in space
K-d tree A B B A Leaf nodes correspond to unique regions in space
K-d tree A C B B A
K-d tree A C B A
K-d tree A C D B C B A
K-d tree A C D B C B D A
K-d tree A D B B C C D A Leaf nodes correspond to unique regions in space
K-d tree traversal A D B B C C D A Leaf nodes correspond to unique regions in space
BSP tree 6 5 9 7 10 8 1 11 2 4 3
BSP tree 6 5 1 inside ones 9 7 10 8 1 11 2 4 3 outside ones
BSP tree 6 5 1 9 7 10 8 1 11 2 4 3 2 3 4 5 6 7 8 9 10 11
BSP tree 6 1 5 9 b 9 7 10 1 11 b 9 a 11 a 2 4 3 5 11 8 6 7 9 a 10 11 a 8 9 b 11 b
BSP tree 6 5 1 9 b 9 7 10 1 11 b 9 a 11 a 2 5 2 8 11 3 4 4 10 11 a 9 b 7 9 a 3 8 6 11 b
BSP tree traversal 6 5 1 9 7 10 1 11 b 9 a 9 a 11 a 2 9 b 8 11 3 4 4 3 5 2 10 11 a 9 b 7 9 a point 8 6 11 b
BSP tree traversal 6 5 1 9 7 10 1 11 b 9 a 9 a 11 a 2 9 b 8 11 3 4 4 3 5 2 10 11 a 9 b 7 9 a point 8 6 11 b
BSP tree traversal 6 5 1 9 7 10 1 11 b 9 a 9 a 11 a 2 9 b 8 11 3 4 4 3 5 2 10 11 a 9 b 7 9 a point 8 6 11 b
Ray-Box intersections • Both Grid. Accel and Kd. Tree. Accel require it • Quick rejection, use enter and exit point to traverse the hierarchy • AABB is the intersection of three slabs
Ray-Box intersections 1 Dx x=x 0 x=x 1
Ray-Box intersections bool BBox: : Intersect. P(const Ray &ray, float *hitt 0, float *hitt 1) { float t 0 = ray. mint, t 1 = ray. maxt; for (int i = 0; i < 3; ++i) { float inv. Ray. Dir = 1. f / ray. d[i]; float t. Near = (p. Min[i] - ray. o[i]) * inv. Ray. Dir; float t. Far = (p. Max[i] - ray. o[i]) * inv. Ray. Dir; if t 0 t 1 if (t. Near > t. Far) swap(t. Near, t. Far); = t. Near > t 0 ? t. Near : t 0; segment intersection = t. Far < t 1 ? t. Far : t 1; (t 0 > t 1) return false; intersection is empty } if (hitt 0) *hitt 0 = t 0; if (hitt 1) *hitt 1 = t 1; return true; }
Grid accelerator • Uniform grid
Teapot in a stadium problem • Not adaptive to distribution of primitives. • Have to determine the number of voxels. (problem with too many or too few)
Grid. Accel Class Grid. Accel: public Aggregate { <Grid. Accel methods> u_int n. Mailboxes; Mailbox. Prim *mailboxes; int NVoxels[3]; BBox bounds; Vector Width, Inv. Width; Voxel **voxels; Object. Arena<Voxel> voxel. Arena; static int cur. Mailbox. Id; }
mailbox struct Mailbox. Prim { Reference<Primitive> primitive; Int last. Mailbox. Id; }
Grid. Accel(vector<Reference<Primitive> > &p, bool for. Refined, bool refine. Immediately) : grid. For. Refined(for. Refined) { // Initialize with primitives for grid vector<Reference<Primitive> > prims; if (refine. Immediately) for (u_int i = 0; i < p. size(); ++i) p[i]->Fully. Refine(prims); else prims = p;
Grid. Accel // Initialize mailboxes for grid n. Mailboxes = prims. size(); mailboxes = (Mailbox. Prim*)Alloc. Aligned( n. Mailboxes * sizeof(Mailbox. Prim)); for (u_int i = 0; i < n. Mailboxes; ++i) new (&mailboxes[i]) Mailbox. Prim(prims[i]);
Determine number of voxels • Too many voxels → slow traverse, large memory consumption (bad cache performance) • Too few voxels → too many primitives in a voxel • Let the axis with the largest extent have partitions Vector delta = bounds. p. Max - bounds. p. Min; int max. Axis=bounds. Maximum. Extent(); float inv. Max. Width=1. f/delta[max. Axis]; float cube. Root=3. f*powf(float(prims. size()), 1. f/3. f); float voxels. Per. Unit. Dist=cube. Root * inv. Max. Width;
Calculate voxel size and allocate voxels for (int axis=0; axis<3; ++axis) { NVoxels[axis]=Round 2 Int(delta[axis]*voxels. Per. Unit. Dist); NVoxels[axis]=Clamp(NVoxels[axis], 1, 64); } for (int axis=0; axis<3; ++axis) { Width[axis]=delta[axis]/NVoxels[axis]; Inv. Width[axis]= (Width[axis]==0. f)? 0. f: 1. f/Width[axis]; } int n. Voxels = NVoxels[0] * NVoxels[1] * NVoxels[2]; voxels=(Voxel **)Alloc. Aligned(n. Voxels*sizeof(Voxel *)); memset(voxels, 0, n. Voxels * sizeof(Voxel *));
Conversion between voxel and position int Pos. To. Voxel(const Point &P, int axis) { int v=Float 2 Int( (P[axis]-bounds. p. Min[axis])*Inv. Width[axis]); return Clamp(v, 0, NVoxels[axis]-1); } float Voxel. To. Pos(int p, int axis) const { return bounds. p. Min[axis]+p*Width[axis]; } Point Voxel. To. Pos(int x, int y, int z) const { return bounds. p. Min+ Vector(x*Width[0], y*Width[1], z*Width[2]); } inline int Offset(int x, int y, int z) { return z*NVoxels[0]*NVoxels[1] + y*NVoxels[0] + x; }
Add primitives into voxels for (u_int i=0; i<prims. size(); ++i) { <Find voxel extent of primitive> <Add primitive to overlapping voxels> }
<Find voxel extent of primitive> BBox pb = prims[i]->World. Bound(); int vmin[3], vmax[3]; for (int axis = 0; axis < 3; ++axis) { vmin[axis] = Pos. To. Voxel(pb. p. Min, axis); vmax[axis] = Pos. To. Voxel(pb. p. Max, axis); }
<Add primitive to overlapping voxels> for (int z = vmin[2]; z <= vmax[2]; ++z) for (int y = vmin[1]; y <= vmax[1]; ++y) for (int x = vmin[0]; x <= vmax[0]; ++x) { int offset = Offset(x, y, z); if (!voxels[offset]) { voxels[offset] = new (voxel. Arena)Voxel(&mailboxes[i]); } else { // Add primitive to already-allocated voxels[offset]->Add. Primitive(&mailboxes[i]); } }
Voxel structure struct Voxel { <Voxel methods> union { Mailbox. Prim *one. Primitive; Mailbox. Prim **primitives; }; u_int all. Can. Intersect: 1; u_int n. Primitives: 31; } Packed into 64 bits
Add. Primitive void Add. Primitive(Mailbox. Prim *prim) { if (n. Primitives == 1) { Mailbox. Prim **p = new Mailbox. Prim *[2]; p[0] = one. Primitive; primitives = p; } else if (Is. Power. Of 2(n. Primitives)) { int n. Alloc = 2 * n. Primitives; Mailbox. Prim **p = new Mailbox. Prim *[n. Alloc]; for (u_int i = 0; i < n. Primitives; ++i) p[i] = primitives[i]; delete[] primitives; primitives = p; } primitives[n. Primitives] = prim; ++n. Primitives; }
Grid. Accel traversal bool Grid. Accel: : Intersect( Ray &ray, Intersection *isect) { <Check ray against overall grid bounds> <Get ray mailbox id> <Set up 3 D DDA for ray> <Walk ray through voxel grid> }
Check against overall bound float ray. T; if (bounds. Inside(ray. mint))) ray. T = ray. mint; else if (!bounds. Intersect. P(ray, &ray. T)) return false; Point grid. Intersect = ray(ray. T);
Set up 3 D DDA (Digital Differential Analyzer) • Similar to Bresenhm’s line drawing algorithm
Set up 3 D DDA (Digital Differential Analyzer) blue values changes along the traversal Out Next. Crossing. T[1] voxel index Delta. T[0] Step[0]=1 ray. T Pos Next. Crossing. T[0] delta: the distance change when voxel changes 1 in that direction
Set up 3 D DDA for (int axis=0; axis<3; ++axis) { Pos[axis]=Pos. To. Voxel(grid. Intersect, axis); if (ray. d[axis]>=0) { Next. Crossing. T[axis] = ray. T+ (Voxel. To. Pos(Pos[axis]+1, axis)-grid. Intersect[axis]) /ray. d[axis]; Delta. T[axis] = Width[axis] / ray. d[axis]; Step[axis] = 1; 1 Out[axis] = NVoxels[axis]; } else { Dx. . . Step[axis] = -1; Out[axis] = -1; } } Width[0]
Walk through grid for (; ; ) { *voxel=voxels[Offset(Pos[0], Pos[1], Pos[2])]; if (voxel != NULL) hit. Something |= voxel->Intersect(ray, isect, ray. Id); <Advance to next voxel> } return hit. Something; Do not return; cut tmax instead Return when entering a voxel that is beyond the closest found intersection.
Advance to next voxel int bits=((Next. Crossing. T[0]<Next. Crossing. T[1])<<2) + ((Next. Crossing. T[0]<Next. Crossing. T[2])<<1) + ((Next. Crossing. T[1]<Next. Crossing. T[2])); const int cmp. To. Axis[8] = { 2, 1, 2, 2, 0, 0 }; int step. Axis=cmp. To. Axis[bits]; if (ray. maxt < Next. Crossing. T[step. Axis]) break; Pos[step. Axis]+=Step[step. Axis]; if (Pos[step. Axis] == Out[step. Axis]) break; Next. Crossing. T[step. Axis] += Delta. T[step. Axis];
conditions x<y x<z y<z 0 0 0 x≥y≥z 2 0 0 1 x≥z>y 1 0 0 1 1 z>x≥y 1 1 0 0 y>x≥z 2 1 0 1 1 1 0 y≥z>x 0 1 1 1 z>y>x 0 - -
KD-Tree accelerator • Non-uniform space subdivision (for example, kd -tree and octree) is better than uniform grid if the scene is irregularly distributed.
Spatial hierarchies A A Letters correspond to planes (A) Point Location by recursive search
Spatial Hierarchies A B B A Letters correspond to planes (A, B) Point Location by recursive search
Spatial Hierarchies A D B B C C D A Letters correspond to planes (A, B, C, D) Point Location by recursive search
“Hack” kd-tree building • Split Axis – Round-robin; largest extent • Split Location – Middle of extent; median of geometry (balanced tree) • Termination – Target # of primitives, limited tree depth • All of these techniques stink.
Building good kd-trees • What split do we really want? – Clever Idea: The one that makes ray tracing cheap – Write down an expression of cost and minimize it – Greedy Cost Optimization • What is the cost of tracing a ray through a cell? Cost(cell) = C_trav + Prob(hit L) * Cost(L) + Prob(hit R) * Cost(R)
Splitting with cost in mind
Split in the middle To get through this part of empty space, you need to test all triangles on the right. • Makes the L & R probabilities equal • Pays no attention to the L & R costs
Split at the median • Makes the L & R costs equal • Pays no attention to the L & R probabilities
Cost-optimized split Since Cost(R) is much higher, make it as small as possible • Automatically and rapidly isolates complexity • Produces large chunks of empty space
Building good kd-trees • Need the probabilities – Turns out to be proportional to surface area • Need the child cell costs – Simple triangle count works great (very rough approx. ) – Empty cell “boost” Cost(cell) = C_trav + Prob(hit L) * Cost(L) + Prob(hit R) * Cost(R) = C_trav + SA(L) * Tri. Count(L) + SA(R) * Tri. Count(R) C_trav is the ratio of the cost to traverse to the cost to intersect C_trav = 1: 80 in pbrt (found by experiments)
Surface area heuristic 2 n splits; must coincides with object boundary. Why? a b
Termination criteria • When should we stop splitting? – Bad: depth limit, number of triangles – Good: when split does not help any more. • Threshold of cost improvement – Stretch over multiple levels – For example, if cost does not go down after three splits in a row, terminate • Threshold of cell size – Absolute probability SA(node)/SA(scene) small
Basic building algorithm 1. Pick an axis, or optimize across all three 2. Build a set of candidate split locations (cost extrema must be at bbox vertices) 3. Sort or bin the triangles 4. Sweep to incrementally track L/R counts, cost 5. Output position of minimum cost split Running time: • Characteristics of highly optimized tree – very deep, very small leaves, big empty cells
Ray traversal algorithm • Recursive inorder traversal Intersect(L, tmin, tmax) Intersect(L, tmin, t*) Intersect(R, tmin, tmax) Intersect(R, t*, tmax) a video for kdtree
Tree representation 8 -byte (reduced from 16 -byte, 20% gain) struct Kd. Accel. Node {. . . union { u_int flags; // Both float split; // Interior u_int n. Prims; // Leaf }; union { u_int above. Child; Mailbox. Prim *one. Primitive; Mailbox. Prim **primitives; }; } interior leaf n // Interior // Leaf
Tree representation 1 8 23 S E M n flags 2 Flag: 0, 1, 2 (interior x, y, z) 3 (leaf)
Kd. Tree. Accel construction • Recursive top-down algorithm • max depth = If (n. Prims <= max. Prims || depth==0) { <create leaf> }
Interior node • Choose split axis position – Medpoint – Medium cut – Area heuristic • Create leaf if no good splits were found • Classify primitives with respect to split
Choose split axis position cost of no split: cost of split: assumptions: 1. ti is the same for all primitives 2. ti : tt = 80 : 1 (determined by experiments, main factor for the performance) cost of no split: cost of split: A B C
Choose split axis position Start from the axis with maximum extent, sort all edge events and process them in order A C B a 0 b 0 a 1 b 1 c 0 c 1
Choose split axis position If there is no split along this axis, try other axes. When all fail, create a leaf.
Kd. Tree. Accel traversal
Kd. Tree. Accel traversal tmax To. Do stack tplane tmin far near
Kd. Tree. Accel traversal To. Do stack tmax tmin far near
Kd. Tree. Accel traversal far tmax tplane tmin near To. Do stack
Kd. Tree. Accel traversal tmax tmin To. Do stack
Kd. Tree. Accel traversal tmax tmin To. Do stack
Kd. Tree. Accel traversal bool Kd. Tree. Accel: : Intersect (const Ray &ray, Intersection *isect) { if (!bounds. Intersect. P(ray, &tmin, &tmax)) return false; Kd. Accel. Node *node=&nodes[0]; while (node!=NULL) { if (ray. maxt<tmin) break; if (!node->Is. Leaf()) <Interior> else <Leaf> } } To. Do stack (max depth)
Leaf node 1. Check whether ray intersects primitive(s) inside the node; update ray’s maxt 2. Grab next node from To. Do queue
Interior node 1. Determine near and far (by testing which side O is) below node+1 above &(nodes[node->above. Child]) 2. Determine whether we can skip a node tmin tmax tplane tmin tmax near far tplane near far
Acceleration techniques
Best efficiency scheme
References • J. Goldsmith and J. Salmon, Automatic Creation of Object Hierarchies for Ray Tracing, IEEE CG&A, 1987. • Brian Smits, Efficiency Issues for Ray Tracing, Journal of Graphics Tools, 1998. • K. Klimaszewski and T. Sederberg, Faster Ray Tracing Using Adaptive Grids, IEEE CG&A Jan/Feb 1999. • Whang et. al. , Octree-R: An Adaptive Octree for efficient ray tracing, IEEE TVCG 1(4), 1995. • A. Glassner, Space subdivision for fast ray tracing. IEEE CG&A, 4(10), 1984
- Centripital acceleration
- Angular quantities and linear quantities cannot be related.
- Radial acceleration formula
- Angular acceleration and linear acceleration
- Tangential acceleration and centripetal acceleration
- Image transform in digital image processing
- Linear position invariant degradation
- Image compression in digital image processing
- Key stage in digital image processing
- Analog image and digital image
- Lossless image compression matlab source code
- Image sharpening in digital image processing
- Geometric transformation in digital image processing
- Steps in digital image processing
- Image transforms in digital image processing
- Imtransform matlab
- Noise
- Nielsen and chuang solutions chapter 4
- Chuang qian ming yue guang li bai
- Liăn
- Nielsen chuang
- Zi chuang
- Pierce chuang
- Chuang
- Cathy chuang
- Rosalind chuang
- Chuang pronunciation
- Cache verilog
- Verilog hdl
- Image quilting for texture synthesis and transfer
- Maksud warga negara
- Digital markets and digital goods
- Digital data digital signals
- Data encoding and transmission
- E-commerce: digital markets, digital goods
- Digital encoding schemes
- "euro digital partners" "digital marketing"
- E-commerce digital markets digital goods
- Explain various boundary descriptors.
- Representation and description in digital image processing
- Double thresholding matlab
- Segmentation in digital image processing
- Basic relationship between pixels
- Piecewise linear transformation in digital image processing
- For coordinates p(2,3)the 4 neighbors of pixel p are
- Digital photography with flash and no-flash image pairs
- Digital image definition
- Gray level transformation in digital image processing
- Adjacency in image processing examples
- Coordinate conventions in digital image processing
- Dam construction in image processing
- Digital image processing java
- Thresholding in digital image processing
- Segmentation in digital image processing
- In digital image processing
- Histogram processing in digital image processing
- Boundary descriptors in digital image processing
- Optimum global thresholding using otsu's method
- Regional descriptors in image processing
- Color slicing in digital image processing
- Qualified forensic duplicate
- Let h and i be the size and intensity of the image
- Intensity transformation and spatial filtering
- A function
- Matlab nextpow
- Digital image processing
- Haar transform for n=4
- Digital image processing
- Lossy compression in digital image processing
- Digital image processing
- What is mach band effect in digital image processing
- In digital image processing
- Digital image processing
- Color fundamentals in digital image processing
- Image processing
- Static image vs dynamic image
- High boost filtering matlab
- Digital path in image processing
- Digital path in image processing
- 472
- Intensity level slicing
- Intensity transformation in digital image processing
- Digital raster graphic image
- Digital image processing
- 매트랩 .* 의미
- Geometric transformation in digital image processing
- A generalization of unsharp masking is
- For a chain code :10103322
- Steps in digital image processing
- پردازش تصویر
- Define point processing
- Digital image processing
- Gonzalez
- Full colour image processing
- Spatial resolution in digital image processing
- Formation d'image
- Digital image processing
- Perform histogram equalization
- Image processing
- Image processing
- Patterns and pattern classes in digital image processing
- Digital image 2006
- Raquel anido
- Digital image processing
- Hadamard transform in digital image processing
- Dense image
- Raster scan gif
- Aliasing in digital image processing
- Shape numbers in digital image processing