vis.js - Network documentation. (2024)

For all qualifying nodes, clusterByConnection is performed on each of them. The options object is described for clusterByConnection and does the same here.

If any nodeId in the chain, especially the first passed in as a parameter, is not present in the current nodes list, an empty array is returned.

Example: cluster 'A' contains cluster 'B', cluster 'B' contains cluster 'C', cluster 'C' contains node 'fred'. network.clustering.findNode('fred') will return ['A','B','C','fred'].

This method is deprecated. Please use getBaseEdges() instead.

Only the base edge id's are returned. All clustered edges id's under clusteredEdgeId are skipped, but scanned recursively to return their base id's.

Example: network.clustering.updateEdge(originalEdge.id, {color : '#aa0000'});
This would turn the base edge and any subsequent edges red, so when opening clusters the edges will all be the same color.

Example: network.clustering.updateClusteredNode(clusteredNodeId, {shape : 'star'});

function releaseFunction (clusterPosition, containedNodesPositions) { var newPositions = {}; // clusterPosition = {x:clusterX, y:clusterY}; // containedNodesPositions = {nodeId:{x:nodeX,y:nodeY}, nodeId2....} newPositions[nodeId] = {x:newPosX, y:newPosY}; return newPositions;}

For all nodeIds not listed in this returned object, we will position them at the location of the cluster. This is also the default behaviour when no releaseFunction is defined.

// All nodes in the network.network.getPositions();> { a123: { x: 5, y: 12 }, b456: { x: 3, y: 4 }, c789: { x: 7, y: 10 } }// Specific nodes.network.getPositions(['a123', 'b456']);> { a123: { x: 5, y: 12 }, b456: { x: 3, y: 4 }, }// A single node.network.getPositions('a123');> { a123: { x: 5, y: 12 } } 

network.getPosition('a123');> { x: 5, y: 12 } 

If the nodes are still moving and you're using dynamic smooth edges (which is on by default), you can use the option stabilization.onlyDynamicEdges in the physics module to improve initialization time.

This method does not support clustering. At the moment it is not possible to cache positions when using clusters since they cannot be correctly initialized from just the positions.

{ top: Number, left: Number, right: Number, bottom: Number}

For a node id, returns an array with the id's of the connected nodes.
If optional parameter direction is set to string 'from', only parent nodes are returned.
If direction is set to 'to', only child nodes are returned.
Any other value or undefined returns both parent and child nodes.

For an edge id, returns an array: [fromId, toId]. Parameter direction is ignored for edges.

{ nodes: [Array of selected nodeIds], edges: [Array of selected edgeIds]}

{ nodes: [Array of nodeIds], edges: [Array of edgeIds]}

{ unselectAll: Boolean, highlightEdges: Boolean}

{ nodes?: (string | number)[], minZoomLevel?: number, maxZoomLevel?: number, animation?: boolean | { duration?: number easingFunction?: string }}

The other options are explained in the moveTo() description below. All options are optional for the fit method.

{ scale: Number, offset: {x:Number, y:Number} locked: boolean animation: { // -------------------> can be a boolean too! duration: Number easingFunction: String }}

{ position: {x:Number, y:Number}, scale: Number, offset: {x:Number, y:Number} animation: { // -------------------> can be a boolean too! duration: Number easingFunction: String }}

var nodes = [ {id: 4, label: 'Node 4'}, {id: 5, label: 'Node 5'}, {id: 6, label: 'Node 6', cid:1}, {id: 7, label: 'Node 7', cid:1}]var options = { joinCondition:function(nodeOptions) { return nodeOptions.cid === 1; }}network.clustering.cluster(options);

var options = { processProperties: function (clusterOptions, childNodes, childEdges) { var totalMass = 0; var totalValue = 0; for (var i = 0; i < childNodes.length; i++) { totalMass += childNodes[i].mass; totalValue = childNodes[i].value ? totalValue + childNodes[i].value : totalValue; } clusterOptions.mass = totalMass; if (totalValue > 0) { clusterOptions.value = totalValue; } return clusterOptions; },}

Default functionality only allows clustering if the cluster will contain 2 or more nodes. To allow clustering of single nodes you can use the allowSingleNodeCluster : true property.

 clusterNodeProperties: { allowSingleNodeCluster: true }

{ nodes: [Array of selected nodeIds], edges: [Array of selected edgeIds], event: [Object] original click event, pointer: { DOM: {x:pointer_x, y:pointer_y}, canvas: {x:canvas_x, y:canvas_y} }}

{... items: [Array of click items],}

 {nodeId:NodeId} // node with given id clicked on {nodeId:NodeId labelId:0} // label of node with given id clicked on {edgeId:EdgeId} // edge with given id clicked on {edge:EdgeId, labelId:0} // label of edge with given id clicked on

{ nodes: [Array of selected nodeIds], edges: [Array of selected edgeIds], event: [Object] original click event, pointer: { DOM: {x:pointer_x, y:pointer_y}, canvas: {x:canvas_x, y:canvas_y} } }, previousSelection: { nodes: [Array of previously selected nodeIds], edges: [Array of previously selected edgeIds] }}

{ nodes: [Array of selected nodeIds], edges: [Array of selected edgeIds], event: [Object] original click event, pointer: { DOM: {x:pointer_x, y:pointer_y}, canvas: {x:canvas_x, y:canvas_y} }, controlEdge: {from:from_node_id, to:to_node_id}}

{ direction: '+'/'-', scale: Number, pointer: {x:pointer_x, y:pointer_y}}

{ iterations: Number // iterations so far, total: Number // total iterations in options}

{ iterations: Number // iterations it took}

{ width: Number // the new width of the canvas height: Number // the new height of the canvas oldWidth: Number // the old width of the canvas oldHeight: Number // the old height of the canvas}