Showing papers on "Adjacency list published in 2004"

Semi-Supervised Learning on Riemannian Manifolds

Abstract: We consider the general problem of utilizing both labeled and unlabeled data to improve classification accuracy. Under the assumption that the data lie on a submanifold in a high dimensional space, we develop an algorithmic framework to classify a partially labeled data set in a principled manner. The central idea of our approach is that classification functions are naturally defined only on the submanifold in question rather than the total ambient space. Using the Laplace-Beltrami operator one produces a basis (the Laplacian Eigenmaps) for a Hilbert space of square integrable functions on the submanifold. To recover such a basis, only unlabeled examples are required. Once such a basis is obtained, training can be performed using the labeled data set. Our algorithm models the manifold using the adjacency graph for the data and approximates the Laplace-Beltrami operator by the graph Laplacian. We provide details of the algorithm, its theoretical justification, and several practical applications for image, speech, and text classification.

Quantum query complexity of some graph problems

Abstract: Quantum algorithms for graph problems are considered, both in the adjacency matrix model and in an adjacency list-like array model. We give almost tight lower and upper bounds for the bounded error quantum query complexity of Connectivity, Strong Connectivity, Minimum Spanning Tree, and Single Source Shortest Paths. For example we show that the query complexity of Minimum Spanning Tree is in Θ(n 3/2) in the matrix model and in \(\Theta(\sqrt{nm})\) in the array model, while the complexity of Connectivity is also in Θ(n 3/2) in the matrix model, but in Θ(n) in the array model. The upper bounds utilize search procedures for finding minima of functions under various conditions.

Optimizing graph algorithms for improved cache performance

Abstract: We develop algorithmic optimizations to improve the cache performance of four fundamental graph algorithms We present a cache-oblivious implementation of the Floyd-Warshall algorithm for the fundamental graph problem of all-pairs shortest paths by relaxing some dependencies in the iterative version We show that this implementation achieves the lower bound on processor-memory traffic of /spl Omega/(N/sup 3///spl radic/C), where N and C are the problem size and cache size, respectively Experimental results show that this cache-oblivious implementation shows more than six times the improvement in real execution time over that of the iterative implementation with the usual row major data layout, on three state-of-the-art architectures Second, we address Dijkstra's algorithm for the single-source shortest paths problem and Prim's algorithm for minimum spanning tree problem For these algorithms, we demonstrate up to two times the improvement in real execution time by using a simple cache-friendly graph representation, namely adjacency arrays Finally, we address the matching algorithm for bipartite graphs We show performance improvements of two to three times in real execution time by using the technique of making the algorithm initially work on subproblems to generate a suboptimal solution and, then, solving the whole problem using the suboptimal solution as a starting point Experimental results are shown for the Pentium III, UltraSPARC III, Alpha 21264, and MIPS R12000 machines

Scalable mining of large disk-based graph databases

Abstract: Mining frequent structural patterns from graph databases is an interesting problem with broad applications. Most of the previous studies focus on pruning unfruitful search subspaces effectively, but few of them address the mining on large, disk-based databases. As many graph databases in applications cannot be held into main memory, scalable mining of large, disk-based graph databases remains a challenging problem. In this paper, we develop an effective index structure, ADI (for adjacency index), to support mining various graph patterns over large databases that cannot be held into main memory. The index is simple and efficient to build. Moreover, the new index structure can be easily adopted in various existing graph pattern mining algorithms. As an example, we adapt the well-known gSpan algorithm by using the ADI structure. The experimental results show that the new index structure enables the scalable graph pattern mining over large databases. In one set of the experiments, the new disk-based method can mine graph databases with one million graphs, while the original gSpan algorithm can only handle databases of up to 300 thousand graphs. Moreover, our new method is faster than gSpan when both can run in main memory.

Method for recursive BGP route updates in MPLS networks

Abstract: A method for providing BGP route updates in an MPLS network is disclosed The route update is performed at a router having a forwarding information table containing BGP routes and an internal label, and an adjacency table containing BGP/VPN labels and said internal label The internal label corresponds to at least one IGP route and has an adjacency associated therewith The method includes updating the adjacency associated with the internal label following an IGP route change

Classification of web documents using graph matching

Abstract: In this paper we describe a classification method that allows the use of graph-based representations of data instead of traditional vector-based representations. We compare the vector approach combined with the k-Nearest Neighbor (k-NN) algorithm to the graph-matching approach when classifying three different web document collections, using the leave-one-out approach for measuring classification accuracy. We also compare the performance of different graph distance measures as well as various document representations that utilize graphs. The results show the graph-based approach can outperform traditional vector-based methods in terms of accuracy, dimensionality and execution time.

Optimizing flooding of information in link-state routing protocol

Abstract: A router executes a flooding algorithm. The router maintains a list of neighbors within an area data structure. When a new neighbor arises on an interface belonging to an area served by the router, the router updates the neighbor data structure describing that adjacency by linking it to a corresponding entry in the list of neighbors. Utilizing information contained in the list of neighbors, as well as information describing the types of interfaces used by the neighbors in the list, the router marks each interface data structure within the area as either flooding-active or flooding-passive. Marking of the interface is performed in connection with an interface election process that selects a flooding-active interface on the basis of, e.g., interface cost, giving preference to faster interfaces. Thereafter, link state protocol data units (PDUs) are sent to the neighbors over those interfaces marked as flooding-active.

Segmentation graph hierarchies

Abstract: The region’s internal properties (color, texture, ...) help to identify them and their external relations (adjacency, inclusion, ...) are used to build groups of regions having a particular consistent meaning in a more abstract context. Low-level cue image segmentation in a bottom-up way, cannot and should not produce a complete final “good” segmentation. We present a hierarchical partitioning of images using a pairwise similarity function on a graph-based representation of an image. The aim of this paper is to build a minimum weight spanning tree (MST) of an image in order to find region borders quickly in a bottom-up ’stimulus-driven’ way based on local differences in a specific feature.

An Experimental Analysis of a Compact Graph Representation

Abstract: In previous work we described a method for compactly representing graphs with small separators, which makes use of small separators, and presented preliminary experimental results In this paper we extend the experimental results in several ways, including extensions for dynamic insertion and deletion of edges, a comparison of a variety of coding schemes, and an implementation of two applications using the representation The results show that the representation is quite effective for a wide variety of real-world graphs, including graphs from finite-element meshes, circuits, street maps, router connectivity, and web links In addition to significantly reducing the memory requirements, our implementation of the representation is faster than standard representations for queries The byte codes we introduce lead to DFT times that are a factor of 25 faster than our previous results with gamma codes and a factor of between 1 and 9 faster than adjacency lists, while using a factor of between 3 and 6 less space

String edit distance, random walks and graph matching

Abstract: This paper shows how the eigenstructure of the adjacency matrix can be used for the purposes of robust graph matching. We commence from the observation that the leading eigenvector of a transition probability matrix is the steady state of the associated Markov chain. When the transition matrix is the normalized adjacency matrix of a graph, then the leading eigenvector gives the sequence of nodes of the steady state random walk on the graph. We use this property to convert the nodes in a graph into a string where the node-order is given by the sequence of nodes visited in the random walk. We match graphs represented in this way, by finding the sequence of string edit operations which minimize edit distance.

Permutation decoding for the binary codes from triangular graphs

Abstract: By finding explicit PD-sets we show that permutation decoding can be used for the binary code obtained from an adjacency matrix of the triangular graph T(n) for any n ≥ 5.

Hardware-determined feature edges

Abstract: Algorithms that detect silhouettes, creases, and other edge based features often perform per-edge and per-face mesh computations using global adjacency information These are unsuitable for hardware-pipeline implementation, where programmability is at the vertex and pixel level and only local information is available Card and Mitchell and Gooch have suggested that adjacency information could be packed into a vertex data structure; we describe the details of converting global/per-edge computations into local/per-vertex computations on a related 'edge mesh' Using this trick, we describe a feature-edge detection algorithm that runs entirely in hardware, and show how to use it to create thick screen-space contours with end-caps that join adjacent thick line segments The end-cap technique favors speed over quality and produces artifacts for some meshesWe present two parameterizations for mapping stroke textures onto these thick lines---a tessellation-independent screen space method that is better suited to still images, and an object space method better suited to animation As additional applications, we show how to create fins for fur rendering and how to extrude contours in world-space to create the sides of a shadow volume directly on the GPUThe edge mesh is about nine times larger than the original mesh when stored at 16-bit precision and is constructed through a linear time pre-processing step As long as topology remains fixed, the edge mesh can be animated as if it were a vertex mesh

Para-Graph: graph-based parameterization of triangle meshes with arbitrary genus

Abstract: This paper describes a novel approach to the parameterization of triangle meshes representing 2-manifolds with an arbitrary genus. A topology-based decomposition of the shape is computed and used to segment the shape into primitives, which define a chart decomposition of the mesh. Then, each chart is parameterized using an extension of the barycentric coordinates method. The charts are all 0-genus and can be of three types only, depending on the number of boundary components. The chart decomposition and the parameterization are used to define a shape graph where each node represents one primitive and the arcs code the adjacency relationships between the primitives. Conical and cylindrical primitives are coded together with their skeletal lines that are computed from and aligned with their parameterization. The application of the parameterization approach to remeshing guarantees that extraordinary vertices are localized only where two patches share a boundary and they are not scattered on the whole surface.

A multi-resolution topological representation for non-manifold meshes

Abstract: We address the problem of representing and processing 3D objects, described through simplicial meshes, which consist of parts of mixed dimensions, and with a non-manifold topology, at different levels of detail. First, we describe a multi-resolution model, that we call a non-manifold multi-tessellation (NMT), and we consider the selective refinement query, which is at the heart of several analysis operations on multi-resolution meshes. Next, we focus on a specific instance of a NMT, generated by simplifying simplicial meshes based on vertex-pair contraction, and we describe a compact data structure for encoding such a model. We also propose a new data structure for two-dimensional simplicial meshes, capable of representing both connectivity and adjacency information with a small memory overhead, which is used to describe the mesh extracted from an NMT through selective refinement. Finally, we present algorithms to efficiently perform updates on such a data structure.

Implicit Flow Maximization by Iterative Squaring

Abstract: Application areas like logic design and network analysis produce large graphs G=(V,E) on which traditional algorithms, which work on adjacency list representations, are not practicable anymore. These large graphs often contain regular structures that enable compact implicit representations by decision diagrams like OBDDs [1, 2, 3]. To solve problems on such implicitly given graphs, specialized algorithms are needed. These are considered as heuristics with typically higher worst-case runtimes than traditional methods. In this paper, an implicit algorithm for flow maximization in 0–1 networks is presented, which works on OBDD-representations of node and edge sets. Because it belongs to the class of layered-network methods, it has to construct blocking-flows. In contrast to previous implicit methods, it avoids breadth-first searches and layer-wise proceeding, and uses iterative squaring instead. In this way, the algorithm needs to execute only O(log2|V|) operations on the OBDDs to obtain a layered-network or at least one augmenting path, respectively. Moreover, each OBDD-operation is efficient if the node and edge sets are represented by compact OBDDs during the flow computation. In order to investigate the algorithm’s behavior on large and structured networks, it has been analyzed on grid networks, on which a maximum flow is computed in polylogarithmic time O(log3|V|) and space O(log2|V|). In contrast, previous methods need time and space Ω(|V|1/2log|V|) on grids, and are beaten also in experiments for |V| ≥ 226.

ACG-adjacent constraint graph for general floorplans

Abstract: ACG (adjacent constraint graph) is invented as a general floorplan representation. It has advantages of both adjacency graph and constraint graph of a floorplan: edges in an ACG are between modules close to each other, thus the physical distance of two modules can be measured directly in the graph; since an ACG is a constraint graph, the floorplan area and module positions can be simply found by longest path computations. A natural combination of horizontal and vertical relations within one graph renders a beautiful data structure with full symmetry. The direct correspondence between geometrical positions of modules and ACG structures also makes it easy to incrementally change a floorplan and evaluate the result. Experimental results show the superiority of this representation.

Programming the Hilbert curve

Abstract: The Hilbert curve has previously been constructed recursively, using p levels of recursion of n‐bit Gray codes to attain a precision of p bits in n dimensions. Implementations have reflected the awkwardness of aligning the recursive steps to preserve geometrical adjacency. We point out that a single global Gray code can instead be applied to all np bits of a Hilbert length. Although this “over‐transforms” the length, the excess work can be undone in a single pass over the bits, leading to compact and efficient computer code.

Systems and methods for forming an adjacency graph for exchanging network routing data

Abstract: A system for exchanging routing information over a communications network constructs a connectivity graph that indicates connectivity between a first node and a first set of nodes in the network. The system constructs an adjacency graph that indicates a second set of nodes with which the first node will exchange routing data, where the adjacency graph is distinct from the connectivity graph. The system exchanges routing data between the first node and each node of the second set of nodes based on the adjacency graph.

A graph search algorithm for optimal control of hybrid systems

Abstract: For optimally controlling hybrid automata with nonlinear continuous dynamics and discrete as well as continuous inputs, an approach combining graph search techniques with principles of optimal control has recently been proposed The main idea is to embed nonlinear programming and hybrid system simulation into a graph search algorithm that selects the discrete degrees of freedom When applying this approach, it can be observed that often large numbers of almost identical evolutions of the hybrid system are explored with no (or marginal) improvement of the system performance In order to obtain a better coverage of the hybrid search space, the method is here extended by the notion of adjacency criteria The principle is to determine locally optimal trajectories from the set of almost identical evolutions, to postpone the evaluation of suboptimal ones, and thus to obtain qualitatively different solutions with low effort The adjacency criteria can either be used as a search heuristics or, if a near-optimal solution is sufficient, to prune the search graph

Fast road network extraction in satellite images using mathematical morphology and Markov random fields

Abstract: We present a fast method for road network extraction in satellite images It can be seen as a transposition of the segmentation scheme "watershed transform + region adjacency graph + Markov random fields" to the extraction of curvilinear objects Many road extractors which are composed of two stages can be found in the literature The first one acts like a filter that can decide from a local analysis, at every image point, if there is a road or not The second stage aims at obtaining the road network structure In the method, we propose to rely on a "potential" image, that is, unstructured image data that can be derived from any road extractor filter In such a potential image, the value assigned to a point is a measure of its likelihood to be located in the middle of a road A filtering step applied on the potential image relies on the area closing operator followed by the watershed transform to obtain a connected line which encloses the road network Then a graph describing adjacency relationships between watershed lines is built Defining Markov random fields upon this graph, associated with an energetic model of road networks, leads to the expression of road network extraction as a global energy minimization problem This method can easily be adapted to other image processing fields, where the recognition of curvilinear structures is involved

Constant Curvature Region Decomposition of 3D- Meshes by a Mixed Approach Vertex-Triangle

Abstract: We present a new and efficient algorithm for decomposition of arbitrary triangle meshes into connected subsets of meshes called regions. Our method, based on discrete curvature analysis decomposes the object into almost constant curvature surfaces and not only “cut” the object along its hard edges like traditional methods. This algorithm is an hybrid approach vertex-triangle, it is based on three major steps: vertices are first classified using their discrete curvature values, then connected triangle regions are extracted via a region growing process and finally similar regions are merged using a region adjacency graph in order to obtain final patches. Experiments were conducted on both CAD and natural models, results are satisfactory. Segmented patches can then be used instead of the complete complex model to facilitate computer graphic tasks such as smoothing, surface fitting or compression.

Multigrid and multi-level Swendsen-Wang cuts for hierarchic graph partition

Abstract: Many vision tasks can be formulated as partitioning an adjacency graph through optimizing a Bayesian posterior probability p defined on the partition-space. In this paper two approaches are proposed to generalize the Swendsen-Wang cut algorithm [A. Barbu and S.C. Zhu 2003] for sampling p. The first method is called multigrid SW-cut which runs SW-cut within a sequence of local "attentional" windows and thus simulates conditional probabilities of p in the partition space. The second method is called multi-level SW-cut which projects the adjacency graph into a hierarchical representation with each vertex in the high level graph corresponding to a sub-graph at the low level, and runs SW-cut at each level. Thus it simulates conditional probabilities of p at the higher level. Both methods are shown to observe the detailed balance equation and thus provide flexibilities in sampling the posterior probability p. We demonstrate the algorithms in image and motion segmentation with three levels (see Fig.1), and compare the speed improvement of the proposed methods.

Levenshtein distance for graph spectral features

Abstract: Graph structures play a critical role in computer vision, but they are inconvenient to use in pattern recognition tasks because of their combinatorial nature and the consequent difficulty in constructing feature vectors. Spectral representations have been used for this task which are based on the eigensystem of the graph Laplacian matrix. However, graphs of different sizes produce eigensystems of different sizes where not all eigenmodes are present in both graphs. We use the Levenshtein distance to compare spectral representations under graph edit operations which add or delete vertices. The spectral representations are therefore of different sizes. We use the concept of the string-edit distance to allow for the missing eigenmodes and compare the correct modes to each other. We evaluate the method by first using generated graphs to compare the effect of vertex deletion operations. We then examine the performance of the method on graphs from a shape database.

Grouping and Segmentation in a Hierarchy of Graphs

Abstract: We review multilevel hierarchies under the special aspect of their potential for segmentation and grouping. The one-to-one correspondence between salient image features and salient model features are a limiting assumption that makes prototypical or generic object recognition impossible. The region's internal properties (color, texture, shape, ...) help to identify them and their external relations (adjacency, inclusion, similarity of properties) are used to build groups of regions having a particular consistent meaning in a more abstract context. Low-level cue image segmentation in a bottom-up way, cannot and should not produce a complete final "good" segmentation. We present a hierarchical partitioning of images using a pairwise similarity function on a graph-based representation of an image. This function measures the difference along the boundary of two components relative to a measure of differences of the components' internal differences. Two components are merged if there is a low-cost connection between them. We use this idea to find region borders quickly and effortlessly in a bottom-up way, based on local differences in a specific feature. The aim of this paper is to build a minimum weight spanning tree (MST) in order to find region borders quickly in a bottom-up 'stimulus-driven' way based on local differences in a specific feature.

Distance in space syntax

Abstract: We explore ways of introducing Euclidean distances associated with street systemsrepresented by axial lines into the two connectivity graphs based on points (or streetjunctions), and on lines (or streets), the so-called dual and primal representations ofthe space syntax problem. As the axial line is embedded in the connectivity graphbetween the points, for the dual problem the specification of Euclidean distancebetween points is relatively trivial but for the original syntax problem, this isproblematic in that it requires us to find a unique point representation for each line.The key is to find the centroids of the lines (of sight or unobstructed movement)between the points on each axial line, and then to use these to form a weightedcentroid of centroids. The distances between axial lines which form paths through theconnectivity graph between streets, are then computed using these centroids asstarting points for each line and routing distance through the street junctions.There are many issues involving interpretation of these measures. It might be thoughtthat the longer an axial line, the more important it is. But by giving an axial linedistance, this suggests that this is a deterrence to interaction, as in spatial interactiontheory, with longer axial lines being individually less important, notwithstanding theprobability that they are better connected within the overall street system. Clearly inmany finer-scale morphologies, this assumption might not be tenable but the measuresdeveloped here can be easily adapted to various circumstances. What this focus ondistance enables us to do is to treat a ?mixed syntax? problem where we are able toembed truly planar graphs into the axial map. This extends the technique to deal withsystems not only comprising streets down which we can see, but also fixed rail lines,subway systems, footpaths and so on which currently are hard to handle in thetraditional theory. We illustrate the extended theory for a pure syntax problem, theFrench village of Gassin, and a mixed syntax problem based on the grid of streets andunderground railways in central Melbourne. In conclusion, we introduce the notionthat proximity or adjacency at different orders might form more appropriate measuresof syntax distance, the proximity of nodes to nodes and lines to lines in the dual andthe primal being illustrated for both Gassin and central Melbourne.

Fast 3-Coloring Triangle-Free Planar Graphs

Abstract: We show the first o(n 2) algorithm for coloring vertices of triangle-free planar graphs using three colors. The time complexity of the algorithm is \(\mathcal{O}\) (n log n). Our approach can be also used to design \(\mathcal{O}\)(n polylog n)-time algorithms for two other similar coloring problems.

Adjacency Preserving Mappings of Rectangular Matrices

Abstract: Let D be a division ring and let m,n be integers ≥ 2. Let Mm×n(D) be the space of m × n matrices. In the fundamental theorem of the geometry of rectangular matrices all bijective mappings φ of Mm×n(D) are determined such that both φ and φ−1 preserve adjacency. We show that if a bijective map φ of Mm×n(D) preserves the adjacency then also φ −1 preserves the adjacency. Thus the supposition that φ−1 preserves adjacency may be omitted in the fundamental theorem. MSC 2000: 15A99, 51D20

Content-based image retrieval by matching hierarchical attributed region adjacency graphs

Abstract: Content-based image retrieval requires a formal description of visual information. In medical applications, all relevant biological objects have to be represented by this description. Although color as the primary feature has proven successful in publicly available retrieval systems of general purpose, this description is not applicable to most medical images. Additionally, it has been shown that global features characterizing the whole image do not lead to acceptable results in the medical context or that they are only suitable for specific applications. For a general purpose content-based comparison of medical images, local, i.e. regional features that are collected on multiple scales must be used. A hierarchical attributed region adjacency graph (HARAG) provides such a representation and transfers image comparison to graph matching. However, building a HARAG from an image requires a restriction in size to be computationally feasible while at the same time all visually plausible information must be preserved. For this purpose, mechanisms for the reduction of the graph size are presented. Even with a reduced graph, the problem of graph matching remains NP-complete. In this paper, the Similarity Flooding approach and Hopfield-style neural networks are adapted from the graph matching community to the needs of HARAG comparison. Based on synthetic image material build from simple geometric objects, all visually similar regions were matched accordingly showing the framework's general applicability to content-based image retrieval of medical images.