Graph

@dynamicMemberLookup public struct Graph: Equatable

Inheritance

Equatable

Nested Types

Initializers

init(width:height:center:scale:)

public init(width: Double, height: Double, center: Center, scale: Double = 1.0)

init(directed:strict:)

Creates a graph.

public init(directed: Bool = false, strict: Bool = false)

Parameters

directed: Whether the graph is directed; false by default.
strict: Whether the graph is strict; false by default.

init?(rawValue:)

public init?(rawValue: Double)

init(directed:strict:_:)

public init(directed: Bool = false, strict: Bool = false, _ builder: () -> GraphMember)

Properties

scale

var scale: Double

attributes

var attributes: Attributes = Attributes()

ordering

If the value of the attribute is "out", then the outedges of a node, that is, edges with the node as its tail node, must appear left-to-right in the same order in which they are defined in the input. If the value of the attribute is "in", then the inedges of a node must appear left-to-right in the same order in which they are defined in the input. If defined as a graph or subgraph attribute, the value is applied to all nodes in the graph or subgraph. Note that the graph attribute takes precedence over the node attribute.

var ordering: Ordering?

nodeSeparation

var nodeSeparation: Double?

Minimum space between two adjacent nodes in the same rank, in inches.

    In dot, this specifies the minimum space between two adjacent nodes in the same rank, in inches.
    For other layouts, this affects the spacing between loops on a single node, or multiedges between a pair of nodes.

noJustify

By default, the justification of multi-line labels is done within the largest context that makes sense. Thus, in the label of a polygonal node, a left-justified line will align with the left side of the node (shifted by the prescribed margin). In record nodes, left-justified line will line up with the left side of the enclosing column of fields. If nojustify is "true", multi-line labels will be justified in the context of itself. For example, if the attribute is set, the first label line is long, and the second is shorter and left-justified, the second will align with the left-most character in the first line, regardless of how large the node might be.

var noJustify: Bool?

backgroundColor

When attached to the root graph, this color is used as the background for entire canvas. When a cluster attribute, it is used as the initial background for the cluster. If a cluster has a filled style, the cluster's fillcolor will overlay the background color.

var backgroundColor: Color?

If the value is a colorList, a gradient fill is used. By default, this is a linear fill; setting style=radial will cause a radial fill. At present, only two colors are used. If the second color (after a colon) is missing, the default color is used for it. See also the gradientangle attribute for setting the gradient angle.

For certain output formats, such as PostScript, no fill is done for the root graph unless bgcolor is explicitly set. For bitmap formats, however, the bits need to be initialized to something, so the canvas is filled with white by default. This means that if the bitmap output is included in some other document, all of the bits within the bitmap's bounding box will be set, overwriting whatever color or graphics were already on the page. If this effect is not desired, and you only want to set bits explicitly assigned in drawing the graph, set bgcolor="transparent".

rotation

Causes the final layout to be rotated counter-clockwise by the specified number of degrees. G int 0 rotation G double 0 sfdp only

var rotation: Double?

forceLabels

If true, all xlabel attributes are placed, even if there is some overlap with nodes or other labels.

var forceLabels: Bool?

aspectRatio

var aspectRatio: AspectRatio?

Sets the aspect ratio (drawing height/drawing width) for the drawing. Note that this is adjusted before the size attribute constraints are enforced.

If ratio is numeric, it is taken as the desired aspect ratio. Then, if the actual aspect ratio is less than the desired ratio, the drawing height is scaled up to achieve the desired ratio; if the actual ratio is greater than that desired ratio, the drawing width is scaled up.

If ratio = "fill" and the size attribute is set, the drawing is scaled to achieve the aspect ratio implied by size. As size is set, when the drawing is later scaled to fit that rectangle, the resulting picture will fill the rectangle.

If ratio = "compress" and the size attribute is set, dot attempts to compress the initial layout to fit in the given size. This achieves a tighter packing of nodes but reduces the balance and symmetry.

height

var height: Double

concentrate

If true, use edge concentrators. This merges multiedges into a single edge and causes partially parallel edges to share part of their paths. The latter feature is not yet available outside of dot.

var concentrate: Bool?

concentrate G bool false

imagePath

Specifies a list of directories in which to look for image files as specified by the image attribute or using the IMG element in HTML-like labels. The string should be a list of (absolute or relative) pathnames, each separated by a semicolon (for Windows) or a colon (all other OS). The first directory in which a file of the given name is found will be used to load the image. If imagepath is not set, relative pathnames for the image file will be interpreted with respect to the current working directory.

var imagePath: URL?

maximumNetworkSimplexIterationsForComputingNodeCoordinates

nslimit nslimit1 G double dot only

var maximumNetworkSimplexIterationsForComputingNodeCoordinates: Int?

nslimit , nslimit1 Used to set number of iterations in network simplex applications. nslimit is used in computing node x coordinates, nslimit1 for ranking nodes. If defined, # iterations = nslimit(1) * # nodes; otherwise, # iterations = MAXINT.

trueColor

If set explicitly to true or false, the value determines whether or not internal bitmap rendering relies on a truecolor color model or uses a color palette. If the attribute is unset, truecolor is not used unless there is a shapefile property for some node in the graph. The output model will use the input model when possible. Use of color palettes results in less memory usage during creation of the bitmaps and smaller output files.

var trueColor: Bool?

Usually, the only time it is necessary to specify the truecolor model is if the graph uses more than 256 colors. However, if one uses bgcolor=transparent with a color palette, font antialiasing can show up as a fuzzy white area around characters. Using truecolor=true avoids this problem.

truecolor G bool bitmap output only

sortValue

If packmode indicates an array packing, this attribute specifies an insertion order among the components, with smaller values inserted first.

var sortValue: Int?

GCN int 0 0

stylesheetURL

A URL or pathname specifying an XML style sheet, used in SVG output. G string "" svg only

var stylesheetURL: URL?

renderingDimensions

**

var renderingDimensions: Int?

center

If true, the drawing is centered in the output canvas.

var center: Bool?

overlapScaling

overlap_scaling When overlap=prism, the layout is scaled by this factor, thereby removing a fair amount of node overlap, and making node overlap removal faster and better able to retain the graph's shape. If overlap_scaling is negative, the layout is scaled by -1*overlap_scaling times the average label size. If overlap_scaling is positive, the layout is scaled by overlap_scaling. If overlap_scaling is zero, no scaling is done. overlap_scaling G double -4 -1.0e10 prism only

var overlapScaling: Double?

runCrossingMinimizationOnce

If true and there are multiple clusters, run crossing minimization a second time.

var runCrossingMinimizationOnce: Bool?

remincross G bool true dot only

overlap

Determines if and how node overlaps should be removed. Nodes are first enlarged using the sep attribute. If "true" , overlaps are retained. If the value is "scale", overlaps are removed by uniformly scaling in x and y. If the value converts to "false", and it is available, Prism, a proximity graph-based algorithm, is used to remove node overlaps. This can also be invoked explicitly with "overlap=prism". This technique starts with a small scaling up, controlled by the overlap_scaling attribute, which can remove a significant portion of the overlap. The prism option also accepts an optional non-negative integer suffix. This can be used to control the number of attempts made at overlap removal. By default, overlap="prism" is equivalent to overlap="prism1000". Setting overlap="prism0" causes only the scaling phase to be run. If Prism is not available, or the version of Graphviz is earlier than 2.28, "overlap=false" uses a Voronoi-based technique. This can always be invoked explicitly with "overlap=voronoi".

var overlap: String?

If the value is "scalexy", x and y are separately scaled to remove overlaps.

If the value is "compress", the layout will be scaled down as much as possible without introducing any overlaps, obviously assuming there are none to begin with.

N.B.The remaining allowed values of overlap correspond to algorithms which, at present, can produce bad aspect ratios. In addition, we deprecate the use of the "ortho*" and "portho*".

If the value is "vpsc", overlap removal is done as a quadratic optimization to minimize node displacement while removing node overlaps.

If the value is "orthoxy" or "orthoyx", overlaps are moved by optimizing two constraint problems, one for the x axis and one for the y. The suffix indicates which axis is processed first. If the value is "ortho", the technique is similar to "orthoxy" except a heuristic is used to reduce the bias between the two passes. If the value is "ortho_yx", the technique is the same as "ortho", except the roles of x and y are reversed. The values "portho", "porthoxy", "porthoxy", and "portho_yx" are similar to the previous four, except only pseudo-orthogonal ordering is enforced.

If the layout is done by neato with mode="ipsep", then one can use overlap=ipsep. In this case, the overlap removal constraints are incorporated into the layout algorithm itself. N.B. At present, this only supports one level of clustering.

Except for fdp and sfdp, the layouts assume overlap="true" as the default. Fdp first uses a number of passes using a built-in, force-directed technique to try to remove overlaps. Thus, fdp accepts overlap with an integer prefix followed by a colon, specifying the number of tries. If there is no prefix, no initial tries will be performed. If there is nothing following a colon, none of the above methods will be attempted. By default, fdp uses overlap="9:prism". Note that overlap="true", overlap="0:true" and overlap="0:" all turn off all overlap removal.

By default, sfdp uses overlap="prism0".

Except for the Voronoi and prism methods, all of these transforms preserve the orthogonal ordering of the original layout. That is, if the x coordinates of two nodes are originally the same, they will remain the same, and if the x coordinate of one node is originally less than the x coordinate of another, this relation will still hold in the transformed layout. The similar properties hold for the y coordinates. This is not quite true for the "porth*" cases. For these, orthogonal ordering is only preserved among nodes related by an edge.

overlap G string bool true not dot

label

var label: String?

Text label attached to objects. Different from ids labels can contain almost any special character, but not ".

If a node does not have the attribute label, the value of the attribute id is used. If a node shall not have a label, label="" must be used.

The escape sequences "\n", "\l" and "\r" divide the label into lines, centered, left-justified and right-justified, respectively.

Change the appearance of the labels with the attributes fontname, fontcolor and fontsize.

href

var href: String?

outputOrder

outputorder G outputMode breadthfirst

var outputOrder: OutputOrder?

outputorder Specify order in which nodes and edges are drawn.

useMOSEK

mosek If Graphviz is built with MOSEK defined, mode=ipsep and mosek=true, the Mosek software (www.mosek.com) is use to solve the ipsep constraints.

var useMOSEK: Bool?

mosek G bool false neato only

mode

var mode: Mode?

width

var width: Double

`class`

Unofficial, but supported by certain output formats, like svg.

var `class`: String?

labelScheme

label_scheme The value indicates whether to treat a node whose name has the form |edgelabel|* as a special node representing an edge label. The default (0) produces no effect. If the attribute is set to 1, sfdp uses a penalty-based method to make that kind of node close to the center of its neighbor. With a value of 2, sfdp uses a penalty-based method to make that kind of node close to the old center of its neighbor. Finally, a value of 3 invokes a two-step process of overlap removal and straightening.

var labelScheme: LabelScheme?

int    0    0    sfdp only

textColor

var textColor: Color?

The font color for object labels.

subgraphs

Subgraphs contained by the graph.

var subgraphs: [Subgraph] = []

boundingBox

Bounding box of drawing in points. bb G rect write only

var boundingBox: Rectangle?

rankDirection

Sets direction of graph layout. For example, if rankdir="LR", and barring cycles, an edge T -> H; will go from left to right. By default, graphs are laid out from top to bottom. This attribute also has a side-effect in determining how record nodes are interpreted. See record shapes.

var rankDirection: RankDirection?

dot only

smoothing

smoothing Specifies a post-processing step used to smooth out an uneven distribution of nodes.

var smoothing: Smoothing?

G    smoothType    "none"        sfdp only

springConstant

Spring constant used in virtual physical model. It roughly corresponds to an ideal edge length (in inches), in that increasing K tends to increase the distance between nodes. Note that the edge attribute len can be used to override this value for adjacent nodes. K GC double 0.3 0 sfdp, fdp only

var springConstant: Double?

fontNamingConvention

Allows user control of how basic fontnames are represented in SVG output. If fontnames is undefined or "svg", the output will try to use known SVG fontnames. For example, the default font "Times-Roman" will be mapped to the basic SVG font "serif". This can be overridden by setting fontnames to "ps" or "gd". In the former case, known PostScript font names such as "Times-Roman" will be used in the output. In the latter case, the fontconfig font conventions are used. Thus, "Times-Roman" would be treated as "Nimbus Roman No9 L". These last two options are useful with SVG viewers that support these richer fontname spaces.

var fontNamingConvention: FontNamingConvention?

SVG only

overlapShrink

overlap_shrink If true, the overlap removal algorithm will perform a compression pass to reduce the size of the layout. overlap_shrink G bool true prism only

var overlapShrink: Bool?

layoutDimensions

Set the number of dimensions used for the layout. The maximum value allowed is 10.

var layoutDimensions: Int?

dim int 2 2 sfdp, fdp, neato only

compound

// If true, allow edges between clusters. (See lhead and ltail below.) // > compound G bool false dot only

var compound: Bool?

fontName

var fontName: String?

The name of the used font. (System dependend) The font size for object labels.

directed

Whether the graph is directed.

var directed: Bool

initialNodeLayoutStrategy

start Parameter used to determine the initial layout of nodes. If unset, the nodes are randomly placed in a unit square with the same seed is always used for the random number generator, so the initial placement is repeatable.

var initialNodeLayoutStrategy: InitialNodeLayoutStrategy?

start G startType "" fdp, neato only

noTranslate

notranslate By default, the final layout is translated so that the lower-left corner of the bounding box is at the origin. This can be annoying if some nodes are pinned or if the user runs neato -n. To avoid this translation, set notranslate to true.

var noTranslate: Bool?

notranslate G bool false neato only

layoutAlgorithm

Specifies the name of the layout algorithm to use, such as "dot" or "neato". Normally, graphs should be kept independent of a type of layout. In some cases, however, it can be convenient to embed the type of layout desired within the graph. For example, a graph containing position information from a layout might want to record what the associated layout algorithm was.

var layoutAlgorithm: LayoutAlgorithm?

This attribute takes precedence over the -K flag or the actual command name used.

quadtreeScheme

Quadtree scheme to use. A TRUE bool value corresponds to "normal"; a FALSE bool value corresponds to "none". As a slight exception to the normal interpretation of bool, a value of "2" corresponds to "fast".

var quadtreeScheme: QuadtreeScheme?

G quadType bool normal sfdp only

scale

If set, after the initial layout, the layout is scaled by the given factors. If only a single number is given, this is used for both factors.

var scale: Size?

not dot

numberOfLevels

Number of levels allowed in the multilevel scheme.

var numberOfLevels: Int?

levels G int MAXINT 0.0 sfdp only

labelDimensionUnit

If quantum > 0.0, node label dimensions will be rounded to integral multiples of the quantum.

var labelDimensionUnit: Double?

G double 0.0 0.0

strict

Whether the graph is strict.

var strict: Bool

repulsiveForce

repulsiveforce The power of the repulsive force used in an extended Fruchterman-Reingold force directed model. Values larger than 1 tend to reduce the warping effect at the expense of less clustering.

var repulsiveForce: Double?

G    double    1.0    0.0    sfdp only

splines

Controls how, and if, edges are represented. If true, edges are drawn as splines routed around nodes; if false, edges are drawn as line segments. If set to none or "", no edges are drawn at all. (1 March 2007) The values line and spline can be used as synonyms for false and true, respectively. In addition, the value polyline specifies that edges should be drawn as polylines.

var splines: Spline?

(28 Sep 2010) The value ortho specifies edges should be routed as polylines of axis-aligned segments. Currently, the routing does not handle ports or, in dot, edge labels.

(25 Sep 2012) The value curved specifies edges should be drawn as curved arcs.

By default, the attribute is unset. How this is interpreted depends on the layout. For dot, the default is to draw edges as splines. For all other layouts, the default is to draw edges as line segments. Note that for these latter layouts, if splines="true", this requires non-overlapping nodes (cf. overlap). If fdp is used for layout and splines="compound", then the edges are drawn to avoid clusters as well as nodes.

minimumNodeSeparation

mindist Specifies the minimum separation between all nodes.

var minimumNodeSeparation: Double?

G double 1.0 0.0 circo only

clusterRank

Mode used for handling clusters. If clusterrank is "local", a subgraph whose name begins with "cluster" is given special treatment. The subgraph is laid out separately, and then integrated as a unit into its parent graph, with a bounding rectangle drawn about it. If the cluster has a label parameter, this label is displayed within the rectangle. Note also that there can be clusters within clusters. At present, the modes "global" and "none" appear to be identical, both turning off the special cluster processing.

var clusterRank: ClusterMode?

dictionaryValue

var dictionaryValue: [String: Any]

pageSize

Width and height of output pages, in inches. If only a single value is given, this is used for both the width and height. If this is set and is smaller than the size of the layout, a rectangular array of pages of the specified page size is overlaid on the layout, with origins aligned in the lower-left corner, thereby partitioning the layout into pages. The pages are then produced one at a time, in pagedir order.

var pageSize: Size?

At present, this only works for PostScript output. For other types of output, one should use another tool to split the output into multiple output files. Or use the viewport to generate multiple files.

edges

Edges contained by the graph.

var edges: [Edge] = []

voronoiMargin

Factor to scale up drawing to allow margin for expansion in Voronoi technique. dim' = (1+2*margin)*dim.

var voronoiMargin: Double?

voro_margin G double 0.05 0.0 not dot

model

model This value specifies how the distance matrix is computed for the input graph. The distance matrix specifies the ideal distance between every pair of nodes. neato attemps to find a layout which best achieves these distances. By default, it uses the length of the shortest path, where the length of each edge is given by its len attribute. If model is "circuit", neato uses the circuit resistance model to compute the distances. This tends to emphasize clusters. If model is "subset", neato uses the subset model. This sets the edge length to be the number of nodes that are neighbors of exactly one of the end points, and then calculates the shortest paths. This helps to separate nodes with high degree. For more control of distances, one can use model=mds. In this case, the len of an edge is used as the ideal distance between its vertices. A shortest path calculation is only used for pairs of nodes not connected by an edge. Thus, by supplying a complete graph, the input can specify all of the relevant distances.

var model: String?

model G string shortpath neato only

damping

Factor damping force motions. On each iteration, a nodes movement is limited to this factor of its potential motion. By being less than 1.0, the system tends to ``cool'', thereby preventing cycling.

var damping: Double?

minimumScaleFactor

mclimit Multiplicative scale factor used to alter the MinQuit (default = 8) and MaxIter (default = 24) parameters used during crossing minimization. These correspond to the number of tries without improvement before quitting and the maximum number of iterations in each pass.

var minimumScaleFactor: Double?

G double 1.0 dot only

normalize

normalize If set, normalize coordinates of final layout so that the first point is at the origin, and then rotate the layout so that the angle of the first edge is specified by the value of normalize in degrees. If normalize is not a number, it is evaluated as a bool, with true corresponding to 0 degrees. NOTE: Since the attribute is evaluated first as a number, 0 and 1 cannot be used for false and true.

var normalize: Double?

G double bool false not dot

guideBoxLocation

showboxes Print guide boxes in PostScript at the beginning of routesplines if 1, or at the end if 2. (Debugging)

var guideBoxLocation: Location?

ENG    int    0    0    dot only

pageDirection

If the page attribute is set and applicable, this attribute specifies the order in which the pages are emitted. This is limited to one of the 8 row or column major orders.

var pageDirection: PageDirection?

epsilon

Terminating condition. If the length squared of all energy gradients are < epsilon, the algorithm stops.

var epsilon: Double?

epsilon G double .0001 * # nodes(mode == KK) .0001(mode == major) neato only

generateDirectedEdgeConstraints

Only valid when mode="ipsep". If true, constraints are generated for each edge in the largest (heuristic) directed acyclic subgraph such that the edge must point downwards. If "hier", generates level constraints similar to those used with mode="hier". The main difference is that, in the latter case, only these constraints are involved, so a faster solver can be used.

var generateDirectedEdgeConstraints: Bool?

string bool false neato only

id

The id of the graph, is any.

var id: String? = nil

defaultDistance

**

var defaultDistance: Double?

comment

Comments are inserted into output. Device-dependent

var comment: String?

levelConstraintStrictness

Specifies strictness of level constraints in neato when mode="ipsep" or "hier". Larger positive values mean stricter constraints, which demand more separation between levels. On the other hand, negative values will relax the constraints by allowing some overlap between the levels.

var levelConstraintStrictness: Double?

rawValue

var rawValue: Double

inputScale

inputscale For layout algorithms that support initial input positions (specified by the pos attribute), this attribute can be used to appropriately scale the values. By default, fdp and neato interpret the x and y values of pos as being in inches. (NOTE: neato -n(2) treats the coordinates as being in points, being the unit used by the layout algorithms for the pos attribute.) Thus, if the graph has pos attributes in points, one should set inputscale=72. This can also be set on the command line using the -s flag flag. If not set, no scaling is done and the units on input are treated as inches. A value of 0 is equivalent to inputscale=72.

var inputScale: Double?

G double fdp, neato only

center

var center: Center

margin

Margin used around polygons for purposes of spline edge routing. The interpretation is the same as given for sep. This should normally be strictly less than sep. G addDouble addPoint +3 not dot

var margin: Double?

maximumNetworkSimplexIterationsForRankingNodes

Used to set number of iterations in network simplex applications. nslimit is used in computing node x coordinates, nslimit1 for ranking nodes. If defined, # iterations = nslimit(1) * # nodes; otherwise, # iterations = MAXINT.

var maximumNetworkSimplexIterationsForRankingNodes: Int?

rankSeparation

In dot, this gives the desired rank separation, in inches. This is the minimum vertical distance between the bottom of the nodes in one rank and the tops of nodes in the next. If the value contains "equally", the centers of all ranks are spaced equally apart. Note that both settings are possible, e.g., ranksep = "1.2 equally". In twopi, this attribute specifies the radial separation of concentric circles. For twopi, ranksep can also be a list of doubles. The first double specifies the radius of the inner circle; the second double specifies the increase in radius from the first circle to the second; etc. If there are more circles than numbers, the last number is used as the increment for the remainder.

var rankSeparation: Double?

dot and twopi only

isEmpty

Returns whether the graph is empty.

var isEmpty: Bool

A graph is considered to be empty if it has no subgraphs, has no edges, has no nodes with attributes, and has no attributes itself.

searchSize

searchsize During network simplex, maximum number of edges with negative cut values to search when looking for one with minimum cut value.

var searchSize: Int?

dot only

fontPath

Directory list used by libgd to search for bitmap fonts if Graphviz was not built with the fontconfig library. If fontpath is not set, the environment variable DOTFONTPATH is checked. If that is not set, GDFONTPATH is checked. If not set, libgd uses its compiled-in font path. Note that fontpath is an attribute of the root graph.

var fontPath: URL?

url

var url: URL?

nodes

Nodes contained by the graph.

var nodes: [Node] = []

viewport

Clipping window on final drawing. Note that this attribute supersedes any size attribute. The width and height of the viewport specify precisely the final size of the output.

var viewport: Viewport?

useNewRankingAlgorithm

newrank The original ranking algorithm in dot is recursive on clusters. This can produce fewer ranks and a more compact layout, but sometimes at the cost of a head node being place on a higher rank than the tail node. It also assumes that a node is not constrained in separate, incompatible subgraphs. For example, a node cannot be in a cluster and also be constrained by rank=same with a node not in the cluster. If newrank=true, the ranking algorithm does a single global ranking, ignoring clusters. This allows nodes to be subject to multiple constraints. Rank constraints will usually take precedence over edge constraints.

var useNewRankingAlgorithm: Bool?

G    bool    false        dot only

orientation

If 90, set drawing orientation to landscape. rotate G int 0

var orientation: Orientation?

maximumNumberOfLayoutIterations

maxiter Sets the number of iterations used. int 100 * # nodes(mode == KK) 200(mode == major) 600(fdp) fdp, neato only

var maximumNumberOfLayoutIterations: Int?

Methods

append(contentsOf:)

public mutating func append<S>(contentsOf edges: S) where S.Element == Edge, S: Sequence

append(_:)

public mutating func append(_ subgraph: Subgraph)

render(using:to:)

public func render(using layout: LayoutAlgorithm, to format: Format) throws -> Data

append(contentsOf:)

public mutating func append<S>(contentsOf nodes: S) where S.Element == Node, S: Sequence

append(_:)

public mutating func append(_ edge: Edge)

append(contentsOf:)

public mutating func append<S>(contentsOf subgraphs: S) where S.Element == Subgraph, S: Sequence

append(_:)

public mutating func append(_ node: Node)

Generated at 2021-01-07T20:25:50+0000 using swift-doc 1.0.0-beta.5.

Types

Protocols

Global Functions

Graph

Graph

Inheritance

Nested Types

Initializers

init(width:height:center:scale:)

init(directed:strict:)

Parameters

init?(rawValue:)

init(directed:strict:_:)

Properties

scale

attributes

ordering

nodeSeparation

noJustify

backgroundColor

rotation

forceLabels

aspectRatio

height

concentrate

imagePath

maximumNetworkSimplexIterationsForComputingNodeCoordinates

trueColor

sortValue

stylesheetURL

renderingDimensions

center

overlapScaling

runCrossingMinimizationOnce

overlap

label

href

outputOrder

useMOSEK

mode

width

`class`

labelScheme

textColor

subgraphs

boundingBox

rankDirection

smoothing

springConstant

fontNamingConvention

overlapShrink

layoutDimensions

compound

fontName

directed

initialNodeLayoutStrategy

noTranslate

layoutAlgorithm

quadtreeScheme

scale

numberOfLevels

labelDimensionUnit

strict

repulsiveForce

splines

minimumNodeSeparation

clusterRank

dictionaryValue

pageSize

edges

voronoiMargin

model

damping

minimumScaleFactor

normalize

guideBoxLocation

pageDirection

epsilon

generateDirectedEdgeConstraints

id

defaultDistance

fontSize

comment