After almost 3 years (see previous post) I revisit the topic this time using the latest version og Glassfish 3.1.2 and GoDaddy as certificate provider. I created a certificate for a sub-domain (sub.whateverdomain.com) this time and make use of the extremly cheap 5.99 U$/year offer (no wildcard included)
Let me summarize the key steps here: Continue reading
Some visualizations seem to be more sophisticated (to implement) than they actual are, specifically the radial projections. Starting from a tree representation with nodes and links it is quite easy to get to the radial version.
Remark: Of course there are more challenging radial diagrams like the bundle, but lets get started with something simple first !
“Standard” Tree
(I added few more nodes to make the visual difference more obvious)
Tree Visualization
We change 1 line of our sourcecode (see previous tutorial for complete code):
var tree = d3.layout.tree().size([300,300]); to var tree = d3.layout.cluster().size([300,300]);
In order to understand the physics of various visualizations I walk through the samples and gists I find, dissect them and strip them down to the bare minimum. From there I explore my own variations. I took Mike’s sample for a stacked bar chart and changed it to chart reading from a matrix instead of the csv file.
Stacked Bar Chart
The matrix object
var matrix = [
[ 1, 5871, 8916, 2868],
[ 2, 10048, 2060, 6171],
[ 3, 16145, 8090, 8045],
[ 4, 990, 940, 6907],
[ 5, 450, 430, 5000]
];
The stack layout expects an object with an array of objects, each member of the array represents the values of one value group (eg. “all dark blue values”), and each object contains x and y value. It will process theis array amnd a y0 value (the offset to the baseline).
You can see this if you run the below code with the console.log output.
Console
<!DOCTYPE html>
<html>
<head>
<title>Simple Stack</title>
<script type="text/javascript" src="libnew/d3.v2.min.js"></script>
<style>
svg {
border: solid 1px #ccc;
font: 10px sans-serif;
shape-rendering: crispEdges;
}
</style>
</head>
<body>
<div id="viz"></div>
<script type="text/javascript">
var w = 960,
h = 500
// create canvas
var svg = d3.select("#viz").append("svg:svg")
.attr("class", "chart")
.attr("width", w)
.attr("height", h )
.append("svg:g")
.attr("transform", "translate(10,470)");
x = d3.scale.ordinal().rangeRoundBands([0, w-50])
y = d3.scale.linear().range([0, h-50])
z = d3.scale.ordinal().range(["darkblue", "blue", "lightblue"])
console.log("RAW MATRIX---------------------------");
// 4 columns: ID,c1,c2,c3
var matrix = [
[ 1, 5871, 8916, 2868],
[ 2, 10048, 2060, 6171],
[ 3, 16145, 8090, 8045],
[ 4, 990, 940, 6907],
[ 5, 450, 430, 5000]
];
console.log(matrix)
console.log("REMAP---------------------------");
var remapped =["c1","c2","c3"].map(function(dat,i){
return matrix.map(function(d,ii){
return {x: ii, y: d[i+1] };
})
});
console.log(remapped)
console.log("LAYOUT---------------------------");
var stacked = d3.layout.stack()(remapped)
console.log(stacked)
x.domain(stacked[0].map(function(d) { return d.x; }));
y.domain([0, d3.max(stacked[stacked.length - 1], function(d) { return d.y0 + d.y; })]);
// show the domains of the scales
console.log("x.domain(): " + x.domain())
console.log("y.domain(): " + y.domain())
console.log("------------------------------------------------------------------");
// Add a group for each column.
var valgroup = svg.selectAll("g.valgroup")
.data(stacked)
.enter().append("svg:g")
.attr("class", "valgroup")
.style("fill", function(d, i) { return z(i); })
.style("stroke", function(d, i) { return d3.rgb(z(i)).darker(); });
// Add a rect for each date.
var rect = valgroup.selectAll("rect")
.data(function(d){return d;})
.enter().append("svg:rect")
.attr("x", function(d) { return x(d.x); })
.attr("y", function(d) { return -y(d.y0) - y(d.y); })
.attr("height", function(d) { return y(d.y); })
.attr("width", x.rangeBand());
</script>
</body>
</html>
My gist: bl.ocks.org/2940908
Based on the previews experiments you will get a flat array with all selected elements.
d3.selectAll("tbody td");
Selection
Using a chained (nested) selection
d3.selectAll("tbody tr").selectAll("td");
we get matrix of cells
Nested Selection
Now we are in full control and can manipulate eg. the color of specific cells and rows
var td = d3.selectAll("tbody tr").selectAll("td");
td.style("color", function(d, i, j) { return (j<2 && i<2) ? null : "red"; });
Nested Selection
One should have a good understanding of selections, it is worth playing with a sandbox and explore the various options you have. I adopted the tutorial from Mike here.
Lets assume we have a simple HTML table:
<!DOCTYPE html>
<html>
<head>
<title>Selections</title>
<script type="text/javascript" src="lib/d3.v2.min.js"></script>
</head>
<body>
<table>
<thead>
<tr><td> A</td><td> B</td><td> C</td><td> D</td></tr>
</thead>
<tbody>
<tr><td> 0</td><td> 1</td><td> 2</td><td> 3</td></tr>
<tr><td> 4</td><td> 5</td><td> 6</td><td> 7</td></tr>
<tr><td> 8</td><td> 9</td><td> 10</td><td> 11</td></tr>
<tr><td> 12</td><td> 13</td><td> 14</td><td> 15</td></tr>
</tbody>
</table>
<script type="text/javascript">
//nothing yet
</script>
</body>
</html>
HTML table
A slightly adopted version using SVG. A form to control radius of randomly drawn circles.
<!DOCTYPE html>
<html>
<head>
<title>Hello, data!</title>
<script type="text/javascript" src="lib/d3.js"></script>
</head>
<body>
<form name="myform" onSubmit="return handleClick()">
<input name="Submit" type="submit" value="Radius" />
<input type="text" id="myRadius"/>
</form>
<div id="viz"></div>
<script type="text/javascript">
var mySVG = d3.select("#viz")
.append("svg:svg")
.attr("width", 600)
.attr("height", 400);
function handleClick(event){
console.log(document.getElementById("myRadius").value)
draw(document.getElementById("myRadius").value)
return false;
}
function draw(rad){
mySVG.append("svg:circle")
.style("stroke", "black")
.style("fill", "grey")
.attr("r", rad)
.attr("cx", Math.round(Math.random()*600))
.attr("cy", Math.round(Math.random()*400))
}
</script>
</body>
</html>
SVG circles
On the journey to learn d3.js it is most important to understand the basic principles first, but once you got your hands dirty, thanks to lots of samples, you want make data ‘speak’. The available samples refer to static data sitting in variables or coming from a json or csv files, sooner or later you want to feed data dynamic into your visualization. In this very simple sample we want values from a form sitting on the same html page to be added to a list, as simple as no svg involved.
<!DOCTYPE html>
<html>
<head>
<title>Hello, data!</title>
<script type="text/javascript" src="lib/d3.js"></script>
</head>
<body>
<form name="myform" onSubmit="return handleClick()">
<input name="Submit" type="submit" value="Add Value" />
<input type="text" id="myVal"/>
</form>
<p></p>
<p></p>
<p></p>
<p></p>
<p></p>
<script type="text/javascript">
var dataset = [];
for(i=0; i<5; i++){
dataset.push(Math.round(Math.random()*50));
}
var p = d3.select("body").selectAll("p")
.data(dataset)
.text(function(d,i){return i + " : " + d;});
function handleClick(event){
console.log(document.getElementById("myVal").value)
draw(document.getElementById("myVal").value)
return false;
}
function draw(val){
d3.select("body").append("p");
dataset.push(val);
var p = d3.select("body").selectAll("p")
.data(dataset)
.text(function(d,i){return i + " : " + d;})
}
</script>
</body>
</html>
Dynamic Data
In the next step we will play with some svg, from there I will explore ZK feeding a visualization from a DB or any other feed.
Even we do development in Netbeans, we still can use the Eclipse plugin to ‘draw’ our processes.
JBoss Drools is more than Expert and Guvnor only, the suite of products also offers Fusion, Planner and Flow (now called jBPM). After getting my hands with dirty with Expert, I want to look at the Fusion part, which covers the event handling. Based on CEP (Complex Event Processing) as an event-driven architecture which is an own science by itself, whole books written about nothing else than events (link).
There is not much information on the web about Fusion other than the JBoss documentation, some chapters in Books (Packt Publishing: Drools 5 Developer Guide, Drools Cookbook) and a handful of blog entries (link), practically no working samples or end-to-end tutorials.
In this tutorial we will apply the necessary changes to our HelloDrools project from the previous tutorial:
import hellodrools.Message
rule "Hello World"
when
message:Message (type=="Hello")
then
System.out.println("Hello World, Drools!");
end
At the ‘hello world’ level we cant see much need to debug our rules, but with growing complexity we will be challenged quickly. We need to see which rules was fired, what parameter, what object, etc. Eclipse IDE users have the advantage of the plugin which even visualizes the RETE tree, for the rest-of-us, aka Netbeans user, we need to rely on the debugging output available. We have 4 options that give us access to almost all information of interest.
To try the below debugging options, use the previous HelloDrools Tutorial
Out-of-the-box we can use 2 debug event listener:
...
ksession = kbase.newStatefulKnowledgeSession();
ksession.addEventListener( new DebugAgendaEventListener() );
ksession.addEventListener( new DebugWorkingMemoryEventListener() );
...
