Showing papers on "Interval tree published in 1997"

Speeding up isosurface extraction using interval trees

Abstract: The interval tree is an optimally efficient search structure proposed by Edelsbrunner (1980) to retrieve intervals on the real line that contain a given query value. We propose the application of such a data structure to the fast location of cells intersected by an isosurface in a volume dataset. The resulting search method can be applied to both structured and unstructured volume datasets, and it can be applied incrementally to exploit coherence between isosurfaces. We also address issues of storage requirements, and operations other than the location of cells, whose impact is relevant in the whole isosurface extraction task. In the case of unstructured grids, the overhead, due to the search structure, is compatible with the storage cost of the dataset, and local coherence in the computation of isosurface patches is exploited through a hash table. In the case of a structured dataset, a new conceptual organization is adopted, called the chess-board approach, which exploits the regular structure of the dataset to reduce memory usage and to exploit local coherence. In both cases, efficiency in the computation of surface normals on the isosurface is obtained by a precomputation of the gradients at the vertices of the mesh. Experiments on different kinds of input show that the practical performance of the method reflects its theoretical optimality.

Succinct representation of balanced parentheses, static trees and planar graphs

Abstract: We consider the implementation of abstract data types for the static objects: binary tree, rooted ordered tree and balanced parenthesis expression. Our representations use an amount of space within a lower order term of the information theoretic minimum and support, in constant time, a richer set of navigational operations than has previously been considered in similar work. In the case of binary trees, for instance, we can move from a node to its left or right child or to the parent in constant time while retaining knowledge of the size of the subtree at which we are positioned. The approach is applied to produce succinct representation of planar graphs in which one can test adjacency in constant time.

New Approximation Algorithms for the Steiner Tree Problems

Abstract: The Steiner tree problem asks for the shortest tree connecting a given set of terminal points in a metric space. We design new approximation algorithms for the Steiner tree problems using a novel technique of choosing Steiner points in dependence on the possible deviation from the optimal solutions. We achieve the best up to now approximation ratios of 1.644 in arbitrary metric and 1.267 in rectilinear plane, respectively.

I/O optimal isosurface extraction

Abstract: The authors give I/O-optimal techniques for the extraction of isosurfaces from volumetric data, by a novel application of the I/O-optimal interval tree of Arge and Vitter (1996). The main idea is to preprocess the data set once and for all to build an efficient search structure in disk, and then each time one wants to extract an isosurface, they perform an output-sensitive query on the search structure to retrieve only those active cells that are intersected by the isosurface. During the query operation, only two blocks of main memory space are needed, and only those active cells are brought into the main memory, plus some negligible overhead of disk accesses. This implies that one can efficiently visualize very large data sets on workstations with just enough main memory to hold the isosurfaces themselves. The implementation is delicate but not complicated. They give the first implementation of the I/O-optimal interval tree, and also implement their methods as an I/O filter for Vtk's isosurface extraction for the case of unstructured grids. They show that, in practice, the algorithms improve the performance of isosurface extraction by speeding up the active-cell searching process so that it is no longer a bottleneck. Moreover, this search time is independent of the main memory available. The practical efficiency of the techniques reflects their theoretical optimality.

Flexible tree-structured signal expansions using time-varying wavelet packets

Abstract: Addresses the problem of finding the best time-varying filter bank tree-structured representation for a signal. The tree is allowed to vary at regular intervals, and the spacing of these changes can be arbitrarily short. The question of how to choose tree-structured representations of signals based on filter banks is considered. Wavelets and their adaptive version, known as wavelet packets, represent one approach that is popular. Wavelet packets are subband trees where the tree is chosen to match the characteristics of the signal. Variations where the tree varies over time have been proposed as the double tree and the time-frequency tree algorithms. Time-variation adds a further level of adaptivity. In all of the approaches proposed so far, the tree must be either fixed for the whole duration of the signal or fixed for its dyadic subintervals. The solution that we propose, as it allows more flexible variation, is an advance on the wavelet packet algorithm, the double tree algorithm, and the recently proposed time-frequency tree algorithm. Our solution is based on casting it in a dynamic programming (DP) setting. Focusing on compression applications, we use a Lagrangian cost of distortion +/spl lambda//spl times/rate as the objective function and explain our algorithm in detail, pointing out its relation to existing approaches to the problem. We demonstrate that the new algorithm indeed searches a larger library of representations than previously possible and that overcoming the constraint of dyadic time segmentations gives a significant improvement in practice.

SS+ tree: an improved index structure for similarity searches in a high-dimensional feature space

Abstract: In this paper, we describe the SS+-tree, a tree structure for supporting similarity searches in a high- dimensional Euclidean space. Compared to the SS-tree, the tree uses a tighter bounding sphere for each node which is an approximation to the smallest enclosing sphere and it also makes a better use of the clustering property of the available data by using a variant of the k-means clustering algorithm as the split heuristic for its nodes. A local reorganization rule is also introduced during the tree building to reduce the overlapping between the nodes' bounding spheres.© (1997) COPYRIGHT SPIE--The International Society for Optical Engineering. Downloading of the abstract is permitted for personal use only.

Temporally ordered binary search method and system

Abstract: A method and system for maintaining a binary tree of pointers to a stream of data and for searching same. A novel binary tree is created by a search engine in which the nodes associated with strings in the data stream which are closer to the current data stream position are nearer the root of the tree than nodes associated with strings which are farther. As the current position in the stream is advanced, the search engine inserts a new node to the tree for that position as the root node. The tree is then restructured based on the relative value of the strings of each node while preserving the temporal order of the tree such that strings nearer the current position are associated with nodes which are closer to the root. The tree is ideal for searching data for LZ77-based data compression, since a single traversal of the tree returns the longest match length with the smallest offset.

Parallel system and method for generating classification/regression tree

Abstract: A classification tree generating system generates a classification tree in response to a training database including a plurality of properly-classified records. A parallel base tree generating means including a plurality of processing nodes generates nodes of a base classification tree in parallel in a series of iterations, in each iteration generating nodes comprising a particular tree level in parallel. After the processing nodes generate the base classification tree in parallel, a serial tree processing means including a single processor generates a plurality of pruned classification trees in response to the base classification tree and at least one selected evaluation metric for each of the pruned trees in response to an evaluation training database including a second plurality of properly-classified records.

Oblique Linear Tree

Abstract: In this paper we present system Ltree for proposicional supervised learning. Ltree is able to define decision surfaces both orthogonal and oblique to the axes defined by the attributes of the input space. This is done combining a decision tree with a linear discriminant by means of constructive induction. At each decision node Ltree defines a new instance space by insertion of new attributes that are projections of the examples that fall at this node over the hyper-planes given by a linear discriminant function. This new instance space is propagated down through the tree. Tests based on those new attributes are oblique with respect to the original input space. Ltree is a probabilistic tree in the sense that it outputs a class probability distribution for each query example. The class probability distribution is computed at learning time, taking into account the different class distributions on the path from the root to the actual node. We have carried out experiments on sixteen benchmark datasets and compared our system with other well known decision tree systems (orthogonal and oblique) like C4.5, OC1 and LMDT. On these datasets we have observed that our system has advantages in what concerns accuracy and tree size at statistically significant confidence levels.

More Geometric Data Structures

Abstract: In the future most cars will be equipped with a vehicle navigation system to help you determine your position and to guide you to your destination. Such a system stores a roadmap of, say, the whole of the U.S. It also keeps track of where you are, so that it can show the appropriate part of the roadmap at any time on a little computer screen; this will usually be a rectangular region around your present position. Sometimes the system will do even more for you. For example, it might warn you when a turn is coming up that you should take to get to your destination.

Image processing in a tree of peano coded images

Abstract: The authors investigate some attractive features of the 1-D sequence of pixels produced by the peano traversal of an image. They introduce two new hardware operations called bit-spreaded-meshing and its inverse brit-collation to produce and invert the sequence in real-time. A compact binary tree built using this sequence at its base implicitly contains the well known quadtree of the image also. The binary tree representation supports efficient design and implementation of divide and conquer algorithms. Its construction is readily extendable to higher dimensional images. They present a global optimization algorithm for image segmentation whose design is based on the binary tree. It produces a minimal cutset of homogeneous nodes in the tree using a dynamic programming technique. The experimental results assert the merit of the binary tree based implementation compared to its counterpart the quadtree.

On dynamic tree growing in hypercubes

Abstract: Abst rac t A key issue in performing tree structured parallel computations is to distribute process components of a parallel program over processors in a parallel computer at run time such that both the maximum load and dilation are minimized. The main contribution of this paper is the application of recurrence relations in studying the performance of a dynamic tree embedding algorithm in hypercubes. We show recurrence relations that characterize the expected maximum load in randomized tree embeddings where, a tree grows by letting its nodes to take random walks of short distance. By using these recurrence relations, we are able to calculate the expected load on each processor. Therefore, for constant dilation embeddings, we are able to evaluate expected loads numerically and analytically. The applicability of recurrence relations is due to the recursive structure of trees and the fact that embeddings of the subtrees of a process node-are independent of each other. Our methodology does not depend on the hypercube topology. Hence, it can be applied to study dynamic tree growing in other networks.

A parallel algorithm for constructing a labeled tree

Abstract: A tree T is labeled when the n vertices are distinguished from one another by names such as v/sub 1/, v/sub 2/...v/sub n/. Two labeled trees are considered to be distinct if they have different vertex labels even though they might be isomorphic. According to Cayley's tree formula, there are n/sup n-2/ labeled trees on n vertices. Prufer used a simple way to prove this formula and demonstrated that there exists a mapping between a labeled tree and a number sequence. From his proof, we can find a naive sequential algorithm which transfers a labeled tree to a number sequence and vice versa. However, it is hard to parallelize. In this paper, we shall propose an O(log n) time parallel algorithm for constructing a labeled tree by using O(n) processors and O(n log n) space on the EREW PRAM computational model.

Increasing retrieval efficiency by index tree adaptation

Abstract: Image databases often operate in a query-by-example mode where images are retrieved according to feature (dis-)similarity to an example image. Retrieval efficiency is increased by using indexing trees such as kd-trees, quadtrees or R*-trees. However, such trees are usually constructed without reference to the similarity measure, and in practice their performance degrades when the threshold on the similarity value increases beyond zero. This phenomenon is analyzed in this paper with a probabilistic model, and an expression is obtained for the average computation in the tree. Based on this analysis, a greedy algorithm is proposed which adapts the tree by eliminating inefficient nodes. The greedy algorithm is based on a lMarkovianr property of indexing trees. The algorithm is iterative and is guaranteed to improve the performance of the tree with every iteration. Experimental evaluation of the performance of adapted trees for randomly distributed data is reported. The experiments indicate that the performance of the tree improves significantly after adaptation

A Note on Updating Suffix Tree Labels

Abstract: We investigate the problem of maintaining the arc labels in the suffix tree data structure [15] when it undergoes string insertions and deletions. In current literature, this problem is solved either by a simple accounting strategy to obtain amortized bounds [10, 18] or by a periodical suffix tree reconstruction to obtain worst-case bounds (according to the global rebuilding technique in [20]). Unfortunately, the former approach is simple and space-efficient at the cost of attaining amortized bounds for the single update; the latter is space-consuming in practice because it needs to keep two extra suffix tree copies. In this paper, we obtain a surprisingly simple real-time algorithm that achieves worst-case bounds and only requires small additional space (i.e., a bi-directional pointer per suffix tree arc). We analyze the problem by introducing a combinatorial coloring problem on the suffix tree arcs.

An efficient method for version control of a tree data structure

Abstract: A new method for version controlling of a tree structure is presented. The key feature of the method is that the latest state of a tree is retained and other versions are constructed from it on request, and information on the change history of a node is maintaind in its parent node. Several algorithms for efficient manipulation of the tree have been developed, and it has been demonstrated that they correctly manipulate the tree. The performance of these algorithms has been compared with those of other tree-based methods, and found to be nearly optimal in all aspects of the comparison. © 1997 John Wiley & Sons, Ltd.

The average diameter of binary tree structures

Abstract: In this paper, we s tudy tile static behavior of dist r ibuted memory architecture with a tree structure as its intercommction network. Particularly, we will show that the averaqe diameter of a binary tree with n processors is (-)(logn). We will also briefly discuss the extension of our results to a general tree structure. 1 M e s s a g e Transmiss ion in a Tree S t ruc tured N e t w o r k As an interconnection network for a distributed memory architecture, tile tree structure, particularly, the binary tree structure, has been studied extensively [3, 7, 12, 16]. Basic parallel algorithms for such operations as addition, comparison and counting, etc., supported with binary trees were investigated in [6], and more recently, in [8]. This structure has also been implemented in experimental, "'Permission to make digital or hard copies of part or all of this work for personal or classroom use is granted without tee provided that copies are not made or distributed for profit or commercial advantage and that copies bear 'his notice ,and the lull citation on the first page. Copyrights for components lhis work owned by others than ACM must be honored. Abstracting with :dit is permitted. To copy otherwise, to republish, to post on servers or to distribute to lists, requires prior specific permission and/or a fee." .,1997 ACM 0-89791-850-9 97 0002 3.50 as well as real machines. For example, tile DADO parallel computer uses a binary tree interconnection network [11] for the rapid execution of rulebased, M-oriented software and the CM5 machine uses an augmented binary tree structure, called fattree [5, 13]. In a binary tree s t ructured network, a significant amount of the inter-processor communicat ion is carried out around the root [8]. Da ta are sent from various internal nodes to the root and then broadcast to others. For a binary tree with n nodes, this part of its communicat ion behavior can be characterized as O( n v ~ ) , which is the average value of the inteT~nal path length, as defined and analyzed in [4, g 2.3.4.5]. A load balancing s t ra tegy was described for tree structures with two way traffic in [7], in which a scheduling program determines "whether a job that arrives at a local node should be processed at the node or should be forwarded to another node for processing." Clearly, such a job could be sent anywhere in the structure, as long as a lighter load is found. Such information exchange over arbi t rary distance is also quite common in AI, e.g., rain-max tree construction and various search algori thm applications, as well as in the ever existing routing problems. In tackling this kinds of problems, it is not desirable to always send message via the root of tile tree, as this will quickly make tile root into a bottleneck [8]. Hence, to achieve high efficiency, tile ordinary, direct, communicat ion between any two processors is also necessary in a tree s t ructured network. The measurement of average diameter satisfactorily characterize this lat ter kind of interprocessor communication, without going through a center, within any network. Originally suggested in [10], average diameter

Context-tree weighting for text-sources

Abstract: The context-tree weighting (CTW) algorithm is a universal source coding algorithm for binary tree sources. This paper presents 3 techniques that modify the CTW algorithm for non-binary, and especially for ASCII-character oriented, tree sources.

Efficient Splitting and Merging Algorithms for Order Decomposable Problems (Extended Abstract)

Abstract: We present a general and novel technique for solving decomposable problems on a set S whose items are sorted with respect to d > 1 total orders. We show how to dynamically maintain S in the following time bounds: O(log p) for the insertion or the deletion of a single item, where p is the number of items currently in S; O(p 1-1/d ) for splits and concatenates along any total order; O(p 1-1/d ) plus an output sensitive cost for rectangular range queries. The space required is O(p). We provide several applications of our technique ranging from two-dimensional priority queues and d-dimensional search trees to concatenable interval trees. This allows us to improve many previously known results on decomposable problems under split and concatenate operations, such as membership query, minimum-weight item, range query, and convex hulls. Our technique is suitable for efficient external memory implementation.

Efficient parallel algorithms for optimally locating a k-leaf tree in a tree network

Abstract: In this paper, an efficient parallel algorithm is proposed for finding a k-tree core of a tree network. The proposed algorithm performs on the EREW PRAM in O(log n log* n) time using O(n) work.

Extending the regular restriction of resolution to non-linear subdeductions

Abstract: A binary resolution proof, represented as a binary tree, is irregular if some atom is resolved away and reappears on the same branch. We develop an algorithm, linear in the size of the tree, which detects whether reordering the resolutions in a given proof will generate an irregular proof. If so, the given proof is not minimal. A deduction system that keeps only minimal proofs retains completeness. We report on an initial implementation.

Seed Sets and Search Structures for Accelerated Isocontouring

Abstract: We present three algorithms for the construction of seed sets, a subset of a cell complex which contains at least one cell for each connected component of each isocontour, for all possible isovalues. Seed sets reduce the storage requirements of high performance search structures for isocontouring, such as the segment tree or the interval tree. The three algorithms determine seed sets with varying properties. The first computes seed sets within a constant factor of the optimal size, requiring O(nlogn) time, where n is the size of the mesh. A more conservative approach computes seed sets of slightly larger size with O(n) processing time, and is very amenable to parallel processing. The seeds produced follow a particular pattern which can be leveraged for performing out-of-core isocontouring, dynamically loading only the data which is necessary from secondary storage or a remote server. A specialized form of the second algorithm for regular grids computes seed sets of intermediate size, with only slightly additional effort and the same computational complexity. We examine the use of three search structures and compare their application to the seed sets and full sets of cells from a variety of computational grids.