@spec community_to_options(Yog.Community.Result.t(), options()) :: options()

Creates DOT options that color nodes by community assignment.

Each community gets a distinct color from a generated palette. The palette cycles through visually distinct hues.

Example

result = Yog.Community.Louvain.detect(graph)
options = Yog.Render.DOT.community_to_options(result)
dot_string = Yog.Render.DOT.to_dot(graph, options)

@spec cut_to_options(Yog.Flow.MinCutResult.t(), options()) :: options()

Creates DOT options that color the source and sink sides of a min-cut.

Source-side nodes are colored with source_color (default: light blue), sink-side nodes with sink_color (default: light coral).

Requires the MinCutResult to have source_side and sink_side populated (use track_partitions: true or extract_min_cut/1).

Example

result = Yog.Flow.MinCut.global_min_cut(graph, track_partitions: true)
options = Yog.Render.DOT.cut_to_options(result)
dot_string = Yog.Render.DOT.to_dot(graph, options)

@spec default_options() :: options()

Creates default DOT options with simple labeling and sensible styling.

Default configuration:

• Layout: Auto-detected by Graphviz
• Direction: Top-to-bottom
• Node shape: Ellipse
• Colors: Light blue nodes, black edges
• Font: Helvetica 12pt

Examples

iex> opts = Yog.Render.DOT.default_options()
iex> opts.graph_name
"G"
iex> opts.node_shape
:ellipse
iex> opts.node_color
"lightblue"

@spec default_options_with(
  node_label: (Yog.node_id(), any() -> String.t()),
  edge_label: (any() -> String.t())
) :: options()

Creates default DOT options with custom label formatters for both nodes and edges.

Example

options = Yog.Render.DOT.default_options_with(
  node_label: fn id, data -> "#{data} (#{id})" end,
  edge_label: fn weight -> "#{weight} ms" end
)

@spec default_options_with_edge_formatter((any() -> String.t())) :: options()

Creates default DOT options with a custom edge formatter.

Use this when your graph has non-String edge data (e.g., Int, Float, custom types).

Example

# For a graph with Int edge weights
options = Yog.Render.DOT.default_options_with_edge_formatter(fn weight ->
  Integer.to_string(weight)
end)

@spec matching_to_options(%{required(Yog.node_id()) => Yog.node_id()}, options()) ::
  options()

Creates DOT options that highlight matched edges from a matching result.

Works with results from both Yog.Matching.hopcroft_karp/1 and Yog.Matching.hungarian/2 (the matching map component).

Example

matching = Yog.Matching.hopcroft_karp(graph)
options = Yog.Render.DOT.matching_to_options(matching)
dot_string = Yog.Render.DOT.to_dot(graph, options)

@spec mst_to_options(Yog.MST.Result.t(), options()) :: options()

Creates DOT options that highlight an MST result.

MST edges are highlighted and non-MST edges use default styling.

Example

result = Yog.MST.kruskal(graph)
options = Yog.Render.DOT.mst_to_options(result)
dot_string = Yog.Render.DOT.to_dot(graph, options)

@spec path_to_options(map(), options()) :: options()

Converts a shortest path result to highlighted DOT options.

Creates a copy of the base options with the path's nodes and edges set to be highlighted. This is useful for visualizing algorithm results.

Example

case Yog.Pathfinding.Dijkstra.shortest_path(...) do
  {:ok, path} ->
    options = Yog.Render.DOT.path_to_options(path, Yog.Render.DOT.default_options())
    dot_string = Yog.Render.DOT.to_dot(graph, options)
  :error ->
    ""
end

@spec theme(atom()) :: options()

Returns a pre-configured theme as DOT options.

Available themes:

• :default — Light blue nodes, black edges (same as default_options/0)
• :dark — Dark background with neon accent colors, ideal for dark UIs
• :minimal — Clean wireframe look with no fills and thin lines
• :presentation — Large fonts and bold colors for slides and demos

Examples

iex> opts = Yog.Render.DOT.theme(:dark)
iex> opts.bgcolor
"#1a1a2e"
iex> opts.node_color
"#16213e"

iex> opts = Yog.Render.DOT.theme(:minimal)
iex> opts.node_style
:solid

iex> opts = Yog.Render.DOT.theme(:presentation)
iex> opts.node_fontsize
18

@spec to_dot(Yog.graph(), options()) :: String.t()

Converts a graph to DOT (Graphviz) syntax.

Works with any node data type and edge data type. Use the options to customize labels, styling, and to define subgraphs.

Time Complexity: O(V + E + S) where S is the total number of nodes across all subgraphs.

Example

graph =
  Yog.directed()
  |> Yog.add_node(1, "Start")
  |> Yog.add_node(2, "Process")
  |> Yog.add_edge_ensure(from: 1, to: 2, with: "5")

diagram = Yog.Render.DOT.to_dot(graph, Yog.Render.DOT.default_options())