Description Usage Arguments Details Value Interactive mouse, key and slide bar controls Author(s) References See Also Examples
vg
creates and starts an animated graphical user interface for
positioning the vertices of a graph in 2 dimensions.
1 2 3 4 5 6 7 8 9 10 
grob 
is a graphical object state saved as a 
directed 
indicates whether or not the graph is directed. By default

running 
indicates whether or not the viewer is started
with the animation running. By default 
Creates and starts a 'Java' graphical user interface (GUI) showing a real time animation of a NewtonRaphson optimization of a force function specified between the vertices of an arbitrary graph. There are attractive forces between adjacent vertices and repulsive forces between all vertices. The repulsions go smoothly to zero in a finite distance between vertices so that, unlike some other methods, different components don't send each other off to infinity.
The program is controlled by a slide bar, some buttons, the arrow, home and shift keys, but mostly by mouse operations. All three mouse buttons are used. These operations are described below.
vg
will replace rViewGraph
, although the latter is
still currently available.
vg
allows for far more control of the graph than rViewGraph
,
including adding and removing vertices and edges, and changing
the appearance of the vertices,
all of which can be done while the animation is running.
It has a different set of force parameter controls that are useful for
directed acyclic graphs (DAGs) specifically, but also,
to a lesser extent, for arbitrary directed graphs.
It also provides functions for saving and restoring a graphical state
including vertices and edges, vertex positions, and vertex appearances.
vg
is intended primarily for interactive use.
When used in a noninteractive environment
it will run without a visible GUI, however, a graph structure can be
created and saved and viewed in future, interactive, R sessions.
vg
returns a list of functions that
specify and query the graph, coordinates and appearance, and control the viewer.
add(i) 
If the graph does not contain vertices indexed by 
remove(i) 
If the graph contains vertices indexed by 
connect(i,j) 
If the graph does not have edges between vertices
indexed by 
disconnect(i,j) 
If the graph has edges between vertices
indexed by 
clear() 
All vertices and edges are removed from the graph,
however, any customizations
made to the appearance of the vertices will persist
until 
isDirected() 
Returns 
getIds() 
Returns a vector of all the vertex indices that the viewer has encountered, whether or not they are currently in the graph. 
contains(id) 
Returns a vector of booleans indicating whether the vertices corresponding to the given indices are currently in the graph. 
connects(i,j) 
Returns a vector of booleans indicating whether the
vertices with the indices in vector 
neighbours(i) 
Returns a list of vectors containing
the neighbours of the vertices indexed by 
neighbors(i) 
Alias for 
inNeighbours(i) 
Returns a list of vectors containing the
indices of vertices with edges from them to the ones in 
inNeighbors(i) 
Alias for 
outNeighbours(i) 
Returns a list of vectors containing the
indices of vertices with edges to them from the ones in 
outNeighbors(i) 
Alias for 
getVertices() 
Returns a vector of the indices of all vertices currently in the graph. 
getEdges() 
Returns a matrix with 2 columns and a row for each edge in the current graph. Each row gives the indices of the vertices that the edge connects. If the edges are directed, the connections are oriented from vertices in the first column to those in the second. 
getX(id) 
Returns the current horizontal
coordinates of the vertices with
indices in 
getY(id) 
Returns the current vertical coordinates of the vertices with
indices in 
setXY(id, x, y) 
Sets the horizontal and vertical coordinates for the
vertices with indices in 
label(i,lab=i) 
Sets the strings shown on the
vertices indexed by 
colour(i,col="yellow") 
Sets the colours of the
vertices indexed by 
color(i,col="yellow") 
Alias for 
shape(i,shp=0) 
Sets the shapes of the vertices
indexed by

size(i,width=1,height=width) 
Sets the sizes of the
vertices indexed by 
map(i,lab=i,col="yellow",shp=0,width=1,height=width 
Combines

clearMap() 
Resets all vertices to the default appearance of yellow rectangle labeled with the index. 
run() 
Starts the GUI running if it's not already doing so. 
stop() 
Stops the GUI running if it's running. 
isRunning() 
Returns 
show() 
Shows the GUI. If it was running
when 
hide() 
Stops the GUI and hides it. 
showPaper(size = "letter", landscape = TRUE) 
Indicates,
with a different colour, the portion of the
plane corresponding to a choice of paper for printing.

hidePaper() 
By default the GUI indicates, with a different colour, the portion of the plane that corresponds to the current choice of paper for printing. This function removes that area. 
showAxes() 
Shows the axes if they are hidden. 
hideAxes() 
By default, axes are shown to indicate the origin. This function hides them. 
ps() 
Starts a 
save() 
Returns a 
restore(grob) 
Restores a saved graph and map state. 
Slide bars at the bottom of the GUI control the repulsive force in the energy equation used to set the coordinates. If the graph is undirected, there is a single 'Repulsion' parameter, if directed, there are 'XRepulsion' and 'YRepulsion' parameters, and a 'Gravity' parameter that influences how these are combined.
Mouse operations without shift key and without control key pressed.
Left mouse: Drags a vertex. Vertex is free on release.
Middle mouse: Drags a vertex. Vertex is fixed at release position.
Right mouse: Translates the view by the amount dragged. A bit like putting your finger on a piece of paper and moving it.
Double click with any mouse button in the background: Resets the vertices to new random positions.
Mouse operations with shift key but without control key pressed.
Left mouse: Drags a vertex and the component it is in. Vertex and component free on release.
Middle mouse: Drags a vertex and the component it is in. Vertex and component are fixed at release positions.
Right mouse: Translates the positions of the vertices relative to the position of the canvas by the amount dragged. This is useful to center the picture on the canvas ready for outputting.
Mouse operations without shift key but with control key pressed.
Left mouse: Click on a vertex to unhide any hidden neighbours.
Middle mouse: Click on a vertex to hide it.
Double click left mouse: Unhides all hidden vertices.
Double click middle mouse: Hides all vertices.
Mouse operations with shift key and with control key pressed.
Left mouse: Click on a vertex to unhide all vertices in the same component.
Middle mouse: Click on a vertex to hide it and the component it is in.
Key functions without shift key pressed. Mouse has to be in the picture canvas.
Up arrow: Increases the scale of viewing by 10%.
Down arrow: Decreases the scale of viewing by 10%.
Left arrow: Rotates the view by 15 degrees clockwise.
Right arrow: Rotates the view by 15 degrees anticlockwise.
Home key: Undoes all scalings and rotations and places the origin at the top left corner of the canvas.
Key functions with shift key pressed. Mouse has to be in the picture canvas.
Up arrow: Increases the vertex positions by 10% relative to the scale of the canvas.
Down arrow: Decreases the vertex positions by 10% relative to the scale of the canvas.
Left arrow: Rotates the vertex positions by 15 degrees clockwise relative to the canvas orientation.
Right arrow: Rotates the vertex positions by 15 degrees anticlockwise relative to the canvas orientation.
Alun Thomas
A full description of the force function and algorithm used is given by C Cannings and A Thomas, Inference, simulation and enumeration of genealogies. In D J Balding, M Bishop, and C Cannings, editors, The Handbook of Statistical Genetics. Third Edition, pages 781805. John Wiley & Sons, Ltd, 2007.
rViewGraph
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84  # Start the viewer.
# This will print a warning message if not run interactively.
require(rviewgraph)
v = vg()
# Generate some random vertices to connect with edges.
from = sample(1:20,15,TRUE)
to = sample(1:20,15,TRUE)
# Connect these edges in the viewer.
v$connect(from,to)
# Negative vertex indices are also allowed.
v$connect(from,to)
# Add some new vertices, unconnected to any others.
v$add(30:35)
# Remove some vertices.
v$rem((5:5)*2)
# Query some of the structure of the graph.
v$contains(1)
v$contains(1)
v$connects(1,1)
v$contains(1:50)
v$connects(from,to)
v$connects(from,to+2)
v$neighbours(from)
# Change what some of the vertices look like.
v$map(10:10, lab = "", col=1, shp=1, width=1:15)
v$label(10:36, lab=LETTERS)
v$colour((1000:1),"cyan")
v$shape((1000:1)*2,2)
# Hide the axes.
v$hideAxes()
# Stop the animation.
# Not necessary for outputting but sometimes helpful.
v$stop()
# Change the paper size and orientation to A4 portrait.
v$showPaper("A4",FALSE)
# Start the print dialog box.
#v$ps()
# Restart the animation, and check that it's running.
v$run()
v$isRunning()
# Save the application.
s = v$save()
# Change the graph and appearance.
v$colour(1000:1000,"red")
v$connect(rep(1,100),1:100)
# Then decide you didn't like the changes so restore
# the saved state.
v$restore(s)
# Can also restore a state in a new GUI.
v2 = vg(s)
# Get a vector of all the indices that the viewer has seen.
ids = v$getIds()
# Get a vector of the indices of the vertices currently
# in the graph.
verts = v$getVertices()
# Get a matrix with 2 columns specifying the current edges
# of the graph.
edges = v$getEdges()
# Get the current coordinates of the specified vertices.
x = v$getX(verts)
y = v$getY(verts)
# Change the current coordinates of the vertices.
v$setXY(verts,2*x,0.5*y+2)

Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.