graphviz-java

Processors allow you to intercept and modify the graph data or the resulting output:

• Pre-processors: Modify the DOT source string before it is sent to the Graphviz engine. This is useful for string replacements or automated graph transformations.
• Post-processors: Modify the engine's output (e.g., an SVG string) after rendering. This allows for programmatic manipulation of the resulting graphic elements (like changing CSS classes or attributes via an SVG finder).

Graph graph = graph().with(node("bad word").link("good word"));
Graphviz g = Graphviz.fromGraph(graph)
        .preProcessor((source, options, processOptions) -> source.replace("bad word", "unicorn"))
        .postProcessor((result, options, processOptions) ->
                result.mapString(svg ->
                        SvgElementFinder.use(svg, finder -> {
                            finder.findNode("unicorn").setAttribute("class", "pink");
                        })));
g.render(Format.PNG).toFile(new File("example/ex9.png"));

To give your graphs a hand-drawn or 'sketchy' appearance, use the graphviz-rough module and apply a Roughifyer processor.

Setup: Add the following dependency:

<dependency>
    <groupId>guru.nidi</groupId>
    <artifactId>graphviz-rough</artifactId>
    <version>0.18.1</version>
</dependency>

Usage: Apply the Roughifyer to your Graphviz instance. You can customize parameters like bowing, curveStepCount, roughness, fillStyle (using FillStyle.hachure()), and font.

final Graph g = graph("ex1").directed().with(
        graph().cluster()
                .nodeAttr().with(Style.FILLED, Color.WHITE)
                .graphAttr().with(Style.FILLED, Color.LIGHTGREY, Label.of("process #1"))
                .with(node("a0").link(node("a1").link(node("a2")))),
        graph("x").cluster()
                .nodeAttr().with(Style.FILLED)
                .graphAttr().with(Color.BLUE, Label.of("process #2"))
                .with(node("b0").link(node("b1").link(node("b2")))),
        node("start").with(Shape.M_DIAMOND).link("a0", "b0"),
        node("a0").with(Style.FILLED, Color.RED.gradient(Color.BLUE)).link("b1"),
        node("b1").link("a2"),
        node("a2").link("end"),
        node("b2").link("end"),
        node("end").with(Shape.M_SQUARE)
);

Graphviz.fromGraph(g)
        .processor(new Roughifyer()
                .bowing(2)
                .curveStepCount(6)
                .roughness(1)
                .fillStyle(FillStyle.hachure().width(2).gap(5).angle(0))
                .font("*serif", "Comic Sans MS"))
        .render(Format.PNG)
        .toFile(new File("example/ex1-rough.png"));

The Graphviz instance allows you to configure the output format, image width, and rasterization settings:

• Format: Use .render(Format.XXX) to specify output like PNG, SVG, DOT, or JSON.
• Width: Use .width(int) to set the output width.
• Rasterization: Use .rasterize(Rasterizer.XXX) to convert vector outputs to raster images. Supported rasterizers include BATIK, SALAMANDER, and built-in PDF engines.
• Engine: Use .engine(Engine.XXX) to specify a specific Graphviz engine (e.g., NEATO).

To use Rasterizer.BATIK, you must include the batik-rasterizer dependency in your project.

Graphviz.useEngine(new GraphvizCmdLineEngine());
Graph g = graph("example5").directed().with(node("abc").link(node("xyz")));
Graphviz viz = Graphviz.fromGraph(g);

viz.width(200).render(Format.SVG).toFile(new File("example/ex5.svg"));
viz.width(200).rasterize(Rasterizer.BATIK).toFile(new File("example/ex5b.png"));
viz.width(200).rasterize(Rasterizer.SALAMANDER).toFile(new File("example/ex5s.png"));
viz.width(200).rasterize(Rasterizer.builtIn("pdf")).toFile(new File("example/ex5p"));

String dot = viz.render(Format.DOT).toString();
String json = viz.engine(Engine.NEATO).render(Format.JSON).toString();
BufferedImage image = viz.render(Format.PNG).toImage();

You can include images in your graphs using two different methods depending on your engine requirements:

1. HTML Labels: Use the <img> tag inside an HTML label. Note: This method only works when using the GraphvizCmdLineEngine because viz.js does not support <img> tags.
2. Node Image Attribute: Use the Image.of(path) attribute on a node. This method is compatible with all engines.

In both cases, use the basedir(File) method on the Graphviz instance to define the base directory for resolving relative image paths.

// Method 1: HTML Label (Requires GraphvizCmdLineEngine)
Graphviz.useEngine(new GraphvizCmdLineEngine());
Graphviz g = Graphviz.fromGraph(graph()
        .with(node(Label.html("<table border='0'><tr><td><img src='graphviz.png' /></td></tr></table>"))));
g.basedir(new File("example")).render(Format.PNG).toFile(new File("example/ex7.png"));

// Method 2: Image Attribute (Works with all engines)
Graphviz g = Graphviz.fromGraph(graph()
        .with(node(" ").with(Size.std().margin(.8, .7), Image.of("graphviz.png"))));
g.basedir(new File("example")).render(Format.PNG).toFile(new File("example/ex8.png"));

The Immutable API uses a functional approach where every 'mutating' method returns a new object.

Warning: Calling node.with(Color.RED) does not change the existing node; you must capture the returned object: node = node.with(Color.RED).

Key patterns:

• Use graph(...) to create a graph.
• Use graphAttr(), nodeAttr(), and linkAttr() for global styling.
• Use node(...) for nodes and to(...) for edges/links.
• Use .with(...) to apply attributes (predefined like Style, Color, or custom strings).

import static guru.nidi.graphviz.model.Factory.*;

Graph g = graph("example1").directed()
        .graphAttr().with(Rank.dir(LEFT_TO_RIGHT))
        .nodeAttr().with(Font.name("arial"))
        .linkAttr().with("class", "link-class")
        .with(
                node("a").with(Color.RED).link(node("b")),
                node("b").link(
                        to(node("c")).with(attr("weight", 5), Style.DASHED)
                )
        );
Graphviz.fromGraph(g).height(100).render(Format.PNG).toFile(new File("example/ex1.png"));