Improvements on the kd-tree

More documents

Recommendations

Info

László Szécsi and Balázs Benedek / <strong>Improvements</strong> on the kd-treethe array is 18n, where 6n nodes are reserved for the cuts, theleaves and the pointers. Although this may still be a roughover-estimation for some simple scenes, going even lowermay involve disadvantageous effects. First of all, if the arrayis filled, the above mentioned termination could occur.Secondly, even if the array is not filled, a deeper tree willallow longer branches without using pointers. Therefore,over-allocation slightly increases compactness and traversalspeed. Setting the array to the size of 18n will allow for thestorage of worst-case kd-trees, and speed-effective representationof simple ones.In the following table the numbers of leaves and pointersfor various scenes are listed. Obviously, the number ofpointers remains below the worst-case bound. This representationdefinitely uses fewer pointers than the previous solutions,which should result in better cache coherence andfaster traversal.Scene Patches Nodes Leaves PointersCornell box 3968 9037 4296 444Beethoven 2636 23140 9883 3373Random 3515 39389 16981 5426Tea 10025 54392 23874 6643Chickens 16467 115455 49094 17266House 24737 156469 65540 253885. kd-trees for animation5.1. Separation of dynamic and static objectsRebuilding the whole kd-tree for every frame is obviouslyvery expensive and also superfluous. If the objects are classifiedas static objects staying at a fixed position during theanimation, and dynamic objects that may move, we can buildtwo different kd-trees. This may have various advantages.First of all, the time of the kd-tree construction is dramaticallyreduced. It also becomes possible to shoot rays onlyinto the dynamic kd-tree, thereby identifying changes of thescene along previous shooting or gathering paths. It is interestingto examine how the data structure could be helpfulat making use of frame-to-frame coherence. However, in thedual kd-tree structure traversal will be slower. Theoretically,if the both trees contain a large number of objects, the traversaltime would be independent of the size of the tree, thereforeseparating them could double the time cost. This wouldof course be unacceptable, and should be addressed.Obviously, the less objects are in the dynamic kd-tree,the faster it can be built. The moving objects in an animationsequence can usually be separated into sets of primitivesthat move together. This is even more characteristic toscenes with rigid bodies, where the primitives of a higherlevelobject are static relative to each other. Reconstructingthe kd-tree using the primitives would not take any advantageof this property. The kd-tree for the rigid objects can bebuilt in advance, but if the objects are rotated, the splittingplanes would not be axis-aligned any more, and such a structurecould not be used as a sub-tree of the dynamic kd-tree.The solution is pre-compute the kd-trees for the rigid objects,attach them these objects, and define the intersectiontest for an object as the ray shot in its kd-tree. If the objectsare translated, rotated or transformed in any other way,then the ray must be transformed into the model space 5 ,inwhich the sub-kd-tree is axis-aligned. This way the dynamictree will be built of a few rigid objects, and not many moreprimitives. The reconstruction of the data structure betweenframes will be done in very little time, and traversal overheadbecause of the dual tree structure will be minimal.However, several questions arise. In order to build a kdtreeof transformed objects, the extremes along every axishave to be found. Computing a bounding box for a set ofpoints is straightforward but may be unacceptably expensivefor a large number of vertices. Furthermore, as an intersectiontest for such a high-level object is costly, a cheaper prefilteringwould be useful. Both problems are addressed by apre-computing a bounding object easy to transform. An ellipsoid,being a quadratic surface, is the most appropriate. Ifthe smallest enclosing ellipsoid for the vertices of the objectis calculated, it can be transformed appropriately for everyframe. Its extremes may be used to determine the boundingbox, and an intersection test with a quadratic object can beused to filter a huge amount of non-intersecting rays out. Thealgorithm used to determine the smallest enclosing ellipsoidis based on linear programming 7 and runs in Ç´nµ time 1 .5.2. Synchronous traversal of the dual treeWe have mentioned above that the traversal cost for two treesmay be the double of the cost for one tree of twice as manyobjects. This is, however, a worst case assumption, and canbe avoided in several ways. First of all, the formerly describeduse of compound rigid objects will decrease the sizeand traversal cost of the dynamic tree. Secondly, it is obviousthat if we have found an intersection in the dynamic tree,the search in the static tree may be limited to the segment ofthe ray between the origin and the intersection point. Thatis, we do not test in areas occluded by dynamic objects. Thissimple modification will result traversal times very close tothe one tree case, especially if the dynamic objects are rarelyoccluded by static ones. However, it is not always possibleto identify rigid objects, and the visibility relation betweenthe dynamic and static objects may not be so determined forsome animation sequences. Therefore, we introduce a costeffectivetraversal algorithm for multiple overlapping kdtrees,especially useful if a large number of independentlymoving primitives are stored in the kd-tree.Basically, a the cell boundaries of a kd-tree separate atraversing ray into segments. A traversal algorithm will identifythose segments, and will compute intersection tests onevery segment in order. If the objects are stored in multiplekd-tree, multiple segmentations exist. The task is to find an
László Szécsi and Balázs Benedek / <strong>Improvements</strong> on the kd-treeoptimal order of the segments, so that no segment furtherthan the first valid intersection is examined. That means, ifany point of segment A is nearer to the origin of the ray thanany point of segment B, then A must precede B in the traversalorder. A known recursive algorithm, described in detailby Havran 2 , is extended the following way:1. Set up a search interval for every tree as the entire ray.2. Choose that ’non-terminated’ tree, for which the minimumpoint of the search interval is the nearest to the origin.3. Traverse the chosen tree using the recursive algorithm. Aseparate traversal stack and a current node identifier hasto be maintained for every tree. Continue until a leaf isreached.4. If a leaf is being processed, test for intersections, and updatethe global closest intersection found if necessary. Setthe search interval to the segment of the ray intersected bythe volume of the next node to be processed according tothe recursive traversal algorithm. If the traversal stack isempty, or a valid intersection was found, mark the tree as’terminated’.5. If a valid intersection was already found, and the searchinterval for every tree is entirely further then the closestintersection, terminate, and return the found intersection.6. If all the trees are marked ’terminated’, there was no intersectionwith the ray in either of the trees, return withouta result.7. Continue with step 2.opposite case the same amount of tests are carried out. However,we have to remark that there is some overhead becauseof some additional administration and weaker cache coherence,a result of handling more kd-trees simultaneously.5.3. ResultsScenes have been divided into a static and dynamic part totest the algorithm. Three cases were examined:One tree: All the patches, static or dynamic, are stored in acommon kd-tree.Sequential: Static and dynamic patches are stored in separatetrees. When calculating a ray-scene intersection, firstwe traverse only the dynamic tree. Thereafter the statictree is tested, but only on the ray segment between theorigin and the intersection point in the dynamic tree.Parallel: Static and dynamic patches are stored in separatetrees. The parallel traversal algorithm is used for raysceneintersections.0 0001 23 045Figure 4: The parallel traversal of two kd-trees partitioningthe same space, containing different sets of objects. The cellsare numbered to indicate the order of their processing. Nonprocessedcells along the ray are marked with 0.Figure 5: One of the test scenes. The two standing chickensare considered static, the other two, those over the ground,are dynamic.Compared to the sequential solution, where the trees aretraversed after one another, on the interval limited by previouslyfound intersections, we spare the traversal of the raysegments between the nearest intersection and those furtherintersections, that were to be found in previously traversedtrees. Speaking about the dual tree structure, we have twooptions: traverse the dynamic tree, and then the static tree, ordo it in parallel. If the nearest intersection is in the static tree,then the parallel algorithm will not investigate the segmentbetween the dynamic and static intersection points. In theThe tests were run with two different kd-tree constructionroutines. We rendered an image using Bi-directional PathTracing 4 . We used a test scene of large static and dynamicobjects with a high primitive count, which simulates a frameof an animation sequence well, we believe. In the other testscene, both the static and dynamic patches were generatedon random. With the first version, we obtained satisfying resultsshowing that the parallel traversal is faster. Executiontimes are specified in seconds:
Page 1 and 2: Improvements on th
Page 3 and 4: László Szécsi and Balázs Benede
Page 5: László Szécsi and Balázs Benede

Improvements on the kd-tree

Create successful ePaper yourself

Delete template?

Save as template?