GraphLayout
Listing of Layouts »is an option to Graph and related functions that specifies what layout to use.
Details
- A graph layout is typically computed using several stages. With GraphLayout->{s1->m1,…}, stage si is handled by method mi.
- Possible graph layout stages si are:
-
"VertexLayout" how to embed vertices "EdgeLayout" how to route edges "PackingLayout" how to place connected components of vertices - "VertexLayout" methods include:
-
Automatic automatically select a layout None do not compute a layout "emb" named embedding - Possible special embeddings "emb" include:
-
"BipartiteEmbedding" vertices on two parallel lines 
"CircularEmbedding" vertices on a circle 
"CircularMultipartiteEmbedding" vertices on segments of a circle 
"DiscreteSpiralEmbedding" vertices on a discrete spiral 
"GridEmbedding" vertices on a grid 
"LinearEmbedding" vertices on a line 
"MultipartiteEmbedding" vertices on several parallel lines 
"SpiralEmbedding" vertices on a 3D spiral projected to 2D 
"StarEmbedding" vertices on a circle with a center - Possible structured embeddings "emb" for layered graphs such as trees and directed acyclic graphs include:
-
"BalloonEmbedding" vertices on a circle with the center at the parent vertex 
"RadialEmbedding" vertices on a circular segment 
"LayeredDigraphEmbedding" vertices on parallel lines for directed acyclic graphs 
"LayeredEmbedding" vertices on parallel lines 
"SymmetricLayeredEmbedding" vertices on symmetric parallel lines 
"HyperbolicRadialEmbedding" vertices on a circular segment on the Poincaré disk - Possible optimizing embeddings "emb" all minimize a quantity and include:
-
"GravityEmbedding" energy with vertices as mass points and edges as springs 
"HighDimensionalEmbedding" energy for spring-electrical in high dimension 
"PlanarEmbedding" number of edge crossings 
"SpectralEmbedding" weighted sum of squares distances 
"SphericalEmbedding" energy with vertices on a sphere and edges as springs 
"SpringElectricalEmbedding" energy with edges as springs and vertices as charges 
"SpringEmbedding" energy with edges as springs 
"TutteEmbedding" number of edge crossings and distance to neighbors 
"HyperbolicSpringEmbedding" energy with edges as springs on the Poincaré disk - "EdgeLayout" methods include:
-
"DividedEdgeBundling" divide edges into segments bundle "HierarchicalEdgeBundling" bundle edges following a hierarchical tree structure "StraightLine" straight lines between edges - "PackingLayout" methods include:
-
"ClosestPacking" approximate closest packing from the top left "ClosestPackingCenter" approximate closest packing from the center "Layered" arrange in layers starting at the top left "LayeredLeft" arrange in layers starting at the left "LayeredTop" arrange in layers starting at the top "NestedGrid" arrange on a nested grid
Examples
open all close allBasic Examples (2)
Graph layouts on particular curves:
Table[PathGraph[Range[20], GraphLayout -> l, PlotLabel -> l], {l, {"CircularEmbedding", "SpiralEmbedding"}}]Graph layouts that satisfy optimality criteria:
Table[GridGraph[{10, 10}, GraphLayout -> l, PlotLabel -> Style[l, 10]], {l, {"SpringEmbedding", "SpringElectricalEmbedding", "HighDimensionalEmbedding"}}]Scope (131)
Basic Use (3)
Change the default layout for Graph:
Graph[{12, 23, 34, 45, 56, 67, 78, 89, 910}]Graph[{12, 23, 34, 45, 56, 67, 78, 89, 910}, GraphLayout -> "DiscreteSpiralEmbedding"]Graph3D[{12, 13, 15, 24, 26, 34, 37, 48, 56, 57, 68, 78}]Graph3D[{12, 23, 34, 45, 56, 67, 78, 89, 910}, GraphLayout -> "DiscreteSpiralEmbedding"]TreeGraph[{12, 13, 14, 45}]TreeGraph[{12, 13, 14, 45}, GraphLayout -> "CircularEmbedding"]PathGraph[Range[20]]PathGraph[Range[20], GraphLayout -> "CircularEmbedding"]Graph[{12, 13, 14, 23, 24, 34}, GraphLayout -> "PlanarEmbedding"]Graph[{14, 15, 16, 24, 25, 26, 34, 35, 36}, GraphLayout -> "BipartiteEmbedding"]Graph[{13, 23, 24, 25, 34, 35}, GraphLayout -> "SpringEmbedding"]Specify a layout for parametric graphs:
PetersenGraph[5, 1, GraphLayout -> "CircularEmbedding"]RandomGraph[{10, 20}, GraphLayout -> "CircularEmbedding"]AdjacencyGraph[{{0, 1, 0}, {0, 0, 1}, {1, 0, 0}}, GraphLayout -> "CircularEmbedding"]LineGraph[PetersenGraph[], GraphLayout -> "CircularEmbedding"]Vertex Layout (116)
"BalloonEmbedding" (8)
Place each vertex in an enclosing circle centered at its parent vertex:
Graph[Table[Floor[j / 12]j, {j, 1, 30}], GraphLayout -> "BalloonEmbedding"]"BalloonEmbedding" works best for tree graphs:
TreeGraph[RandomInteger[{1, #}]# + 1& /@ Range[30], GraphLayout -> "BalloonEmbedding"]Use the option "EvenAngle"->True to place vertices evenly in an enclosing circle:
{KaryTree[48, 5, GraphLayout -> {"BalloonEmbedding", "EvenAngle" -> True}],
KaryTree[48, 5, GraphLayout -> {"BalloonEmbedding", "EvenAngle" -> False}]}With the setting "OptimalOrder"->True, the vertex ordering optimizes the angular resolution and the aspect ratio:
{KaryTree[48, 5, GraphLayout -> {"BalloonEmbedding", "OptimalOrder" -> True}],
KaryTree[48, 5, GraphLayout -> {"BalloonEmbedding", "OptimalOrder" -> False}]}Use the option "RootVertex"->v to set the root vertex:
{KaryTree[48, 5, GraphLayout -> {"BalloonEmbedding", "RootVertex" -> 1}],
KaryTree[48, 5, GraphLayout -> {"BalloonEmbedding", "RootVertex" -> 2}]}Use the option "Rotation"->r to rotate the layout:
KaryTree[48, 5, GraphLayout -> {"BalloonEmbedding", "Rotation" -> 90Degree}]Use "SectorAngles"->s to control the size of each sector:
KaryTree[48, 5, GraphLayout -> {"BalloonEmbedding", "SectorAngles" -> {1 -> Pi / 2}}]The balloon layout works with arbitrary graphs:
RandomGraph[{10, 15}, GraphLayout -> "BalloonEmbedding"]"BipartiteEmbedding" (2)
Place vertices on two vertical lines based on a bipartite partition:
Graph[Table[iMod[i + 1, 5], {i, 8}], GraphLayout -> "BipartiteEmbedding"]"BipartiteEmbedding" works for bipartite graphs only:
CycleGraph[8, GraphLayout -> "BipartiteEmbedding"]"CircularEmbedding" (4)
Graph[Table[iMod[i + 1, 3], {i, 8}], GraphLayout -> "CircularEmbedding"]"CircularEmbedding" works best for circulant graphs, LCF notation embeddings and cycle graphs:
CycleGraph[10, GraphLayout -> "CircularEmbedding"]Use the option "Offset"->offset to specify the offset angles:
CompleteGraph[7, GraphLayout -> {"CircularEmbedding", "Offset" -> #}]& /@ {Automatic, {30Degree, 30Degree}, {50Degree, 80Degree}}With the setting "OptimalOrder"->True, vertices are reordered so that they lie nicely on a circle:
edges = RandomSample[EdgeList[CycleGraph[20]], 20];
{Graph[edges, GraphLayout -> {"CircularEmbedding", "OptimalOrder" -> True}],
Graph[edges, GraphLayout -> {"CircularEmbedding", "OptimalOrder" -> False}]}"CircularMultipartiteEmbedding" (3)
Place vertices on polygon lines based on a vertex partition:
Graph[Flatten[Table[ij, {i, 4}, {j, 5, 8}]], GraphLayout -> {"CircularMultipartiteEmbedding", "VertexPartition" -> {2, 3, 3}}]"CircularMultipartiteEmbedding" works best for k-partite graphs:
CompleteGraph[{2, 3, 2, 3}, GraphLayout -> {"CircularMultipartiteEmbedding", "VertexPartition" -> {2, 3, 2, 3}}]Use "VertexPartition"->partition to specify a partition of vertices:
CompleteGraph[{3, 3, 2}, GraphLayout -> {"CircularMultipartiteEmbedding", "VertexPartition" -> {3, 3, 2}}]"DiscreteSpiralEmbedding" (3)
Place vertices on a discrete spiral:
Graph[Table[ii + 1, {i, 11}], GraphLayout -> "DiscreteSpiralEmbedding"]"DiscreteSpiralEmbedding" works best for path graphs:
PathGraph[Range[30], GraphLayout -> "DiscreteSpiralEmbedding"]With the setting "OptimalOrder"->True, vertices are reordered so that they lie nicely on a discrete spiral:
edges = RandomSample[EdgeList[PathGraph[Range[20]]], 19];
{Graph[edges, GraphLayout -> {"DiscreteSpiralEmbedding", "OptimalOrder" -> True}],
Graph[edges, GraphLayout -> {"DiscreteSpiralEmbedding", "OptimalOrder" -> False}]}"GravityEmbedding" (2)
Place vertices so that they minimize mechanical, electrical and gravitational energy when each vertex has a charge and a mass, and each edge corresponds to a spring:
Graph[Table[Floor[j / 12]j, {j, 1, 30}], GraphLayout -> "GravityEmbedding"]Use the option "RootVertex"->v to set the root vertex:
{KaryTree[48, 5, GraphLayout -> {"GravityEmbedding", "RootVertex" -> 1}],
KaryTree[48, 5, GraphLayout -> {"GravityEmbedding", "RootVertex" -> 2}]}"GridEmbedding" (3)
Graph[Table[iMod[i + 3, 8], {i, 15}], GraphLayout -> {"GridEmbedding", "Dimension" -> {4, 4}}]"GridEmbedding" works best for grid graphs:
GridGraph[{10, 10}, GraphLayout -> {"GridEmbedding", "Dimension" -> {10, 10}}]Use "Dimension"->dim to specify a dimension of a grid:
GridGraph[{12, 12}, GraphLayout -> {"GridEmbedding", "Dimension" -> {12, 12}}]"HighDimensionalEmbedding" (3)
Place vertices in high dimension according to spring-electrical embedding and project down:
Graph[{12, 13, 15, 19, 24, 26, 210, 34, 37, 311, 48, 412, 56, 57, 513, 68, 614, 78, 715, 816, 910, 911, 913, 1012, 1014, 1112, 1115, 1216, 1314, 1315, 1416, 1516}, GraphLayout -> "HighDimensionalEmbedding"]"HighDimensionalEmbedding" works best for large graphs:
GridGraph[{50, 50}, GraphLayout -> "HighDimensionalEmbedding"]Use "RandomSeed"->int to specify a seed for the random number generator that computes the initial vertex placement:
edge = {13, 15, 17, 23, 26, 27, 28, 34, 38, 46, 58, 78};Graph[edge, GraphLayout -> {"HighDimensionalEmbedding", "RandomSeed" -> #}]& /@ {1, 50}"HyperbolicRadialEmbedding" (4)
Place vertices on a Poincaré disk:
KaryTree[30, GraphLayout -> "HyperbolicRadialEmbedding"]"HyperbolicRadialEmbedding" works best for tree graphs:
TreeGraph[RandomInteger[{1, #}]# + 1& /@ Range[30], GraphLayout -> "HyperbolicRadialEmbedding"]Use the option "RootVertex"v to set the root vertex:
KaryTree[60, 5, GraphLayout -> {"HyperbolicRadialEmbedding", "RootVertex" -> #}]& /@ {1, 2}Use "Rotation"r to rotate the layout:
KaryTree[60, 5, GraphLayout -> {"HyperbolicRadialEmbedding", "Rotation" -> 45Degree}]"HyperbolicSpringEmbedding" (10)
Place vertices on a Poincaré disk:
KaryTree[30, GraphLayout -> "HyperbolicSpringEmbedding"]"HyperbolicSpringEmbedding" works best for tree graphs:
KaryTree[20, GraphLayout -> "HyperbolicSpringEmbedding"]With the setting "EdgeWeighted"True, edge weights are used:
edge = RandomInteger[#]# + 1& /@ Range[0, 10];
weight = RandomInteger[{1, 5}, 11];Graph[edge, EdgeWeight -> weight, GraphLayout -> {"HyperbolicSpringEmbedding", "EdgeWeighted" -> #}]& /@ {True, False}Use the option "EnergyControl"e to specify limitations on the total energy of the system during minimization:
edge = RandomInteger[#]# + 1& /@ Range[0, 30];Graph[edge, {GraphLayout -> {"HyperbolicSpringEmbedding", "EnergyControl" -> #}}]& /@ {Automatic, "Monotonic", "NonMonotonic"}Use "InferentialDistance"d to specify a cutoff distance beyond which the interaction between vertices is assumed to be nonexistent:
edge = RandomInteger[#]# + 1& /@ Range[0, 30];Graph[edge, GraphLayout -> {"HyperbolicSpringEmbedding", "InferentialDistance" -> #}]& /@ {Automatic, .5, 2}Use "MaxIteration"it to specify a maximum number of iterations to be used in attempting to minimize the energy:
edge = RandomInteger[#]# + 1& /@ Range[0, 30];Graph[edge, GraphLayout -> {"HyperbolicSpringEmbedding", "MaxIteration" -> #}]& /@ {Automatic, 1, 2}Use "RandomSeed"int to specify a seed for the random number generator that computes the initial vertex placement:
edge = RandomInteger[#]# + 1& /@ Range[0, 30];Graph[edge, GraphLayout -> {"HyperbolicSpringEmbedding", "RandomSeed" -> #}]& /@ {1, 5}Use "StepControl"method to define how step length is modified during energy minimization:
edge = RandomInteger[#]# + 1& /@ Range[0, 30];Graph[edge, GraphLayout -> {"HyperbolicSpringEmbedding", "StepControl" -> #}]& /@ {Automatic, "Monotonic", "NonMonotonic", "StrictlyMonotonic"}Use "StepLength"r to specify the initial step length used in moving the vertices around:
edge = RandomInteger[#]# + 1& /@ Range[0, 30];Graph[edge, GraphLayout -> {"HyperbolicSpringEmbedding", "StepLength" -> #}]& /@ {1, 4.5}Use "Tolerance"r to specify the tolerance used in terminating the energy minimization process:
edge = RandomInteger[#]# + 1& /@ Range[0, 30];Graph[edge, GraphLayout -> {"HyperbolicSpringEmbedding", "Tolerance" -> #}]& /@ {Automatic, .5}"LayeredEmbedding" (7)
Place vertices in several layers in such a way as to minimize edges between nonadjacent layers:
Graph[Table[iMod[i + 1, 5], {i, 12}], GraphLayout -> "LayeredEmbedding"]"LayeredEmbedding" works best for tree graphs:
TreeGraph[RandomInteger[{1, #}]# + 1& /@ Range[20], GraphLayout -> "LayeredEmbedding"]Use the option "LayerSizeFunction"->func to specify the relative height:
KaryTree[10, 3, GraphLayout -> {"LayeredEmbedding", LayerSizeFunction -> (2&)}]Use the option "RootVertex"->v to set the root vertex:
{KaryTree[10, 3, GraphLayout -> {"LayeredEmbedding", "RootVertex" -> 1}],
KaryTree[10, 3, GraphLayout -> {"LayeredEmbedding", "RootVertex" -> 4}]}Use the option "LeafDistance"->d to specify the leaf distance:
{KaryTree[10, 3, GraphLayout -> {"LayeredEmbedding", "LeafDistance" -> 1}],
KaryTree[10, 3, GraphLayout -> {"LayeredEmbedding", "LeafDistance" -> 2}]}Use the option "Orientation"->o to draw a tree with different orientations:
Table[KaryTree[6, 3, GraphLayout -> {"LayeredEmbedding", "Orientation" -> o}], {o, {Top, Bottom, Left, Right}}]The layered drawing works on arbitrary graphs:
RandomGraph[{20, 30}, GraphLayout -> "LayeredEmbedding"]"LayeredDigraphEmbedding" (7)
Place vertices in a series of layers:
Graph[{12, 13, 23, 14, 24, 15}, GraphLayout -> "LayeredDigraphEmbedding"]"LayeredDigraphEmbedding" works best for directed acyclic graphs:
TreeGraph[RandomInteger[{1, #}]# + 1& /@ Range[20], GraphLayout -> "LayeredDigraphEmbedding"]Use the option "RootVertex"->v to set the root vertex:
Graph[{12, 13, 23, 14, 24, 15}, GraphLayout -> {"LayeredDigraphEmbedding", "RootVertex" -> #}]& /@ {1, 3}Use the option "Rotation"r to rotate the layout:
Table[Graph[{12, 13, 23, 14, 24, 15}, GraphLayout -> {"LayeredDigraphEmbedding", "Rotation" -> r Degree}], {r, {30, 60, 90, 120}}]Use the option "Orientation"->o to draw a tree with different orientations:
Table[Graph[{12, 13, 23, 14, 24, 15}, GraphLayout -> {"LayeredDigraphEmbedding", "Orientation" -> o}], {o, {Top, Bottom, Left, Right}}]Use the option "VertexLayerPosition"->positions to specify the positions of layers:
Table[Graph[{12, 13, 23, 14, 24, 15}, GraphLayout -> {"LayeredDigraphEmbedding", "VertexLayerPosition" -> pos}], {pos, {{1, 3, 4, 5, 6}, {2, 1, 3, 4, 5}, {5, 4, 2, 1, 3}, {3, 6, 1, 2, 4}}}]The layered digraph drawing works on arbitrary graphs:
RandomGraph[{20, 35}, GraphLayout -> "LayeredDigraphDrawing"]"LinearEmbedding" (2)
Graph[{12, 23, 34}, GraphLayout -> "LinearEmbedding"]Use the option Method->m to specify the algorithm:
Table[CompleteGraph[4, GraphLayout -> {"LinearEmbedding", Method -> m}], {m, {"Spectral", "SpectralOrdering", "TwoNormApproximation", "TwoNormApproximationOrdering"}}]"MultipartiteEmbedding" (3)
Place vertices on multiple line grids based on a vertex partition:
Graph[Flatten[Table[ij, {i, 3}, {j, 4, 8}]], GraphLayout -> {"MultipartiteEmbedding", "VertexPartition" -> {2, 1, 3, 2}}]"MultipartiteEmbedding" works best for k-partite graphs:
CompleteGraph[{4, 4, 4}, GraphLayout -> {"MultipartiteEmbedding", "VertexPartition" -> {4, 4, 4}}]Use "VertexPartition"->partition to specify a partition of vertices:
CompleteGraph[{3, 2, 4}, GraphLayout -> {"MultipartiteEmbedding", "VertexPartition" -> {3, 2, 4}}]"PlanarEmbedding" (2)
Place vertices on a plane without an edge crossing:
Graph[{12, 13, 14, 23, 24, 34}, GraphLayout -> "PlanarEmbedding"]"PlanarEmbedding" works for planar graphs only:
HararyGraph[3, 5, GraphLayout -> "PlanarEmbedding"]"RadialEmbedding" (5)
Place vertices in concentric circles:
Graph[Table[Floor[j / 7]j, {j, 1, 30}], GraphLayout -> "RadialEmbedding"]"RadialEmbedding" works best for tree graphs:
TreeGraph[RandomInteger[{1, #}]# + 1& /@ Range[30], GraphLayout -> "RadialEmbedding"]Use the option "RootVertex"->v to set the root vertex:
KaryTree[60, 5, GraphLayout -> {"RadialEmbedding", "RootVertex" -> #}]& /@ {1, 2}Use the option "Rotation"r to rotate the layout:
Table[KaryTree[60, 5, GraphLayout -> {"ComponentLayout" -> {"RadialEmbedding", "Rotation" -> r Degree}}], {r, {0, 30, 60, 90}}]The radial drawing works on arbitrary graphs:
RandomGraph[{20, 40}, GraphLayout -> "RadialEmbedding"]"RandomEmbedding" (1)
"SpectralEmbedding" (3)
Place vertices so the weighted sum of squares of mutual distances is minimized:
Graph[{12, 13, 15, 19, 24, 26, 210, 34, 37, 311, 48, 412, 56, 57, 513, 68, 614, 78, 715, 816, 910, 911, 913, 1012, 1014, 1112, 1115, 1216, 1314, 1315, 1416, 1516}, GraphLayout -> "SpectralEmbedding"]"SpectralEmbedding" works best for well-structured graphs:
HypercubeGraph[9, GraphLayout -> "SpectralEmbedding"]Use the option "RelaxationFactor"->r to get the layout based on a relaxed Laplace matrix:
Table[GridGraph[{10, 10}, GraphLayout -> {"SpectralEmbedding", "RelaxationFactor" -> i}], {i, 0, 1, .3}]"SphericalEmbedding" (2)
Graph[{114, 115, 116, 25, 26, 213, 37, 314, 319, 48, 415, 420, 511, 519, 612, 620, 711, 716, 812, 816, 910, 914, 917, 1015, 1018, 1112, 1317, 1318, 1719, 1820}, GraphLayout -> "SphericalEmbedding"]"SphericalEmbedding" works best for regular structured graphs:
Graph[GraphData[{"GeneralizedPetersen", {9, 2}}, "Edges"], GraphLayout -> "SphericalEmbedding"]"SpiralEmbedding" (3)
Graph[Table[iMod[i + 1, 20, 1], {i, 20}], GraphLayout -> "SpiralEmbedding"]"SpiralEmbedding" works best for path graphs:
PathGraph[Range[40], GraphLayout -> "SpiralEmbedding"]With the setting "OptimalOrder"->True, vertices are reordered so that they lie on the spiral nicely:
edges = RandomSample[EdgeList[CycleGraph[20]], 20];
{Graph[edges, GraphLayout -> {"SpiralEmbedding", "OptimalOrder" -> True}],
Graph[edges, GraphLayout -> {"SpiralEmbedding", "OptimalOrder" -> False}]}"SpringElectricalEmbedding" (15)
Place vertices so that they minimize mechanical and electrical energy when each vertex has a charge and each edge corresponds to a spring:
Graph[{12, 13, 15, 19, 24, 26, 210, 34, 37, 311, 48, 412, 56, 57, 513, 68, 614, 78, 715, 816, 910, 911, 913, 1012, 1014, 1112, 1115, 1216, 1314, 1315, 1416, 1516}, GraphLayout -> "SpringElectricalEmbedding"]"SpringElectricalEmbedding" works best for most graphs:
KnightTourGraph[10, 10, GraphLayout -> "SpringElectricalEmbedding"]With the setting "EdgeWeighted"->True, edge weights are used:
edge = RandomInteger[#]# + 1& /@ Range[0, 10];
weight = RandomInteger[{1, 5}, 11];Graph[edge, EdgeWeight -> weight, GraphLayout -> {"SpringElectricalEmbedding", "EdgeWeighted" -> #}]& /@ {True, False}Use the option "EnergyControl"->e to specify limitations on the total energy of the system during minimization:
edge = RandomInteger[#]# + 1& /@ Range[0, 20];Graph[edge, {GraphLayout -> {"SpringElectricalEmbedding", "EnergyControl" -> #, "StepControl" -> "Monotonic"}}]& /@ {Automatic, "Monotonic", "NonMonotonic"}Use "InferentialDistance"->d to specify a cutoff distance beyond which the interaction between vertices is assumed to be nonexistent:
edge = RandomInteger[#]# + 1& /@ Range[0, 20];Graph[edge, GraphLayout -> {"SpringElectricalEmbedding", "InferentialDistance" -> #}]& /@ {Automatic, .1, .5}Use "MaxIteration"->it to specify a maximum number of iterations to be used in attempting to minimize the energy:
edge = RandomInteger[#]# + 1& /@ Range[0, 20];Graph[edge, GraphLayout -> {"SpringElectricalEmbedding", "MaxIteration" -> #}]& /@ {Automatic, 1, 2}Use "Multilevel"->method to specify a method used during a recursive procedure of coarsening a graph:
edge = RandomInteger[#]# + 1& /@ Range[0, 20];Graph[edge, GraphLayout -> {"SpringElectricalEmbedding", "Multilevel" -> #}]& /@ {Automatic, None, "MaximalIndependentVertexSet", "MaximalIndependentVertexSetRugeStuben", "MaximalIndependentVertexSetInjection", "MaximalIndependentVertexSetRugeStubenInjection", "MaximalIndependentEdgeSetHeavyEdge", "MaximalIndependentEdgeSet", "MaximalIndependentEdgeSetSmallestVertexWeight", "Hybrid"}With the setting "Octree"->True, an octree data structure (in three dimensions) or a quadtree data structure (in two dimensions) is used in the calculation of repulsive force:
edge = RandomInteger[#]# + 1& /@ Range[0, 20];Graph[edge, GraphLayout -> {"SpringElectricalEmbedding", "Octree" -> #}]& /@ {True, False}Use "RandomSeed"->int to specify a seed for the random number generator that computes the initial vertex placement:
edge = RandomInteger[#]# + 1& /@ Range[0, 20];Graph[edge, GraphLayout -> {"SpringElectricalEmbedding", "RandomSeed" -> #}]& /@ {1, 5}Use "RepulsiveForcePower"->r to control how fast the repulsive force decays over distance:
edge = RandomInteger[#]# + 1& /@ Range[0, 20];Graph[edge, GraphLayout -> {"SpringElectricalEmbedding", "RepulsiveForcePower" -> #}]& /@ {-1, -2.5}Use the option "Rotation"r to rotate the layout:
edge = RandomInteger[#]# + 1& /@ Range[0, 50];Graph[edge, {GraphLayout -> {"SpringElectricalEmbedding", "Rotation" -> #}}]& /@ {0, 90Degree}Use "SpringConstant"r to control the constant in the attractive force:
edge = RandomInteger[#]# + 1& /@ Range[0, 20];Graph[edge, GraphLayout -> {"SpringElectricalEmbedding", "SpringConstant" -> #}]& /@ {1, 4.5, 8}Use "StepControl"->method to define how step length is modified during energy minimization:
edge = RandomInteger[#]# + 1& /@ Range[0, 20];Graph[edge, GraphLayout -> {"SpringElectricalEmbedding", "StepControl" -> #}]& /@ {Automatic, "Monotonic", "NonMonotonic", "StrictlyMonotonic"}Use "StepLength"->r to specify the initial step length used in moving the vertices around:
edge = RandomInteger[#]# + 1& /@ Range[0, 20];Graph[edge, GraphLayout -> {"SpringElectricalEmbedding", "StepLength" -> #}]& /@ {1, 4.5}Use "Tolerance"->r to specify the tolerance used in terminating the energy minimization process:
edge = RandomInteger[#]# + 1& /@ Range[0, 20];Graph[edge, GraphLayout -> {"SpringElectricalEmbedding", "Tolerance" -> #}]& /@ {Automatic, .5}"SpringEmbedding" (12)
Place vertices so that they minimize mechanical energy when each edge corresponds to a spring:
Graph[{114, 115, 116, 25, 26, 213, 37, 314, 319, 48, 415, 420, 511, 519, 612, 620, 711, 716, 812, 816, 910, 914, 917, 1015, 1018, 1112, 1317, 1318, 1719, 1820}, GraphLayout -> "SpringEmbedding"]"SpringEmbedding" works best for regular structured graphs:
Graph[GraphData[{"GeneralizedPetersen", {9, 2}}, "EdgeRules"], GraphLayout -> "SpringEmbedding"]With the setting "EdgeWeighted"->True, edge weights are used:
edge = RandomInteger[#]# + 1& /@ Range[0, 10];
weight = RandomInteger[{1, 5}, 11];Graph[edge, EdgeWeight -> weight, GraphLayout -> {"SpringEmbedding", "EdgeWeighted" -> #}]& /@ {True, False}Use the option "EnergyControl"->e to specify limitations on the total energy of the system during minimization:
edge = RandomInteger[#]# + 1& /@ Range[0, 30];Graph[edge, {GraphLayout -> {"SpringEmbedding", "EnergyControl" -> #}}]& /@ {Automatic, "Monotonic", "NonMonotonic"}Use "InferentialDistance"->d to specify a cutoff distance beyond which the interaction between vertices is assumed to be nonexistent:
edge = RandomInteger[#]# + 1& /@ Range[0, 30];Graph[edge, GraphLayout -> {"SpringEmbedding", "InferentialDistance" -> #}]& /@ {Automatic, .5, 2}Use "MaxIteration"->it to specify a maximum number of iterations to be used in attempting to minimize the energy:
edge = RandomInteger[#]# + 1& /@ Range[0, 30];Graph[edge, GraphLayout -> {"SpringEmbedding", "MaxIteration" -> #}]& /@ {Automatic, 1, 2}Use "Multilevel"->method to specify a method used during a recursive procedure of coarsening a graph:
edge = RandomInteger[#]# + 1& /@ Range[0, 30];Graph[edge, GraphLayout -> {"SpringEmbedding", "Multilevel" -> #}]& /@ {Automatic, None, "MaximalIndependentVertexSet", "MaximalIndependentVertexSetRugeStuben", "MaximalIndependentVertexSetInjection", "MaximalIndependentVertexSetRugeStubenInjection", "MaximalIndependentEdgeSetHeavyEdge", "MaximalIndependentEdgeSet", "MaximalIndependentEdgeSetSmallestVertexWeight", "Hybrid"}Use "RandomSeed"->int to specify a seed for the random number generator that computes the initial vertex placement:
edge = RandomInteger[#]# + 1& /@ Range[0, 30];Graph[edge, GraphLayout -> {"SpringEmbedding", "RandomSeed" -> #}]& /@ {1, 5}Use the option "Rotation"r to rotate the layout:
edge = RandomInteger[#]# + 1& /@ Range[0, 30];Graph[edge, {GraphLayout -> {"SpringEmbedding", "Rotation" -> #}}]& /@ {0, 90Degree}Use "StepControl"->method to define how step length is modified during energy minimization:
edge = RandomInteger[#]# + 1& /@ Range[0, 30];Graph[edge, GraphLayout -> {"SpringEmbedding", "StepControl" -> #}]& /@ {Automatic, "Monotonic", "NonMonotonic", "StrictlyMonotonic"}Use "StepLength"->r to specify the initial step length used in moving the vertices around:
edge = RandomInteger[#]# + 1& /@ Range[0, 30];Graph[edge, GraphLayout -> {"SpringEmbedding", "StepLength" -> #}]& /@ {1, 4.5}Use "Tolerance"->r to specify the tolerance used in terminating the energy minimization process:
edge = RandomInteger[#]# + 1& /@ Range[0, 30];Graph[edge, GraphLayout -> {"SpringEmbedding", "Tolerance" -> #}]& /@ {Automatic, .5}"StarEmbedding" (4)
Place vertices on a star shape:
Graph[Table[1i, {i, 2, 6}], GraphLayout -> "StarEmbedding"]"StarEmbedding" works best for star-like graphs:
{StarGraph[12, GraphLayout -> "StarEmbedding"], WheelGraph[12, GraphLayout -> "StarEmbedding"]}Use the option "Offset"->offset to specify the offset angles:
StarGraph[15, GraphLayout -> {"StarEmbedding", "Offset" -> #}]& /@ {Automatic, {30Degree, 30Degree}, {50Degree, 80Degree}}Use the option "Center"->center to specify the center:
StarGraph[15, GraphLayout -> {"StarEmbedding", "Center" -> #}]& /@ {Automatic, 10}"SymmetricLayeredEmbedding" (4)
Place vertices in a series of layers symmetrically:
Graph[{12, 13, 14, 25, 35, 45}, GraphLayout -> "SymmetricLayeredEmbedding"]"SymmetricLayeredEmbedding" works best for symmetric directed acyclic graphs:
NestGraph[{f[#], g[#]}&, x, 3, GraphLayout -> "SymmetricLayeredEmbedding"]Use the option "Rotation"r to rotate the layout:
Table[Graph[{12, 13, 14, 25, 35, 45}, GraphLayout -> {"SymmetricLayeredEmbedding", "Rotation" -> r Degree}], {r, {30, 60, 90, 120}}]The layered digraph drawing works on arbitrary graphs:
RandomGraph[{20, 35}, GraphLayout -> "SymmetricLayeredEmbedding"]"TutteEmbedding" (2)
Place vertices without crossing edges and minimize the sum of distances to neighbors:
Graph[{12, 13, 14, 23, 24, 34}, GraphLayout -> "TutteEmbedding"]"TutteEmbedding" works for 3-connected planar graphs only:
Graph[GraphData[{"JohnsonSkeleton", 77}, "EdgeList"], GraphLayout -> "TutteEmbedding"]Edge Layout (3)
"DividedEdgeBundling" (1)
"HierarchicalEdgeBundling" (1)
Packing Layout (6)
"ClosestPacking" (1)
"ClosestPackingCenter" (1)
"Layered" (1)
"LayeredLeft" (1)
"LayeredTop" (1)
Rendering Order (3)
"VertexFirst" (1)
"EdgeFirst" (1)
Applications (2)
Layout of Wolfram System installation directory:
files = Flatten[Rest[NestList[Union[Flatten[Thread[# -> FileNames["*", #]]& /@ Last /@ #]]&, {"" -> $InstallationDirectory}, 2]]];Graph[files, GraphLayout -> "BalloonEmbedding"]Show the relationships between early versions of the Unix operating system:
systems = {"5th Edition""6th Edition", "5th Edition""PWB 1.0", "6th Edition""1 BSD", "6th Edition""Interdata", "6th Edition""LSX", "6th Edition""Mini Unix", "6th Edition""Wollongong", "PWB 1.0""PWB 1.2", "PWB 1.0""USG 1.0", "1 BSD""2 BSD", "Interdata""PWB 2.0", "Interdata""Unix/TS 3.0", "Interdata""7th Edition", "PWB 1.2""PWB 2.0", "USG 1.0""USG 2.0", "USG 1.0""CB Unix 1", "7th Edition""2 BSD", "7th Edition""32V", "7th Edition""Xenix", "7th Edition""Ultrix-11", "7th Edition""UniPlus+", "7th Edition""V7M", "PWB 2.0""Unix/TS 3.0", "USG 2.0""USG 3.0", "CB Unix 1""CB Unix 2", "32V""3 BSD", "Unix/TS 1.0""Unix/TS 3.0", "USG 3.0""Unix/TS 3.0", "CB Unix 2""CB Unix 3", "3 BSD""4 BSD", "V7M""Ultrix-11", "Unix/TS 3.0""TS 4.0", "CB Unix 3""Unix/TS++", "CB Unix 3""PDP-11 Sys V", "4 BSD""4.1 BSD", "Unix/TS++""TS 4.0", "4.1 BSD""8th Edition", "4.1 BSD""4.2 BSD", "4.1 BSD""2.8 BSD", "2 BSD""2.8 BSD", "TS 4.0""System V.0", "4.2 BSD""4.3 BSD", "4.2 BSD""Ultrix-32", "2.8 BSD""2.9 BSD", "2.8 BSD""Ultrix-11", "System V.0""System V.2", "8th Edition""9th Edition", "System V.2""System V.3"};Automatically use the layered digraph embedding:
Graph[systems, VertexShapeFunction -> "Square", VertexSize -> {.5, .2}, VertexLabels -> Placed["Name", Center], VertexStyle -> Hue[0.125, 0.7, 0.9], VertexLabelStyle -> Directive[FontFamily -> "Arial", 8], ImageSize -> 480, EdgeShapeFunction -> ({Arrowheads[{{.02, .6}}], Arrow[#]}&)]Properties & Relations (6)
GraphLayout can be used for general graphs:
{Graph[{12, 23, 31}, GraphLayout -> "SpringEmbedding"], PathGraph[Range[10], GraphLayout -> "SpringEmbedding"]}AdjacencyGraph[{{0, 1, 0}, {0, 0, 1}, {1, 0, 0}}, GraphLayout -> "SpringEmbedding"]{PetersenGraph[5, 2, GraphLayout -> "SpringEmbedding"], GridGraph[{5, 5}, GraphLayout -> "SpringEmbedding"]}RandomGraph[UniformGraphDistribution[50, 100], GraphLayout -> "CircularEmbedding"]VertexCoordinates overrides GraphLayout coordinates:
{Graph[{12, 23, 31}, GraphLayout -> "SpringElectricalEmbedding"],
Graph[{12, 23, 31}, GraphLayout -> "SpringElectricalEmbedding", VertexCoordinates -> Table[{i, i}, {i, 0, 2}]]}Use AbsoluteOptions to extract VertexCoordinates computed using a layout algorithm:
Graph[{12, 23, 31}]AbsoluteOptions[%, VertexCoordinates]Text
Wolfram Research (2010), GraphLayout, Wolfram Language function, https://reference.wolfram.com/language/ref/GraphLayout.html (updated 2025).
CMS
Wolfram Language. 2010. "GraphLayout." Wolfram Language & System Documentation Center. Wolfram Research. Last Modified 2025. https://reference.wolfram.com/language/ref/GraphLayout.html.
APA
Wolfram Language. (2010). GraphLayout. Wolfram Language & System Documentation Center. Retrieved from https://reference.wolfram.com/language/ref/GraphLayout.html