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.