1
0
Fork 0
arangodb/html/admin/js/graphViewer/graph/nodeReducer.js

364 lines
9.2 KiB
JavaScript

/*jslint indent: 2, nomen: true, maxlen: 100, white: true plusplus: true */
/*global $, d3, _, console, alert*/
////////////////////////////////////////////////////////////////////////////////
/// @brief Graph functionality
///
/// @file
///
/// DISCLAIMER
///
/// Copyright 2010-2012 triagens GmbH, Cologne, Germany
///
/// Licensed under the Apache License, Version 2.0 (the "License");
/// you may not use this file except in compliance with the License.
/// You may obtain a copy of the License at
///
/// http://www.apache.org/licenses/LICENSE-2.0
///
/// Unless required by applicable law or agreed to in writing, software
/// distributed under the License is distributed on an "AS IS" BASIS,
/// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
/// See the License for the specific language governing permissions and
/// limitations under the License.
///
/// Copyright holder is triAGENS GmbH, Cologne, Germany
///
/// @author Michael Hackstein
/// @author Copyright 2011-2013, triAGENS GmbH, Cologne, Germany
////////////////////////////////////////////////////////////////////////////////
function NodeReducer(nodes, edges) {
"use strict";
if (nodes === undefined) {
throw "Nodes have to be given.";
}
if (edges === undefined) {
throw "Edges have to be given.";
}
var self = this,
getDegree = function(id) {
return $.grep(nodes, function(e){
return e._id === id;
})[0];
},
// Will Overwrite dQ, a and heap!
populateValues = function(dQ, a, heap) {
var m = edges.length,
twoM = 2 * m,
cFact = 1 / twoM;
_.each(nodes, function(n) {
a[n._id] = (n._outboundCounter + n._inboundCounter) / twoM;
});
_.each(edges, function(e) {
var sID, lID;
if (e.source._id < e.target._id) {
sID = e.source._id;
lID = e.target._id;
} else {
sID = e.target._id;
lID = e.source._id;
}
if (dQ[sID] === undefined) {
dQ[sID] = {};
heap[sID] = {};
heap[sID].val = -1;
}
dQ[sID][lID] = cFact - a[sID] * a[lID];
if (heap[sID].val < dQ[sID][lID]) {
heap[sID].val = dQ[sID][lID];
heap[sID].sID = sID;
heap[sID].lID = lID;
}
});
},
getLargestOnHeap = function(heap) {
return _.max(heap, function(e) {
return e.val;
});
},
joinCommunities = function(sID, lID, coms, heap, val) {
coms[sID] = coms[sID] || {com: [sID], q: 0};
coms[lID] = coms[lID] || {com: [lID], q: 0};
var old = coms[sID].com,
newC = coms[lID].com;
coms[lID].com = old.concat(newC);
coms[lID].q += coms[sID].q + val;
delete coms[sID];
},
getDQValue = function(dQ, a, b) {
if (a < b) {
if (dQ[a] !== undefined) {
return dQ[a][b];
}
return undefined;
}
if (dQ[b] !== undefined) {
return dQ[b][a];
}
return undefined;
},
setDQValue = function(dQ, heap, a, b, val) {
if (a < b) {
if(dQ[a] === undefined) {
dQ[a] = {};
heap[a] = {};
heap[a].val = -1;
}
dQ[a][b] = val;
if (heap[a].val < val) {
heap[a].val = val;
heap[a].sID = a;
heap[a].lID = b;
}
} else {
if(dQ[b] === undefined) {
dQ[b] = {};
heap[b] = {};
heap[b].val = -1;
}
dQ[b][a] = val;
if (heap[b].val < val) {
heap[b].val = val;
heap[b].sID = b;
heap[b].lID = a;
}
}
},
delDQValue = function(dQ, a, b) {
if (a < b) {
delete dQ[a][b];
} else {
delete dQ[b][a];
}
},
updateValues = function(largest, dQ, a, heap) {
var lID = largest.lID,
sID = largest.sID;
_.each(nodes, function (n) {
var id = n._id,
c1, c2;
if (id === sID || id === lID) {
return null;
}
c1 = getDQValue(dQ, id, sID);
c2 = getDQValue(dQ, id, lID);
if (c1 !== undefined) {
if (c2 !== undefined) {
setDQValue(dQ, heap, id, lID, c1 + c2);
} else {
setDQValue(dQ, heap, id, lID, c1 - 2 * a[lID] * a[id]);
}
delDQValue(dQ, id, sID);
} else {
if (c2 !== undefined) {
setDQValue(dQ, heap, id, lID, c2- 2 * a[sID] * a[id]);
}
}
});
delete dQ[sID];
delete heap[sID];
a[lID] += a[sID];
delete a[sID];
},
sortBySize = function(a, b) {
return b.length - a.length;
},
neighbors = function(sID) {
var neigh = [];
_.each(edges, function(e) {
if (e.source._id === sID) {
neigh.push(e.target._id);
return;
}
if (e.target._id === sID) {
neigh.push(e.source._id);
return;
}
});
return neigh;
},
minDist = function(dist) {
return function(a) {
return dist[a];
};
},
dijkstra = function(sID) {
var dist = {},
toDo, next, neigh,
filterNotNext = function(e) {
return e !== next;
},
computeNeighbours = function(v) {
if (_.contains(toDo, v)) {
if (dist[v] > dist[next] + 1) {
dist[v] = dist[next] + 1;
}
}
};
toDo = _.pluck(nodes, "_id");
_.each(toDo, function(n) {
dist[n] = Number.POSITIVE_INFINITY;
});
dist[sID] = 0;
while(toDo.length > 0) {
next = _.min(toDo, minDist(dist));
if (next === Number.POSITIVE_INFINITY) {
break;
}
toDo = toDo.filter(filterNotNext);
neigh = neighbors(next);
_.each(neigh, computeNeighbours);
}
return dist;
},
floatDistStep = function(dist, depth, todo) {
if (todo.length === 0) {
return true;
}
var nextTodo = [];
_.each(todo, function(t) {
if (dist[t] !== Number.POSITIVE_INFINITY) {
return;
}
dist[t] = depth;
nextTodo = nextTodo.concat(neighbors(t));
});
return floatDistStep(dist, depth+1, nextTodo);
},
floatDist = function(sID) {
var dist = {};
_.each(_.pluck(nodes, "_id"), function(n) {
dist[n] = Number.POSITIVE_INFINITY;
});
dist[sID] = 0;
if (floatDistStep(dist, 1, neighbors(sID))) {
return dist;
}
throw "FAIL!";
},
communityDetectionStep = function(dQ, a, heap, coms) {
//console.log("COMS: " + JSON.stringify(coms));
//console.log("HEAP: " + JSON.stringify(heap));
var l = getLargestOnHeap(heap);
if (l === Number.NEGATIVE_INFINITY || l.val < 0) {
return false;
}
joinCommunities(l.sID, l.lID, coms, heap, l.val);
updateValues(l, dQ, a, heap);
return true;
},
addNode = function(bucket, node) {
bucket.push(node);
},
getSimilarityValue = function(bucket, node) {
if (bucket.length === 0) {
return 1;
}
var comp = bucket[0],
props = _.union(_.keys(comp), _.keys(node)),
countMatch = 0,
propCount = 0;
_.each(props, function(key) {
if (comp[key] !== undefined && node[key]!== undefined) {
countMatch++;
if (comp[key] === node[key]) {
countMatch += 4;
}
}
});
propCount = props.length * 5;
propCount++;
countMatch++;
return countMatch / propCount;
};
self.getCommunity = function(limit, focus) {
var dQ = {},
a = {},
heap = {},
coms = {},
res = [],
dist = {},
dist2 = {},
detectSteps = true,
sortByDistance = function (a, b) {
var d1 = dist[_.min(a,minDist(dist))],
d2 = dist[_.min(b,minDist(dist))],
val = d2 - d1;
if (val === 0) {
val = coms[b[b.length-1]].q - coms[a[a.length-1]].q;
}
return val;
};
if (nodes.length === 0 || edges.length === 0) {
throw "Load some nodes first.";
}
populateValues(dQ, a, heap);
while (detectSteps) {
detectSteps = communityDetectionStep(dQ, a, heap, coms);
}
res = _.pluck(_.values(coms), "com");
if (focus !== undefined) {
dist = floatDist(focus._id);
res = res.filter(function(e) {return !_.contains(e, focus._id);});
res = res.filter(function(e) {return e.length > 1;});
res.sort(sortByDistance);
} else {
res = res.filter(function(e) {return e.length > 1;});
}
return res[0];
};
self.bucketNodes = function(toSort, numBuckets) {
var res = [],
threshold = 0.5;
if (toSort.length <= numBuckets) {
res = _.map(toSort, function(n) {
return [n];
});
return res;
}
_.each(toSort, function(n) {
var i, shortest, sLength;
shortest = 0;
sLength = Number.POSITIVE_INFINITY;
for (i = 0; i < numBuckets; i++) {
res[i] = res[i] || [];
if (getSimilarityValue(res[i], n) > threshold) {
addNode(res[i], n);
return;
}
if (sLength > res[i].length) {
shortest = i;
sLength = res[i].length;
}
}
addNode(res[shortest], n);
});
return res;
};
}