GraphView

To reduce visual clutter, the SugiyamaAlgorithm performs node ordering within each layer to minimize edge crossings. This is an expensive operation performed during the run method.

It uses two main techniques:

1. Median Heuristic: Reorders nodes in a layer based on the median position of their neighbors in the adjacent layer.
2. Transpose Heuristic: Fine-tunes the ordering by swapping adjacent nodes. Depending on the crossMinimizationStrategy configured, it uses either:
   • transposeSimple: A basic approach that swaps nodes if it reduces crossings.
   • transposeAccumulator: A more advanced approach using an AccumulatorTree to efficiently calculate crossing counts during trial swaps.

During the layout process, the Eiglsperger algorithm uses 'dummy' nodes to facilitate layered placement. The denormalize() phase is responsible for cleaning up these nodes and ensuring edges look natural.

When a dummy node is encountered, the algorithm:

1. Identifies the predecessor and successor nodes.
2. Creates bendPoints for the edge connecting the predecessor and successor.
3. Calculates coordinates based on the dummy node's position to create a smooth bend.
4. Removes the dummy node from the graph.
5. Re-adds the edge with EiglspergerEdgeData containing the calculated bendPoints.

This ensures that even though the layout logic uses intermediate nodes, the final rendered graph shows continuous, articulated edges rather than a series of disconnected segments.

The SugiyamaAlgorithm supports several strategies for assigning nodes to layers, which affects the visual hierarchy and density of the graph:

• Top-Down (LayeringStrategy.topDown): Assigns layers by iteratively finding root nodes (nodes with no predecessors) and removing them from the graph.
• Longest Path (LayeringStrategy.longestPath): Assigns nodes to layers based on the longest path from a source, often resulting in fewer layers.
• Coffman-Graham (LayeringStrategy.coffmanGraham): A strategy that uses in-degree and lambda values to assign nodes to layers, aiming to minimize the number of layers while respecting constraints.
• Network Simplex (LayeringStrategy.networkSimplex): Starts with a longest-path assignment and iteratively optimizes by attempting to move nodes to different layers to minimize edge span.

GraphView is a Flutter library for displaying data in various graph structures, including trees, directed graphs, layered graphs, mindmaps, and radial layouts.

There are two primary ways to use the widget:

1. GraphView(...) (Default constructor): Best for non-interactive graphs embedded in scrollable layouts. It provides a static view of the graph.
2. GraphView.builder(...): Designed for interactive graphs. It enables pan/zoom via InteractiveViewer, supports node collapse/expand functionality, and allows programmatic navigation using a GraphViewController.

```dart
// Example of a basic GraphView
GraphView(
  graph: myGraph,
  algorithm: myAlgorithm,
  builder: (node) => MyNodeWidget(node),
);

The builder property in GraphView.builder allows you to map a Node to any Flutter widget. You can use the node's key (often an ID) to decide which widget to render.

When using Node.Id(id), the value can be retrieved via node.key?.value.

builder: (Node node) {
  var id = node.key?.value as int;
  if (id == 2) {
    return rectangleWidget(id);
  } else {
    return circleWidget(id);
  }
}

Use the GraphViewController to programmatically move the camera or refresh the layout:

• jumpToNode(ValueKey('nodeId')): Instantly moves the view to a specific node.
• animateToNode(ValueKey('nodeId')): Smoothly scrolls/pans to a specific node.
• zoomToFit(): Zooms the view so all nodes are visible.
• resetView(): Returns the view to the origin.
• forceRecalculation(): Forces the layout algorithm to run again.

// Animate to a specific node by its key
controller.animateToNode(ValueKey('node_123'));

// Zoom out to see everything
controller.zoomToFit();

// Reset view
controller.resetView();

The Sugiyama algorithm (used for layered graph layouts) supports two different strategies for handling cycles in the graph via the cycleRemovalStrategy configuration option. Choosing the right strategy affects how the algorithm identifies and temporarily reverses edges to create a Directed Acyclic Graph (DAG) for layering.

Available strategies:

• CycleRemovalStrategy.dfs: Uses a Depth-First Search approach for recursive cycle removal.
• CycleRemovalStrategy.greedy: Uses a greedy approach that identifies feedback arcs based on node degrees (out-degree minus in-degree).

// Example of how strategies are applied via configuration
// (Note: The exact configuration object structure depends on the parent class/setup)
configuration.cycleRemovalStrategy = CycleRemovalStrategy.greedy;

The getPosition method in the Sugiyama implementation uses an orientation value from the configuration to determine how node coordinates are transformed into the final layout offset. This allows the graph to be oriented in different directions (e.g., top-to-bottom, left-to-right, etc.).

Supported orientation values:

• 1: Custom transformation (likely horizontal/vertical variant)
• 2: Custom transformation (likely vertical/horizontal variant)
• 3: Custom transformation
• 4: Custom transformation
• default: Returns Offset(0, 0)