You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
642 lines
22 KiB
642 lines
22 KiB
/**
|
|
* @constructor Cluster
|
|
* Contains the cluster properties for the graph object
|
|
*/
|
|
function Cluster() {
|
|
this.clusterSession = 0;
|
|
}
|
|
|
|
/**
|
|
* This function can be called to increase the cluster level. This means that the nodes with only one edge connection will
|
|
* be clustered with their connected node. This can be repeated as many times as needed.
|
|
* This can be called externally (by a keybind for instance) to reduce the complexity of big datasets.
|
|
*/
|
|
Cluster.prototype.increaseClusterLevel = function() {
|
|
var isMovingBeforeClustering = this.moving;
|
|
|
|
this._formClusters(true);
|
|
|
|
// if the simulation was settled, we restart the simulation if a cluster has been formed or expanded
|
|
if (this.moving != isMovingBeforeClustering) {
|
|
this.start();
|
|
}
|
|
};
|
|
|
|
/**
|
|
* This function can be called to decrease the cluster level. This means that the nodes with only one edge connection will
|
|
* be unpacked if they are a cluster. This can be repeated as many times as needed.
|
|
* This can be called externally (by a key-bind for instance) to look into clusters without zooming.
|
|
*/
|
|
Cluster.prototype.decreaseClusterLevel = function() {
|
|
var isMovingBeforeClustering = this.moving;
|
|
|
|
for (var i = 0; i < this.nodeIndices.length; i++) {
|
|
var node = this.nodes[this.nodeIndices[i]];
|
|
if (node.clusterSize > 1) {
|
|
this._expandClusterNode(node,false,true);
|
|
}
|
|
}
|
|
this._updateNodeIndexList();
|
|
|
|
this.clusterSession = (this.clusterSession == 0) ? 0 : this.clusterSession - 1;
|
|
|
|
// if the simulation was settled, we restart the simulation if a cluster has been formed or expanded
|
|
if (this.moving != isMovingBeforeClustering) {
|
|
this.start();
|
|
}
|
|
|
|
this._updateLabels();
|
|
};
|
|
|
|
|
|
/**
|
|
* This function can be called to open up a specific cluster.
|
|
* It will unpack the cluster back one level.
|
|
*
|
|
* @param node | Node object: cluster to open.
|
|
*/
|
|
Cluster.prototype.openCluster = function(node) {
|
|
var isMovingBeforeClustering = this.moving;
|
|
|
|
this._expandClusterNode(node,false,true);
|
|
this._updateNodeIndexList();
|
|
|
|
// if the simulation was settled, we restart the simulation if a cluster has been formed or expanded
|
|
if (this.moving != isMovingBeforeClustering) {
|
|
this.start();
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* This function checks if the zoom action is in or out.
|
|
* If out, check if we can form clusters, if in, check if we can open clusters.
|
|
* This function is only called from _zoom()
|
|
*
|
|
* @private
|
|
*/
|
|
Cluster.prototype._updateClusters = function() {
|
|
var isMovingBeforeClustering = this.moving;
|
|
|
|
if (this.previousScale > this.scale) { // zoom out
|
|
this._formClusters(false);
|
|
}
|
|
else if (this.previousScale < this.scale) { // zoom out
|
|
this._openClusters();
|
|
}
|
|
|
|
this._updateClusterLabels();
|
|
this._updateNodeLabels();
|
|
this._updateLabels();
|
|
this.previousScale = this.scale;
|
|
|
|
// if the simulation was settled, we restart the simulation if a cluster has been formed or expanded
|
|
if (this.moving != isMovingBeforeClustering) {
|
|
this.start();
|
|
}
|
|
};
|
|
|
|
/**
|
|
* This updates the node labels for all nodes (for debugging purposes)
|
|
* @private
|
|
*/
|
|
Cluster.prototype._updateLabels = function() {
|
|
// update node labels
|
|
//this._updateClusterLabels();
|
|
// this._updateNodeLabels();
|
|
|
|
// Debug :
|
|
for (var nodeID in this.nodes) {
|
|
if (this.nodes.hasOwnProperty(nodeID)) {
|
|
var node = this.nodes[nodeID];
|
|
node.label = String(node.dynamicEdges.length).concat(":",node.dynamicEdgesLength,":",String(node.clusterSize),":::",String(node.id));
|
|
}
|
|
}
|
|
|
|
};
|
|
|
|
/**
|
|
* This updates the node labels for all clusters
|
|
* @private
|
|
*/
|
|
Cluster.prototype._updateClusterLabels = function() {
|
|
// update node labels
|
|
for (var nodeID in this.nodes) {
|
|
if (this.nodes.hasOwnProperty(nodeID)) {
|
|
var node = this.nodes[nodeID];
|
|
if (node.clusterSize > 1) {
|
|
node.label = "[".concat(String(node.clusterSize),"]");
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* This updates the node labels for all nodes that are NOT clusters
|
|
* @private
|
|
*/
|
|
Cluster.prototype._updateNodeLabels = function() {
|
|
// update node labels
|
|
for (var nodeID in this.nodes) {
|
|
var node = this.nodes[nodeID];
|
|
if (node.clusterSize == 1) {
|
|
node.label = String(node.id);
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* This function loops over all nodes in the nodeIndices list. For each node it checks if it is a cluster and if it
|
|
* has to be opened based on the current zoom level.
|
|
*
|
|
* @private
|
|
*/
|
|
Cluster.prototype._openClusters = function() {
|
|
var amountOfNodes = this.nodeIndices.length;
|
|
|
|
for (var i = 0; i < this.nodeIndices.length; i++) {
|
|
var node = this.nodes[this.nodeIndices[i]];
|
|
this._expandClusterNode(node,true,false);
|
|
}
|
|
|
|
this._updateNodeIndexList();
|
|
|
|
if (this.nodeIndices.length != amountOfNodes) { // this means a clustering operation has taken place
|
|
this.clusterSession -= 1;
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* This function checks if a node has to be opened. This is done by checking the zoom level.
|
|
* If the node contains child nodes, this function is recursively called on the child nodes as well.
|
|
* This recursive behaviour is optional and can be set by the recursive argument.
|
|
*
|
|
* @param parentNode | Node object: to check for cluster and expand
|
|
* @param recursive | Boolean: enable or disable recursive calling
|
|
* @param forceExpand | Boolean: enable or disable forcing the last node to join the cluster to be expelled
|
|
* @private
|
|
*/
|
|
Cluster.prototype._expandClusterNode = function(parentNode, recursive, forceExpand) {
|
|
// first check if node is a cluster
|
|
if (parentNode.clusterSize > 1) {
|
|
// if the last child has been added on a smaller scale than current scale (@optimization)
|
|
if (parentNode.formationScale < this.scale || forceExpand == true) {
|
|
// we will check if any of the contained child nodes should be removed from the cluster
|
|
for (var containedNodeID in parentNode.containedNodes) {
|
|
if (parentNode.containedNodes.hasOwnProperty(containedNodeID)) {
|
|
var childNode = parentNode.containedNodes[containedNodeID];
|
|
|
|
// force expand will expand the largest cluster size clusters. Since we cluster from outside in, we assume that
|
|
// the largest cluster is the one that comes from outside
|
|
if (forceExpand == true) {
|
|
if (childNode.clusterSession == this.clusterSession - 1) {
|
|
this._expelChildFromParent(parentNode,containedNodeID,recursive,forceExpand);
|
|
}
|
|
}
|
|
else {
|
|
if (this._parentNodeInActiveArea(parentNode)) {
|
|
this._expelChildFromParent(parentNode,containedNodeID,recursive,forceExpand);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
Cluster.prototype._parentNodeInActiveArea = function(node) {
|
|
if (Math.abs(node.x - this.zoomCenter.x) <= this.constants.clustering.activeAreaRadius/this.scale &&
|
|
Math.abs(node.y - this.zoomCenter.y) <= this.constants.clustering.activeAreaRadius/this.scale) {
|
|
return true;
|
|
}
|
|
else {
|
|
return false;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* This function will expel a child_node from a parent_node. This is to de-cluster the node. This function will remove
|
|
* the child node from the parent contained_node object and put it back into the global nodes object.
|
|
* The same holds for the edge that was connected to the child node. It is moved back into the global edges object.
|
|
*
|
|
* @param parentNode | Node object: the parent node
|
|
* @param containedNodeID | String: child_node id as it is contained in the containedNodes object of the parent node
|
|
* @param recursive | Boolean: This will also check if the child needs to be expanded.
|
|
* With force and recursive both true, the entire cluster is unpacked
|
|
* @param forceExpand | Boolean: This will disregard the zoom level and will expel this child from the parent
|
|
* @private
|
|
*/
|
|
Cluster.prototype._expelChildFromParent = function(parentNode, containedNodeID, recursive, forceExpand) {
|
|
var childNode = parentNode.containedNodes[containedNodeID];
|
|
|
|
// if child node has been added on smaller scale than current, kick out
|
|
if (childNode.formationScale < this.scale || forceExpand == true) {
|
|
|
|
// put the child node back in the global nodes object
|
|
this.nodes[containedNodeID] = childNode;
|
|
|
|
// release the contained edges from this childNode back into the global edges
|
|
this._releaseContainedEdges(parentNode,childNode)
|
|
|
|
// reconnect rerouted edges to the childNode
|
|
this._connectEdgeBackToChild(parentNode,childNode);
|
|
|
|
// undo the changes from the clustering operation on the parent node
|
|
parentNode.mass -= this.constants.clustering.massTransferCoefficient * childNode.mass;
|
|
parentNode.fontSize -= this.constants.clustering.fontSizeMultiplier * childNode.clusterSize;
|
|
parentNode.clusterSize -= childNode.clusterSize;
|
|
parentNode.dynamicEdgesLength = parentNode.dynamicEdges.length;
|
|
|
|
// place the child node near the parent, not at the exact same location to avoid chaos in the system
|
|
childNode.x = parentNode.x + this.constants.edges.length * 0.2 * (0.5 - Math.random()) * parentNode.clusterSize;
|
|
childNode.y = parentNode.y + this.constants.edges.length * 0.2 * (0.5 - Math.random()) * parentNode.clusterSize;
|
|
|
|
// remove the clusterSession from the child node
|
|
childNode.clusterSession = 0;
|
|
|
|
// remove node from the list
|
|
delete parentNode.containedNodes[containedNodeID];
|
|
|
|
// restart the simulation to reorganise all nodes
|
|
this.moving = true;
|
|
|
|
// recalculate the size of the node on the next time the node is rendered
|
|
parentNode.clearSizeCache();
|
|
}
|
|
|
|
// check if a further expansion step is possible if recursivity is enabled
|
|
if (recursive == true) {
|
|
this._expandClusterNode(childNode,recursive,forceExpand);
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* This function checks if any nodes at the end of their trees have edges below a threshold length
|
|
* This function is called only from _updateClusters()
|
|
* forceLevelCollapse ignores the length of the edge and collapses one level
|
|
* This means that a node with only one edge will be clustered with its connected node
|
|
*
|
|
* @private
|
|
* @param force_level_collapse | Boolean
|
|
*/
|
|
Cluster.prototype._formClusters = function(forceLevelCollapse) {
|
|
var amountOfNodes = this.nodeIndices.length;
|
|
|
|
if (forceLevelCollapse == false) {
|
|
this._formClustersByZoom();
|
|
}
|
|
else {
|
|
this._forceClustersByZoom();
|
|
}
|
|
|
|
if (this.nodeIndices.length != amountOfNodes) { // this means a clustering operation has taken place
|
|
this.clusterSession += 1;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* This function handles the clustering by zooming out, this is based on minimum edge distance
|
|
*
|
|
* @private
|
|
*/
|
|
Cluster.prototype._formClustersByZoom = function() {
|
|
var dx,dy,length,
|
|
minLength = this.constants.clustering.clusterLength/this.scale;
|
|
// create an array of edge ids
|
|
var edgesIDarray = []
|
|
for (var id in this.edges) {
|
|
if (this.edges.hasOwnProperty(id)) {
|
|
edgesIDarray.push(id);
|
|
}
|
|
}
|
|
|
|
// check if any edges are shorter than minLength and start the clustering
|
|
// the clustering favours the node with the larger mass
|
|
for (var i = 0; i < edgesIDarray.length; i++) {
|
|
var edgeID = edgesIDarray[i];
|
|
var edge = this.edges[edgeID];
|
|
if (edge.connected) {
|
|
dx = (edge.to.x - edge.from.x);
|
|
dy = (edge.to.y - edge.from.y);
|
|
length = Math.sqrt(dx * dx + dy * dy);
|
|
|
|
|
|
if (length < minLength) {
|
|
// first check which node is larger
|
|
var parentNode = edge.from
|
|
var childNode = edge.to
|
|
if (edge.to.mass > edge.from.mass) {
|
|
parentNode = edge.to
|
|
childNode = edge.from
|
|
}
|
|
|
|
// we allow clustering from outside in
|
|
// if we do not cluster from outside in, we would have to reconnect edges or keep
|
|
// a second set of edges for the clusters.
|
|
// This will also have to be altered in the force calculation and rendering.
|
|
// This method is non-destructive and does not require a second set of data.
|
|
if (childNode.dynamicEdgesLength == 1) {
|
|
this._addToCluster(parentNode,childNode,edge,false);
|
|
}
|
|
else if (parentNode.dynamicEdgesLength == 1) {
|
|
this._addToCluster(childNode,parentNode,edge,false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
this._updateNodeIndexList();
|
|
};
|
|
|
|
/**
|
|
* This function forces the graph to cluster all nodes with only one connecting edge to their
|
|
* connected node.
|
|
*
|
|
* @private
|
|
*/
|
|
Cluster.prototype._forceClustersByZoom = function() {
|
|
for (var nodeID = 0; nodeID < this.nodeIndices.length; nodeID++) {
|
|
var childNode = this.nodes[this.nodeIndices[nodeID]];
|
|
if (childNode.dynamicEdgesLength == 1) {
|
|
var edge = childNode.dynamicEdges[0];
|
|
var parentNode = (edge.toId == childNode.id) ? this.nodes[edge.fromId] : this.nodes[edge.toId];
|
|
this._addToCluster(parentNode,childNode,true);
|
|
}
|
|
}
|
|
this._updateNodeIndexList();
|
|
this._updateDynamicEdges();
|
|
};
|
|
|
|
|
|
Cluster.prototype.aggregateHubs = function() {
|
|
var isMovingBeforeClustering = this.moving;
|
|
|
|
var hubThreshold = 4;
|
|
this._forceClustersByHub(hubThreshold);
|
|
|
|
// if the simulation was settled, we restart the simulation if a cluster has been formed or expanded
|
|
if (this.moving != isMovingBeforeClustering) {
|
|
this.start();
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
*
|
|
* @param hubThreshold
|
|
* @private
|
|
*/
|
|
Cluster.prototype._forceClustersByHub = function(hubThreshold) {
|
|
for (var nodeID = 0; nodeID < this.nodeIndices.length; nodeID++) {
|
|
if (this.nodes.hasOwnProperty(this.nodeIndices[nodeID])) {
|
|
var hubNode = this.nodes[this.nodeIndices[nodeID]];
|
|
if (hubNode.dynamicEdges.length >= hubThreshold) {
|
|
var edgesIDarray = []
|
|
var amountOfInitialEdges = hubNode.dynamicEdges.length;
|
|
for (var i = 0; i < amountOfInitialEdges; i++) {
|
|
edgesIDarray.push(hubNode.dynamicEdges[i].id);
|
|
}
|
|
for (var i = 0; i < amountOfInitialEdges; i++) {
|
|
var edge = this.edges[edgesIDarray[i]];
|
|
var childNode = this.nodes[(edge.fromId == hubNode.id) ? edge.toId : edge.fromId];
|
|
this._addToCluster(hubNode,childNode,true);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
this._updateNodeIndexList();
|
|
this._updateDynamicEdges();
|
|
this._updateLabels();
|
|
|
|
if (this.moving != isMovingBeforeClustering) {
|
|
this.start();
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
* This function adds the child node to the parent node, creating a cluster if it is not already.
|
|
* This function is called only from _updateClusters()
|
|
*
|
|
* @param parent_node | Node object: this is the node that will house the child node
|
|
* @param child_node | Node object: this node will be deleted from the global this.nodes and stored in the parent node
|
|
* @param force_level_collapse | Boolean: true will only update the remainingEdges at the very end of the clustering, ensuring single level collapse
|
|
* @private
|
|
*/
|
|
Cluster.prototype._addToCluster = function(parentNode, childNode, forceLevelCollapse) {
|
|
// join child node in the parent node
|
|
parentNode.containedNodes[childNode.id] = childNode;
|
|
|
|
if (forceLevelCollapse == false) {
|
|
parentNode.dynamicEdgesLength += childNode.dynamicEdges.length - 2;
|
|
}
|
|
|
|
for (var i = 0; i < childNode.dynamicEdges.length; i++) {
|
|
var edge = childNode.dynamicEdges[i];
|
|
if (edge.toId == parentNode.id || edge.fromId == parentNode.id) { // edge connected to parentNode
|
|
this._addToContainedEdges(parentNode,childNode,edge);
|
|
}
|
|
else {
|
|
console.log('connecting edge to cluster');
|
|
this._connectEdgeToCluster(parentNode,childNode,edge);
|
|
}
|
|
}
|
|
childNode.dynamicEdges = [];
|
|
|
|
|
|
// remove the childNode from the global nodes object
|
|
delete this.nodes[childNode.id];
|
|
|
|
childNode.clusterSession = this.clusterSession;
|
|
parentNode.mass += this.constants.clustering.massTransferCoefficient * childNode.mass;
|
|
parentNode.clusterSize += childNode.clusterSize;
|
|
parentNode.fontSize += this.constants.clustering.fontSizeMultiplier * childNode.clusterSize
|
|
|
|
// giving the clusters a dynamic formationScale to ensure not all clusters open up when zoomed
|
|
if (forceLevelCollapse == true) {
|
|
parentNode.formationScale = this.scale * Math.pow(1.0/11.0,this.clusterSession);
|
|
}
|
|
else {
|
|
parentNode.formationScale = this.scale; // The latest child has been added on this scale
|
|
parentNode.dynamicEdgesLength = parentNode.dynamicEdges.length;
|
|
}
|
|
|
|
// recalculate the size of the node on the next time the node is rendered
|
|
parentNode.clearSizeCache();
|
|
|
|
parentNode.containedNodes[childNode.id].formationScale = this.scale; // this child has been added at this scale.
|
|
|
|
// restart the simulation to reorganise all nodes
|
|
this.moving = true;
|
|
};
|
|
|
|
|
|
/**
|
|
* This function will apply the changes made to the remainingEdges during the formation of the clusters.
|
|
* This is a seperate function to allow for level-wise collapsing of the node tree.
|
|
* It has to be called if a level is collapsed. It is called by _formClusters().
|
|
* @private
|
|
*/
|
|
Cluster.prototype._updateDynamicEdges = function() {
|
|
for (var i = 0; i < this.nodeIndices.length; i++) {
|
|
var node = this.nodes[this.nodeIndices[i]];
|
|
node.dynamicEdgesLength = node.dynamicEdges.length;
|
|
}
|
|
};
|
|
|
|
|
|
Cluster.prototype._repositionNodes = function() {
|
|
for (var i = 0; i < this.nodeIndices.length; i++) {
|
|
var node = this.nodes[this.nodeIndices[i]];
|
|
if (!node.isFixed()) {
|
|
// TODO: position new nodes in a smarter way!
|
|
var radius = this.constants.edges.length * (1 + 0.5*node.clusterSize);
|
|
var angle = 2 * Math.PI * Math.random();
|
|
node.x = radius * Math.cos(angle);
|
|
node.y = radius * Math.sin(angle);
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* This adds an edge from the childNode to the contained edges of the parent node
|
|
*
|
|
* @param parentNode | Node object
|
|
* @param childNode | Node object
|
|
* @param edge | Edge object
|
|
* @private
|
|
*/
|
|
Cluster.prototype._addToContainedEdges = function(parentNode, childNode, edge) {
|
|
// create an array object if it does not yet exist for this childNode
|
|
if (!(parentNode.containedEdges.hasOwnProperty(childNode.id))) {
|
|
parentNode.containedEdges[childNode.id] = []
|
|
}
|
|
// add this edge to the list
|
|
parentNode.containedEdges[childNode.id].push(edge);
|
|
|
|
// remove the edge from the global edges object
|
|
delete this.edges[edge.id];
|
|
|
|
// remove the edge from the parent object
|
|
for (var i = 0; i < parentNode.dynamicEdges.length; i++) {
|
|
if (parentNode.dynamicEdges[i].id == edge.id) {
|
|
parentNode.dynamicEdges.splice(i,1);
|
|
break;
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* This function connects an edge that was connected to a child node to the parent node.
|
|
* It keeps track of which nodes it has been connected to with the originalID array.
|
|
*
|
|
* @param parentNode | Node object
|
|
* @param childNode | Node object
|
|
* @param edge | Edge object
|
|
* @private
|
|
*/
|
|
Cluster.prototype._connectEdgeToCluster = function(parentNode, childNode, edge) {
|
|
if (edge.toId == childNode.id) { // edge connected to other node on the "to" side
|
|
edge.originalToID.push(childNode.id);
|
|
edge.to = parentNode;
|
|
edge.toId = parentNode.id;
|
|
}
|
|
else { // edge connected to other node with the "from" side
|
|
edge.originalFromID.push(childNode.id);
|
|
edge.from = parentNode;
|
|
edge.fromId = parentNode.id;
|
|
}
|
|
|
|
this._addToReroutedEdges(parentNode,childNode,edge);
|
|
};
|
|
|
|
|
|
/**
|
|
* This adds an edge from the childNode to the rerouted edges of the parent node
|
|
*
|
|
* @param parentNode | Node object
|
|
* @param childNode | Node object
|
|
* @param edge | Edge object
|
|
* @private
|
|
*/
|
|
Cluster.prototype._addToReroutedEdges = function(parentNode, childNode, edge) {
|
|
// create an array object if it does not yet exist for this childNode
|
|
// we store the edge in the rerouted edges so we can restore it when the cluster pops open
|
|
if (!(parentNode.reroutedEdges.hasOwnProperty(childNode.id))) {
|
|
parentNode.reroutedEdges[childNode.id] = [];
|
|
}
|
|
parentNode.reroutedEdges[childNode.id].push(edge);
|
|
|
|
// this edge becomes part of the dynamicEdges of the cluster node
|
|
parentNode.dynamicEdges.push(edge);
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
* This function connects an edge that was connected to a cluster node back to the child node.
|
|
*
|
|
* @param parentNode | Node object
|
|
* @param childNode | Node object
|
|
* @private
|
|
*/
|
|
Cluster.prototype._connectEdgeBackToChild = function(parentNode, childNode) {
|
|
if (parentNode.reroutedEdges[childNode.id] != undefined) {
|
|
for (var i = 0; i < parentNode.reroutedEdges[childNode.id].length; i++) {
|
|
var edge = parentNode.reroutedEdges[childNode.id][i];
|
|
if (edge.originalFromID[edge.originalFromID.length-1] == childNode.id) {
|
|
edge.originalFromID.pop();
|
|
edge.fromId = childNode.id;
|
|
edge.from = childNode;
|
|
}
|
|
else {
|
|
edge.originalToID.pop();
|
|
edge.toId = childNode.id;
|
|
edge.to = childNode;
|
|
}
|
|
|
|
// append this edge to the list of edges connecting to the childnode
|
|
childNode.dynamicEdges.push(edge);
|
|
|
|
// remove the edge from the parent object
|
|
for (var j = 0; j < parentNode.dynamicEdges.length; j++) {
|
|
if (parentNode.dynamicEdges[j].id == edge.id) {
|
|
parentNode.dynamicEdges.splice(j,1);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
// remove the entry from the rerouted edges
|
|
delete parentNode.reroutedEdges[childNode.id];
|
|
}
|
|
};
|
|
|
|
/**
|
|
* This function released the contained edges back into the global domain and puts them back into the
|
|
* dynamic edges of both parent and child.
|
|
*
|
|
* @param parentNode | Node object
|
|
* @param childNode | Node object
|
|
* @private
|
|
*/
|
|
Cluster.prototype._releaseContainedEdges = function(parentNode, childNode) {
|
|
for (var i = 0; i < parentNode.containedEdges[childNode.id].length; i++) {
|
|
var edge = parentNode.containedEdges[childNode.id][i];
|
|
|
|
// put the edge back in the global edges object
|
|
this.edges[edge.id] = edge;
|
|
|
|
// put the edge back in the dynamic edges of the child and parent
|
|
childNode.dynamicEdges.push(edge);
|
|
parentNode.dynamicEdges.push(edge);
|
|
}
|
|
// remove the entry from the contained edges
|
|
delete parentNode.containedEdges[childNode.id];
|
|
|
|
};
|