SFDP(; kwargs...)(adj_matrix)
sfdp(adj_matrix; kwargs...)

Using the Spring-Electric model suggested by Hu (2005, The Mathematica Journal, pdf).

Forces are calculated as:

    f_attr(i,j) = ‖xi - xj‖ ² / K ,    i<->j
    f_repln(i,j) = -CK² / ‖xi - xj‖ ,  i!=j

Takes adjacency matrix representation of a network and returns coordinates of the nodes.

Keyword Arguments

• dim=2, Ptype=Float64: Determines dimension and output type Point{dim,Ptype}.

• tol=1.0: Stop if position changes of last step Δp <= tol*K for all nodes

• C=0.2, K=1.0: Parameters to tweak forces.

• iterations=100: maximum number of iterations

• initialpos=Point{dim,Ptype}[]

  Provide Vector or Dict of initial positions. All positions will be initialized using random coordinates between [-1,1]. Random positions will be overwritten using the key-val-pairs provided by this argument.

• pin=[]: Pin node positions (won't be updated). Can be given as Vector or Dict of node index -> value pairings. Values can be either

  • (12, 4.0) : overwrite initial position and pin
  • true/false : pin this position
  • (true, false, false) : only pin certain coordinates

• seed=1: Seed for random initial positions.

• rng=DEFAULT_RNG[](seed)

  Create rng based on seed. Defaults to MersenneTwister, can be specified by overwriting DEFAULT_RNG[]

Buchheim(; kwargs...)(adj_matrix)
Buchheim(; kwargs...)(adj_list)
buchheim(adj_matrix; kwargs...)
buchheim(adj_list; kwargs...)

Using the algorithm proposed by Buchheim, Junger and Leipert (2002, doi 10.1007/3-540-36151-0_32).

Takes adjacency matrix or list representation of given tree and returns coordinates of the nodes.

Keyword Arguments

• Ptype=Float64: Determines the output type Point{2,Ptype}.

• nodesize=Float64[]

  Determines the size of each of the node. If network size does not match the length of nodesize fill up with ones or truncate given parameter.

Spring(; kwargs...)(adj_matrix)
spring(adj_matrix; kwargs...)

Use the spring/repulsion model of Fruchterman and Reingold (1991, doi 10.1002/spe.4380211102) with

• Attractive force: f_a(d) = d^2 / k
• Repulsive force: f_r(d) = -k^2 / d

where d is distance between two vertices and the optimal distance between vertices k is defined as C * sqrt( area / num_vertices ) where C is a parameter we can adjust

Takes adjacency matrix representation of a network and returns coordinates of the nodes.

Keyword Arguments

• dim=2, Ptype=Float64: Determines dimension and output type Point{dim,Ptype}.

• C=2.0: Constant to fiddle with density of resulting layout

• iterations=100: maximum number of iterations

• initialtemp=2.0: Initial "temperature", controls movement per iteration

• initialpos=Point{dim,Ptype}[]

  Provide Vector or Dict of initial positions. All positions will be initialized using random coordinates between [-1,1]. Random positions will be overwritten using the key-val-pairs provided by this argument.

• pin=[]: Pin node positions (won't be updated). Can be given as Vector or Dict of node index -> value pairings. Values can be either

  • (12, 4.0) : overwrite initial position and pin
  • true/false : pin this position
  • (true, false, false) : only pin certain coordinates

• seed=1: Seed for random initial positions.

• rng=DEFAULT_RNG[](seed)

  Create rng based on seed. Defaults to MersenneTwister, can be specified by overwriting DEFAULT_RNG[]

Align(inner_layout :: AbstractLayout{2, Ptype}, angle :: Ptype = zero(Ptype))

Align the vertex positions of inner_layout so that the principal axis of the resulting layout makes an angle with the x-axis. Also automatically centers the layout origin to its center of mass (average node position).

Only supports two-dimensional inner layouts.

Stress(; kwargs...)(adj_matrix)
stress(adj_matrix; kwargs...)

Compute graph layout using stress majorization. Takes adjacency matrix representation of a network and returns coordinates of the nodes.

The main equation to solve is (8) in Gansner, Koren and North (2005, doi 10.1007/978-3-540-31843-9_25).

Inputs:

• adj_matrix: Matrix of pairwise distances.

Keyword Arguments

• dim=2, Ptype=Float64: Determines dimension and output type Point{dim,Ptype}.

• iterations=:auto: maximum number of iterations (:auto means 400*N^2 where N are the number of vertices)

• abstols=0

  Absolute tolerance for convergence of stress. The iterations terminate if the difference between two successive stresses is less than abstol.

• reltols=10e-6

  Relative tolerance for convergence of stress. The iterations terminate if the difference between two successive stresses relative to the current stress is less than reltol.

• abstolx=10e-6

  Absolute tolerance for convergence of layout. The iterations terminate if the Frobenius norm of two successive layouts is less than abstolx.

• weights=Array{Float64}(undef, 0, 0)

  Matrix of weights. If empty (i.e. not specified), defaults to weights[i,j] = δ[i,j]^-2 if δ[i,j] is nonzero, or 0 otherwise.

• initialpos=Point{dim,Ptype}[]

  Provide Vector or Dict of initial positions. All positions will be initialized using random coordinates from normal distribution. Random positions will be overwritten using the key-val-pairs provided by this argument.

• pin=[]: Pin node positions (won't be updated). Can be given as Vector or Dict of node index -> value pairings. Values can be either

  • (12, 4.0) : overwrite initial position and pin
  • true/false : pin this position
  • (true, false, false) : only pin certain coordinates

• seed=1: Seed for random initial positions.

• rng=DEFAULT_RNG[](seed)

  Create rng based on seed. Defaults to MersenneTwister, can be specified by overwriting DEFAULT_RNG[]

• uncon_dist=(maxdist, Ncomps)->maxdist*Ncomps^(1/3)

  Per default, unconnected vertices in the graph get a pairwise "ideal" distance which scales with the number of connected components and the maximum distance within the components.

Egocentric(; kwargs...)(adj_matrix)
egocentric(adj_matrix; kwargs...)

Compute an egocentric ("focus") graph layout using stress majorization, centered on a single focal vertex. Takes an adjacency matrix representation of a network and returns coordinates of the nodes, translated such that the focal vertex sits at the origin.

The layout interpolates between two objectives, following Brandes and Pich, "More Flexible Radial Layout", Journal of Graph Algorithms and Applications 15(1):157-173 (2011, doi 10.7155/jgaa.00221):

• a plain stress objective, which tries to match all pairwise euclidean distances to the corresponding graph distances (this is Stress), and
• a focus objective, which only weights the pairs involving the focal vertex.

Minimizing the focus objective alone places every vertex at a radius equal to its graph distance from the focal vertex, producing concentric rings of constant geodesic distance. Optimization proceeds along a schedule tseq of mixing parameters t ∈ [0,1], where the weights used in iteration stage t are (1-t)*W + t*Z with W[i,j] = d[i,j]^-2 and Z equal to W on the row and column of the focal vertex and zero elsewhere. Each stage is majorized to convergence before moving on to the next. Starting at t=0 and ending at t=1 therefore uses the unconstrained stress layout to pick sensible angles, then gradually enforces the radii.

Inputs:

• adj_matrix: Matrix of pairwise distances.

Keyword Arguments

• focus=1: Index of the focal vertex. It is held at the origin, so all returned positions are relative to it. Pinning it has no effect.

• dim=2, Ptype=Float64: Determines dimension and output type Point{dim,Ptype}.

• tseq=0.0:0.1:1.0

  Schedule of mixing parameters, from pure stress (t=0) to pure focus (t=1). Must be non-empty with entries in [0,1].

• iterations=100: maximum number of majorization steps per entry of tseq.

• abstols=0.0

  Absolute tolerance for convergence of stress. A stage terminates if the difference between two successive stresses is less than abstol.

• reltols=10e-5

  Relative tolerance for convergence of stress. A stage terminates if the improvement in stress relative to the current stress is less than reltol.

• abstolx=10e-6

  Absolute tolerance for convergence of layout. A stage terminates if the largest movement of any single node is less than abstolx.

• maxdist=nothing

  If given, radially compress every vertex further than maxdist from the focal vertex onto a narrow band outside maxdist, keeping its angle. This bounds the extent of the layout so that the interesting, near part of the network fills the frame. Vertices that are unconnected to the focal vertex are affected by this too (see uncon_dist). Without maxdist no compression is applied.

• compress=log1p

  How far past maxdist a vertex at excess radius Δ = r - maxdist is drawn: its new radius is maxdist + compress(Δ). May be a function, a real number (all distant vertices land on a single ring at maxdist + compress), or nothing (equivalent to 0, i.e. clamp onto the maxdist ring). Ignored when maxdist is nothing.

• uncon_dist=(maxdist, Ncomps)->maxdist*Ncomps^(1/3)

  Per default, unconnected vertices in the graph get a pairwise "ideal" distance which scales with the number of connected components and the maximum distance within the components.

• initialpos=Point{dim,Ptype}[]

  Provide Vector or Dict of initial positions. By default all positions are initialized using classical multidimensional scaling of the graph distances plus a small random jitter, which makes the result largely deterministic. Those positions will be overwritten using the key-val-pairs provided by this argument.

• pin=[]: Pin node positions (won't be updated). Can be given as Vector or Dict of node index -> value pairings. Values can be either

  • (12, 4.0) : overwrite initial position and pin
  • true/false : pin this position
  • (true, false, false) : only pin certain coordinates

  Pinned positions are given relative to the focal vertex (which sits at the origin), and are exempt from the maxdist compression.

• seed=1: Seed for the random jitter on the initial positions.

• rng=DEFAULT_RNG[](seed)

  Create rng based on seed. Defaults to MersenneTwister, can be specified by overwriting DEFAULT_RNG[]

Shell(; kwargs...)(adj_matrix)
shell(adj_matrix; kwargs...)

Position nodes in concentric circles. Without further arguments all nodes will be placed on a circle with radius 1.0. Specify placement of nodes using the nlist argument.

Takes adjacency matrix representation of a network and returns coordinates of the nodes.

Keyword Arguments

• Ptype=Float64: Determines the output type Point{2,Ptype}.

• nlist=Vector{Int}[]

  Vector of Vector of node indices. Tells the algorithm, which nodes to place on which shell from inner to outer. Nodes which are not present in this list will be place on additional outermost shell.

This function started as a copy from IainNZ's GraphLayout.jl

SquareGrid(; kwargs...)(adj_matrix)
squaregrid(adj_matrix; kwargs...)

Position nodes on a 2 dimensional rectagular grid. The nodes are placed in order from upper left to lower right. To skip positions see skip argument.

Takes adjacency matrix representation of a network and returns coordinates of the nodes.

Keyword Arguments

• Ptype=Float64: Determines the output type Point{2,Ptype}
• cols=:auto: Columns of the grid, the rows are determined automatic. If :auto the layout will be square-ish.
• dx=Ptype(1), dy=Ptype(-1): Ofsets between rows/cols.
• skip=Tuple{Int,Int}[]: Specify positions to skip when placing nodes. skip=[(i,j)] means to keep the position in the i-th row and j-th column empty.

Spectral(; kwargs...)(adj_matrix)
spectral(adj_matrix; kwargs...)

This algorithm uses the technique of Spectral Graph Drawing. For reference see Koren (2003, doi 10.1007/3-540-45071-8_50).

Takes adjacency matrix representation of a network and returns coordinates of the nodes.

Keyword Arguments

• dim=3, Ptype=Float64: Determines dimension and output type Point{dim,Ptype}.
• nodeweights=Float64[]: Vector of weights. If network size does not match the length of nodesize use ones instead.