## Documentation ¶

### Overview ¶

Package layout defines functions for performing graph layout.

### Constants ¶

This section is empty.

### Variables ¶

This section is empty.

### Functions ¶

This section is empty.

### Types ¶

```type EadesR2 struct {

// Repulsion is the strength of the global
// repulsive force between nodes in the
// layout. It corresponds to C3 in the paper.
Repulsion float64

// Rate is the gradient descent rate. It
// corresponds to C4 in the paper.
Rate float64

// Theta is the Barnes-Hut theta constant.
Theta float64

// Src is the source of randomness used
// to initialize the nodes' locations. If
// Src is nil, the global random number
// generator is used.
Src rand.Source
// contains filtered or unexported fields
}```

EadesR2 implements the graph layout algorithm essentially as described in "A heuristic for graph drawing", Congressus numerantium 42:149-160. The implementation here uses the Barnes-Hut approximation for global repulsion calculation, and edge weights are considered when calculating adjacent node attraction.

Example
```Output:

```

`func (u *EadesR2) Update(g graph.Graph, layout LayoutR2) bool`

Update is the EadesR2 spatial graph update function.

#### type GraphR2 ¶

```type GraphR2 interface {
graph.Graph
LayoutNodeR2(id int64) NodeR2
}```

GraphR2 is a graph with planar spatial representation of node positions.

#### type IsomapR2 ¶

`type IsomapR2 struct{}`

IsomapR2 implements a graph layout algorithm based on the Isomap non-linear dimensionality reduction method. Coordinates of nodes are computed by finding a Torgerson multidimensional scaling of the shortest path distances between all pairs of node in the graph. The all pair shortest path distances are calculated using the Floyd-Warshall algorithm and so IsomapR2 will not scale to large graphs. Graphs with more than one connected component cannot be laid out by IsomapR2.

#### func (IsomapR2) Update ¶

`func (IsomapR2) Update(g graph.Graph, layout LayoutR2) bool`

Update is the IsomapR2 spatial graph update function.

#### type LayoutR2 ¶

```type LayoutR2 interface {
// IsInitialized returns whether the Layout is initialized.
IsInitialized() bool

// SetCoord2 sets the coordinates of the node with the given
// id to coords.
SetCoord2(id int64, coords r2.Vec)

// Coord2 returns the coordinated of the node with the given
// id in the graph layout.
Coord2(id int64) r2.Vec
}```

LayoutR2 implements graph layout updates and representations.

#### type NodeR2 ¶

```type NodeR2 struct {
graph.Node
Coord2 r2.Vec
}```

NodeR2 is a graph node with planar spatial representation of its position. A NodeR2 is only valid when the graph.Node is not nil.

#### type OptimizerR2 ¶

```type OptimizerR2 struct {

// Updater is the function called for each call to Update.
// It updates the OptimizerR2's spatial distribution of the
// nodes in the backing graph.
Updater func(graph.Graph, LayoutR2) bool
// contains filtered or unexported fields
}```

OptimizerR2 is a helper type that holds a graph and layout optimization state.

#### func NewOptimizerR2 ¶

`func NewOptimizerR2(g graph.Graph, update func(graph.Graph, LayoutR2) bool) OptimizerR2`

NewOptimizerR2 returns a new layout optimizer. If g implements LayoutR2 the layout will be updated into g, otherwise the OptimizerR2 will hold the graph layout. A nil value for update is a valid no-op layout update function.

#### func (OptimizerR2) Coord2 ¶

`func (g OptimizerR2) Coord2(id int64) r2.Vec`

Coord2 returns the location of the node with the given ID. The returned value is only valid if the node exists in the graph.

#### func (OptimizerR2) Edge ¶

`func (g OptimizerR2) Edge(uid, vid int64) graph.Edge`

Edge returns the edge from u to v, with IDs uid and vid, if such an edge exists and nil otherwise. The node v must be directly reachable from u as defined by the From method.

#### func (OptimizerR2) From ¶

`func (g OptimizerR2) From(id int64) graph.Nodes`

From returns all nodes that can be reached directly from the node with the given ID.

#### func (OptimizerR2) HasEdgeBetween ¶

`func (g OptimizerR2) HasEdgeBetween(xid, yid int64) bool`

HasEdgeBetween returns whether an edge exists between nodes with IDs xid and yid without considering direction.

#### func (OptimizerR2) LayoutNodeR2 ¶

`func (g OptimizerR2) LayoutNodeR2(id int64) NodeR2`

LayoutNodeR2 implements the GraphR2 interface.

#### func (OptimizerR2) Node ¶

`func (g OptimizerR2) Node(id int64) graph.Node`

Node returns the node with the given ID if it exists in the graph, and nil otherwise.

#### func (OptimizerR2) Nodes ¶

`func (g OptimizerR2) Nodes() graph.Nodes`

Nodes returns all the nodes in the graph.

#### func (OptimizerR2) Update ¶

`func (g OptimizerR2) Update() bool`

Update updates the locations of the nodes in the graph according to the provided update function. It returns whether the update function is able to further refine the graph's node locations.