Linear Size Binary Space Partitions for Uncluttered Scenes

This paper discusses an approach to automating CAD model acquisition by creating binary space partitioning (BSP) trees from laser range data. Distinct views of the object, each represented by a BSP tree, are then merged using set operations. BSP trees have proven their utility in 3D modeling, graphics and image processing, and their tree structure allows efficient algorithms to be developed that are compact and numerically robust. These properties are of primary importance when considering an intermediate representation between raw sensor data and existing CAD models.

Spatial data structures form a core ingredient of many geometric algorithms, both in theory and in practice. Many of these data structures, especially the ones used in practice, are based on partitioning the underlying space (examples are binary space partitions and decompositions of polygons) or partitioning the set of objects (examples are bounding-volume hierarchies). The efficiency of such data structures---and, hence, of the algorithms that use them---depends on certain characteristics of the partitioning. For example the performance of many algorithms that use binary space partitions (BSPs) depends on the size of the BSPs. Similarly, the performance of answering range queries using bounding-volume hierarchies (BVHs) depends on the so-called crossing number that can be associated with the partitioning on which the BVH is based. Much research has been done on the problem of computing partitioning whose characteristics are good in the worst case. In this thesis, we studied the problem from a different point of view, namely instance-optimality. In particular, we considered the following question: given a class of geometric partitioning structures---like BSPs, simplicial partitions, polygon triangulations, …---and a cost function---like size or crossing number---can we design an algorithm that computes a structure whose cost is optimal or close to optimal for any input instance (rather than only worst-case optimal). We studied the problem of finding optimal data structures for some of the most important spatial data structures. As an example having a set of n points and an input parameter r, It has been proved that there are input sets for which any simplicial partitions has crossing number ¿(vr). It has also been shown that for any set of n input points and the parameter r one can make a simplicial partition with stabbing number O(vr). However, there are input point sets for which one can make simplicial partition with lower stabbing number. As an example when the points are on a diagonal, one can always make a simplicial partition with stabbing number 1. We started our research by studying BSPs for line segments in the plane, where the cost function is the size of the BSPs. A popular type of BSPs for line segments are the so-called auto-partitions. We proved that finding an optimal auto-partition is NP-hard. In fact, finding out if a set of input segments admits an auto-partition without any cuts is already NP-hard. We also studied the relation between two other types of BSPs, called free and restricted BSPs, and showed that the number of cuts of an optimal restricted BSP for a set of segments in R2 is at most twice the number of cuts of an optimal free BSP for that set. The details are being represented in Chapter 1 of the thesis. Then we turned our attention to so-called rectilinear r-partitions for planar point sets, with the crossing number as cost function. A rectilinear r-partition of a point set P is a partitioning of P into r subsets, each having roughly |P|/r points. The crossing number of the partition is defined using the bounding boxes of the subsets; in particular, it is the maximum number of bounding boxes that can be intersected by any horizontal or vertical line. We performed some theoretical as well as experimental studies on rectilinear r-partitions. On the theoretical side, we proved that computing a rectilinear r-partition with optimal stabbing number for a given set of points and parameter r is NP-hard. We also proposed an exact algorithm for finding optimal rectilinear r-partitions whose running time is polynomial when r is a constant, and a faster 2-approximation algorithm. Our last theoretical result showed that considering only partitions whose bounding boxes are disjoint is not sufficient for finding optimal rectilinear r-partitions. On the experimental side, we performed a comparison between four different heuristics for constructing rectilinear r-partitions. The so-called windmill KD-tree gave the best results. Chapter 2 of the thesis describes all the details of our research on rectilinear r-partitions. We studied another spatial data structure in Chapter 3 of the thesis. Decomposition of the interior of polygons is one of the fundamental problems in computational geometry. In case of a simple polygon one usually wants to make a Steiner triangulation of it, and when we have a rectilinear polygon at hand, one typically wants to make a rectilinear decomposition for it. Due to this reason there are algorithms which make Steiner triangulations and rectangular decompositions with low stabbing number. These algorithms are worst-case optimal. However, similar to the two previous data structures, there are polygons for which one can make decompositions with lower stabbing numbers. In 3 we proposed a 3-approximation for finding an optimal rectangular decomposition of a rectilinear polygon. We also proposed an O(1)-approximation for finding optimal Steiner triangulation of a simple polygon. Finally, in Chapter 4 of the thesis, we considered another optimization problem, namely how to approximate a piecewise-linear function F: R ¿R with another piecewise-linear function with fewer pieces. Here one can distinguish two versions of the problem. The first one is called the min-k problem; the goal is then to approximate the function within a given error e such that the resulting function has the minimum number of links. The second one is called the min-e problem; here the goal is to find an approximation with at most k links (for a given k) such that the error is minimized. These problems have already been studied before. Our contribution is to consider the problem for so-called uncertain functions, where the value of the input function F at its vertices is given as a discrete set of different values, each with an associated probability. We show how to compute an approximation that minimizes the expected error.

New results on binary space partitions in the plane

Non-revisiting stochastic search revisited: Results, perspectives, and future directions

An image coding technique based on symmetry extraction and Binary Space Partitioning (BSP) tree representation for still pictures is presented. Axes of symmetry, detected through a principal axis of inertia approach and a coefficient of symmetry measure, are used to divide recursively an input image into a finite number of convex regions. This recursive partitioning results in the BSP tree representation of the image data. The iterative partition occurs whenever the current left/right node of the tree cannot be represented `symmetrically' by its counterpart, i.e., the right/left node. This splitting process may also end whenever the region associated with a given node has homogeneous characteristics or its size falls below a certain threshold. Given a BSP tree partition for a given input image, and the `seed' leaf nodes (i.e., those that cannot be generated by mirroring their counterparts), the remaining leaf nodes of the tree are reconstructed using a predictive scheme with respect to the `seed' leaf nodes.

BSP trees have been shown to provide an effective representation of polyhedra through the use of spatial subdivision, and are an alternative to the topologically based b-reps. While bsp tree algorithms are known for a number of important operations, such as rendering, no previous work on bsp trees has provided the capability of performing boolean set operations between two objects represented by bsp trees, i.e. there has been no closed boolean algebra when using bsp trees. This paper presents the algorithms required to perform such operations. In doing so, a distinction is made between the semantics of polyhedra and the more fundamental mechanism of spatial partitioning. Given a partitioning of a space, a particular semantics is induced on the space by associating attributes required by the desired semantics with the cells of the partitioning. So, for example, polyhedra are obtained simply by associating a boolean attribute with each cell. Set operations on polyhedra are then constructed on top of the operation of merging spatial partitionings. We present then the algorithm for merging two bsp trees independent of any attributes/semantics, and then follow this by the additional algorithmic considerations needed to provide set operations on polyhedra. The result is a simple and numerically robust algorithm for set operations.

We show that there is always a binary space partition (BSP) of size O(n log k) and an autopartition of size O(nk) for n disjoint line segments in the plane, assuming that the segments have k distinct orientations. In particular, if k is a constant, these bounds imply that there is a linear-size BSP and autopartition. Our proof is constructive and can be turned into algorithms computing such a BSP or autopartition in O(n2 ) and O(n2k ) times.

We present a reactive data structure, that is, a spatial data structure with detail levels. The two properties, spatial organization and detail levels, are the basis for a geographic information system (GIS) with a multi-scale database. A reactive data structure is a novel type of data structure catering to multiple detail levels with rapid responses to spatial queries. It is presented here as a modification of the binary space partitioning tree that includes the levels of detail. This tree is one of the few spatial data structures that does not organize space in a rectangular manner. A prototype system has been implemented. An important result of this implementation is that it shows that binary space partitioning trees of real maps have O(n) storage space complexity in contrast to the theoretical worst case O(n2 ), with n the number of line segments in the map.

The research aims to address one of the complex problems that may be encountered when generating computer images for three-dimensional (3D) objects, which is the hidden surface detection and elimination. Several methods have been devised, through the last three decades, to solve this problem. However, the most popular methods used widely nowadays are depth or Z-Buffer (ZB) and Binary Space Partition Tree (BSPT). The first method (ZB) is very simple and more general but requires additional memory to store depth values in addition to intensity. On the other hand, (BSPT) method is more complex to implement but requires memory for pixel intensity only. Modelling graphical database in a binary tree make the dealing with parts of the database feasible. This is so important for clipping a part or more of the database when outside the viewing zone. The focus of this paper is to study these two methods, design an algorithm to implement each of them. After that a reasonable procedure is to found and applied for testing the performance of each of the two methods using exactly the same graphic load. A step by step increase of this load should be possible so that the behavior of the execution time at different complexity level and on average bases can be reported. The outcome results of the two methods should be compared and a recommendation to use which one of them is to be concluded [1]. Since one of the most popular graphics library which is being used during the last ten years and nowadays is the Open Graphic Library( OpenGL) from(Silicon Graphic Incorporation (SGI)[2], the algorithms of this work are implemented and the related software is carried out using this library with visual C platform.

We revisit the notion of kinetic efficiency for noncanonically defined discrete attributes of moving data, like binary space partitions and triangulations. Under reasonable computational models, we obtain lower bounds on the minimum amount of work required to maintain any binary space partition of moving segments in the plane or any Steiner triangulation of moving points in the plane. Such lower bounds—the first to be obtained in the kinetic context—are necessary to evaluate the efficiency of kinetic data structures when the attribute to be maintained is not canonically defined.

We provide a variety of new results, including upper and lower bounds, as well as simpler proof techniques for the efficient construction of binary space partitions (BSP's) of axis-parallel segments, rectangles, and hyperrectangles. (a) A consequence of the analysis in \cite{dAF} is that any set of $n$ axis-parallel and pairwise-disjoint line segments in the plane admits a binary space partition of size at most $2n-1$. We establish a worst-case lower bound of $2n-o(n)$ for the size of such a BSP, thus showing that this bound is almost tight in the worst case. (b) We give an improved worst-case lower bound of $\frac{9}{4}n-o(n)$ on the size of a BSP for isothetic pairwise disjoint rectangles. (c) We present simple methods, with equally simple analysis, for constructing BSP's for axis-parallel segments in higher dimensions, simplifying the technique of \cite{PY2} and improving the constants. (d) We obtain an alternative construction (to that in \cite{PY2}) of BSP's for collections of axis-parallel rectangles in 3-space. (e) We present a construction of BSP's of size $O(n^{5/3})$ for $n$ axis-parallel pairwise disjoint 2-rectangles in $\reals^4$, and give a matching worst-case lower bound of $\Omega(n^{5/3})$ for the size of such a BSP. (f) We extend the results of \cite{PY2} to axis-parallel $k$-dimensional rectangles in $\reals^d$, for $k

Real-time interference analysis between a tool and an environment

We introduce a parallel approach to geometric modeling of complex objects and scenes, combining a dataflow streaming of BSP trees with a partition of the object space into independent portions, to be evaluated in parallel with minimal interprocess communication. Binary Space Partition (BSP) is a space index used in graphics for hidden-surface removal and animation. We use BSP trees with fuzzy leaves as a progressive representation of solid meshes. Our approach is implemented as a dataflow with processes that progress concurrently, where each refinement of the input to a process is mapped instantly to a refinement of the output, so that the result is also a stream of progressive refinements. This framework allows for progressive generation of complex geometric parts and large-scale assemblies. We have adapted several graphics techniques, including BSP, boundary polygons, CSG, splines and subdivision methods, to fit into our dataflow graph, where four types of processes produce, transform, combineor consume mesh cells. This approach is scalable over different kinds of HPC hardware and different number of computing nodes, by way of the decomposition of the object space and of the distribution of computational processes. Compiling a generative geometric expression into a dataflow graph is well suited to SMP machines, whereas a space decomposition into independent portions fits well with computing clusters and grids.

We present a volume and complexity bounded solid simplification of models represented by Binary Space Partition (BSP). Depending on the compact and robust representation of a solid model in BSP-tree, the boundary surface of a simplified model is guaranteed to be watertight and self-intersection free. Two techniques are investigated in this paper. The volume bounded convex simplification can collapse parts with small volumes on the model into a simple convex volume enclosing the volumetric cells on the input model. The selection of which region to simplify is based on a volume-difference metric, with the help of which the volume difference between the given model and the simplified one is minimized. Another technique is a plane collapse method which reduces the depth of the BSP-tree. These two techniques are integrated into our solid simplification algorithm to give satisfactory results.

A new and efficient ray-tracing method based on the combination of the image theory and the binary space partitioning (BSP) algorithm is presented. The efficiency of the method allows a full three-dimensional implementation of the geometrical optics and the uniform theory of diffraction (GO/UTD). The main feature of the method is the possibility of analyzing the radio channel in general enclosed spaces, including indoor, outdoor and mixed indoor/urban environments. This approach can be used for developing efficient engineering tools for the analysis of the radio channel in wireless and mobile communications systems. Several results that show the accuracy and efficiency of the method are presented.