1. 2.8. B INARY S PACE P ARTITIONING T REES Exploration of BSP trees

2. Overview of binary space-partitioning trees

3. A binary space-partitioning (BSP) tree recursively partitions space into pairs of subspaces with respect to dividing planes of arbitrary position and orientation. The two partitions are referred to as the positive and negative halfspaces (respectively in front of and behind the dividing plane). A BSP tree is a versatile data structure, capable of performing the same tasks as a k-d tree or octree (but not vice versa). The BSP tree can also be used to provide boundary/solid representations of arbitrary polyhedral scenes.

4. BSP trees are very versatile in collision detection as they can provide both a spatial partitioning (a nonboundary representation) and a volume representation (a boundary representation, for a solid object). As a volume representation, BSP trees can be used to represent and distinguish the interiors of polygons and polyhedra from their exteriors.

5. The left figure provides an example of spatial partitioning (with a typical lookup cost of O(log n)). The right figure shows how a BSP tree can map out the exterior/internal of a polygonal object. When, as illustrated, the dividing planes are selected to match the faces of the input geometry it is termed autopartitioning (or polygon aligned). In contrast, dividing planes coplanar to the xy, xz, or yz planes are called axis aligned. Dividing planes that have no restrictions put on them (nor on the partitionings they form) are called arbitrary or general. Aside: BSP trees using only axis-aligned dividing planes are k-d trees.

6. A leaf-storing (or leaf-based) BSP tree stores geometry in the leaves of the tree (rather than in the internal nodes). Each internal node only contains the dividing plane and references to the child subtrees. The dividing planes of leaf-storing trees can be either arbitrary or autopartitioning. An example leaf-storing tree is shown using arbitrary positioning. Aside: When autopartitioning, all faces coplanar with a selected dividing plane are marked to ensure they are not used when selecting future dividing planes.

7. Solid-leaf BSP trees are built to represent the solid volume occupied by the input geometry, i.e. dividing planes are selected to separate the solid volume from the exterior of the object. No geometry is stored in the tree, with leaf nodes only indicating if the area in front and behind of the dividing plane is empty or solid. Consider the example in which a solid-leaf BSP tree is constructed to represent the interior of a concave (dart-shaped) polygon. Solid-leaf BSP trees are useful for collision detection as there is no need to perform specific polygon tests (no polygons are explicitly stored).

8. Overview of how a BSP tree can be constructed

9. Building a BSP tree (either from scratch or recomputing parts of a tree) is computationally expensive, i.e. BSP trees are typically pre-computed and hold static background geometry (moving objects are handled using some other approach). Building a BSP tree involves three steps. 1. Selection of a partitioning plane. 2. Partitioning input geometry into the positive and negative halfspaces of the dividing plane. Geometry that straddles the plane is split to the plane before partitioning. 3. Recursively repeat the above steps for each subtree until some termination condition is reached.

10. BSPNode BuildBSPTree(List polygons, int depth) { if (polygons.empty()) return NULL; if (depth >= MAX_DEPTH || polygons.Count <= MIN_LEAF_SIZE) || etc. ) return new BSPNode(polygons); Plane splitPlane = PickSplittingPlane(polygons); List frontList = new List (); List backList = new List (); for (int i = 0; i < numPolygons; i++) { switch (ClassifyPolygonToPlane(polygons[i], splitPlane)) { // ->... } } BSPNode frontTree = BuildBSPTree(frontList, depth + 1); BSPNode backTree = BuildBSPTree(backList, depth + 1); return new BSPNode(frontTree, backTree); } Recursively build a leaf storing BSP using the input list of polygons (depth initially equal to o) If no more polygons are available, then return If leaf creation criteria is met, then create leaf node Select the partitioning plane based on the input geometry Test each polygon against the dividing plane, adding them to their forwarding list(s) Recursively build child subtrees and return the combined node case COPLANAR_WITH_PLANE: case IN_FRONT_OF_PLANE: frontList.AddAtBack(polygons[i]); break; case BEHIND_PLANE: backList.push_back(poly); break; case STRADDLING_PLANE: Polygon frontPart, backPart; SplitPolygon(polygons[i], splitPlane, out frontPart, out backPart); frontList.AddAtBack(frontPart); backList.AddAtBack(backPart); break; For a leaf-storing tree, coplanar polygons can be sent to either side, to the front in this implementation. Straddling polygons are split, with a part sent to each side

11. The PickSplittingPlane() function is non-trivial if a good partitioning plane is to be selected. The condition under which tree construction halts depends on the type of tree. For a solid-leaf tree construction proceeds until the set of remaining input polygons becomes empty. A leaf-storing BSP tree is typically stopped when: o The leaf contains less than some preset number of polygons. o A fixed cutoff depth has been reached. o A good dividing plane cannot be found.

12. The dividing planes selected during tree construction greatly effects the size and shape of the resulting tree (and hence performance and memory). Typically good results can be obtained by trying a number of candidate dividing planes at each level of the tree, picking the one that scores best according to an evaluation function If using autopartitioning then the search is restricted to the supporting planes of the faces in the input geometry. Whilst simple to implement, autopartitioning may produce more splitting than desired in leaf-storing trees – e.g. consider the autopartitioning of a polygon sphere (all convex faces will lie on the same side of the plane, with a resultant tree depth equal to the number of sphere faces!)

13. A good approach of handling detailed objects within a scene, is to use bounding volume approximations of the objects and autopartition through the faces of the bounding volumes before performing any splitting involving the geometry within the bounding volumes. Alternative candidate dividing planes can include planes in a few predetermined directions (e.g. coordinate axes) or evenly distributed across the extents of the input geometry (i.e. forming a grid across the geometry). Arbitrary planes can also be selected through a hill-climbing approach whereby, repeatedly, a number of slightly different planes to a candidate plane are tested to determine the new candidate plane.

14. Evaluation criteria of use to collision detection includes picking planes so as to minimize splitting of geometry (least-crossed stragegy) or to attempt to balance the geometry equally on both sides of the splitting plane. The approaches tend not to be complementary, with a strong focus on one criteria likely to provide poor performance in the other criteria. A weighted linear combination of the two is often used in practice (with reduced splitting often weighted higher than balancing). Line A minimises split polygons; Line B balances the number of polygons; Line C represents a compromise.

15. When building a BSP tree, all polygons need to be partitioned with respect of a dividing plane into those that: lie in front of the dividing plane. lie behind the dividing plane. straddle the dividing plane. lie coincident with the dividing plane Whilst mathematically straightforward, inaccuracies in floating-point arithmetic entail that a split polygon may still be found to straddle the dividing plane. A practical solution to this problem is to use thick planes defined as n (X − P) < ε (for some ε), i.e. all points within a small distance of the plane are considered lying on the plane.

16. During BSP tree construction, when a polygon is found straddling a dividing plane it must be split in two. Clipping a polygon against a plane is done using the Sutherland– Hodgman algorithm. The algorithm considers one polygon edge at a time and returns a set of points based on an intersection test between the edge and plane. Aside: Why is splitting needed? Consider the figure. If T is not split on partition 1 (and is sent down both sides), then in split 2 T is (incorrectly) found to be on both sides (and would end up in leaf C), i.e. clipping is needed to prevent incorrect assignment.

17. Whilst polygons are split during the construction of the tree, this need not mean that the polygon fragments ending up in the leaves must be the polygons output in the final tree. For collision detection, it is better to store a reference to the original polygon with each fragment generated during splitting. In the leaves, the reference is output, and not the fragment. Aside: The normal Sutherland– Hodgman algorithm simply discards any part behind the cutting plane, i.e. a modified version is needed for BSP tree construction that will return the portion behind the plane. Additionally, the algorithm should also be mindful of any thick plane assumption introduced to prevent floating point inaccuracies.

18. Overview of how a BSP tree can be used

19. Determining if a point lies in empty or solid space of a solid-leaf BSP tree can be done by evaluating the point with respect to a node’s dividing plane. The side on which the point falls determines which child node is next visited. Traversal continues until a leaf node is reached. The value of the leaf node answers the query. If the tested point lies on the boundary of a solid volume represented by the BSP tree then both subtrees should be explored. When both subtrees are traversed if different results are returned (e.g. solid and empty) then the point lies on the boundary (a matching return from both subtrees is simply returned).

20. HitType PointInSolidSpace(BSPNode node, Point p) { while (!node.IsLeaf) { float dist = Dot(node.Plane.n, p) – node.Plane.d; if (dist > EPSILON) { node = node.Child[0]; } else if (dist < -EPSILON) { node = node.Child[1]; } else { HitType front = PointInSolidSpace(node.Child[0], p); HitType back = PointInSolidSpace(node.Child[1], p); return (front == back) ? front : HitType.OnBoundary; } } return node.IsSolid ? HitType.Inside : HitType.Outside; } Determine the distance the point is from the plane If the point lies in front of the plane, then visit the first subtree, else if behind the plane, then visit the second subtree If the point lies on the dividing plane then visit both subtrees If the returned results differ, then return that the point is on the boundary If a leaf node has been reached then return it’s recorded type

21. When testing for intersection of a ray or segment against the tree care must be exercised to ensure that the tested ray or segment is not repeatedly subdivided against the splitting plane (as repeated subdivision can introduce drift due to accumulated floating point inaccuracies). A better approach is to determine the intersection ‘time’ of the ray against the plane (R(t) = P + td, t min ≤ t ≤ t max ). The time t hit of the first intersection with a solid leaf is returned (should an intersection be found). Aside: If thick planes are used, then an epsilon term needs to be added to the plane intersection tests, with both sides explored given plane intersection.

22. HitType RayIntersect(BSPNode node, Point p, Vector d, float tmin, float tmax, out float thit) { Stack nodeStack; Stack timeStack; while (true) { if (node.IsLeaf == false) { float dist = node.Plane.d - Dot(node.Plane.n, p); int nearIndex = dist > 0.0f ? 1 : 0; float denom = Dot(node.Plane.n, d); if (denom != 0.0f) { float t = dist / denom; if (0.0f <= t && t <= tmax) { if (t >= tmin) { nodeStack.Push(node.Child[1 ∧ nearIndex]); timeStack.Push(tmax); tmax = t; } else nearIndex = 1 ∧ nearIndex; } } node = node.Child[nearIndex]; } Determine if the ray (or segment) intersects with solid geometry. If available, also return the ‘time’ of intersection thit (where R(t) = p + t*d, tmin <=t <=tmax). Define two stacks to hold ‘recursive’ information Determine the direction of the ray relative to the plane (a value of 0.0 denotes a parallel ray – in which case the side of the plane the ray lies will be followed) Find the side of the splitting plane on which the ray starts Determine the ray ‘time’ of intersection A straddling ray has been detected, i.e. push far side onto stack and visit near side If 0 <= t < tmin, then visit far side

23. else { if (node.IsSolid) { thit = tmin; return HitType.Inside; } if (nodeStack.empty()) break; tmin = tmax; node = nodeStack.Top(); nodeStack.Pop(); tmax = timeStack.Top(); timeStack.Pop(); } } return HitType.Outside; } If reaching here, no solid leaf node could be found. A leaf node has been reached. If it is solid, then record a hit at tmin If no more subtrees remain to be considered, then exit, otherwise pop the topmost node from the stack and continue.

24. Directed mathematical reading Directed reading

25. Directed reading Read Chapter 8 of Real Time Collision Detection (pp349-381) Related papers can be found from: http://realtimecollisiondetection.net/books/rtcd/references/

26. To do: Read the directed material After reading the directed material, have a ponder if this is the type of material you would like to explore within a project. Today we explored: How to build and use a BSP tree