blob: c6a8210bcda2f915c9ae9025b3f9eb239b76e51d [file] [log] [blame]
<!DOCTYPE html>
<!--
~ Copyright 2014 Open Networking Laboratory
~
~ 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.
-->
<!--
Testing transformations for transitioning between overhead and
perspective projections of two layers.
@author Simon Hunt
-->
<html>
<head>
<meta charset="utf-8">
<title>Layer Transformations</title>
<script src="../tp/d3.js"></script>
<script src="../tp/jquery-2.1.1.min.js"></script>
<style>
html,
body {
background-color: #ccc;
font-family: Arial, Helvetica, sans-serif;
font-size: 9pt;
}
svg {
position: absolute;
background-color: #fff;
top: 30px;
left: 60px;
}
svg text {
font-size: 3pt;
}
</style>
</head>
<body>
<svg width="1000px" height="600px" viewBox="0 0 160 120"></svg>
<script>
(function (){
// Configuration...
var w = 160,
h = 120,
time = 1500;
var pktData = [
[20,60,'a'],
[60,20,'b'],
[100,20,'c'],
[140,60,'d'],
[100,100,'e'],
[60,100,'f'],
[20,20,'w'],
[140,20,'x'],
[20,100,'y'],
[140,100,'z']
],
optData = [
[40,40,'p'],
[120,40,'q'],
[120,80,'r'],
[40,80,'s'],
[20,20,'j'],
[140,20,'k'],
[20,100,'l'],
[140,100,'m']
],
linkData = [
['a','p'],
['p','b'],
['b','c'],
['c','q'],
['q','d'],
['d','r'],
['r','e'],
['e','f'],
['f','s'],
['s','a'],
['s','q'],
['p','r'],
['b','f'],
['c','e'],
['w','j'],
['x','k'],
['z','m'],
['y','l']
];
// Transform parameters
var tf = {
tt: -.7, // x skew y factor
xsk: -35, // x skew angle
ysc: 0.5, // y scale
ytr: 50, // y translate
pad: 5
},
rectFill = {
pkt: 'rgba(130,130,170,0.3)',
opt: 'rgba(170,130,170,0.3)'
};
// Internal state...
var nodes = [],
links = [],
overhead = true,
xffn;
// D3/DOM magic...
var svg = d3.select('svg'),
nodeG,
linkG,
node,
link,
force,
pktLayer,
optLayer;
// General functions ...
function isF(f) {
return $.isFunction(f) ? f : null;
}
function translate(x,y) {
return 'translate(' + x + ',' + y + ')';
}
function scale(x,y) {
return 'scale(' + x + ',' + y + ')';
}
function skewX(x) {
return 'skewX(' + x + ')';
}
// Key Bindings...
var keyHandler = {
T: transform
};
function whatKey(code) {
switch (code) {
case 13: return 'enter';
case 16: return 'shift';
case 17: return 'ctrl';
case 18: return 'alt';
case 27: return 'esc';
case 32: return 'space';
case 37: return 'leftArrow';
case 38: return 'upArrow';
case 39: return 'rightArrow';
case 40: return 'downArrow';
case 91: return 'cmdLeft';
case 93: return 'cmdRight';
case 187: return 'equals';
case 189: return 'dash';
case 191: return 'slash';
default:
if ((code >= 48 && code <= 57) ||
(code >= 65 && code <= 90)) {
return String.fromCharCode(code);
} else if (code >= 112 && code <= 123) {
return 'F' + (code - 111);
}
return '.';
}
}
function keyIn() {
var event = d3.event,
keyCode = event.keyCode,
key = whatKey(keyCode),
fn = isF(keyHandler[key]);
if (fn) {
fn(key, keyCode, event);
}
}
// Key events....
function transform() {
overhead = !overhead;
if (overhead) {
toOverhead();
} else {
toOblique();
}
}
function toOverhead() {
xffn = null;
hidePlane(pktLayer);
hidePlane(optLayer);
transitionNodes();
}
function padBox(box, p) {
box.x -= p;
box.y -= p;
box.width += p*2;
box.height += p*2;
}
function toOblique() {
var box = nodeG.node().getBBox();
padBox(box, tf.pad);
xffn = function (xy, dir) {
var x = xy.x + xy.y*tf.tt,
y = xy.y*tf.ysc + tf.ysc*tf.ytr*dir;
return { x: x, y: y};
};
showPlane(pktLayer, box, -1);
showPlane(optLayer, box, 1);
transitionNodes();
}
function transitionNodes() {
// note: turn off force layout while transitioning.. if it is on
// force.stop();
if (xffn) {
nodes.forEach(function (d) {
var dir = d.type === 'pkt' ? -1 : 1,
oldxy = {x: d.x, y: d.y},
coords = xffn(oldxy, dir);
d.oldxy = oldxy;
d.x = coords.x;
d.y = coords.y;
});
} else {
nodes.forEach(function (d) {
d.x = d.oldxy.x;
d.y = d.oldxy.y;
delete d.oldxy;
});
}
nodeG.selectAll('.node')
.transition()
.duration(time)
.attr({
transform: function (d) {
return translate(d.x, d.y);
}
});
linkG.selectAll('.link')
.transition()
.duration(time)
.attr({
x1: function (d) { return d.source.x; },
y1: function (d) { return d.source.y; },
x2: function (d) { return d.target.x; },
y2: function (d) { return d.target.y; }
});
}
function showPlane(layer, box, dir) {
layer.select('rect')
.attr(box)
.attr('opacity', 0)
.transition()
.duration(time)
.attr('opacity', 1)
.attr('transform', obliqueXform(dir));
}
function hidePlane(layer) {
var rect = layer.select('rect');
rect.transition()
.duration(time)
.attr('opacity', 0)
.attr('transform', overheadXform());
}
function obliqueXform(dir) {
return scale(1, tf.ysc) + translate(0, dir * tf.ytr) + skewX(tf.xsk);
}
function overheadXform() {
return skewX(0) + translate(0,0) + scale(1,1);
}
// Nodes and Links...
function prepareNodes() {
var hw = w/2,
hh = h/2;
function addNode(t, d) {
nodes.push({
type: t,
x: d[0] - hw,
y: d[1] - hh,
id: d[2],
fixed: true
});
}
optData.forEach(function (d) {
addNode('opt', d);
});
pktData.forEach(function (d) {
addNode('pkt', d);
});
}
function findNode(id) {
for (var i=0,n=nodes.length; i<n; i++) {
if (nodes[i].id === id) {
return nodes[i];
}
}
return null;
}
function prepareLinks() {
linkData.forEach(function (d) {
var src = d[0],
dst = d[1];
links.push({
id: src + '-' + dst,
source: findNode(src),
target: findNode(dst)
});
});
}
function updateNodes() {
node = nodeG.selectAll('.node')
.data(nodes, function (d) { return d.id; });
var entering = node.enter()
.append('g').attr({
id: function (d) { return d.id; },
'class': function (d) { return 'node ' + d.type; }
});
entering.each(function (d) {
var el = d3.select(this);
d.el = el;
el.append('rect').attr({
width: 5,
height: 5,
fill: function (d) {
return d.type === 'pkt' ? '#669' : '#969';
},
rx: 1,
transform: 'translate(-2.5,-2.5)'
});
el.append('text')
.text(d.id)
.attr({
dy: '0.9em',
'text-anchor': 'middle',
transform: 'translate(0,-2.5)',
fill: 'white'
});
});
}
function updateLinks() {
link = linkG.selectAll('.link')
.data(links, function (d) { return d.id; });
var entering = link.enter()
.append('line').attr({
id: function (d) { return d.id; },
class: 'link',
stroke: '#888',
'stroke-width': 0.4,
opacity: 0.7
});
entering.each(function (d) {
d.el = d3.select(this);
});
}
function update() {
updateNodes();
updateLinks();
}
var ntick = 0;
function tick() {
console.log('tick ' + (++ntick));
node.attr({
transform: function (d) { return translate(d.x, d.y); }
});
link.attr({
x1: function (d) { return d.source.x; },
y1: function (d) { return d.source.y; },
x2: function (d) { return d.target.x; },
y2: function (d) { return d.target.y; }
});
}
function setOrigin(/*varargs*/) {
var i, n, g;
for (i= 0,n=arguments.length; i< n; i++) {
g = arguments[i];
g.attr('transform', translate(w/2, h/2));
}
}
function initLayers() {
optLayer.attr('class', 'layer').append('rect')
.attr('fill', rectFill.opt);
pktLayer.attr('class', 'layer').append('rect')
.attr('fill', rectFill.pkt);
}
function init() {
svg.append('text')
.text('Press the "T" key....')
.attr({ dy: '1.2em', fill: '#999'})
.style('font-size', '2.4pt')
.style('font-style', 'italic');
optLayer = svg.append('g').attr('id', 'optLayer');
pktLayer = svg.append('g').attr('id', 'pktLayer');
linkG = svg.append('g').attr('id', 'links');
nodeG = svg.append('g').attr('id', 'nodes');
setOrigin(optLayer, pktLayer, linkG, nodeG);
node = nodeG.selectAll('.node');
link = linkG.selectAll('.link');
initLayers();
prepareNodes();
prepareLinks();
force = d3.layout.force()
.size([w,h])
.nodes(nodes)
.links(links)
.gravity(0.4)
.friction(0.7)
.on('tick', tick);
update();
tick();
d3.select('body').on('keydown', keyIn);
}
init();
})();
</script>
</body>
</html>