Binary Space Partitioning Research Articles

A Fast 3-D Visualization Methodology Using Characteristic Views of Objects

This paper describes a 3-D visualization method based on the concept of characteristic views (CVs). The idea of characteristic views was derived based on the observation that the infinite possible views of a 3-D object can be grouped into a finite number of equivalence classes so that within each class all the views are isomorphic in the sense that they have the same line-junction graphs. To visualize the changes of scenes in real time, the BSP tree algorithm is known to be efficient in a static environment in which the viewpoint can be changed easily. However, if a scene consists of many objects and each object consists of many polygons, the time complexity involved in traversing a BSP tree increases rapidly so that the original BSP tree algorithm may not be efficient. The method proposed in this paper is object-oriented in the sense that, for all viewpoints, at the preprocessing stage the ordering for displaying the objects is determined. At run time, the objects are displayed based on a pre-calculated ordering according to the viewpoint. In addition, a CV is used as a basic 2-D projected image of a 3-D object.

New results on binary space partitions in the plane

We prove the existence of linear size binary space partitions for sets of objects in the plane under certain conditions. In particular, we construct linear size binary space partitions for sets of fat objects, for sets of line segments where the ratio between the lengths of the longest and shortest segment is bounded by a constant, and for homothetic objects. For all cases we also show how to turn the existence proofs into efficient algorithms.

DIMENSION-INDEPENDENT BSP (1): SECTION AND INTERIOR-TO-BOUNDARY MAPPING

In this paper we discuss an algorithm to perform the conversion from the interior to the boundary of d-dimensional polyhedra, where both the d-polyhedron and its (d - 1) boundary faces are represented as BSP trees. This approach allows also to compute the BSP tree of the set intersection between any hyperplane in ed and the BSP representation of a d-polyhedron. If such section hyperplane is the affine support of a (d - 1)-face, then a BSP tree of the face is generated. The algorithm may be iteratively applied to compute the k-skeletons of a d-polyhedron.

Perfect binary space partitions

A binary space partition is a recursive partitioning of a configuration of objects by hyperplanes until all objects are separated. A binary space partition is called perfect if none of the objects is cut by the hyperplanes used by the binary space partition. We present an algorithm that, given a set S of n non-intersecting line segments in the plane, constructs a perfect binary space partition for S, or decides that no perfect binary space partition exists for S, in O(min( n 2, n log 3 n+ m log n)) time, where m is the number of edges in the visibility graph of S. We also prove that deciding whether a set of segments admits a perfect BSP is 3 sum-hard.

Converting discrete images to partitioning trees

The discrete space representation of most scientific datasets, generated through instruments or by sampling continuously defined fields, while being simple, is also verbose and structureless. We propose the use of a particular spatial structure, the binary space partitioning tree as a new representation to perform efficient geometric computation in discretely defined domains. The ease of performing affine transformations, set operations between objects, and correct implementation of transparency makes the partitioning tree a good candidate for probing and analyzing medical reconstructions, in such applications as surgery planning and prostheses design. The multiresolution characteristics of the representation can be exploited to perform such operations at interactive rates by smooth variation of the amount of geometry. Application to ultrasound data segmentation and visualization is proposed. The paper describes methods for constructing partitioning trees from a discrete image/volume data set. Discrete space operators developed for edge detection are used to locate discontinuities in the image from which lines/planes containing the discontinuities are fitted by using either the Hough transform or a hyperplane sort. A multiresolution representation can be generated by ordering the choice of hyperplanes by the magnitude of the discontinuities. Various approximations can be obtained by pruning the tree according to an error metric. The segmentation of the image into edgeless regions can yield significant data compression. A hierarchical encoding schema for both lossless and lossy encodings is described.

Fast Robust BSP Tree Traversal Algorithm for Ray Tracing

An orthogonal BSP (binary space partitioning) tree is a commonly used spatial subdivision data structure for ray-tracing acceleration. While the construction of a BSP tree takes a relatively short time, the efficiency of a traversal algorithm significantly influences the overall rendering time. We propose a new fast traversal algorithm based on statistical evaluation of all possible cases occuring during the traversal of a BSP tree. More frequent cases are handled simply, while less frequent ones are more computationally expensive. The proposed traversal algorithm handles all singularities correctly, and saves between 30% and 50% of traversal time compared with the commonly-known Sung and Arvo algorithms.

Image compression using binary space partitioning trees

For low bit-rate compression applications, segmentation-based coding methods provide, in general, high compression ratios when compared with traditional (e.g., transform and subband) coding approaches. In this paper, we present a new segmentation-based image coding method that divides the desired image using binary space partitioning (BSP). The BSP approach partitions the desired image recursively by arbitrarily oriented lines in a hierarchical manner. This recursive partitioning generates a binary tree, which is referred to as the BSP-tree representation of the desired image. The most critical aspect of the BSP-tree method is the criterion used to select the partitioning lines of the BSP tree representation, In previous works, we developed novel methods for selecting the BSP-tree lines, and showed that the BSP approach provides efficient segmentation of images. In this paper, we describe a hierarchical approach for coding the partitioning lines of the BSP-tree representation. We also show that the image signal within the different regions (resulting from the recursive partitioning) can be represented using low-order polynomials. Furthermore, we employ an optimum pruning algorithm to minimize the bit rate of the BSP tree representation (for a given budget constraint) while minimizing distortion. Simulation results and comparisons with other compression methods are also presented.

BOXTREE: A Hierarchical Representation for Surfaces in 3D

AbstractWe introduce the boxtree, a versatile data structure for representing triangulated or meshed surfaces in 3D. A boxtree is a hierarchical structure of nested boxes that supports efficient ray tracing and collision detection. It is simple and robust, and requires minimal space. In situations where storage is at a premium, boxtrees are effective alternatives to octrees and BSP trees. They are also more flexible and efficient than R‐trees, and nearly as simple to implement.

Block model conversion using binary space partitioning trees

This paper presents an efficient block model conversion algorithm that converts a general polyhedron into a set of discrete blocks. Block model conversion is an important problem in three-dimensional orebody modeling where solid shells representing orebody zones must be discretized so that geostatistical or conventional ore reserve estimation methods can be used to estimate grades of individual blocks. However, the problem has not received adequate treatment. The core of the conversion task is repeated applications of a point-in-polyhedron test using a ray casting technique. Naive implementation of this test procedure is too slow for general polyhedra consisting of hundreds of faces. To speed up the process, an efficient space subdivision scheme is employed, which is known as a Binary Space Partitioning Tree. The resulting algorithm is not only efficient, but also robust, and has been incorporated into a three-dimensional mine modeling, visualization and information system developed by the author.

Optimization of a Priority List Algorithm for 3‐D Rendering of Buildings

AbstractArchitectural scenes usually have some peculiar properties, like parallel surfaces, symmetry, instantiation, easy clustering, etc. These properties can be used by visualization algorithms in order to improve the solution of the hidden surface removal problem.This paper presents some practical implementation policies for the binary space partition algorithm proposed by Fuchs. They take advantage of the characteristics found in architectural scenes. These suggestions help to minimize both the time needed to build the tree and the memory space used. Five optimization techniques are presented and applied to fourteen architectural scenes.

Assessment of five radiosity acceleration techniques

Five visibility acceleration techniques for speeding up the form factor computation are presented and compared in this paper: 3-D bounding boxes, illumination volumes, binary space partition trees and binary space partition trees with 3-D bounding boxes are described. A new method that enhances the binary space partition tree method with illumination volumes is proposed. The results of these methods are discussed. In addition, the advantages and disadvantages of each of the techniques are highlighted.

Ray tracing: A quantitative analysis and a new practical algorithm

We present a new method to accelerate the process of finding nearest ray-object intersections in ray tracing. The algorithm consumes an amount of memory more or less linear in the number of objects. The basic ideas can be characterized with a modified BSP tree and plane traversal. Plane traversal is a fast linear time algorithm to find the closest intersection point in a list of bounding volumes hit by a ray. We use plane traversal at every node of the high outdegree BSP tree. Our implementation is competitive to fast ray-tracing programs. We present a benchmark suite that allows for an extensive comparison of ray-tracing algorithms.

Efficient image representation using binary space partitioning trees

Images are traditionally represented by a set of picture elements, or pixels, defined over a discrete two or three-dimensional lattice. Pixel-based representation of images, however, requires a large amount of storage memory and processing power when performing complex image operations. Several image processing, computer vision, and computer graphics applications have resorted to employing more efficient representations of images. Tree-based representations, such as quadtrees and octrees, have received a great deal of attention by researchers in many imaging, vision and graphics areas. Binary Space Partitioning (BSP) trees have been used in computer graphics as an efficient representation of objects with planar faces (i.e., polyhedra). In this dissertation we propose using BSP trees as an efficient representation of images for image compression and geometric transformation applications. The BSP tree approach partitions the image domain, in a recursive manner, using arbitrarily oriented lines. The result of this partitioning is a set of convex (unpartitioned) regions, known as the BSP tree cells. In order to generate an efficient segmentation of the image, the number of cells has to be as small as possible such that the image signal within each cell is smooth. Therefore, the most critical aspect of a BSP tree construction method is the criterion used for selecting the partitioning lines. Here, we introduce a boundary-based approach and an optimization method for selecting the lines of a BSP tree. Under the former approach, the partitionings are based on the boundaries of the objects within the image under consideration. By using an optimization method, the lines are selected based on a Least-Square-Error (LSE) criterion. As demonstrated in this work, both the boundarybased and LSE methods provide efficient segmentation when applied to complex images. In addition, we develop a multiresolution algorithm for constructing a multiresolution BSP tree. In this case, the coarse (high frequency) information of the image is represented by the nodes close to the root node, and the fine (low frequency) details are contained within the nodes close to the leaves of the BSP tree. Based on these BSP tree construction methods, a coding system is proposed for compressing still images. A hierarchical method for coding the partitioning lines of the tree is developed. Meanwhile, the image signal within the unpartitioned regions (cells) is coded using low order polynomials (zero and first order). Moreover, an optimum pruning algorithm is used to reduce the number of bits required for encoding the BSP tree representation while minimizing distortion. By employing this BSP tree-based compression method on typical images (of human faces), high compression ratios in the range of 50-100 were obtained. Unlike other tree-based representations (e.g. quadtrees), and due to the flexible representation of the BSP tree approach (namely, the use of arbitrarily oriented lines), line-preserving transformations can be applied very efficiently to BSP trees without the need for reconstructing the tree under consideration. In here, we show the result of performing affine and perspective projection transformations on the BSP tree representation of images. These geometric manipulations were achieved by performing parametric transformations on the partitioning lines of the tree.

A Multiprocessor Implementation of Radiosity

AbstractThis paper describes a multi‐processor implementation of form factor computation in the radiosity method. Form factors are computed using the ray casting method and the algorithm is enhanced with Binary Space Partition (BSP) Trees and bounding boxes. Experimental results are presented together with a discussion of load balance efficiency.

On the optimal binary plane partition for sets of isothetic rectangles

We present a binary space partition algorithm for a set of disjoint isothetic rectangles. It recursively splits the set by means of isothetic cutting lines, until no two rectangles belong to the same portion of the plane. Rectangles intersected by a cutting line are split. We provide an algorithm that given n rectangles builds a linear sized Binary Space Partition with no empty regions by means of at most 4 n-1 cuts. The algorithm runs in O( n log n) worst-case space and time. We generalize and improve a previous result achieved on isothetic line segments by Paterson and Yao.

Computing Dynamic Changes to BSP Trees

This paper investigates a new method for dynamically changing Binary Space Partition (BSP) trees. A BSP tree representation of a 3D polygonal scene provides an ideal data structure for rapidly performing the hidden surface computations involved in changing the viewpoint. However, BSP trees have generally been thought to be unsuitable for applications where the geometry of objects in the scene changes dynamically. The purpose of this paper is to introduce a dynamic BSP tree algorithm which does allow for such changes, and which maintains the simplicity and integrity of the BSP tree representation. The algorithm is extended to include dynamic changes to shadows. We calibrate the algorithms by transforming a range of objects in a scene, and reporting on the observed timing results. © 1992 Eurographics Association

Optimal binary space partitions for orthogonal objects

A binary space partition, or BSP, is a scheme for recursively dividing a configuration of objects by hyperplanes until all objects are separated. BSPs are widely used in computer graphics as the underlying data structure for computations such as real-time hidden-surface removal, ray tracing, and solid modeling. In these applications, the computational cost is directly related to the size of the BSP, i.e., the total number of fragments of the objects generated by the partition. Until recently, the question of minimizing the size of BSPs for given inputs had been studied only empirically. We concentrate here on orthogonal objects, a case which arises frequently in practice and deserves special attention. We construct BSPs of linear size for any set of orthogonal line segments in the plane. In three dimensions, BSPs of size O(n 3 2 ) for any set of n mutually orthogonal ine segments or rectangles are constructed. These bounds are optimal and may be contrasted with the Θ( n 2) bound for general polygonal objects in R 3.

A comparison of three shadow volume algorithms

This paper describes and compares three different approaches to computing shadows. Each is based on the idea of shadow volumes: basic algorithm, Shadow Volume BSP Tree algorithm, and Shadow Tiling, based on 2D space subdivision. Binary Space Partition trees are used to organise the polygons in the scene in a front-toback order from the point of view of the light source, and then shadows on a polygon are computed by clipping the polygon to the shadow volumes of polygons closer to the light source. The three algorithms differ in their approach to minimising the number of comparisons of a polygon with the shadow volumes of its predecessors, and one of the algorithms represents the total shadow volume itelf by a BSP tree. The algorithms are compared analytically and statistically.

Front-to-back display of BSP trees

A technique for displaying binary space partitioning (BSP) trees that is faster than the usual back-to-front display method is presented. By combining polygon scan-conversion with a dynamic screen data structure, the technique, a front-to-back approach, provides significant speedup in the display time of polygonal scenes that depend on BSP trees, especially in cases where the number of polygons is large. This speedup is confirmed by applying the technique to randomly generated triangles.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Binary space partitioning tree representation of images

Keywords: LTS1 Reference LCAV-ARTICLE-1991-004doi:10.1016/1047-3203(91)90023-9 Record created on 2005-04-18, modified on 2017-05-12