All Classes and Interfaces

Class
Description
Scales to the absolute value passed as an argument.
Base class for element parsers - provides some minimal functionality.
Abstract implementation of the Graph interface.
a base class for GraphMousePlugin instances.
An abstract class for algorithms that assign scores to vertices based on iterative methods.
An abstract class for iterative random-walk-based vertex scoring algorithms that have a fixed probability, for each vertex, of 'jumping' to that vertex at each step in the algorithm (rather than following a link out of that vertex).
Abstract class for implementations of Layout.
A class to make it easy to add an examining lens to a jung graph application.
the background for the hyperbolic projection
the background for the hyperbolic projection
Abstract base class for metadata - implements the property functionality
AbstractModalGraphMouse is a PluggableGraphMouse class that manages a collection of plugins for picking and transforming the graph.
An abstract class to support ItemEvents for PickedState
 
Abstract class for algorithms that rank nodes or edges by some "importance" metric.
An abstract class for graphs whose edges all have the same EdgeType.
 
Demonstrates visualization of a graph being actively updated.
Provides methods to map points from one coordinate system to another, by delegating to a wrapped AffineTransform (uniform) and its inverse.
 
A Layout implementation that combines multiple other layouts so that they may be manipulated as one layout.
AnimatedPickingGraphMousePlugin supports the picking of one Graph Vertex.
A variation of AddNodeDemo that animates transitions between graph states.
 
AnnotatingGraphMousePlugin can create Shape and Text annotations in a layer of the graph visualization.
a graph mouse that supplies an annotations mode
 
stores an annotation, either a shape or a string
 
a collection of controls for annotations.
handles the selection of annotations, and the support for the tools to draw them at specific layers.
handles the actual drawing of annotations
AnnotationRenderer is similar to the cell renderers used by the JTable and JTree JFC classes.
Demonstrates annotation of graph elements.
A utility class for creating arrowhead shapes.
A Layout implementation that assigns positions to Tree or Forest vertices using associations with nested circles ("balloons").
Demonstrates the visualization of a Tree using TreeLayout and BalloonLayout.
Simple evolving scale-free random graph generator.
Assigns scores to each vertex according to the sum of its distances to all other vertices.
 
 
 
An simple minimal implementation of Map.Entry.
The default implementation of the Renderer used by the VisualizationViewer.
A basic implementation of the MultiLayerTransformer interface that provides two Layers: VIEW and LAYOUT.
 
 
 
 
A class that maintains many of the details necessary for creating visualizations of graphs.
Computes betweenness centrality for each vertex and edge in the graph.
Computes betweenness centrality for each vertex and edge in the graph.
Labels each node in the graph according to the BFS distance from the start node(s).
Finds all biconnected components (bicomponents) of an undirected graph.
Provides methods to map points from one coordinate system to another: graph to screen and screen to graph.
 
 
Interface to provide external controls to an implementing class that manages a cache.
 
A LayoutDecorator that caches locations in a clearable Map.
 
 
 
the implementing class provides support for ChangeEvents.
a simple Icon that draws a checkmark in the lower-right quadrant of its area.
A Layout implementation that positions vertices equally spaced on a regular circle.
 
Assigns scores to each vertex based on the mean distance to each other vertex.
A GraphElementAccessor that finds the closest element to the pick point, and returns it if it is within the element's shape.
This simple app demonstrates how one can use our algorithms and visualization libraries in unison.
Returns the constructor-specified value for each edge type.
A class that is used to link together a graph element and a specific graph.
A scaling control that has a crossover point.
 
An implementation of Layout suitable for tree-like directed acyclic graphs.
Parses the data element.
Metadata structure for the 'data' GraphML element.
Basic implementation of ChangeEventSupport, using standard jdk classes
DefaultEdgeLabelRenderer is similar to the cell renderers used by the JTable and JTree jfc classes.
DefaultModalGraphMouse is a PluggableGraphMouse class that pre-installs a large collection of plugins for picking and transforming the graph.
 
A class which creates and maintains indices for parallel edges.
DefaultVertexLabelRenderer is similar to the cell renderers used by the JTable and JTree JFC classes.
The model containing state values for visualizations of graphs.
Assigns a score to each vertex equal to its degree.
An implementation of Forest that delegates to a specified DirectedGraph instance.
A Transformer<VEPair,Number that delegates its operation to a Transformer<E,Number>.
An implementation of Tree that delegates to a specified instance of DirectedGraph.
Demonstrates the use of images to represent graph vertices.
 
Calculates distances in a specified graph, using Dijkstra's single-source-shortest-path algorithm.
Compares according to distances, so that the BinaryHeap knows how to order the tree.
Calculates distances and shortest paths using Dijkstra's single-source-shortest-path algorithm.
A tagging interface for implementations of Graph that accept only directed edges.
An implementation of DirectedGraph, suitable for sparse graphs, that orders its vertex and edge collections according to insertion time.
An implementation of DirectedGraph suitable for sparse graphs.
An implementation of DirectedGraph, suitable for sparse graphs, that permits parallel edges.
Returns wedge arrows for undirected edges and notched arrows for directed edges, of the specified dimensions.
Functions for transforming graphs into directed or undirected graphs.
A utility class for calculating properties of discrete distributions.
An interface for classes which calculate the distance between one vertex and another.
Assigns scores to vertices based on their distances to each other vertex in the graph.
Statistics relating to vertex-vertex distances in a graph.
A demo that shows drawn Icons as vertices
 
An algorithm for computing clusters (community structure) in graphs based on edge betweenness.
 
Parses an edge element.
An interface for a service to access the index of a given edge (in a given graph) into the set formed by the given edge and all the other edges it is parallel to.
Demonstrates jung support for drawing edge labels that can be positioned at any point along the edge, and can be rotated to be parallel with the edge.
 
Metadata structure for the 'edge' GraphML element.
Transforms the input graph into one which contains only those edges that pass the specified Predicate.
An interface for algorithms that assign scores to edges.
An interface for decorators that return a Shape for a specified edge.
interface to support the creation of new edges by the EditingGraphMousePlugin SimpleEdgeSupport is a sample implementation
Defines the possible edge types for graphs which assign types to edges.
A plugin that can create vertices, undirected edges, and directed edges using mouse gestures.
 
 
 
a plugin that uses popup menus to create vertices, undirected edges, and directed edges.
Implements the Edmonds-Karp maximum flow algorithm for solving the maximum flow problem.
Calculates eigenvector centrality for each vertex in the graph.
Interface for all element parsers.
Registry for all element parsers.
 
Parses endpoint elements.
Metadata structure for the 'endpoint' GraphML element.
 
Graph generator that generates undirected graphs with power-law degree distributions.
Generates a random graph using the Erdos-Renyi binomial model (each pair of vertices is connected with probability p).
An interface for algorithms that generate graphs that evolve iteratively.
Converts an exception to the a GraphIOException.
maintains caches of vertices and edges that will be the subset of the delegate graph's elements that are contained in some Rectangle.
break into several rectangular areas, each of which will have a reference Graph
An interface for classes that return a subset of the input Graph as a Graph.
Utility methods relating to filtering.
Methods for creating a "folded" graph based on a k-partite graph or a hypergraph.
An interface for a graph which consists of a collection of rooted directed acyclic graphs.
Provides Supplier methods that, given a BufferedImage, an Image, or the fileName of an image, will return a java.awt.Shape that is the contiguous traced outline of the opaque part of the image.
Implements the Fruchterman-Reingold force-directed algorithm for node layout.
 
Implements the Fruchterman-Reingold force-directed algorithm for node layout.
 
Creates GradientPaint instances which can be used to paint an Edge.
A renderer that will fill vertex shapes with a GradientPaint
A graph consisting of a set of vertices of type V set and a set of edges of type E.
 
An implementation of Graph that delegates its method calls to a constructor-specified Graph instance.
Shows how to create a graph editor with JUNG.
Interface for coordinate-based selection of graph components.
Parses graph elements.
 
An event type pertaining to graph edges.
Types of graph events.
An event type pertaining to graph vertices.
An interface for classes that listen for graph events.
General interface for loading and saving a graph from/to disk.
Demonstrates loading (and visualizing) a graph from a GraphML file.
A nested class to demo the GraphMouseListener finding the right vertices after zoom/pan
An interface for algorithms that generate graphs.
a complete wrapping of Graphics2D, useful as a base class.
an extendion of Graphics2DWrapper that adds enhanced methods for drawing icons and components
Exception thrown when IO errors occur when reading/writing graphs.
Metadata structure for the 'graph' GraphML element.
 
Provides some constants for element/attribute names in GraphML
Maintains all the metadata read in from a single GraphML XML document.
Filter to ignore unsupported XML events.
Maintains information relating to data for the specified type.
Reads in data from a GraphML-formatted file and generates graphs based on that data.
 
 
Reads in data from a GraphML-formatted file and generates graphs based on that data.
Writes graphs out in GraphML format.
Simple extension of MouseAdapter that supplies modifier checking
This interface allows users to register listeners to register to receive vertex clicks.
the interface for all plugins to the PluggableGraphMouse
Interface for a reader of graph objects
Provides specialized implementations of GraphDecorator.
 
 
 
 
 
 
 
 
 
 
 
 
GraphZoomScrollPane is a Container for the Graph's VisualizationViewer and includes custom horizontal and vertical scrollbars.
Demonstrates the use of GraphZoomScrollPane.
A nested class to demo the GraphMouseListener finding the right vertices after zoom/pan
Assigns hub and authority scores to each vertex depending on the topology of the network.
Maintains hub and authority score information for a vertex.
A generalization of HITS that permits non-uniformly-distributed random jumps.
HyperbolicShapeTransformer extends HyperbolicTransformer and adds implementations for methods in ShapeFlatnessTransformer.
HyperbolicTransformer wraps a MutableAffineTransformer and modifies the transform and inverseTransform methods so that they create a fisheye projection of the graph points, with points near the center spread out and points near the edges collapsed onto the circumference of an ellipse.
Parses hyper edge elements.
Metadata structure for the 'hyperedge' GraphML element.
A hypergraph, consisting of a set of vertices of type V and a set of hyperedges of type E which connect the vertices.
Demonstrates the use of images on graph edge labels.
 
A class which creates and maintains indices for incident edges.
A class providing static methods useful for improving the performance of graph algorithms.
Similar to the SatelliteViewDemo, but using JInternalFrame.
Provides vertex sizes that are spaced proportionally between min_size and max_size depending on
 
Implements a self-organizing map layout algorithm, based on Meyer's self-organizing graph methods.
 
An interface for algorithms that proceed iteratively.
Provides basic infrastructure for iterative algorithms.
GraphML key object that was parsed from the input stream.
Enumeration for the 'for' type of this key.
Parses key elements.
A KeyMap is a storage mechanism for the keys read from the GraphML file.
Implements the Kamada-Kawai algorithm for node layout.
Graph generator that produces a random graph with small world properties.
Groups items into a specified number of clusters, based on their proximity in d-dimensional space, using the k-means algorithm.
An exception that indicates that the specified data points cannot be clustered into the number of clusters requested by the user.
A filter used to extract the k-neighborhood around one or more root node(s).
The type of edge to follow for defining the neighborhood.
An interface for graphs whose vertices are each members of one of 2 or more disjoint sets (partitions), and whose edges connect only vertices in distinct partitions.
Algorithm variant of PageRankWithPriors that computes the importance of a node based upon taking fixed-length random walks out from the root set and then computing the stationary probability of being at each node.
A special case of PageRankWithPriors in which the final scores represent a probability distribution over position assuming a random (Markovian) walk of exactly k steps, based on the initial distribution specified by the priors.
A variant of TreeLayoutDemo that rotates the view by 90 degrees from the default orientation.
 
A utility to wrap long lines, creating html strings with line breaks at a settable max line length
Simple generator of an m x n lattice where each vertex is incident with each of its neighbors (to the left, right, up, and down).
 
An icon that is made up of a collection of Icons.
A generalized interface is a mechanism for returning (x,y) coordinates from vertices.
 
a pure decorator for the Layout interface.
 
 
ShapePickSupport provides access to Vertices and EdgeType based on their actual shapes.
A class to make it easy to add an examining lens to a jung graph application.
LayoutScalingControl applies a scaling transformation to the graph layout.
 
Demonstrates the use of HyperbolicTransform and MagnifyTransform applied to either the model (graph layout) or the view (VisualizationViewer) The hyperbolic transform is applied in an elliptical lens that affects that part of the visualization.
 
HyperbolicMagnificationGraphMousePlugin changes the magnification within the Hyperbolic projection of the HyperbolicTransformer.
basic API for implementing lens projection support
LensTransformer wraps a MutableAffineTransformer and modifies the transform and inverseTransform methods so that they create a projection of the graph points within an elliptical lens.
Extends TranslatingGraphMousePlugin and adds the capability to drag and resize the viewing lens in the graph view.
Demonstrates the use of images to represent graph vertices.
 
Subclassed to apply a magnification transform to an icon.
Changes various visualization settings to activate or deactivate an examining lens for a jung graph application.
MagnifyShapeTransformer extends MagnifyTransformer and adds implementations for methods in ShapeTransformer.
MagnifyTransformer wraps a MutableAffineTransformer and modifies the transform and inverseTransform methods so that they create an enlarging projection of the graph points.
An array-based binary heap implementation of a priority queue, which also provides efficient update() and contains operations.
A SettableTransformer that operates on an underlying Map instance.
Interface for any GraphML metadata.
Metadata type enumeration
A class consisting of static methods for calculating graph metrics.
For the input Graph, creates a MinimumSpanningTree using a variation of Prim's algorithm.
For the input Graph, creates a MinimumSpanningTree using a variation of Prim's algorithm.
Demonstrates a single graph with 3 layouts in 3 views.
Generates a mixed-mode random graph (with random edge weights) based on the output of BarabasiAlbertGenerator.
Interface for a GraphMouse that supports modality.
 
an implementation of the AbstractModalGraphMouse that includes plugins for manipulating a view that is using a LensTransformer.
 
 
This class translates mouse clicks into vertex clicks
A tagging interface which indicates that the implementing graph accepts parallel edges.
 
Maintains the state of what has been 'picked' in the graph.
Demonstrates 3 views of one graph in one model with one layout.
Provides methods to mutate the AffineTransform used by AffineTransformer base class to map points from one coordinate system to another.
Provides an API for the mutation of a Function and for adding listeners for changes on the Function
a complete decorator that wraps a MutableTransformer.
Parses node elements.
Metadata structure for the 'node' GraphML element.
Transforms inputs to String representations by chaining an input Number-generating Function with an internal NumberFormat instance.
A LayoutDecorator that fires ChangeEvents when certain methods are called.
A decorator class for graphs which generates events
An implementation of Tree in which each vertex has ≤ k children.
An implementation of Graph that orders its vertex and edge collections according to insertion time, is suitable for sparse graphs, and permits directed, undirected, and parallel edges.
Assigns scores to each vertex according to the PageRank algorithm.
A generalization of PageRank that permits non-uniformly-distributed random jumps.
An implementation of Collection that stores exactly 2 non-null objects and is not mutable.
Reads a Graph from a Pajek NET formatted source.
A Predicate which evaluates to true if the argument ends with the string "list".
A Predicate which evaluates to true if the argument starts with the constructor-specified String.
Writes graphs in the Pajek NET format.
An abstract class for edge-to-Shape functions that work with parallel edges.
Provides resources related to the current parsing context.
interface for PersistentLayout Also holds a nested class Point to serialize the Vertex locations
a serializable class to save locations
Demonstrates the use of PersistentLayout and PersistentLayoutImpl.
Implementation of PersistentLayout.
 
Paints each edge according to the Paint parameters given in the constructor, so that picked and non-picked edges can be made to look different.
Supplies an Icon for each vertex according to the Icon parameters given in the constructor, so that picked and non-picked vertices can be made to look different.
Paints each vertex according to the Paint parameters given in the constructor, so that picked and non-picked vertices can be made to look different.
An interface for classes that return information regarding whether a given graph element (vertex or edge) has been selected.
An interface for classes that keep track of the "picked" state of edges or vertices.
PickingGraphMousePlugin supports the picking of graph elements with the mouse.
Provides Supplier methods that, given a BufferedImage, an Image, or the fileName of an image, will return a java.awt.Shape that is the contiguous traced outline of the opaque part of the image.
a GraphMouse that accepts plugins for various mouse events.
 
Shows off some of the capabilities of PluggableRenderer.
 
 
 
 
 
Controls the shape, size, and aspect ratio for each vertex.
 
Represents a point in polar coordinates: distance and angle from the origin.
Parses port elements.
Metadata structure for the 'port' GraphML element.
A class which creates and maintains indices for parallel edges.
For the input Graph, creates a MinimumSpanningTree using a variation of Prim's algorithm.
A radial layout for Tree or Forest graphs.
Shows a RadialTreeLayout view of a Forest.
Simple implementation of PickSupport that returns the vertex or edge that is closest to the specified location.
Simple implementation of PickSupport that returns the vertex or edge that is closest to the specified location.
Provides a random vertex location within the bounds of the Dimension property.
Abstract data container for ranking objects.
This class provides basic infrastructure for relative authority algorithms that compute the importance of nodes relative to one or more root nodes.
Interface for operating the relax iterations on a layout.
 
 
 
The interface for drawing vertices, edges, and their labels.
 
 
 
 
 
 
 
 
 
 
uses a flatness argument to break edges into smaller segments.
RotatingGraphMouse provides the abiity to rotate the graph using the mouse.
A version of the AnimatedPickingGraphMousePlugin that is for the SatelliteVisualizationViewer.
Mouse events in the SatelliteView that match the modifiers will cause the Main view to rotate
Overrides ScalingGraphMousePlugin so that mouse events in the satellite view will cause scaling in the main view
Overrides ShearingGraphMousePlugin so that mouse events in the satellite view cause shearing of the main view
Overrides TranslatingGraphMousePlugin so that mouse events in the satellite view cause translating of the main view
Demonstrates the construction of a graph visualization with a main and a satellite view.
draws a grid on the SatelliteViewer's lens
A VisualizationViewer that can act as a satellite view for another (master) VisualizationViewer.
A four-sided shape that represents the visible part of the master view and is drawn in the satellite view
 
ScalingGraphMouse applies a scaling transformation to the graph layout.
Methods for assigning values (to be interpreted as prior probabilities) to vertices in the context of random-walk-based scoring algorithms.
A Predicate that returns true if the input edge's endpoints in the input graph are identical.
An implementation of Hypergraph that is suitable for sparse graphs and permits parallel edges.
An interface for classes that can set the value to be returned (from transform()) when invoked on a given input.
 
Provides methods to map points from one coordinate system to another: graph to screen and screen to graph.
A GraphElementAccessor that returns elements whose Shape contains the specified pick point or region.
The available picking heuristics: Style.CENTERED: returns the element whose center is closest to the pick point.
Provides methods to map points from one coordinate system to another: graph to screen and screen to graph.
ShearingGraphMousePlugin allows the user to drag with the mouse to shear the transform either in the horizontal or vertical direction.
An interface for algorithms that calculate shortest paths.
Demonstrates use of the shortest path algorithm and visualization of the results.
 
 
 
Utilities relating to the shortest paths in a graph.
Demonstrates several of the graph layout algorithms.
 
 
 
A class that shows the minimal work necessary to load and visualize a graph.
sample implementation showing how to use the VertexSupport interface member of the EditingGraphMousePlugin.
An implementation of Graph that is suitable for sparse graphs, orders its vertex and edge collections according to either specified Comparator instances or the natural ordering of their elements, and permits directed, undirected, and parallel edges.
An implementation of Graph that is suitable for sparse graphs and permits both directed and undirected edges.
An implementation of Graph that is suitable for sparse graphs and permits directed, undirected, and parallel edges.
The SpringLayout package represents a visualization of a set of nodes.
 
The SpringLayout package represents a visualization of a set of nodes.
StaticLayout places the vertices in the locations specified by its initializer, and has no other behavior.
Parses an element that just contains text.
Calculates some of the measures from Burt's text "Structural Holes: The Social Structure of Competition".
Identifies sets of structurally equivalent vertices in a graph.
Demonstrates the AggregateLayout class.
Provides generators for several different test graphs.
Labels vertices by their toString.
subclassed to pass certain operations thru the Function before the base class method is applied This is useful when you want to apply non-affine transformations to the Graphics2D used to draw elements of the graph.
subclassed to pass certain operations thru the Function before the base class method is applied This is useful when you want to apply non-affine transformations to the Graphics2D used to draw elements of the graph.
TranslatingGraphMousePlugin uses a MouseButtonOne press and drag gesture to translate the graph display in the x and y direction.
A subtype of Graph which is a (directed, rooted) tree.
Demonstrates "collapsing"/"expanding" of a tree's subtrees.
 
 
Demonsrates TreeLayout and RadialTreeLayout.
Contains static methods for operating on instances of Tree.
TriadicCensus is a standard social network tool that counts, for each of the different possible configurations of three vertices, the number of times that that configuration occurs in the given graph.
Demonstrates a single graph with 2 layouts in 2 views.
A tagging interface for extensions of Graph that accept only undirected edges.
An implementation of UndirectedGraph that is suitable for sparse graphs, orders its vertex and edge collections according to insertion time, and permits parallel edges.
An implementation of UndirectedGraph that is suitable for sparse graphs.
An implementation of UndirectedGraph that is suitable for sparse graphs and permits parallel edges.
A demo that shows flag images as vertices, and uses unicode to render vertex labels.
An edge weight function that assigns weights as uniform transition probabilities.
Assigns weights to directed edges (the edge of the vertex/edge pair) depending on whether the vertex is the edge's source or its destination.
Skips an entire unknown subtree of the XML
Computes the shortest path distances for graphs whose edges are not weighted (using BFS).
Convenience class for associating a vertex and an edge.
A demo that shows how collections of vertices can be collapsed into a single vertex.
A demo that shows how collections of vertices can be collapsed into a single vertex.
A default implementation that stores images in a Map keyed on the vertex.
Demonstrates the use of images to represent graph vertices.
this class exists only to provide settings to turn on/off shapes and image fill in this demo.
This class exists only to provide settings to turn on/off shapes and image fill in this demo.
When Vertices are picked, add a checkmark icon to the imager.
A simple implementation of VertexStringer that gets Vertex labels from a Map
This demo shows how to use the vertex labels themselves as the vertex shapes.
Renders Vertex Labels, but can also supply Shapes for vertices.
Demonstrates vertex label positioning controlled by the user.
 
Maintains information about a vertex partition of a graph.
This class transforms a graph with a known vertex partitioning into a graph whose vertices correspond to the input graph's partitions.
Transforms the input graph into one which contains only those vertices that pass the specified Predicate.
An interface for algorithms that assign scores to vertices.
A Function convenience wrapper around VertexScorer.
A utility class for generating Shapes for drawing vertices.
interface to support the creation of new vertices by the EditingGraphMousePlugin.
ShapePickSupport provides access to Vertices and EdgeType based on their actual shapes.
Uses a LensTransformer to use in the view transform.
ViewScalingGraphMouse applies a scaling transform to the View of the graph.
ViewTranslatingGraphMousePlugin uses a MouseButtonOne press and drag gesture to translate the graph display in the x and y direction by changing the AffineTransform applied to the Graphics2D.
Implementation of a relaxer thread for layouts.
A class that could be used on the server side of a thin-client application.
Demonstrates VisualizationImageServer.
Interface for the state holding model of the VisualizationViewer.
 
an interface for the preRender and postRender
Adds mouse behaviors and tooltips to the graph visualization base class
a convenience type to represent a class that processes all types of mouse events for the graph
Clusters vertices of a Graph based on their ranks as calculated by VoltageScorer.
Assigns scores to vertices according to their 'voltage' in an approximate solution to the Kirchoff equations.
Finds all weak components in a graph as sets of vertex sets.
Selects items according to their probability in an arbitrary probability distribution.
This algorithm measures the importance of nodes based upon both the number and length of disjoint paths that lead to a given node from each of the nodes in the root set.
Shows a graph overlaid on a world map image.