BSP

Brief of Binary Space Partitioning.

Target: examine the areas where one can draw advantages of the structure supplied and study the generating process.

Drawbacks: BSP is static and it is very expensive to modify during run-time.

What is BSP-tree?

In the beginning of the 90’s the main reason BSP-trees were being used was that they sorted the polygons in the scene so that you always drew back-to-front, meaning that the polygon with the lowest Z-value[*] was drawn last. There are other ways to sort the polygons so that the closest polygon is drawn last, for example the Painter’s algorithm[3], but few are as cheap as BSP-trees, because the sorting of the polygons is done during the pre-processing[*] of the map and not under run-time. The algorithm for generating a BSP-tree is actually an extension of Painter’s algorithm[5].

How to split?

There are several ways to split up the set of polygons into smaller subsets. For example, you can choose an arbitrary plane in space and divide the polygons by putting the ones on the positive side of the plane in the right sub tree and the polygons on the negative side in the left sub tree. The problem with this approach is that it is very difficult to find a plane that divides the polygons into two approximately equally sized sets, since there are an infinite set of planes in space. So the most common way to do this is by taking one of the polygons in the scene and dividing the polygons according to the plane that polygon defines.

How to choose ploygon?

When a BSP-tree is created, one has to decide whether the need is of a balanced tree, meaning that there should not be too big a difference in depth between the left and the right sub tree of each node, or try to limit the number of splits, since each split creates new polygons. If too many new polygons is created during the BSP-tree creation the graphic card will have a hard time rendering the map, thus reducing the frame rate, while a unbalanced tree will require more expensive traversal of the tree. We decided to accept a certain number of splits in order to get a more balanced tree. But the main concern was reducing the number of new polygons created.

CHOOSE-DIVIDING-POLYGON
 Indata:
   PolygonSet – The set of polygons to search for the best dividing polygon.
 Outdata:
   The best dividing polygon
 Effect:
   Searches through the set of polygons and returns the polygons that
   splits the set into the two best resulting sets. If the set is
   convex no polygon can be returned.

HOOSE-DIVIDING-POLYGON (PolygonSet)
  if (IS-CONVEX-SET (PolygonSet))
      then return NOPOLYGON
  MinRelation = MINIMUMRELATION
  BestPolygon = NOPOLYGON
  LeastSplits = INFINITY
  BestRelation = 0
  // Loop to find the polygon that best divides the set.
  while(BestPolygon = NOPOLYGON)
      for each polygon P1 in PolygonSet
          if (Polygon P1 has not been used as divider previously
              during the creation of the tree)

              // Count the number of polygons on the positive side, negative side
              // of and spanning the plane defined by the current polygon.
0             NumPositive = 0, NumNegative = 0, NumSpanning = 0
1             for each polygon P2 in PolygonSet except P1
2                 Value = CALCULATE-SIDE(P1, P2)
3                 if(Value = INFRONT)
4                     NumPositive = NumPositive + 1
5                 else if(Value = BEHIND)
6                     NumNegative = NumNegative + 1
7                 else if(Value = SPANNING)
8                     NumSpanning = NumSpanning + 1

          // Calculate the relation between the number of polygons in the two
          // sets divided by the current polygon.
9         if (NumPositive < NumNegative)
0             Relation = NumPositive / NumNegative
1         else
2             Relation = NumNegative / NumPositive

          // Compare the results given by the current polygon to the best this
          // far. If the this polygon splits fewer polygons and the relation
          // between the resulting sets is acceptable this is the new candidate
          // polygon. If the current polygon splits the same amount of polygons
          // as the best polygon this far and the relation between the two
          // resulting sets is better -> this polygon is the new candidate
          // polygon.
3         if (Relation > MinRelation && (NumSpanning < LeastSplits ||
              NumSpanning = LeastSplits && Relation > BestRelation))
4            BestPolygon = P1
5            LeastSplits = NumSpanning
6            BestRelation = Relation

      // Decrease the number least acceptable relation by dividing it with
      // a predefined constant.
7     MinRelation = MinRelation / MINRELATIONSCALE
8 return BestPolygon

What is the complexity?

Assume that the initial value for MinRelation is 1, which is the highest possible value since the relation is always between 0 and 1, so:

1 / MINRELATIONSCALEⁱ < 1/(n-1)
1 < MINRELATIONSCALEⁱ/(n-1)
(n-1) < MINRELATIONSCALEⁱ
log_{MINRELATIONSCALE} (n-1) < i

This is no upper bound for i, but since i will be very close to log_{MINRELATIONSCALE} (n-1) we will, for simplicity assume they are equal. Another practical assumption to make is that MINRELATIONSCALEalways should be greater than or equal to 2. Thus giving us:

log_{MINRELATIONSCALE} (n-1) = i MINRELATIONSCALE >= 2
i = log_{MINRELATIONSCALE} (n-1) < lg(n-1) = O(lg n)

So这个算法的时间复杂度是O(n^2 *lg n), 算法中要选择恰当的MINIMUBERELATION, MINRELATIONSCALE.

How to build BSP-Tree?

► GENERATE-BSP-TREE
* Indata:
*   Node - The sub tree to build of the type BSPTreeNode.
*   PolygonSet – The set of polygons to create a BSP-tree from.
* Outdata:
*   A BSP-tree stored in the incoming node.
* Effect:
*   Generates a BSP-tree out of a set of polygons.

GENERATE-BSP-TREE (Node, PolygonSet)
1  if (IS-CONVEX-SET (PolygonSet))
2      Tree = BSPTreeNode (PolygonSet)
3  Divider = CHOOSE-DIVIDING-POLYGON (PolygonSet)
4  PositiveSet = {}
5  NegativeSet = {}
6  for each polygon P1 in PolygonSet
7      Value f CALCULATE-SIDE (Divider, P1)
8      if(Value = INFRONT)
9          PositiveSet = PositiveSet U P1
10     else if (Value = BEHIND)
11         NegativeSet = NegativeSet U P1
12     else if (Value = SPANNING)
13         Split_Polygon (P1, Divider, Front, Back)
14         PositiveSet = PositiveSet U Front
15         NegativeSet = NegativeSet U Back
16 GENERATE-BSP-TREE (Tree.RightChild, PositiveSet)
17 GENERATE-BSP-TREE (Tree.LeftChild, NegativeSet)

时间复杂度T(n) = 1/2T(1/2*n) + O(n^2lgn). 由递归树求得T(n) = O(n^2lgn)

Using BSP-Tree to draw the scene.

DRAW-BSP-TREE
 Indata:
   Node – The node to draw.
   Position – The viewer’s position.
 Outdata:
   None
 Effect:
   Draws the polygons contained in the node and its sub trees.

RAW-BSP-TREE (Node, Position)
  if (IS-LEAF(Node))
      DRAW-POLYGONS (Node.PolygonSet)
      return

  // Calculate which sub tree the viewer is in.
  Side = CLASSIFY-POINT (Node.Divider, Position)

  // If the viewer is in the right sub tree draw that tree before the
  // left.
  if (Side = INFRONT || Side = COINCIDING)
      DRAW-BSP-TREE (Node.RightChild, Position)
      DRAW-BSP-TREE (Node.LeftChild, Position)

  // Otherwise draw the left first.
  else if(Value = BEHIND)
      DRAW-BSP-TREE (Node.LeftChild, Position)
0     DRAW-BSP-TREE (Node.RightChild, Position)

REFERENCE:

http://www.devmaster.net/articles/bsp-trees/#Reference