NodeNetwork

https://github.com/wouterdek/nodenetwork
Admin
NodeNetwork is a .NET C# WPF library that provides an interactive node editor component with...
Tokens:3,919
Snippets:36
Trust Score:6.8
License:Apache-2.0
Update:5 months ago
Show doc for...
Tokens:
Raw
### Topological Node Traversal with GraphAlgorithms

Source: https://context7.com/wouterdek/nodenetwork/llms.txt

Use GraphAlgorithms.GetConnectedNodesBubbling for a topological traversal starting from a specific node. Specify includeInputs, includeOutputs, and includeSelf to control traversal.

```csharp
using NodeNetwork.Toolkit;

// Topological-order traversal from a specific output node
var outputNode = network.Nodes.Items.OfType<OutputNodeViewModel>().First();
var orderedNodes = GraphAlgorithms.GetConnectedNodesBubbling(
    outputNode, includeInputs: true, includeOutputs: false, includeSelf: true);

foreach (var node in orderedNodes)
    Console.WriteLine(node.Name); // leaves first, output last
```

--------------------------------

### Initialize and Configure NetworkViewModel

Source: https://context7.com/wouterdek/nodenetwork/llms.txt

Demonstrates initializing a NetworkViewModel, plugging in a custom validator, and reacting to network changes and validation events. The network can be made read-only.

```csharp
using NodeNetwork.ViewModels;
using NodeNetwork.Toolkit;
using ReactiveUI;

// Create the network
var network = new NetworkViewModel();

// Plug in a custom validator that forbids loops and division-by-zero
network.Validator = net =>
{
    if (GraphAlgorithms.FindLoops(net).Any())
        return new NetworkValidationResult(false, false,
            new ErrorMessageViewModel("Network contains loops!"));

    return new NetworkValidationResult(true, true, null);
};

// React to every structural change
network.NetworkChanged.Subscribe(_ =>
    Console.WriteLine("Graph changed, valid = " + network.LatestValidation?.IsValid));

// Manually trigger validation and read the result
await network.UpdateValidation.Execute();
Console.WriteLine(network.LatestValidation.IsValid); // true / false

// Listen to the validation stream
network.Validation.Subscribe(result =>
    Console.WriteLine($"Valid={result.IsValid}, Traversable={result.NetworkIsTraversable}"));

// Make the whole graph read-only
network.IsReadOnly = true;
```

--------------------------------

### Managing Connections in NetworkViewModel

Source: https://context7.com/wouterdek/nodenetwork/llms.txt

Shows how to create, manipulate, and customize connections programmatically. Use for establishing links between nodes and controlling their behavior.

```csharp
using NodeNetwork.ViewModels;

var network = new NetworkViewModel();
var nodeA  = new SumNodeViewModel();
var nodeB  = new OutputNodeViewModel();
network.Nodes.Add(nodeA);
network.Nodes.Add(nodeB);

// Create a connection programmatically
var connection = network.ConnectionFactory(nodeB.ResultInput, nodeA.Output);
network.Connections.Add(connection);

// Highlight a connection
connection.IsHighlighted = true;

// Prevent the user from deleting it via the UI
connection.CanBeRemovedByUser = false;

// Remove it programmatically
network.Connections.Remove(connection);

// Use a custom ConnectionFactory to inject your own subclass
network.ConnectionFactory = (input, output) =>
    new MyColoredConnectionViewModel(network, input, output);
```

--------------------------------

### Custom NodeInputViewModel and NodeOutputViewModel

Source: https://context7.com/wouterdek/nodenetwork/llms.txt

Demonstrates creating custom input and output endpoints with type checking and unlimited connections. Use for defining node connection logic and appearance.

```csharp
using NodeNetwork.ViewModels;

// --- Custom input with type-checked validator ---
var typedInput = new NodeInputViewModel
{
    Name = "Value",
    // Only allow connections from outputs of the correct type
    ConnectionValidator = pending =>
        new ConnectionValidationResult(
            pending.Output is ValueNodeOutputViewModel<int?>,
            pending.Output is ValueNodeOutputViewModel<int?> ? null
                : new ErrorMessageViewModel("Type mismatch: expected int")),
    MaxConnections = 1,
    HideEditorIfConnected = true,
    Visibility = EndpointVisibility.AlwaysVisible,
    SortIndex = 0
};

// --- Multi-connection output ---
var multiOutput = new NodeOutputViewModel
{
    Name = "Result",
    MaxConnections = int.MaxValue  // unlimited connections (default for outputs)
};

// --- Group endpoints under a collapsible header ---
var group = new EndpointGroup("Geometry");
var xInput = new NodeInputViewModel { Name = "X", Group = group };
var yInput = new NodeInputViewModel { Name = "Y", Group = group };

var node = new NodeViewModel();
node.Inputs.Add(typedInput);
node.Inputs.Add(xInput);
node.Inputs.Add(yInput);
node.Outputs.Add(multiOutput);
```

--------------------------------

### Implement Add Node Context Menu with AddNodeContextMenuViewModel

Source: https://context7.com/wouterdek/nodenetwork/llms.txt

Illustrates the usage of AddNodeContextMenuViewModel for creating a right-click menu to add nodes to the network. It supports filtering nodes based on connection compatibility and configuring node placement.

```csharp
using NodeNetwork.Toolkit.ContextMenu;
using NodeNetwork.ViewModels;

var contextMenu = new AddNodeContextMenuViewModel(labelFormat: "Add {0}");
contextMenu.Network = network;

// Place the new node at the mouse position
contextMenu.NodePositionFunc = node => mousePosition;

// Register available types
var templates = new[] { new NodeTemplate(() => new SumNodeViewModel()) };
contextMenu.AddNodeTypes(templates);

// Show a filtered menu when the user drops a connection onto empty canvas
network.OnPendingConnectionDropped = () =>
{
    if (network.PendingConnection != null)
        contextMenu.ShowAddNodeForPendingConnectionMenu(network.PendingConnection);
};

// After a node is added, auto-select it
contextMenu.OnNodeAdded = node => node.IsSelected = true;
```

--------------------------------

### Manage Node Catalog with NodeListViewModel

Source: https://context7.com/wouterdek/nodenetwork/llms.txt

Shows how to set up a NodeListViewModel to display available node types in a network graph. It supports different display modes, live search filtering, and programmatic addition of node types.

```csharp
using NodeNetwork.Toolkit.NodeList;
using NodeNetwork.ViewModels;

var nodeList = new NodeListViewModel
{
    Title      = "Nodes",
    EmptyLabel = "No nodes match your search.",
    Display    = NodeListViewModel.DisplayMode.Tiles
};

// Register node types – a new instance is created each time the user adds one
nodeList.AddNodeType(() => new SumNodeViewModel());
nodeList.AddNodeType(() => new ConstantNodeViewModel());
nodeList.AddNodeType(() => new DivisionNodeViewModel());

// Filter by name in real time (e.g. bound to a search TextBox)
nodeList.SearchQuery = "Sum";  // VisibleNodes now contains only SumNodeViewModel
```

--------------------------------

### Apply Physics-Based Layout with ForceDirectedLayouter

Source: https://context7.com/wouterdek/nodenetwork/llms.txt

Demonstrates how to use ForceDirectedLayouter for automatically arranging nodes in a graph using a physics simulation. It includes configurations for both blocking and animated asynchronous layout operations.

```csharp
using NodeNetwork.Toolkit.Layout.ForceDirected;

var layouter = new ForceDirectedLayouter();

// --- Blocking layout (e.g. on first load) ---
var config = new Configuration
{
    Network            = network,
    TimeModifier       = 3.5f,
    UpdatesPerIteration= 2,
    NodeRepulsionForce = 150,
    EquilibriumDistance= conn => 120,
    SpringConstant     = conn => 1.2,
    RowForce           = conn => 80,
    IsFixedNode        = node => node.Name == "Output"  // pin the output node
};
layouter.Layout(config, maxIterations: 500);

// --- Animated async layout (shows live simulation) ---
var cts = new CancellationTokenSource();
await layouter.LayoutAsync(config, cts.Token);
// Stop after 3 seconds
await Task.Delay(3000);
cts.Cancel();
```

--------------------------------

### Create a Custom NodeViewModel (SumNodeViewModel)

Source: https://context7.com/wouterdek/nodenetwork/llms.txt

Defines a custom SumNodeViewModel inheriting from NodeViewModel, with two integer inputs and one integer output. The output value is a reactive expression based on the inputs.

```csharp
using NodeNetwork.ViewModels;

public class SumNodeViewModel : NodeViewModel
{
    public ValueNodeInputViewModel<int?> Input1 { get; }
    public ValueNodeInputViewModel<int?> Input2 { get; }
    public ValueNodeOutputViewModel<int?> Output { get; }

    public SumNodeViewModel()
    {
        Name = "Sum";

        Input1 = new ValueNodeInputViewModel<int?> { Name = "A" };
        Inputs.Add(Input1);

        Input2 = new ValueNodeInputViewModel<int?> { Name = "B" };
        Inputs.Add(Input2);

        Output = new ValueNodeOutputViewModel<int?>
        {
            Name = "A + B",
            // Reactive expression: recomputes whenever either input changes
            Value = this.WhenAnyValue(vm => vm.Input1.Value, vm => vm.Input2.Value)
                        .Select(_ => Input1.Value + Input2.Value)
        };
        Outputs.Add(Output);
    }
}

// Add to a network
var network = new NetworkViewModel();
var sumNode = new SumNodeViewModel { Position = new Point(200, 100) };
network.Nodes.Add(sumNode);

// Collapse the node (hides unconnected endpoints)
sumNode.IsCollapsed = true;

// Prevent the user from deleting it
sumNode.CanBeRemovedByUser = false;
```

--------------------------------

### Partition Network into Subgraphs with GraphAlgorithms

Source: https://context7.com/wouterdek/nodenetwork/llms.txt

Use GraphAlgorithms.FindSubGraphs to partition a network's nodes into disconnected components. This helps identify separate subgraphs within the network.

```csharp
using NodeNetwork.Toolkit;

// Find all disconnected subgraphs
var subgraphs = GraphAlgorithms.FindSubGraphs(network.Nodes.Items);
Console.WriteLine($"Graph has {subgraphs.Count()} disconnected components");
```

--------------------------------

### ValueNodeInputViewModel and ValueNodeOutputViewModel for Reactive Propagation

Source: https://context7.com/wouterdek/nodenetwork/llms.txt

Illustrates using typed ValueNode wrappers for reactive value propagation. Use when nodes need to pass and react to changing values through the graph.

```csharp
using NodeNetwork.Toolkit.ValueNode;
using NodeNetwork.ViewModels;

// --- Output node that produces a constant integer ---
public class ConstantNodeViewModel : NodeViewModel
{
    public ValueEditorViewModel<int?> ValueEditor { get; }
    public ValueNodeOutputViewModel<int?> Output { get; }

    public ConstantNodeViewModel()
    {
        Name = "Constant";
        ValueEditor = new ValueEditorViewModel<int?> { Value = 42 };
        Output = new ValueNodeOutputViewModel<int?>
        {
            Name = "Value",
            Value = ValueEditor.ValueChanged
        };
        Outputs.Add(Output);
    }
}

// --- Input that reacts to changes ---
var network  = new NetworkViewModel();
var constant = new ConstantNodeViewModel();
var sumNode  = new SumNodeViewModel();
network.Nodes.Add(constant);
network.Nodes.Add(sumNode);
network.Connections.Add(network.ConnectionFactory(sumNode.Input1, constant.Output));

// ValueChanged emits every time the upstream constant changes
sumNode.Input1.ValueChanged.Subscribe(v => Console.WriteLine("Input1 = " + v));

constant.ValueEditor.Value = 10; // triggers subscription → "Input1 = 10"
```

--------------------------------

### Aggregate Values with ValueListNodeInputViewModel

Source: https://context7.com/wouterdek/nodenetwork/llms.txt

Demonstrates how to use ValueListNodeInputViewModel to aggregate integer values from multiple outputs into a single observable list. This is useful for summing or processing a dynamic set of inputs.

```csharp
using NodeNetwork.Toolkit.ValueNode;
using NodeNetwork.ViewModels;

public class SumAllNodeViewModel : NodeViewModel
{
    public ValueListNodeInputViewModel<int?> Inputs_ { get; }
    public ValueNodeOutputViewModel<int?> Output { get; }

    public SumAllNodeViewModel()
    {
        Name = "Sum All";
        Inputs_ = new ValueListNodeInputViewModel<int?>();
        Inputs.Add(Inputs_);

        // React to the dynamic list of connected values
        Output = new ValueNodeOutputViewModel<int?>
        {
            Name = "Total",
            Value = Inputs_.Values.Connect()
                .QueryWhenChanged(list => list.Sum())
        };
        Outputs.Add(Output);
    }
}
```

--------------------------------

### Detect Loops in Network with GraphAlgorithms

Source: https://context7.com/wouterdek/nodenetwork/llms.txt

Use GraphAlgorithms.FindLoops to detect cycles in a network. This is useful for network validation. An empty collection indicates no loops.

```csharp
using NodeNetwork.Toolkit;

// Detect loops (cycles) – use in a network Validator
var loops = GraphAlgorithms.FindLoops(network);
if (loops.Any())
    return new NetworkValidationResult(false, false,
        new ErrorMessageViewModel("Network contains a cycle"));
```

--------------------------------

### Group Nodes into Sub-network with NodeGrouper

Source: https://context7.com/wouterdek/nodenetwork/llms.txt

Use NodeGrouper to group selected nodes into a collapsible sub-network. External connections are rewired automatically. Call Ungroup to reverse the operation.

```csharp
using NodeNetwork.Toolkit.Group;

var grouper = new NodeGrouper
{
    SubNetworkFactory  = () => new NetworkViewModel(),
    GroupNodeFactory   = subnet => new GroupNodeViewModel(subnet),
    EntranceNodeFactory= () => new GroupSubnetIONodeViewModel(),
    ExitNodeFactory    = () => new GroupSubnetIONodeViewModel(),
    IOBindingFactory   = (groupNode, entrance, exit) =>
        new ValueNodeGroupIOBinding(groupNode, entrance, exit)
};

// Group the currently selected nodes
var selected = network.SelectedNodes.Items.ToList();
var ioBinding = grouper.MergeIntoGroup(network, selected);
// ioBinding is null if the nodes don't form a contiguous subgraph

// Later, dissolve the group back into the parent network
grouper.Ungroup(ioBinding);
```

--------------------------------

### Check for Contiguous Subgraph with GraphAlgorithms

Source: https://context7.com/wouterdek/nodenetwork/llms.txt

Use GraphAlgorithms.IsContinuousSubGraphSet to check if a set of selected nodes forms a contiguous subgraph, which is a requirement for grouping.

```csharp
using NodeNetwork.Toolkit;

// Check whether a set of nodes can be grouped (must be contiguous)
var candidates = network.SelectedNodes.Items;
bool canGroup = GraphAlgorithms.IsContinuousSubGraphSet(candidates);
```
Tokens:
Raw