Skip to content
forked from ztellman/rhizome

simple graph and tree visualization

Notifications You must be signed in to change notification settings

clojusc/rhizome

 
 

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

75 Commits
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

Rhizome is a library for visualizing graph and tree structures.

Usage

To include in your project, add this to your project.clj:

[clojusc/rhizome "0.3.0-SNAPSHOT"]

Use of this project requires that Graphviz is installed, which can be checked by running dot -V at the command line. If it's not installed, you can do the following:

platform directions
Linux install graphviz using your package manager
OS X use brew install graphiz if you use Homebrew, or sudo port install graphviz if you use MacPorts
Windows download the installer

There are three namespaces, rhizome.dot, rhizome.img, and rhizome.viz. The former will take a graph and return a string representation of a Graphviz dot file, the second takes graphs and renders them, the last one displays graphs. In practice, you will likely be using one of the latter two.

The core function is rhizome.viz/view-graph. It takes two parameters: nodes, which is a list of nodes in the graph, and adjacent, which is a function that takes a node and returns adjacent nodes. Nodes can be of any type you like, as long as the objects in nodes and the objects returned by adjacent are equivalent.

These can be followed by zero or more of the following keyword arguments:

name description
:directed? whether the graph should be rendered as a directed graph, defaults to true
:vertical? whether the graph should be rendered top-to-bottom, defaults to true
:node->descriptor takes a node, and returns a map of attributes onto values describing how the node should be rendered
:edge->descriptor takes the source and destination node, and returns a map of attributes onto values describing how the edge should be rendered
:options a map of attributes onto values describing how the graph should be rendered
:node->cluster takes a node and returns which cluster, if any, the node belongs to
:cluster->parent takes a cluster and returns which cluster, if any, it is contained within
:cluster->descriptor takes a cluster and returns a map of attributes onto values describing how the cluster should be rendered

The rendering attributes described by :node->descriptor, :edge->descriptor, :cluster->descriptor, and :options are described in detail here. String and keyword values are interchangeable.

The most commonly-used attributes are label, which describes the text overlaid on a node, edge, or cluster, and shape, the options for which are described here. For the :options, it's sometimes useful to adjust the dpi, which controls the size of the image.

An example:

> (require '[rhizome.viz :refer :all)
> (require '[rhizome.img :refer :all)
nil
> (def g
    {:a [:b :c]
     :b [:c]
     :c [:a]})
#'g
> (view-graph (keys g) g
    :node->descriptor (fn [n] {:label n}))

Clusters are a way of grouping certain nodes together. They can be any object you like, including values also used by a node. Using :cluster->parent, they can be nested:

> (view-graph (keys g) g
    :cluster->descriptor (fn [n] {:label n})
    :node->cluster identity
    :cluster->parent {:b :c, :a :c})

While trees are a special case of graphs, using view-graph to visualize trees can be a little indirect. To make this simpler, there's a view-tree function, which is modeled after Clojure's tree-seq operator. This function takes three parameters, branch?, children, and root, followed by zero or more of the keyword arguments taken by view-graph. This can make it easy to visualize hierarchical structures:

> (def t [[1 [2 3]] [4 [5]]])
#'t
> (view-tree sequential? seq t
    :node->descriptor (fn [n] {:label (when (number? n) n)}))

If the value for label is not a string, typically it will be displayed as a string representation of the value. However, if the value is sequential, then the node will be displayed as a Record type:

> (def t '([1 2] ([3 4] ([5 6 7]))))
#'t
> (view-tree list? seq t
    :node->descriptor (fn [n] {:label (when (vector? n) n)}))

rhizome.viz/graph->svg can be used to render the graph as SVG.

There are also view-* functions for each of Graphviz's layout engines. For example:

> (def t
	  {1 [2 3 4 5 7 14 24 25]
	   2 []
	   3 [6 8 9 10 11 13 16 18 19 20 22]
	   4 [23]
	   5 []
	   6 [15]
	   7 [17]
	   8 []
	   9 []
	   10 [12]
	   11 []
	   12 [21]
	   13 []
	   14 []
	   15 [19]
	   16 []
	   17 []
	   18 []
	   19 []
	   20 []
	   21 []
	   22 []
	   23 []
	   24 []
	   25 []})
> (viz/view-twopi (keys t) t
    :directed? false
    :node->descriptor (fn [n] {:label n}))

> (viz/view-fdp (keys t) t
    :directed? false
    :node->descriptor (fn [n] {:label n}))

License

Copyright © 2013 Zachary Tellman

Copyright © 2019 Clojure-Aided Enrichment Center

Distributed under the MIT License

About

simple graph and tree visualization

Resources

Stars

Watchers

Forks

Packages

No packages published

Languages

  • Clojure 100.0%