792 lines
21 KiB
JavaScript
792 lines
21 KiB
JavaScript
define(["d3"], function (d3) {
|
|
var margin = 200
|
|
var NODE_RADIUS = 15
|
|
var LINE_RADIUS = 7
|
|
|
|
return function (config, linkScale, sidebar, router) {
|
|
var self = this
|
|
var canvas, ctx, screenRect
|
|
var nodesDict, linksDict
|
|
var zoomBehavior
|
|
var force
|
|
var el
|
|
var doAnimation = false
|
|
var intNodes = []
|
|
var intLinks = []
|
|
var highlight
|
|
var highlightedNodes = []
|
|
var highlightedLinks = []
|
|
var nodes = []
|
|
var uplinkNodes = []
|
|
var nonUplinkNodes = []
|
|
var unseenNodes = []
|
|
var unknownNodes = []
|
|
var savedPanZoom
|
|
|
|
var draggedNode
|
|
|
|
var LINK_DISTANCE = 70
|
|
|
|
function graphDiameter(nodes) {
|
|
return Math.sqrt(nodes.length / Math.PI) * LINK_DISTANCE * 1.41
|
|
}
|
|
|
|
function savePositions() {
|
|
if (!localStorageTest())
|
|
return
|
|
|
|
var save = intNodes.map( function (d) {
|
|
return { id: d.o.id, x: d.x, y: d.y }
|
|
})
|
|
|
|
localStorage.setItem("graph/nodeposition", JSON.stringify(save))
|
|
}
|
|
|
|
function nodeName(d) {
|
|
if (d.o.node && d.o.node.nodeinfo)
|
|
return d.o.node.nodeinfo.hostname
|
|
else
|
|
return d.o.id
|
|
}
|
|
|
|
function dragstart() {
|
|
var e = translateXY(d3.mouse(el))
|
|
|
|
var nodes = intNodes.filter(function (d) {
|
|
return distancePoint(e, d) < NODE_RADIUS
|
|
})
|
|
|
|
if (nodes.length === 0)
|
|
return
|
|
|
|
draggedNode = nodes[0]
|
|
d3.event.sourceEvent.stopPropagation()
|
|
d3.event.sourceEvent.preventDefault()
|
|
draggedNode.fixed |= 2
|
|
|
|
draggedNode.px = draggedNode.x
|
|
draggedNode.py = draggedNode.y
|
|
}
|
|
|
|
function dragmove() {
|
|
if (draggedNode) {
|
|
var e = translateXY(d3.mouse(el))
|
|
|
|
draggedNode.px = e.x
|
|
draggedNode.py = e.y
|
|
force.resume()
|
|
}
|
|
}
|
|
|
|
function dragend() {
|
|
if (draggedNode) {
|
|
d3.event.sourceEvent.stopPropagation()
|
|
d3.event.sourceEvent.preventDefault()
|
|
draggedNode.fixed &= ~2
|
|
draggedNode = undefined
|
|
}
|
|
}
|
|
|
|
var draggableNode = d3.behavior.drag()
|
|
.on("dragstart", dragstart)
|
|
.on("drag", dragmove)
|
|
.on("dragend", dragend)
|
|
|
|
function animatePanzoom(translate, scale) {
|
|
var translateP = zoomBehavior.translate()
|
|
var scaleP = zoomBehavior.scale()
|
|
|
|
if (!doAnimation) {
|
|
zoomBehavior.translate(translate)
|
|
zoomBehavior.scale(scale)
|
|
panzoom()
|
|
} else {
|
|
var start = {x: translateP[0], y: translateP[1], scale: scaleP}
|
|
var end = {x: translate[0], y: translate[1], scale: scale}
|
|
|
|
var interpolate = d3.interpolateObject(start, end)
|
|
var duration = 500
|
|
|
|
var ease = d3.ease("cubic-in-out")
|
|
|
|
d3.timer(function (t) {
|
|
if (t >= duration)
|
|
return true
|
|
|
|
var v = interpolate(ease(t / duration))
|
|
zoomBehavior.translate([v.x, v.y])
|
|
zoomBehavior.scale(v.scale)
|
|
panzoom()
|
|
|
|
return false
|
|
})
|
|
}
|
|
}
|
|
|
|
function onPanZoom() {
|
|
savedPanZoom = {translate: zoomBehavior.translate(),
|
|
scale: zoomBehavior.scale()}
|
|
panzoom()
|
|
}
|
|
|
|
function panzoom() {
|
|
var translate = zoomBehavior.translate()
|
|
var scale = zoomBehavior.scale()
|
|
|
|
|
|
panzoomReal(translate, scale)
|
|
}
|
|
|
|
function panzoomReal(translate, scale) {
|
|
screenRect = {left: -translate[0] / scale, top: -translate[1] / scale,
|
|
right: (canvas.width - translate[0]) / scale,
|
|
bottom: (canvas.height - translate[1]) / scale}
|
|
|
|
requestAnimationFrame(redraw)
|
|
}
|
|
|
|
function getSize() {
|
|
var sidebarWidth = sidebar()
|
|
var width = el.offsetWidth - sidebarWidth
|
|
var height = el.offsetHeight
|
|
|
|
return [width, height]
|
|
}
|
|
|
|
function panzoomTo(a, b) {
|
|
var sidebarWidth = sidebar()
|
|
var size = getSize()
|
|
|
|
var targetWidth = Math.max(1, b[0] - a[0])
|
|
var targetHeight = Math.max(1, b[1] - a[1])
|
|
|
|
var scaleX = size[0] / targetWidth
|
|
var scaleY = size[1] / targetHeight
|
|
var scaleMax = zoomBehavior.scaleExtent()[1]
|
|
var scale = 0.5 * Math.min(scaleMax, Math.min(scaleX, scaleY))
|
|
|
|
var centroid = [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2]
|
|
var x = -centroid[0] * scale + size[0] / 2
|
|
var y = -centroid[1] * scale + size[1] / 2
|
|
var translate = [x + sidebarWidth, y]
|
|
|
|
animatePanzoom(translate, scale)
|
|
}
|
|
|
|
function updateHighlight(nopanzoom) {
|
|
highlightedNodes = []
|
|
highlightedLinks = []
|
|
|
|
if (highlight !== undefined)
|
|
if (highlight.type === "node") {
|
|
var n = nodesDict[highlight.o.nodeinfo.node_id]
|
|
|
|
if (n) {
|
|
highlightedNodes = [n]
|
|
|
|
if (!nopanzoom)
|
|
panzoomTo([n.x, n.y], [n.x, n.y])
|
|
}
|
|
|
|
return
|
|
} else if (highlight.type === "link") {
|
|
var l = linksDict[highlight.o.id]
|
|
|
|
if (l) {
|
|
highlightedLinks = [l]
|
|
|
|
if (!nopanzoom) {
|
|
var x = d3.extent([l.source, l.target], function (d) { return d.x })
|
|
var y = d3.extent([l.source, l.target], function (d) { return d.y })
|
|
panzoomTo([x[0], y[0]], [x[1], y[1]])
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
if (!nopanzoom)
|
|
if (!savedPanZoom)
|
|
panzoomTo([0, 0], force.size())
|
|
else
|
|
animatePanzoom(savedPanZoom.translate, savedPanZoom.scale)
|
|
}
|
|
|
|
function drawLabel(d) {
|
|
var neighbours = d.neighbours.filter(function (d) {
|
|
return !d.link.o.isVPN
|
|
})
|
|
|
|
var sum = neighbours.reduce(function (a, b) {
|
|
return [a[0] + b.node.x, a[1] + b.node.y]
|
|
}, [0, 0])
|
|
|
|
var sumCos = sum[0] - d.x * neighbours.length
|
|
var sumSin = sum[1] - d.y * neighbours.length
|
|
|
|
var angle = Math.PI / 2
|
|
|
|
if (neighbours.length > 0)
|
|
angle = Math.PI + Math.atan2(sumSin, sumCos)
|
|
|
|
var cos = Math.cos(angle)
|
|
var sin = Math.sin(angle)
|
|
|
|
var width = d.labelWidth
|
|
var height = d.labelHeight
|
|
|
|
var x = d.x + d.labelA * Math.pow(Math.abs(cos), 2 / 5) * Math.sign(cos) - width / 2
|
|
var y = d.y + d.labelB * Math.pow(Math.abs(sin), 2 / 5) * Math.sign(sin) - height / 2
|
|
|
|
ctx.drawImage(d.label, x, y, width, height)
|
|
}
|
|
|
|
function visibleLinks(d) {
|
|
return (d.o.isVPN ||
|
|
d.source.x > screenRect.left && d.source.x < screenRect.right &&
|
|
d.source.y > screenRect.top && d.source.y < screenRect.bottom) ||
|
|
(d.target.x > screenRect.left && d.target.x < screenRect.right &&
|
|
d.target.y > screenRect.top && d.target.y < screenRect.bottom)
|
|
}
|
|
|
|
function visibleNodes(d) {
|
|
return d.x + margin > screenRect.left && d.x - margin < screenRect.right &&
|
|
d.y + margin > screenRect.top && d.y - margin < screenRect.bottom
|
|
}
|
|
|
|
function drawNode(color, radius, scale, r) {
|
|
var node = document.createElement("canvas")
|
|
node.width = scale * radius * 8 * r
|
|
node.height = node.width
|
|
|
|
var nctx = node.getContext("2d")
|
|
nctx.scale(scale * r, scale * r)
|
|
nctx.save()
|
|
|
|
nctx.translate(-node.width / scale, -node.height / scale)
|
|
nctx.lineWidth = radius
|
|
|
|
nctx.beginPath()
|
|
nctx.moveTo(radius, 0)
|
|
nctx.arc(0, 0, radius, 0, 2 * Math.PI)
|
|
|
|
nctx.strokeStyle = "rgba(255, 0, 0, 1)"
|
|
nctx.shadowOffsetX = node.width * 1.5 + 0
|
|
nctx.shadowOffsetY = node.height * 1.5 + 3
|
|
nctx.shadowBlur = 12
|
|
nctx.shadowColor = "rgba(0, 0, 0, 0.16)"
|
|
nctx.stroke()
|
|
nctx.shadowOffsetX = node.width * 1.5 + 0
|
|
nctx.shadowOffsetY = node.height * 1.5 + 3
|
|
nctx.shadowBlur = 12
|
|
nctx.shadowColor = "rgba(0, 0, 0, 0.23)"
|
|
nctx.stroke()
|
|
|
|
nctx.restore()
|
|
nctx.translate(node.width / 2 / scale / r, node.height / 2 / scale / r)
|
|
|
|
nctx.beginPath()
|
|
nctx.moveTo(radius, 0)
|
|
nctx.arc(0, 0, radius, 0, 2 * Math.PI)
|
|
|
|
nctx.strokeStyle = color
|
|
nctx.lineWidth = radius
|
|
nctx.stroke()
|
|
|
|
return node
|
|
}
|
|
|
|
function redraw() {
|
|
var r = window.devicePixelRatio
|
|
var translate = zoomBehavior.translate()
|
|
var scale = zoomBehavior.scale()
|
|
var links = intLinks.filter(visibleLinks)
|
|
|
|
ctx.save()
|
|
ctx.setTransform(1, 0, 0, 1, 0, 0)
|
|
ctx.clearRect(0, 0, canvas.width, canvas.height)
|
|
ctx.restore()
|
|
|
|
ctx.save()
|
|
ctx.translate(translate[0], translate[1])
|
|
ctx.scale(scale, scale)
|
|
|
|
var clientColor = "rgba(230, 50, 75, 1.0)"
|
|
var unknownColor = "#D10E2A"
|
|
var nonUplinkColor = "#F2E3C6"
|
|
var uplinkColor = "#5BAAEB"
|
|
var unseenColor = "#FFA726"
|
|
var highlightColor = "rgba(252, 227, 198, 0.15)"
|
|
var nodeRadius = 6
|
|
var cableColor = "#50B0F0"
|
|
|
|
// -- draw links --
|
|
ctx.save()
|
|
links.forEach(function (d) {
|
|
var dx = d.target.x - d.source.x
|
|
var dy = d.target.y - d.source.y
|
|
var a = Math.sqrt(dx * dx + dy * dy) * 2
|
|
dx /= a
|
|
dy /= a
|
|
|
|
var distancex = d.target.x - d.source.x - (10 * dx)
|
|
var distancey = d.target.y - d.source.y - (10 * dy)
|
|
|
|
ctx.beginPath()
|
|
ctx.moveTo(d.source.x + dx * nodeRadius, d.source.y + dy * nodeRadius)
|
|
ctx.lineTo(d.target.x - (distancex / 2) - dx * nodeRadius, d.target.y - (distancey / 2) - dy * nodeRadius)
|
|
ctx.strokeStyle = d.o.type === "Kabel" ? cableColor : d.color
|
|
ctx.globalAlpha = d.o.isVPN ? 0.1 : 0.8
|
|
ctx.lineWidth = d.o.isVPN ? 1.5 : 2.5
|
|
ctx.stroke()
|
|
})
|
|
|
|
ctx.restore()
|
|
|
|
// -- draw unknown nodes --
|
|
ctx.beginPath()
|
|
unknownNodes.filter(visibleNodes).forEach(function (d) {
|
|
ctx.moveTo(d.x + nodeRadius, d.y)
|
|
ctx.arc(d.x, d.y, nodeRadius, 0, 2 * Math.PI)
|
|
})
|
|
|
|
ctx.strokeStyle = unknownColor
|
|
ctx.lineWidth = nodeRadius
|
|
|
|
ctx.stroke()
|
|
|
|
|
|
// -- draw nodes --
|
|
ctx.save()
|
|
ctx.scale(1 / scale / r, 1 / scale / r)
|
|
|
|
var nonUplinkNode = drawNode(nonUplinkColor, nodeRadius, scale, r)
|
|
nonUplinkNodes.filter(visibleNodes).forEach(function (d) {
|
|
ctx.drawImage(nonUplinkNode, scale * r * d.x - nonUplinkNode.width / 2, scale * r * d.y - nonUplinkNode.height / 2)
|
|
})
|
|
|
|
var uplinkNode = drawNode(uplinkColor, nodeRadius, scale, r)
|
|
uplinkNodes.filter(visibleNodes).forEach(function (d) {
|
|
ctx.drawImage(uplinkNode, scale * r * d.x - uplinkNode.width / 2, scale * r * d.y - uplinkNode.height / 2)
|
|
})
|
|
|
|
var unseenNode = drawNode(unseenColor, nodeRadius, scale, r)
|
|
unseenNodes.filter(visibleNodes).forEach(function (d) {
|
|
ctx.drawImage(unseenNode, scale * r * d.x - unseenNode.width / 2, scale * r * d.y - unseenNode.height / 2)
|
|
})
|
|
|
|
ctx.restore()
|
|
|
|
// -- draw clients --
|
|
ctx.save()
|
|
ctx.beginPath()
|
|
nodes.filter(visibleNodes).forEach(function (d) {
|
|
var clients = d.o.node.statistics.clients
|
|
if (clients === 0)
|
|
return
|
|
|
|
var startDistance = 16
|
|
var radius = 3
|
|
var a = 1.2
|
|
var startAngle = Math.PI
|
|
|
|
for (var orbit = 0, i = 0; i < clients; orbit++) {
|
|
var distance = startDistance + orbit * 2 * radius * a
|
|
var n = Math.floor((Math.PI * distance) / (a * radius))
|
|
var delta = clients - i
|
|
|
|
for (var j = 0; j < Math.min(delta, n); i++, j++) {
|
|
var angle = 2 * Math.PI / n * j
|
|
var x = d.x + distance * Math.cos(angle + startAngle)
|
|
var y = d.y + distance * Math.sin(angle + startAngle)
|
|
|
|
ctx.moveTo(x, y)
|
|
ctx.arc(x, y, radius, 0, 2 * Math.PI)
|
|
}
|
|
}
|
|
})
|
|
|
|
ctx.fillStyle = clientColor
|
|
ctx.fill()
|
|
ctx.restore()
|
|
|
|
// -- draw node highlights --
|
|
if (highlightedNodes.length) {
|
|
ctx.save()
|
|
ctx.shadowColor = "rgba(255, 255, 255, 1.0)"
|
|
ctx.shadowBlur = 10 * nodeRadius
|
|
ctx.shadowOffsetX = 0
|
|
ctx.shadowOffsetY = 0
|
|
ctx.globalCompositeOperation = "lighten"
|
|
ctx.fillStyle = highlightColor
|
|
|
|
ctx.beginPath()
|
|
highlightedNodes.forEach(function (d) {
|
|
ctx.moveTo(d.x + 5 * nodeRadius, d.y)
|
|
ctx.arc(d.x, d.y, 5 * nodeRadius, 0, 2 * Math.PI)
|
|
})
|
|
ctx.fill()
|
|
|
|
ctx.restore()
|
|
}
|
|
|
|
// -- draw link highlights --
|
|
if (highlightedLinks.length) {
|
|
ctx.save()
|
|
ctx.lineWidth = 2 * 5 * nodeRadius
|
|
ctx.shadowColor = "rgba(255, 255, 255, 1.0)"
|
|
ctx.shadowBlur = 10 * nodeRadius
|
|
ctx.shadowOffsetX = 0
|
|
ctx.shadowOffsetY = 0
|
|
ctx.globalCompositeOperation = "lighten"
|
|
ctx.strokeStyle = highlightColor
|
|
ctx.lineCap = "round"
|
|
|
|
ctx.beginPath()
|
|
highlightedLinks.forEach(function (d) {
|
|
ctx.moveTo(d.source.x, d.source.y)
|
|
ctx.lineTo(d.target.x, d.target.y)
|
|
})
|
|
ctx.stroke()
|
|
|
|
ctx.restore()
|
|
}
|
|
|
|
// -- draw labels --
|
|
if (scale > 0.9)
|
|
intNodes.filter(visibleNodes).forEach(drawLabel, scale)
|
|
|
|
ctx.restore()
|
|
}
|
|
|
|
function tickEvent() {
|
|
redraw()
|
|
}
|
|
|
|
function resizeCanvas() {
|
|
var r = window.devicePixelRatio
|
|
canvas.width = el.offsetWidth * r
|
|
canvas.height = el.offsetHeight * r
|
|
canvas.style.width = el.offsetWidth + "px"
|
|
canvas.style.height = el.offsetHeight + "px"
|
|
ctx.setTransform(1, 0, 0, 1, 0, 0)
|
|
ctx.scale(r, r)
|
|
requestAnimationFrame(redraw)
|
|
}
|
|
|
|
function distance(ax, ay, bx, by) {
|
|
return Math.pow(ax - bx, 2) + Math.pow(ay - by, 2)
|
|
}
|
|
|
|
function distancePoint(a, b) {
|
|
return Math.sqrt(distance(a.x, a.y, b.x, b.y))
|
|
}
|
|
|
|
function distanceLink(p, a, b) {
|
|
/* http://stackoverflow.com/questions/849211 */
|
|
|
|
var bx = b.x - ((b.x - a.x) / 2)
|
|
var by = b.y - ((b.y - a.y) / 2)
|
|
|
|
var l2 = distance(a.x, a.y, bx, by)
|
|
|
|
if (l2 === 0)
|
|
return distance(p.x, p.y, a.x, a.y)
|
|
|
|
var t = ((p.x - a.x) * (bx - a.x) + (p.y - a.y) * (by - a.y)) / l2
|
|
|
|
if (t < 0)
|
|
return distance(p.x, p.y, a.x, a.y)
|
|
|
|
if (t > 1)
|
|
return distance(p.x, p.y, bx, by)
|
|
|
|
return Math.sqrt(distance(p.x, p.y, a.x + t * (bx - a.x), a.y + t * (by - a.y) ))
|
|
}
|
|
|
|
function translateXY(d) {
|
|
var translate = zoomBehavior.translate()
|
|
var scale = zoomBehavior.scale()
|
|
|
|
return {x: (d[0] - translate[0]) / scale,
|
|
y: (d[1] - translate[1]) / scale
|
|
}
|
|
}
|
|
|
|
function onClick() {
|
|
if (d3.event.defaultPrevented)
|
|
return
|
|
|
|
var e = translateXY(d3.mouse(el))
|
|
|
|
var nodes = intNodes.filter(function (d) {
|
|
return distancePoint(e, d) < NODE_RADIUS
|
|
})
|
|
|
|
if (nodes.length > 0) {
|
|
router.node(nodes[0].o.node)()
|
|
return
|
|
}
|
|
|
|
var links = intLinks.filter(function (d) {
|
|
return !d.o.isVPN
|
|
}).filter(function (d) {
|
|
return distanceLink(e, d.source, d.target) < LINE_RADIUS
|
|
})
|
|
|
|
if (links.length > 0) {
|
|
router.link(links[0].o)()
|
|
return
|
|
}
|
|
}
|
|
|
|
function zoom(z, scale) {
|
|
var size = getSize()
|
|
var newSize = [size[0] / scale, size[1] / scale]
|
|
|
|
var sidebarWidth = sidebar()
|
|
var delta = [size[0] - newSize[0], size[1] - newSize[1]]
|
|
var translate = z.translate()
|
|
var translateNew = [sidebarWidth + (translate[0] - sidebarWidth - delta[0] / 2) * scale, (translate[1] - delta[1] / 2) * scale]
|
|
|
|
animatePanzoom(translateNew, z.scale() * scale)
|
|
}
|
|
|
|
function keyboardZoom(z) {
|
|
return function () {
|
|
var e = d3.event
|
|
|
|
if (e.altKey || e.ctrlKey || e.metaKey)
|
|
return
|
|
|
|
if (e.keyCode === 43)
|
|
zoom(z, 1.41)
|
|
|
|
if (e.keyCode === 45)
|
|
zoom(z, 1 / 1.41)
|
|
}
|
|
}
|
|
|
|
el = document.createElement("div")
|
|
el.classList.add("graph")
|
|
|
|
zoomBehavior = d3.behavior.zoom()
|
|
.scaleExtent([1 / 3, 3])
|
|
.on("zoom", onPanZoom)
|
|
.translate([sidebar(), 0])
|
|
|
|
canvas = d3.select(el)
|
|
.attr("tabindex", 1)
|
|
.on("keypress", keyboardZoom(zoomBehavior))
|
|
.call(zoomBehavior)
|
|
.append("canvas")
|
|
.on("click", onClick)
|
|
.call(draggableNode)
|
|
.node()
|
|
|
|
ctx = canvas.getContext("2d")
|
|
|
|
force = d3.layout.force()
|
|
.charge(-250)
|
|
.gravity(0.1)
|
|
.linkDistance(function (d) {
|
|
if (d.o.isVPN)
|
|
return 0
|
|
else
|
|
return LINK_DISTANCE
|
|
})
|
|
.linkStrength(function (d) {
|
|
if (d.o.isVPN)
|
|
return 0
|
|
else
|
|
return Math.max(0.5, 1 / d.o.tq)
|
|
})
|
|
.on("tick", tickEvent)
|
|
.on("end", savePositions)
|
|
|
|
window.addEventListener("resize", resizeCanvas)
|
|
|
|
panzoom()
|
|
|
|
self.setData = function (data) {
|
|
var oldNodes = {}
|
|
|
|
intNodes.forEach( function (d) {
|
|
oldNodes[d.o.id] = d
|
|
})
|
|
|
|
intNodes = data.graph.nodes.map( function (d) {
|
|
var e
|
|
if (d.id in oldNodes)
|
|
e = oldNodes[d.id]
|
|
else
|
|
e = {}
|
|
|
|
e.o = d
|
|
|
|
return e
|
|
})
|
|
|
|
var newNodesDict = {}
|
|
|
|
intNodes.forEach( function (d) {
|
|
newNodesDict[d.o.id] = d
|
|
})
|
|
|
|
var oldLinks = {}
|
|
|
|
intLinks.forEach( function (d) {
|
|
oldLinks[d.o.id] = d
|
|
})
|
|
|
|
intLinks = data.graph.links.map( function (d) {
|
|
var e
|
|
if (d.id in oldLinks)
|
|
e = oldLinks[d.id]
|
|
else
|
|
e = {}
|
|
|
|
e.o = d
|
|
e.source = newNodesDict[d.source.id]
|
|
e.target = newNodesDict[d.target.id]
|
|
|
|
if (d.isVPN)
|
|
e.color = "rgba(255, 255, 255, " + (0.6 / d.tq) + ")"
|
|
else
|
|
e.color = linkScale(d.tq).hex()
|
|
|
|
return e
|
|
})
|
|
|
|
linksDict = {}
|
|
nodesDict = {}
|
|
|
|
intNodes.forEach(function (d) {
|
|
d.neighbours = {}
|
|
|
|
if (d.o.node)
|
|
nodesDict[d.o.node.nodeinfo.node_id] = d
|
|
|
|
var name = nodeName(d)
|
|
|
|
var offset = 5
|
|
var lineWidth = 3
|
|
var buffer = document.createElement("canvas")
|
|
var r = window.devicePixelRatio
|
|
var bctx = buffer.getContext("2d")
|
|
bctx.font = "11px Roboto"
|
|
var width = bctx.measureText(name).width
|
|
var scale = zoomBehavior.scaleExtent()[1] * r
|
|
buffer.width = (width + 2 * lineWidth) * scale
|
|
buffer.height = (16 + 2 * lineWidth) * scale
|
|
bctx.scale(scale, scale)
|
|
bctx.textBaseline = "middle"
|
|
bctx.textAlign = "center"
|
|
bctx.fillStyle = "rgba(242, 227, 198, 1.0)"
|
|
bctx.shadowColor = "rgba(0, 0, 0, 1)"
|
|
bctx.shadowBlur = 5
|
|
bctx.fillText(name, buffer.width / (2 * scale), buffer.height / (2 * scale))
|
|
|
|
d.label = buffer
|
|
d.labelWidth = buffer.width / scale
|
|
d.labelHeight = buffer.height / scale
|
|
d.labelA = offset + buffer.width / (2 * scale)
|
|
d.labelB = offset + buffer.height / (2 * scale)
|
|
})
|
|
|
|
intLinks.forEach(function (d) {
|
|
d.source.neighbours[d.target.o.id] = {node: d.target, link: d}
|
|
d.target.neighbours[d.source.o.id] = {node: d.source, link: d}
|
|
|
|
if (d.o.source && d.o.target)
|
|
linksDict[d.o.id] = d
|
|
})
|
|
|
|
intLinks.forEach(function (d) {
|
|
if (linksDict[d.target.o.node_id + "-" + d.source.o.node_id])
|
|
return
|
|
|
|
var obj = { source: d.target, target: d.source, o: { isVPN: d.o.isVPN, type: "dead", id: d.target.o.node_id + "-" + d.source.o.node_id, tq: 1 }, color: "rgba(255, 255, 255, 0.6)" }
|
|
intLinks.push(obj)
|
|
linksDict[d.target.o.node_id + "-" + d.source.o.node_id] = obj
|
|
})
|
|
|
|
intNodes.forEach(function (d) {
|
|
d.neighbours = Object.keys(d.neighbours).map(function (k) {
|
|
return d.neighbours[k]
|
|
})
|
|
})
|
|
|
|
nodes = intNodes.filter(function (d) { return !d.o.unseen && d.o.node })
|
|
uplinkNodes = nodes.filter(function (d) { return d.o.node.flags.uplink })
|
|
nonUplinkNodes = nodes.filter(function (d) { return !d.o.node.flags.uplink })
|
|
unseenNodes = intNodes.filter(function (d) { return d.o.unseen && d.o.node })
|
|
unknownNodes = intNodes.filter(function (d) { return !d.o.node })
|
|
|
|
if (localStorageTest()) {
|
|
var save = JSON.parse(localStorage.getItem("graph/nodeposition"))
|
|
|
|
if (save) {
|
|
var nodePositions = {}
|
|
save.forEach( function (d) {
|
|
nodePositions[d.id] = d
|
|
})
|
|
|
|
intNodes.forEach( function (d) {
|
|
if (nodePositions[d.o.id] && (d.x === undefined || d.y === undefined)) {
|
|
d.x = nodePositions[d.o.id].x
|
|
d.y = nodePositions[d.o.id].y
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
var diameter = graphDiameter(intNodes)
|
|
|
|
force.nodes(intNodes)
|
|
.links(intLinks)
|
|
.size([diameter, diameter])
|
|
|
|
updateHighlight(true)
|
|
|
|
force.start()
|
|
resizeCanvas()
|
|
}
|
|
|
|
self.resetView = function () {
|
|
highlight = undefined
|
|
updateHighlight()
|
|
doAnimation = true
|
|
}
|
|
|
|
self.gotoNode = function (d) {
|
|
highlight = {type: "node", o: d}
|
|
updateHighlight()
|
|
doAnimation = true
|
|
}
|
|
|
|
self.gotoLink = function (d) {
|
|
highlight = {type: "link", o: d}
|
|
updateHighlight()
|
|
doAnimation = true
|
|
}
|
|
|
|
self.destroy = function () {
|
|
force.stop()
|
|
canvas.remove()
|
|
force = null
|
|
|
|
if (el.parentNode)
|
|
el.parentNode.removeChild(el)
|
|
}
|
|
|
|
self.render = function (d) {
|
|
d.appendChild(el)
|
|
resizeCanvas()
|
|
updateHighlight()
|
|
}
|
|
|
|
return self
|
|
}
|
|
})
|