--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/annot-server/static/js/annotviz.js	Thu Jan 22 09:29:49 2015 +0100
@@ -0,0 +1,1278 @@
+!function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var n;"undefined"!=typeof window?n=window:"undefined"!=typeof global?n=global:"undefined"!=typeof self&&(n=self),n.annotviz=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
+/**
+ * scripts/main.js
+ *
+ * This is the starting point for your application.
+ * Take a look at http://browserify.org/ for more info
+ */
+
+'use strict';
+
+var doubleroll = require('./doubleroll');
+var annotsroll = require('./annotsroll');
+var annotstimeline = require('./annotstimeline');
+var annotsvizview = require('./annotsvizview');
+var stageview = require('./stageview');
+var wswrapper = require('./wswrapper');
+var logger = require('./logger');
+
+var _ = require('lodash');
+
+module.exports = _({})
+    .extend(doubleroll)
+    .extend(annotsroll)
+    .extend(annotstimeline)
+    .extend(annotsvizview)
+    .extend(stageview)
+    .extend(wswrapper)
+    .extend(logger)
+    .value();
+},{"./annotsroll":2,"./annotstimeline":3,"./annotsvizview":4,"./doubleroll":5,"./logger":6,"./stageview":8,"./wswrapper":10,"lodash":"lodash"}],2:[function(require,module,exports){
+/**
+* js/annotsRoll.js
+*
+* annotsRoll basic component
+*
+*/
+
+'use strict';
+
+var PIXI = require('pixi');
+var _ = require('lodash');
+
+var DEFAULT_ANNOT_COLOR = '#bababa';
+
+var defaultAnnotStyles = {
+    'label': { font: '16pt Arial Bold', fill: '#65A954', wordWrap: true},
+    'text' : { font: '12pt Arial Regular', fill: '#444444', wordWrap: true},
+    'user' : { font: '14pt Arial regular', fill: '#666666' },
+};
+
+var defaultOptions = {
+    externalRefresh: false,
+    defaultColor: DEFAULT_ANNOT_COLOR,
+    annotStyles: defaultAnnotStyles
+};
+
+function AnnotsRoll(options) {
+
+//parentContainer, xInit, yInit, width, height, widthRoll, pixelsPerSecond, annotColors
+    var _this = this;
+    var opts = _(options).defaults(defaultOptions).value();
+
+
+    this.container = new PIXI.DisplayObjectContainer();
+    this.container.x = opts.xInit;
+    this.container.y = opts.yInit;
+    this.container.width = opts.width;
+
+    this.height = opts.height;
+    this.width = opts.width;
+    this.widthRoll = opts.widthRoll;
+    this.pixelsPerSecond = opts.pixelsPerSecond;
+    this.annotColors = opts.annotColors;
+    this.startTs = options.startTs || Date.now();
+
+    var yInit = opts.yInit;
+    var annotStyles = _(opts.annotStyles).defaults(defaultAnnotStyles).value();
+    for(var style in annotStyles) {
+    	if (annotStyles[style].wordWrap === true){
+    		annotStyles[style].wordWrapWidth = this.widthRoll;
+    	}
+    }
+    var started = false;
+    var ws = opts.ws;
+    var externalRefresh = opts.externalRefresh;
+    var stageView = opts.stageView;
+
+    stageView.registerComponent(this);
+
+    var isHidden = function(child) {
+        // TODO: the origin point is an approximation. Should refine this
+        var globalPos = child.toGlobal(new PIXI.Point(0,0));
+        return ((globalPos.x + child.width) < 0) || ((globalPos.y + child.height) < 0) ;
+    };
+
+    this.addAnnots = function(data) {
+
+        //var title = data.content.category.label;
+        //var user = data.content.user;
+        //Test cat and color
+        //var colorAnnot = 0x65A954;
+        var category = data.content.category.label,
+            text     = data.content.text,
+            user     = data.content.user,
+            ts       = Date.parse(data.ts),
+            color    = data.content.color || this.getColor(ts, data.content.category.code);
+
+        this.addAnnot(category, text, user, color, ts);
+    };
+
+    this.getColor = function(ts, code) {
+        var colorsDef;
+        _(this.annotColors).eachRight(function(cdef) {
+            console.log("cDef", cdef);
+            console.log("cDef ts", cdef.ts, ts);
+            if(cdef.ts < ts) {
+                colorsDef = cdef.colors;
+                return false;
+            }
+        });
+        var resColor;
+        console.log("colorsDef", colorsDef);
+        if(colorsDef) {
+            resColor = colorsDef[code];
+        }
+        if(!resColor) {
+            resColor = DEFAULT_ANNOT_COLOR;
+        }
+        return resColor;
+    }
+
+    this.addAnnot = function(category, text, user, catColor, ts){
+
+        var color = catColor ? catColor : DEFAULT_ANNOT_COLOR;
+        var x = 0;
+        var y = (ts-this.startTs) * this.pixelsPerSecond / 1000 + yInit;
+
+        var colorHex = parseInt(color.replace(/^#/, ''), 16);
+
+        var graphics = new PIXI.Graphics()
+            .beginFill(colorHex)
+            .drawRect(x, y, 10, 3)
+            .endFill();
+
+        this.container.addChild(graphics);
+
+        var textHeight = 0;
+        var catLabel = new PIXI.Text(
+            category,
+            _(annotStyles.label).extend({fill: color}).value()
+        );
+        catLabel.x = x + 20;
+        catLabel.y = y - 23;
+        this.container.addChild(catLabel);
+        textHeight += (catLabel.height - 23 + 2);
+
+        if(text) {
+            var catText = new PIXI.Text(text, annotStyles.text);
+            catText.x = x + 20;
+            catText.y = y + 2;
+            this.container.addChild(catText);
+            textHeight += (catText.height + 2);
+        }
+
+        var catUser = new PIXI.Text(user, annotStyles.user);
+        catUser.x = x + 20;
+        catUser.y = y + 2 + textHeight;
+        this.container.addChild(catUser);
+
+        this.addAnnotLine(colorHex, y);
+    };
+
+    this.addAnnotLine = function(color, y) {
+        var x = this.widthRoll;
+
+
+        var graphics = new PIXI.Graphics()
+            .beginFill(color)
+            .drawRect(x, y, this.width - x, 3)
+            .endFill();
+
+        this.container.addChild(graphics);
+    };
+
+    this.moveTo = function(diffTime){
+    	this.container.y = Math.floor(diffTime*this.pixelsPerSecond);
+    };
+
+    this.move = this.refresh = function() {
+        var diff = (this.startTs - Date.now())/1000;
+        this.moveTo(diff);
+    };
+
+    this.removePassedObjets = function(){
+        var childrenToRemove = [];
+        _(_this.container.children).forEach(function(child) {
+            return typeof(child) === 'undefined' ||
+                (isHidden(child) && childrenToRemove.push(child));
+        });
+        childrenToRemove.forEach(function(child) {
+            _this.container.removeChild(child);
+        });
+    };
+
+    this.init = function() {
+
+        ws.message(function(data) {
+            _this.addAnnots(data);
+        });
+
+    };
+
+    this.start = function() {
+        if(!started) {
+            this.startTs = Date.now();
+            started = true;
+        }
+        this.cleanInterval = setInterval(function () { _this.removePassedObjets(); }, 1000 * this.height / this.pixelsPerSecond );
+        if(!externalRefresh) {
+            this.refreshInterval = setInterval(function() {_this.move();}, 1000/this.framerate);
+        }
+    };
+
+    this.stop = function() {
+        clearInterval(this.cleanInterval);
+        if(!externalRefresh) {
+            clearInterval(this.refreshInterval);
+        }
+    };
+
+}
+
+module.exports = {
+    AnnotsRoll: AnnotsRoll,
+};
+
+},{"lodash":"lodash","pixi":"pixi"}],3:[function(require,module,exports){
+/**
+* js/annotstimeline
+*
+* annotstimeline basic component
+*
+*/
+
+'use strict';
+
+var PIXI = require('pixi');
+var Utils = require('./utils.js');
+var _ = require('lodash');
+
+var defaultOptions = {
+    logger: undefined,
+    intervalWidth: 10,
+    intervalHeight: 5,
+    maxCellHeight: 200,
+    radius: 300
+};
+
+
+function AnnotsTimeLine(options){
+    var _this = this;
+    var opts = _(options).defaults(defaultOptions).value();
+
+    this.container = new PIXI.DisplayObjectContainer();
+    this.container.x = opts.xInit;
+    this.container.y = opts.yInit;
+    this.container.width = opts.width;
+    this.container.height = opts.height;
+
+    this.timeBegin = opts.timeBegin;
+    this.timeEnd = opts.timeEnd;
+    this.duration = (this.timeEnd - this.timeBegin)/1000;
+    this.width = opts.width;
+    this.height = opts.height;
+    this.intervalHeight = opts.intervalHeight;
+    this.intervalWidth = opts.intervalWidth;
+    this.maxCellHeight = opts.maxCellHeight;
+    this.annotCategories = opts.annotCategories;
+
+    this.circleX = opts.circleX || (this.width/2);
+    this.circleY = opts.circleY || (this.height/2);
+    this.radius = opts.radius;
+    this.perimeter = 2*Math.PI* this.radius;
+    this.intervalDuration = (this.intervalWidth * this.duration / this.perimeter);
+
+    var currentTime = this.timeBegin;
+    var totalIndex = Math.floor(this.perimeter/this.intervalWidth);
+
+    this.cells = []
+    for (var i=0; i<(this.perimeter/this.intervalWidth) ; i++){
+    	this.cells[i] = [];
+    	this.cells[i].i = i;
+    	this.cells[i].totalAnnots = 0;
+    	this.cells[i].categories = {};
+
+    	for (var category in this.annotCategories[0].colors){
+    		this.cells[i].categories[category] = {
+				"count": 0,
+				"color": this.annotCategories[0].colors[category]
+    		};
+    	}
+    }
+
+    var ws = opts.ws;
+    var stageView = opts.stageView;
+
+    //draw the base - circle and line to locate the scene
+    var graphics = new PIXI.Graphics();
+    graphics.lineStyle(2, 0x646464)
+    	.drawCircle(this.circleX, this.circleY, this.radius - 3)
+    	.lineStyle(1, 0xD7D7D7)
+    	.drawCircle(this.circleX, this.circleY, this.radius*2/3)
+    	.drawCircle(this.circleX, this.circleY, this.radius/3)
+    	.lineStyle(1, 0x646464)
+    	.moveTo(this.circleX, this.circleY - (this.radius/3)/2)
+    	.lineTo(this.circleX, this.circleY - this.radius - this.maxCellHeight - 10)
+    	.endFill()
+    this.container.addChild(graphics);
+
+    //set time text
+    //TODO : move this to annotsvizview
+    var currentTimeText = new PIXI.Text("-- : -- : --", { font: '18pt Gothic Standard', fill: '#646464' });
+    currentTimeText.x = this.circleX - currentTimeText.width/2;
+    currentTimeText.y = this.circleY - currentTimeText.height/2;
+    this.container.addChild(currentTimeText);
+
+    stageView.registerComponent(this);
+
+    //Add Annotation to the TimeLine
+    this.addAnnot = function(data){
+    	if (typeof(this.annotCategories[0].colors[data.content.category.code]) !== 'undefined'){
+    		var annotCode = data.content.category.code;
+    	} else {
+    		var annotCode = this.annotCategories[0].order[this.annotCategories[0].order.length -1];
+    	}
+    	var annotTime = Date.parse(data.ts);
+
+    	if (this.timeEnd > Date.parse(data.ts)){
+	    	var i = Math.floor((Date.parse(data.ts)-this.timeBegin)/(1000*this.intervalDuration));
+
+			this.cells[i].categories[annotCode].count += 1;
+			this.cells[i].totalAnnots +=1;
+			this.redrawCell(this.cells[i], i);
+    	}
+    };
+
+    this.initGraphics = function(cell){
+    	cell.graphics = new PIXI.Graphics();
+    	cell.graphics.position.x = this.circleX + this.radius * Math.sin(cell.i*(360/totalIndex)*(Math.PI/180));
+    	cell.graphics.position.y = this.circleY - this.radius * Math.cos(cell.i*(360/totalIndex)*(Math.PI/180));
+    	cell.graphics.rotation = (cell.i)*(360/totalIndex)*(Math.PI/180) + (360/(totalIndex*2))*(Math.PI/180);
+    	this.container.addChild(cell.graphics);
+    }
+
+    this.initTimeTexts = function() {
+	    var tBeg = new PIXI.Text(Utils.formatTime(this.timeBegin), { font: '12pt Gothic Standard', fill: '#646464' });
+	    tBeg.x = this.circleX + 15;
+	    tBeg.y = this.circleY - this.radius - this.maxCellHeight - 10;
+	    this.container.addChild(tBeg);
+
+	    var tEnd = new PIXI.Text(Utils.formatTime(this.timeEnd), { font: '12pt Gothic Standard', fill: '#646464' });
+	    tEnd.x = this.circleX - 15 - tEnd.width;
+	    tEnd.y = this.circleY - this.radius - this.maxCellHeight - 10;
+	    this.container.addChild(tEnd);
+
+	    var t15 = new PIXI.Text(Utils.formatTime(((this.timeEnd - this.timeBegin)/4) + this.timeBegin), { font: '12pt Gothic Standard', fill: '#646464' });
+	    t15.x = this.circleX + this.radius + this.maxCellHeight + 10 ;
+	    t15.y = this.circleY - t15.height;
+	    t15.rotation = Math.PI /2;
+	    this.container.addChild(t15);
+
+	    var t30 = new PIXI.Text(Utils.formatTime(((this.timeEnd - this.timeBegin)/2) + this.timeBegin), { font: '12pt Gothic Standard', fill: '#646464' });
+	    t30.x = this.circleX - t30.width/2;
+	    t30.y = this.circleY + this.radius + this.maxCellHeight - 2;
+	    this.container.addChild(t30);
+
+	    var t45 = new PIXI.Text(Utils.formatTime(((this.timeEnd - this.timeBegin)*3/4) + this.timeBegin), { font: '12pt Gothic Standard', fill: '#646464' });
+	    t45.x = this.circleX - this.radius - this.maxCellHeight - 10 ;
+	    t45.y = this.circleY + t15.height;
+	    t45.rotation = -Math.PI/2;
+	    this.container.addChild(t45);
+    }
+
+    //Draw the cellule
+    this.redrawCell = function(cell){
+
+    	if (typeof(cell.graphics) === 'undefined'){
+    		this.initGraphics(cell);
+    	} else {
+    		cell.graphics.clear();
+    	}
+
+    	var y = 0;
+
+    	//Check if total height is higher than Max Cell Height
+    	if ((cell.totalAnnots*this.intervalHeight) > this.maxCellHeight){
+    		var heightStep = this.maxCellHeight/cell.totalAnnots;
+    	} else {
+    		var heightStep = this.intervalHeight;
+    	}
+
+    	//Draw the rect depending on the height step calculated
+    	for (var i=0; i< this.annotCategories[0].order.length; i++){
+    		var currentCode = this.annotCategories[0].order[i];
+			cell.graphics.beginFill(cell.categories[currentCode].color.replace("#", "0x"))
+    			.drawRect(0, y, this.intervalWidth-1, -cell.categories[currentCode].count * heightStep)
+    			.endFill();
+    		y -= cell.categories[currentCode].count*heightStep;
+    	}
+    }
+
+    this.init = function() {
+    	ws.message(function(data) {
+            _this.addAnnot(data);
+        });
+
+    	this.initTimeTexts();
+    };
+
+    this.updateTime = function(){
+    	currentTime += 1000;
+
+        var nbSec = currentTime / 1000;
+        var hours = Math.floor( nbSec / 3600 ) % 24;
+        var minutes = Math.floor( nbSec / 60 ) % 60;
+        var seconds = Math.floor(nbSec % 60);
+        var timeStr = (hours < 10 ? '0' + hours : hours) + ':' + (minutes < 10 ? '0' + minutes : minutes) + ':' + (seconds  < 10 ? '0' + seconds : seconds);
+
+        currentTimeText.setText(timeStr);
+    };
+
+    var refreshTimeInterval;
+
+    this.start = function() {
+    	refreshTimeInterval = setInterval(function() {_this.updateTime();}, 1000);
+    };
+
+    this.refresh = function() {
+
+    };
+
+    this.stop = function(){
+    	console.log(this.cells);
+    };
+
+    return this;
+}
+
+module.exports = {
+	AnnotsTimeLine: AnnotsTimeLine
+};
+
+},{"./utils.js":9,"lodash":"lodash","pixi":"pixi"}],4:[function(require,module,exports){
+/**
+* js/annotsvizview.js
+*
+* This is the starting point for your application.
+* Take a look at http://browserify.org/ for more info
+*/
+
+'use strict';
+
+var PIXI = require('pixi');
+var _ = require('lodash');
+var DoubleRoll = require('./doubleroll.js');
+var AnnotsTimeLine = require('./annotstimeline.js');
+var AnnotsRoll = require('./annotsroll.js');
+
+var defaultOptions = {
+    xInit: 0,
+    yInit: 0,
+    width: 1024,
+    height: 768,
+    annotCategories: [
+    {
+        "ts": 1421928213000,
+        "colors": {
+            "transgressions": "#b90000",
+            "rythmique": "#af931e",
+            "narration": "#4bdd71",
+            "relation": "#1c28ba"
+        },
+        "order": [
+            "transgressions",
+            "rythmique",
+            "narration",
+            "relation"
+        ],
+        "defaultColor": "#536991"
+    }]
+};
+
+function AnnotsVizView(options){
+	var _this = this;
+    var opts = _(options).defaults(defaultOptions).value();
+
+    this.container = new PIXI.DisplayObjectContainer();
+    this.container.x = opts.xInit;
+    this.container.y = opts.yInit;
+	this.width = opts.width;
+	this.height= opts.height;
+    this.annotCategories = opts.annotCategories;
+
+	var wsPianoroll = opts.wsPianoroll;
+	var wsAnnot = opts.wsAnnot;
+	var stageView = opts.stageView;
+
+	stageView.registerComponent(this);
+
+	var timeLine = new AnnotsTimeLine.AnnotsTimeLine({
+    	stageView : stageView,
+        logger: logger,
+        ws: new annotviz.WsWrapper(wsUriAnnotation, logger),
+        xInit: 0,
+        yInit: 0,
+        width: 1024 - 200 - 200,
+        height: 768-200,
+        timeBegin: Date.now(),
+        timeEnd: Date.now() + 3000000,
+        intervalWidth: 6,
+        intervalHeight: 10,
+        maxCellHeight: 70,
+        radius: 200,
+        annotCategories: this.annotCategories
+    });
+
+	var doubleRollH = new DoubleRoll.DoubleRoll({
+        stageView : stageView,
+    	logger: logger,
+        ws: wsPianoroll,
+        yInit: (this.height - 200),
+        sceneHeight: 200,
+        pianorolls : [
+            {
+                height: 200,
+                timeWidth: 10,
+                lineInterval: 5000,
+                noteHeight: 10
+            },
+        ]
+    });
+
+	var doubleRollV = new DoubleRoll.DoubleRoll({
+        stageView : stageView,
+    	logger: logger,
+        ws: wsPianoroll,
+        orientation: 'vertical',
+        sceneHeight: 768-200,
+        pianorolls : [
+            {
+                height: 200,
+                timeWidth: 60,
+                lineInterval: 5000,
+                noteHeight: 5,
+            },
+        ]
+    });
+
+	var annotsRoll = new AnnotsRoll.AnnotsRoll({
+    	stageView : stageView,
+        logger: logger,
+        ws: wsAnnot,
+        parentContainer: doubleRollV.stage,
+        xInit: 1024 - 200 - 200,
+        yInit: 768-200,
+        width: 200 + 200,
+        height: 768-200,
+        widthRoll: 200,
+        framerate: doubleRollV.framerate,
+        pixelsPerSecond: Math.floor(1024 / 60),
+        annotColors: this.annotCategories
+    });
+
+	var limiters = new PIXI.Graphics()
+		.lineStyle(1, 0x646464)
+		.moveTo(annotsRoll.container.x, annotsRoll.container.y)
+		.lineTo(annotsRoll.container.x, annotsRoll.container.y - annotsRoll.height)
+		.moveTo(annotsRoll.container.x + annotsRoll.widthRoll, annotsRoll.container.y)
+		.lineTo(annotsRoll.container.x + annotsRoll.widthRoll, annotsRoll.container.y - annotsRoll.height)
+		.moveTo(0, this.height - 200)
+		.lineTo(this.width, this.height - 200)
+		.drawRect(0, 0, this.width -1, this.height -1)
+		.beginFill(0xECECEC)
+		.drawRect(1024 - 200, 0, 200, 768-200)
+		.endFill();
+	this.container.addChild(limiters);
+
+//	var doubleRollV = new DoubleRoll.DoubleRoll({});
+
+	this.init = function(){
+
+	}
+
+	this.start = function() {
+    };
+
+    this.refresh = function() {
+    };
+
+    this.stop = function(){
+    };
+
+    return this;
+
+}
+
+module.exports = {
+	AnnotsVizView: AnnotsVizView
+};
+
+},{"./annotsroll.js":2,"./annotstimeline.js":3,"./doubleroll.js":5,"lodash":"lodash","pixi":"pixi"}],5:[function(require,module,exports){
+/**
+* scripts/doubleroll.js
+*
+* This is the starting point for your application.
+* Take a look at http://browserify.org/ for more info
+*/
+
+/* global document: false */
+
+'use strict';
+
+
+var PIXI = require('pixi');
+var _ = require('lodash');
+var PianoRoll = require('./pianoroll.js');
+
+var defaultConfig = {
+    orientation: 'horizontal',
+    logger: undefined,
+    sceneWidth: 1024,
+    pianorolls : [
+      {
+        height: 435,
+        timeWidth: 10,
+        lineInterval: 5000,
+        noteHeight: undefined
+      },
+      {
+        height: 645,
+        timeWidth: 60,
+        lineInterval: 5000,
+        noteHeight: undefined
+      },
+    ],
+    framerate: 25,
+    offsetMusic: false,
+    sceneBgColor: 0xFFFFFF,
+    lineColor: 0x444444,
+    lineFillColor: 0xFFFF00,
+    noteColors: [0xB90000, 0x4BDD71, 0xAF931E, 0x1C28BA, 0x536991],
+    noteHeight: undefined,
+    zeroShift: 0.9,
+    timeWidth: 60,
+    lineInterval: 5000,
+//    wsUri: undefined,
+//    eventCode: undefined
+
+};
+
+function DoubleRoll(options) {
+
+    var _this = this;
+    var opts = _(options).defaults(defaultConfig).value();
+
+    var orientation = opts.orientation;
+    var isHorizontal = (orientation !== 'vertical');
+
+    this.logger = opts.logger;
+    this.lineColor = opts.lineColor;
+    this.lineFillColor = opts.lineFillColor;
+    this.framerate = opts.framerate;
+    this.offsetMusic = opts.offsetMusic;
+    this.noteColors = opts.noteColors;
+
+    var noteHeight = opts.noteHeight;
+    var sceneBgColor = opts.sceneBgColor;
+    var sceneHeight = opts.sceneHeight || _(opts.pianorolls).reduce(function(s,p) { return s + p.height; }, 0);
+    var timeWidth = opts.timeWidth;
+    var lineInterval = opts.lineInterval;
+    var offsetMusic = opts.offsetMusic;
+
+    var sceneWidth = opts.sceneWidth;
+    var stageView = opts.stageView;
+
+    var zeroShift = opts.zeroShift;
+
+    var ws = opts.ws;
+
+    var colorsReg = {};
+
+    this.container = new PIXI.DisplayObjectContainer();
+    this.container.x = Math.floor(sceneWidth*zeroShift);
+    this.container.y = 0;
+    
+    stageView.registerComponent(this);
+
+    var pianorollList = [];
+
+    var pianorollOptions = {
+        parentContainer: this.container,
+        orientation: orientation,
+        xInit: 0,
+        width: sceneWidth,
+        noteColors: this.noteColors,
+        colorsReg: colorsReg,
+        lineColor: this.lineColor,
+        lineInterval: lineInterval,
+        offsetMusic: offsetMusic,
+    };
+
+    var yInit = opts.yInit || 0;
+    var linesDown = true;
+    _(opts.pianorolls).forEach(function(prDef, i) {
+        var prNoteHeight = noteHeight || prDef.noteHeight || prDef.height / 128;
+        var prTimeWidth = prDef.timeWidth || timeWidth;
+        pianorollList.push(new PianoRoll(_({
+            yInit: yInit,
+            height: prDef.height,
+            linesDown: linesDown,
+            pixelsPerSecond: Math.floor(sceneWidth / prTimeWidth),
+            noteHeight: prNoteHeight,
+            lineInterval: prDef.lineInterval
+        }).defaults(pianorollOptions).value()));
+        yInit += prDef.height;
+        linesDown = !linesDown;
+
+        if(i<(opts.pianorolls.length-1)) {
+            var lineGraphics = new PIXI.Graphics()
+                .beginFill(_this.lineFillColor)
+                .lineStyle(1, _this.lineColor)
+                .moveTo(Math.floor(sceneWidth*zeroShift), yInit)
+                .lineTo(-sceneWidth - Math.floor(sceneWidth*zeroShift), yInit)
+                .endFill();
+            _this.container.addChild(lineGraphics);
+        }
+    });
+
+    if(!isHorizontal) {
+        this.container.rotation = Math.PI/2;
+        this.container.y = sceneHeight;
+        this.container.x = sceneWidth;
+    }
+
+
+    this.init = function() {
+
+    	ws.message(function(data) {
+            _this.addNotes(data);
+        });
+
+    };
+
+
+    this.addNotes = function(data) {
+
+        pianorollList.forEach(function(c) {
+            c.addNoteRaw(data);
+        });
+    };
+
+    this.refresh = function() {
+        pianorollList.forEach(function(c) {
+            c.move();
+        });
+    };
+
+    // Init page and intervals
+    var startTs;
+
+    this.start = function() {
+
+        startTs = Date.now();
+        pianorollList.forEach(function(c) {
+            c.start();
+        });
+    };
+
+    this.stop = function() {
+    	
+        pianorollList.forEach(function(c) {
+            c.stop();
+        });
+    };
+
+
+    this.log = function(m) {
+        if(this.logger) {
+            this.logger.log(m);
+        }
+    };
+
+
+
+    return this;
+}
+
+module.exports = {
+    DoubleRoll: DoubleRoll
+};
+
+},{"./pianoroll.js":7,"lodash":"lodash","pixi":"pixi"}],6:[function(require,module,exports){
+/**
+* js/wswrapper.js
+*
+* simple logger service
+*
+*/
+
+/* global document: false */
+
+'use strict';
+
+function HtmlLogger(doLog, container) {
+
+    var logContainer = container;
+    if(typeof(container) === 'string') {
+        logContainer = document.getElementById(container);
+    }
+    if(!doLog) {
+        document.body.removeChild(logContainer);
+        logContainer = undefined;
+    }
+
+
+    this.log = function(msg) {
+        if(doLog && logContainer) {
+            logContainer.innerHTML += msg + '\n';
+            logContainer.scrollTop = logContainer.scrollHeight;
+        }
+    };
+}
+
+function ConsoleLogger(doLog) {
+
+    this.log = function(msg) {
+        if(doLog) {
+            console.log(msg);
+        }
+    }
+
+}
+
+module.exports = {
+    HtmlLogger: HtmlLogger,
+    ConsoleLogger: ConsoleLogger
+};
+
+},{}],7:[function(require,module,exports){
+/**
+* js/pianoroll.js
+*
+* pianoroll basic component
+*
+*/
+
+'use strict';
+
+
+var PIXI = require('pixi');
+var randomColor = require('randomColor');
+var _ = require('lodash');
+
+var NTP_EPOCH_DELTA = 2208988800; //c.f. RFC 868
+
+function PianoRoll(options) {
+    var _this = this;
+    this.container = new PIXI.DisplayObjectContainer();
+    this.container.x = options.xInit;
+    this.container.y = options.yInit;
+    options.parentContainer.addChild(this.container);
+
+    var orientation = options.orientation;
+    var isHorizontal = (orientation !== 'vertical');
+
+    this.linesDown = options.linesDown;
+    this.height = options.height;
+    this.pixelsPerSecond = options.pixelsPerSecond;
+    this.width = options.width;
+    this.noteColors = options.noteColors;
+    this.colorsReg = options.colorsReg || {};
+    this.lineColor = options.lineColor;
+    this.lineInterval = options.lineInterval;
+    this.offsetMusic = options.offsetMusic || false;
+    this.noteHeight = options.noteHeight;
+    this.noteDict = {};
+    this.startTs = options.startTs || Date.now();
+
+    var started = false;
+
+    var isHidden = function(child) {
+        // TODO: the origin point is an approximation. Should refine this
+        var globalPos = child.toGlobal(new PIXI.Point(0,0));
+        return ((globalPos.x + child.width) < 0) || ((globalPos.y + child.height) < 0) ;
+    };
+
+    //TODO: I do not like the "regColor" object. This should not be global, but local
+    this.getColor = function(canal) {
+        var color = this.colorsReg[canal];
+        if(typeof(color) === 'undefined') {
+            var colorsRegSize = Object.keys(this.colorsReg).length;
+            if(colorsRegSize < this.noteColors.length) {
+                color = this.colorsReg[canal] = this.noteColors[colorsRegSize];
+            }
+            else {
+                color = this.colorsReg[canal] = parseInt(randomColor({ luminosity: 'light', hue: 'random', format:'hex'}).replace(/^#/, ''), 16);
+            }
+        }
+        return color;
+    };
+
+    this.getNoteRect = function(x, y, color, alpha, width, height) {
+        var graphics = new PIXI.Graphics();
+        graphics.beginFill(color, alpha);
+        graphics.drawRect(0, 0, width, height);
+        graphics.endFill();
+        graphics.x = x;
+        graphics.y = y;
+        graphics.width = width;
+        graphics.height = height;
+        return graphics;
+    };
+
+    this.addNoteRaw = function(data) {
+    	console.log(data);
+        var note = data.content[3];
+        var velocity = data.content[4];
+        var ts = (data.content[0] - NTP_EPOCH_DELTA)*1000;
+        var channel = data.content[2];
+        var sessionTs = data.content[1];
+
+        this.addNote(note, ts, sessionTs, velocity, channel, 0);
+    };
+
+    this.addNote = function(note, startTime, sessionTs, velocity, channel, duration) {
+
+        var ts = startTime;
+        if(this.offsetMusic) {
+            ts = this.startTs + sessionTs;
+        }
+
+        var noteDuration = duration;
+        var noteVelocity = velocity;
+        var graphics;
+        if(!duration) {
+            if(typeof this.noteDict[channel]==='undefined'){
+                this.noteDict[channel] = {};
+            }
+            if(velocity===0) {
+                if(typeof this.noteDict[channel][note] !== 'undefined') {
+                    var noteDef = this.noteDict[channel][note];
+                    delete this.noteDict[channel][note];
+                    noteDuration = sessionTs - noteDef.sessionTs;
+                    graphics = noteDef.graphics;
+                    noteVelocity = noteDef.velocity;
+                    ts = noteDef.ts;
+                }
+            }
+            else {
+                noteDuration = Date.now() - ts;
+                this.noteDict[channel][note] = { ts: ts, velocity: velocity, sessionTs: sessionTs};
+            }
+        }
+
+
+        if(!this.offsetMusic || velocity===0) {
+
+            var width = noteDuration * this.pixelsPerSecond / 1000;
+            if(!graphics) {
+                var x = (ts-this.startTs) * this.pixelsPerSecond / 1000;
+                if((x+width) <  (Math.abs(this.container.x) - this.width)) {
+                    // not visible. do nothing
+                    return;
+                }
+                var y = Math.floor((128-note+0.5) * this.height / 128 - (this.noteHeight/2));
+                var color = this.getColor(channel);
+                var alpha = (noteVelocity / 128);
+
+                graphics = this.getNoteRect(x, y, color, alpha, width, this.noteHeight);
+                this.container.addChild(graphics);
+            }
+            else {
+                graphics.width = width;
+            }
+
+            if(!duration && velocity) {
+                this.noteDict[channel][note].graphics = graphics;
+            }
+        }
+    };
+
+    this.addLine = function(ts){
+
+        if(typeof(ts) === 'undefined') {
+            ts = new Date();
+        }
+        var x = -this.container.x;
+        var y = this.linesDown ? this.height - 20 : 0;
+
+        var graphics = new PIXI.Graphics()
+            .beginFill(0xFFFF00)
+            .lineStyle(1, this.lineColor)
+            .moveTo(0, 0)
+            .lineTo(0, 20)
+            .endFill();
+        graphics.x = x;
+        graphics.y = y;
+        this.container.addChild(graphics);
+        // Add text
+        //var totalSec = lineNb * this.lineInterval / 1000;
+        var hours = ts.getHours();
+        var minutes =ts.getMinutes();
+        var seconds = ts.getSeconds();
+        var timeStr = (hours < 10 ? '0' + hours : hours) + ':' + (minutes < 10 ? '0' + minutes : minutes) + ':' + (seconds  < 10 ? '0' + seconds : seconds);
+
+        var fontObj = { font: '10pt Arial', fill: '#444444' };
+        var t = new PIXI.Text(timeStr, fontObj);
+        if(isHorizontal) {
+            t.x = x + 2;
+            t.y = this.linesDown ? this.height - 15 : 2;
+        }
+        else {
+            t.rotation = -Math.PI/2;
+            t.x = x ;
+            t.y = this.linesDown ? this.height - 2 : t.width + 2;
+        }
+        this.container.addChild(t);
+    };
+
+    this.moveTo = function(diffTime){
+        var oldX = this.container.x;
+        this.container.x = Math.floor(diffTime*this.pixelsPerSecond);
+        var deltaX = Math.abs(oldX-this.container.x);
+        _.forOwn(this.noteDict, function(channelDict) {
+            _.forOwn(channelDict, function(noteDef) {
+                if(noteDef.graphics) {
+                    noteDef.graphics.width = noteDef.graphics.width + deltaX;
+                }
+            });
+        });
+    };
+
+    this.move = function() {
+        var diff = (this.startTs - Date.now())/1000;
+        this.moveTo(diff);
+    };
+
+    this.removePassedObjets = function(){
+        var childrenToRemove = [];
+        _(_this.container.children).forEach(function(child) {
+            return typeof(child) === 'undefined' ||
+                (isHidden(child) && childrenToRemove.push(child));
+        });
+        childrenToRemove.forEach(function(child) {
+            _this.container.removeChild(child);
+        });
+    };
+
+    this.start = function() {
+        if(!started) {
+            this.startTs = Date.now();
+            this.addLine();
+            started = true;
+        }
+        this.verticalLinesInterval = setInterval(function() { _this.addLine(); }, this.lineInterval);
+        this.cleanInterval = setInterval(function () { _this.removePassedObjets(); }, 1000 * this.width / this.pixelsPerSecond );
+    };
+
+    this.stop = function() {
+        //window.clearInterval(this.moveInterval);
+        clearInterval(this.verticalLinesInterval);
+        clearInterval(this.cleanInterval);
+    };
+
+
+}
+
+module.exports = PianoRoll;
+
+},{"lodash":"lodash","pixi":"pixi","randomColor":"randomColor"}],8:[function(require,module,exports){
+/**
+* scripts/stageview.js
+*
+* This is the starting point for your application.
+* Take a look at http://browserify.org/ for more info
+*/
+
+/* global document: false */
+
+'use strict';
+
+
+var PIXI = require('pixi');
+var _ = require('lodash');
+
+var defaultConfig = {
+    externalRefresh: false,
+    logger: undefined,
+    sceneWidth: 1024,
+    sceneHeight: 768,
+    framerate: 25,
+    sceneBgColor: 0xFFFFFF,
+    canvasContainer: 'canvasContainer',
+};
+
+function StageView(options) {
+
+    var _this = this;
+    var opts = _(options).defaults(defaultConfig).value();
+
+    var externalRefresh = opts.externalRefresh;
+
+    this.logger = opts.logger;
+    this.framerate = opts.framerate;
+    var sceneBgColor = opts.sceneBgColor;
+    var sceneWidth = opts.sceneWidth;
+    var sceneHeight = opts.sceneHeight;
+    var canvasContainer = opts.canvasContainer;
+    var timeContainer = [];
+    var components = []; 
+    
+    //create an new instance of a pixi stage
+    this.stage = new PIXI.Stage(sceneBgColor);
+    //create a renderer instance.
+    var renderer = PIXI.autoDetectRenderer(sceneWidth, sceneHeight);
+    	
+    this.init = function() {
+
+        if(typeof(canvasContainer) === 'string') {
+            canvasContainer = document.getElementById(canvasContainer);
+        }
+        if(typeof(timeContainer) === 'string') {
+            timeContainer = document.getElementById(timeContainer);
+        }
+
+        canvasContainer.appendChild(renderer.view);
+        
+        components.forEach(function(c){
+    		c.init();
+    	});
+    };
+    
+    this.registerTimeContainer = function(container) {
+    	timeContainer.push(container);
+    };
+    
+    this.registerComponent = function(component) {
+    	components.push(component);
+    	this.stage.addChild(component.container);
+    };
+
+    this.refresh = function() {
+    	components.forEach(function(c){
+    		c.refresh();
+    	});
+        renderer.render(this.stage);
+    };
+
+    // Init page and intervals
+    var refreshInterval;
+
+    this.start = function() {
+
+        if(!externalRefresh) {
+            refreshInterval = setInterval(function() {_this.refresh();}, 1000/this.framerate);
+        }
+        
+        components.forEach(function(c){
+    		c.start();
+    	});
+    };
+
+    this.stop = function() {
+        if(!externalRefresh) {
+            clearInterval(refreshInterval);
+        }
+        clearInterval(refreshTimeInterval);
+        
+        components.forEach(function(c){
+    		c.stop();
+    	});
+    };
+
+
+    this.log = function(m) {
+        if(this.logger) {
+            this.logger.log(m);
+        }
+    };
+
+
+    return this;
+}
+
+module.exports = {
+    StageView: StageView
+};
+
+},{"lodash":"lodash","pixi":"pixi"}],9:[function(require,module,exports){
+/**
+* js/utils.js
+*
+* basic tools
+*
+*/
+
+'use strict';
+
+function formatTime (ts) {
+	var hours = Math.floor( (ts/1000) / 3600 ) % 24;
+	var minutes = Math.floor( (ts/1000) / 60 ) % 60;
+	var seconds = Math.floor( (ts/1000) % 60);
+	return ((hours < 10 ? '0' + hours : hours) + ':' + (minutes < 10 ? '0' + minutes : minutes) + ':' + (seconds  < 10 ? '0' + seconds : seconds));
+}
+
+
+module.exports = {
+	formatTime: formatTime
+};
+
+},{}],10:[function(require,module,exports){
+/**
+* js/wswrapper.js
+*
+* simple webservice wrapper to register callbacks on onmessage
+*
+*/
+
+/* global WebSocket: false */
+
+'use strict';
+
+function WsWrapper(wsurl, logger) {
+
+    var url = wsurl;
+    var sock = new WebSocket(url);
+    var loggerObj = logger;
+
+    var log = function(msg) {
+        if(loggerObj) {
+            loggerObj.log(msg);
+        }
+    };
+
+    var handlers = [];
+
+    sock.onopen = function() {
+        log('Connected to ' + url);
+    };
+
+    sock.onclose = function(e) {
+        log('Connection closed (wasClean = ' + e.wasClean + ', code = ' + e.code + ', reason = \'' + e.reason + '\')');
+        sock = null;
+    };
+
+    sock.onmessage = function(e) {
+        log('received ' + e.data);
+        var data = JSON.parse(e.data);
+        handlers.forEach(function(handler) {
+            handler(data);
+        });
+    };
+
+    this.message = function(handler) {
+        if(handler) {
+            handlers.push(handler);
+        }
+    };
+
+}
+
+module.exports = {
+    WsWrapper: WsWrapper
+};
+
+},{}]},{},[1])(1)
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["node_modules/browserify/node_modules/browser-pack/_prelude.js","./app/js/main.js","/Users/ymh/dev/projects/mons/dev/client/annotviz/app/js/annotsroll.js","/Users/ymh/dev/projects/mons/dev/client/annotviz/app/js/annotstimeline.js","/Users/ymh/dev/projects/mons/dev/client/annotviz/app/js/annotsvizview.js","/Users/ymh/dev/projects/mons/dev/client/annotviz/app/js/doubleroll.js","/Users/ymh/dev/projects/mons/dev/client/annotviz/app/js/logger.js","/Users/ymh/dev/projects/mons/dev/client/annotviz/app/js/pianoroll.js","/Users/ymh/dev/projects/mons/dev/client/annotviz/app/js/stageview.js","/Users/ymh/dev/projects/mons/dev/client/annotviz/app/js/utils.js","/Users/ymh/dev/projects/mons/dev/client/annotviz/app/js/wswrapper.js"],"names":[],"mappings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tNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5JA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7LA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","/**\n * scripts/main.js\n *\n * This is the starting point for your application.\n * Take a look at http://browserify.org/ for more info\n */\n\n'use strict';\n\nvar doubleroll = require('./doubleroll');\nvar annotsroll = require('./annotsroll');\nvar annotstimeline = require('./annotstimeline');\nvar annotsvizview = require('./annotsvizview');\nvar stageview = require('./stageview');\nvar wswrapper = require('./wswrapper');\nvar logger = require('./logger');\n\nvar _ = require('lodash');\n\nmodule.exports = _({})\n    .extend(doubleroll)\n    .extend(annotsroll)\n    .extend(annotstimeline)\n    .extend(annotsvizview)\n    .extend(stageview)\n    .extend(wswrapper)\n    .extend(logger)\n    .value();","/**\n* js/annotsRoll.js\n*\n* annotsRoll basic component\n*\n*/\n\n'use strict';\n\nvar PIXI = require('pixi');\nvar _ = require('lodash');\n\nvar DEFAULT_ANNOT_COLOR = '#bababa';\n\nvar defaultAnnotStyles = {\n    'label': { font: '16pt Arial Bold', fill: '#65A954', wordWrap: true},\n    'text' : { font: '12pt Arial Regular', fill: '#444444', wordWrap: true},\n    'user' : { font: '14pt Arial regular', fill: '#666666' },\n};\n\nvar defaultOptions = {\n    externalRefresh: false,\n    defaultColor: DEFAULT_ANNOT_COLOR,\n    annotStyles: defaultAnnotStyles\n};\n\nfunction AnnotsRoll(options) {\n\n//parentContainer, xInit, yInit, width, height, widthRoll, pixelsPerSecond, annotColors\n    var _this = this;\n    var opts = _(options).defaults(defaultOptions).value();\n\n\n    this.container = new PIXI.DisplayObjectContainer();\n    this.container.x = opts.xInit;\n    this.container.y = opts.yInit;\n    this.container.width = opts.width;\n\n    this.height = opts.height;\n    this.width = opts.width;\n    this.widthRoll = opts.widthRoll;\n    this.pixelsPerSecond = opts.pixelsPerSecond;\n    this.annotColors = opts.annotColors;\n    this.startTs = options.startTs || Date.now();\n\n    var yInit = opts.yInit;\n    var annotStyles = _(opts.annotStyles).defaults(defaultAnnotStyles).value();\n    for(var style in annotStyles) {\n    \tif (annotStyles[style].wordWrap === true){\n    \t\tannotStyles[style].wordWrapWidth = this.widthRoll;\n    \t}\n    }\n    var started = false;\n    var ws = opts.ws;\n    var externalRefresh = opts.externalRefresh;\n    var stageView = opts.stageView;\n\n    stageView.registerComponent(this);\n\n    var isHidden = function(child) {\n        // TODO: the origin point is an approximation. Should refine this\n        var globalPos = child.toGlobal(new PIXI.Point(0,0));\n        return ((globalPos.x + child.width) < 0) || ((globalPos.y + child.height) < 0) ;\n    };\n\n    this.addAnnots = function(data) {\n\n        //var title = data.content.category.label;\n        //var user = data.content.user;\n        //Test cat and color\n        //var colorAnnot = 0x65A954;\n        var category = data.content.category.label,\n            text     = data.content.text,\n            user     = data.content.user,\n            ts       = Date.parse(data.ts),\n            color    = data.content.color || this.getColor(ts, data.content.category.code);\n\n        this.addAnnot(category, text, user, color, ts);\n    };\n\n    this.getColor = function(ts, code) {\n        var colorsDef;\n        _(this.annotColors).eachRight(function(cdef) {\n            console.log(\"cDef\", cdef);\n            console.log(\"cDef ts\", cdef.ts, ts);\n            if(cdef.ts < ts) {\n                colorsDef = cdef.colors;\n                return false;\n            }\n        });\n        var resColor;\n        console.log(\"colorsDef\", colorsDef);\n        if(colorsDef) {\n            resColor = colorsDef[code];\n        }\n        if(!resColor) {\n            resColor = DEFAULT_ANNOT_COLOR;\n        }\n        return resColor;\n    }\n\n    this.addAnnot = function(category, text, user, catColor, ts){\n\n        var color = catColor ? catColor : DEFAULT_ANNOT_COLOR;\n        var x = 0;\n        var y = (ts-this.startTs) * this.pixelsPerSecond / 1000 + yInit;\n\n        var colorHex = parseInt(color.replace(/^#/, ''), 16);\n\n        var graphics = new PIXI.Graphics()\n            .beginFill(colorHex)\n            .drawRect(x, y, 10, 3)\n            .endFill();\n\n        this.container.addChild(graphics);\n\n        var textHeight = 0;\n        var catLabel = new PIXI.Text(\n            category,\n            _(annotStyles.label).extend({fill: color}).value()\n        );\n        catLabel.x = x + 20;\n        catLabel.y = y - 23;\n        this.container.addChild(catLabel);\n        textHeight += (catLabel.height - 23 + 2);\n\n        if(text) {\n            var catText = new PIXI.Text(text, annotStyles.text);\n            catText.x = x + 20;\n            catText.y = y + 2;\n            this.container.addChild(catText);\n            textHeight += (catText.height + 2);\n        }\n\n        var catUser = new PIXI.Text(user, annotStyles.user);\n        catUser.x = x + 20;\n        catUser.y = y + 2 + textHeight;\n        this.container.addChild(catUser);\n\n        this.addAnnotLine(colorHex, y);\n    };\n\n    this.addAnnotLine = function(color, y) {\n        var x = this.widthRoll;\n\n\n        var graphics = new PIXI.Graphics()\n            .beginFill(color)\n            .drawRect(x, y, this.width - x, 3)\n            .endFill();\n\n        this.container.addChild(graphics);\n    };\n\n    this.moveTo = function(diffTime){\n    \tthis.container.y = Math.floor(diffTime*this.pixelsPerSecond);\n    };\n\n    this.move = this.refresh = function() {\n        var diff = (this.startTs - Date.now())/1000;\n        this.moveTo(diff);\n    };\n\n    this.removePassedObjets = function(){\n        var childrenToRemove = [];\n        _(_this.container.children).forEach(function(child) {\n            return typeof(child) === 'undefined' ||\n                (isHidden(child) && childrenToRemove.push(child));\n        });\n        childrenToRemove.forEach(function(child) {\n            _this.container.removeChild(child);\n        });\n    };\n\n    this.init = function() {\n\n        ws.message(function(data) {\n            _this.addAnnots(data);\n        });\n\n    };\n\n    this.start = function() {\n        if(!started) {\n            this.startTs = Date.now();\n            started = true;\n        }\n        this.cleanInterval = setInterval(function () { _this.removePassedObjets(); }, 1000 * this.height / this.pixelsPerSecond );\n        if(!externalRefresh) {\n            this.refreshInterval = setInterval(function() {_this.move();}, 1000/this.framerate);\n        }\n    };\n\n    this.stop = function() {\n        clearInterval(this.cleanInterval);\n        if(!externalRefresh) {\n            clearInterval(this.refreshInterval);\n        }\n    };\n\n}\n\nmodule.exports = {\n    AnnotsRoll: AnnotsRoll,\n};\n","/**\n* js/annotstimeline\n*\n* annotstimeline basic component\n*\n*/\n\n'use strict';\n\nvar PIXI = require('pixi');\nvar Utils = require('./utils.js');\nvar _ = require('lodash');\n\nvar defaultOptions = {\n    logger: undefined,\n    intervalWidth: 10,\n    intervalHeight: 5,\n    maxCellHeight: 200,\n    radius: 300\n};\n\n\nfunction AnnotsTimeLine(options){\n    var _this = this;\n    var opts = _(options).defaults(defaultOptions).value();\n\n    this.container = new PIXI.DisplayObjectContainer();\n    this.container.x = opts.xInit;\n    this.container.y = opts.yInit;\n    this.container.width = opts.width;\n    this.container.height = opts.height;\n\n    this.timeBegin = opts.timeBegin;\n    this.timeEnd = opts.timeEnd;\n    this.duration = (this.timeEnd - this.timeBegin)/1000;\n    this.width = opts.width;\n    this.height = opts.height;\n    this.intervalHeight = opts.intervalHeight;\n    this.intervalWidth = opts.intervalWidth;\n    this.maxCellHeight = opts.maxCellHeight;\n    this.annotCategories = opts.annotCategories;\n\n    this.circleX = opts.circleX || (this.width/2);\n    this.circleY = opts.circleY || (this.height/2);\n    this.radius = opts.radius;\n    this.perimeter = 2*Math.PI* this.radius;\n    this.intervalDuration = (this.intervalWidth * this.duration / this.perimeter);\n\n    var currentTime = this.timeBegin;\n    var totalIndex = Math.floor(this.perimeter/this.intervalWidth);\n\n    this.cells = []\n    for (var i=0; i<(this.perimeter/this.intervalWidth) ; i++){\n    \tthis.cells[i] = [];\n    \tthis.cells[i].i = i;\n    \tthis.cells[i].totalAnnots = 0;\n    \tthis.cells[i].categories = {};\n\n    \tfor (var category in this.annotCategories[0].colors){\n    \t\tthis.cells[i].categories[category] = {\n\t\t\t\t\"count\": 0,\n\t\t\t\t\"color\": this.annotCategories[0].colors[category]\n    \t\t};\n    \t}\n    }\n\n    var ws = opts.ws;\n    var stageView = opts.stageView;\n\n    //draw the base - circle and line to locate the scene\n    var graphics = new PIXI.Graphics();\n    graphics.lineStyle(2, 0x646464)\n    \t.drawCircle(this.circleX, this.circleY, this.radius - 3)\n    \t.lineStyle(1, 0xD7D7D7)\n    \t.drawCircle(this.circleX, this.circleY, this.radius*2/3)\n    \t.drawCircle(this.circleX, this.circleY, this.radius/3)\n    \t.lineStyle(1, 0x646464)\n    \t.moveTo(this.circleX, this.circleY - (this.radius/3)/2)\n    \t.lineTo(this.circleX, this.circleY - this.radius - this.maxCellHeight - 10)\n    \t.endFill()\n    this.container.addChild(graphics);\n\n    //set time text\n    //TODO : move this to annotsvizview\n    var currentTimeText = new PIXI.Text(\"-- : -- : --\", { font: '18pt Gothic Standard', fill: '#646464' });\n    currentTimeText.x = this.circleX - currentTimeText.width/2;\n    currentTimeText.y = this.circleY - currentTimeText.height/2;\n    this.container.addChild(currentTimeText);\n\n    stageView.registerComponent(this);\n\n    //Add Annotation to the TimeLine\n    this.addAnnot = function(data){\n    \tif (typeof(this.annotCategories[0].colors[data.content.category.code]) !== 'undefined'){\n    \t\tvar annotCode = data.content.category.code;\n    \t} else {\n    \t\tvar annotCode = this.annotCategories[0].order[this.annotCategories[0].order.length -1];\n    \t}\n    \tvar annotTime = Date.parse(data.ts);\n\n    \tif (this.timeEnd > Date.parse(data.ts)){\n\t    \tvar i = Math.floor((Date.parse(data.ts)-this.timeBegin)/(1000*this.intervalDuration));\n\n\t\t\tthis.cells[i].categories[annotCode].count += 1;\n\t\t\tthis.cells[i].totalAnnots +=1;\n\t\t\tthis.redrawCell(this.cells[i], i);\n    \t}\n    };\n\n    this.initGraphics = function(cell){\n    \tcell.graphics = new PIXI.Graphics();\n    \tcell.graphics.position.x = this.circleX + this.radius * Math.sin(cell.i*(360/totalIndex)*(Math.PI/180));\n    \tcell.graphics.position.y = this.circleY - this.radius * Math.cos(cell.i*(360/totalIndex)*(Math.PI/180));\n    \tcell.graphics.rotation = (cell.i)*(360/totalIndex)*(Math.PI/180) + (360/(totalIndex*2))*(Math.PI/180);\n    \tthis.container.addChild(cell.graphics);\n    }\n\n    this.initTimeTexts = function() {\n\t    var tBeg = new PIXI.Text(Utils.formatTime(this.timeBegin), { font: '12pt Gothic Standard', fill: '#646464' });\n\t    tBeg.x = this.circleX + 15;\n\t    tBeg.y = this.circleY - this.radius - this.maxCellHeight - 10;\n\t    this.container.addChild(tBeg);\n\n\t    var tEnd = new PIXI.Text(Utils.formatTime(this.timeEnd), { font: '12pt Gothic Standard', fill: '#646464' });\n\t    tEnd.x = this.circleX - 15 - tEnd.width;\n\t    tEnd.y = this.circleY - this.radius - this.maxCellHeight - 10;\n\t    this.container.addChild(tEnd);\n\n\t    var t15 = new PIXI.Text(Utils.formatTime(((this.timeEnd - this.timeBegin)/4) + this.timeBegin), { font: '12pt Gothic Standard', fill: '#646464' });\n\t    t15.x = this.circleX + this.radius + this.maxCellHeight + 10 ;\n\t    t15.y = this.circleY - t15.height;\n\t    t15.rotation = Math.PI /2;\n\t    this.container.addChild(t15);\n\n\t    var t30 = new PIXI.Text(Utils.formatTime(((this.timeEnd - this.timeBegin)/2) + this.timeBegin), { font: '12pt Gothic Standard', fill: '#646464' });\n\t    t30.x = this.circleX - t30.width/2;\n\t    t30.y = this.circleY + this.radius + this.maxCellHeight - 2;\n\t    this.container.addChild(t30);\n\n\t    var t45 = new PIXI.Text(Utils.formatTime(((this.timeEnd - this.timeBegin)*3/4) + this.timeBegin), { font: '12pt Gothic Standard', fill: '#646464' });\n\t    t45.x = this.circleX - this.radius - this.maxCellHeight - 10 ;\n\t    t45.y = this.circleY + t15.height;\n\t    t45.rotation = -Math.PI/2;\n\t    this.container.addChild(t45);\n    }\n\n    //Draw the cellule\n    this.redrawCell = function(cell){\n\n    \tif (typeof(cell.graphics) === 'undefined'){\n    \t\tthis.initGraphics(cell);\n    \t} else {\n    \t\tcell.graphics.clear();\n    \t}\n\n    \tvar y = 0;\n\n    \t//Check if total height is higher than Max Cell Height\n    \tif ((cell.totalAnnots*this.intervalHeight) > this.maxCellHeight){\n    \t\tvar heightStep = this.maxCellHeight/cell.totalAnnots;\n    \t} else {\n    \t\tvar heightStep = this.intervalHeight;\n    \t}\n\n    \t//Draw the rect depending on the height step calculated\n    \tfor (var i=0; i< this.annotCategories[0].order.length; i++){\n    \t\tvar currentCode = this.annotCategories[0].order[i];\n\t\t\tcell.graphics.beginFill(cell.categories[currentCode].color.replace(\"#\", \"0x\"))\n    \t\t\t.drawRect(0, y, this.intervalWidth-1, -cell.categories[currentCode].count * heightStep)\n    \t\t\t.endFill();\n    \t\ty -= cell.categories[currentCode].count*heightStep;\n    \t}\n    }\n\n    this.init = function() {\n    \tws.message(function(data) {\n            _this.addAnnot(data);\n        });\n\n    \tthis.initTimeTexts();\n    };\n\n    this.updateTime = function(){\n    \tcurrentTime += 1000;\n\n        var nbSec = currentTime / 1000;\n        var hours = Math.floor( nbSec / 3600 ) % 24;\n        var minutes = Math.floor( nbSec / 60 ) % 60;\n        var seconds = Math.floor(nbSec % 60);\n        var timeStr = (hours < 10 ? '0' + hours : hours) + ':' + (minutes < 10 ? '0' + minutes : minutes) + ':' + (seconds  < 10 ? '0' + seconds : seconds);\n\n        currentTimeText.setText(timeStr);\n    };\n\n    var refreshTimeInterval;\n\n    this.start = function() {\n    \trefreshTimeInterval = setInterval(function() {_this.updateTime();}, 1000);\n    };\n\n    this.refresh = function() {\n\n    };\n\n    this.stop = function(){\n    \tconsole.log(this.cells);\n    };\n\n    return this;\n}\n\nmodule.exports = {\n\tAnnotsTimeLine: AnnotsTimeLine\n};\n","/**\n* js/annotsvizview.js\n*\n* This is the starting point for your application.\n* Take a look at http://browserify.org/ for more info\n*/\n\n'use strict';\n\nvar PIXI = require('pixi');\nvar _ = require('lodash');\nvar DoubleRoll = require('./doubleroll.js');\nvar AnnotsTimeLine = require('./annotstimeline.js');\nvar AnnotsRoll = require('./annotsroll.js');\n\nvar defaultOptions = {\n    xInit: 0,\n    yInit: 0,\n    width: 1024,\n    height: 768,\n    annotCategories: [\n    {\n        \"ts\": 1421928213000,\n        \"colors\": {\n            \"transgressions\": \"#b90000\",\n            \"rythmique\": \"#af931e\",\n            \"narration\": \"#4bdd71\",\n            \"relation\": \"#1c28ba\"\n        },\n        \"order\": [\n            \"transgressions\",\n            \"rythmique\",\n            \"narration\",\n            \"relation\"\n        ],\n        \"defaultColor\": \"#536991\"\n    }]\n};\n\nfunction AnnotsVizView(options){\n\tvar _this = this;\n    var opts = _(options).defaults(defaultOptions).value();\n\n    this.container = new PIXI.DisplayObjectContainer();\n    this.container.x = opts.xInit;\n    this.container.y = opts.yInit;\n\tthis.width = opts.width;\n\tthis.height= opts.height;\n    this.annotCategories = opts.annotCategories;\n\n\tvar wsPianoroll = opts.wsPianoroll;\n\tvar wsAnnot = opts.wsAnnot;\n\tvar stageView = opts.stageView;\n\n\tstageView.registerComponent(this);\n\n\tvar timeLine = new AnnotsTimeLine.AnnotsTimeLine({\n    \tstageView : stageView,\n        logger: logger,\n        ws: new annotviz.WsWrapper(wsUriAnnotation, logger),\n        xInit: 0,\n        yInit: 0,\n        width: 1024 - 200 - 200,\n        height: 768-200,\n        timeBegin: Date.now(),\n        timeEnd: Date.now() + 3000000,\n        intervalWidth: 6,\n        intervalHeight: 10,\n        maxCellHeight: 70,\n        radius: 200,\n        annotCategories: this.annotCategories\n    });\n\n\tvar doubleRollH = new DoubleRoll.DoubleRoll({\n        stageView : stageView,\n    \tlogger: logger,\n        ws: wsPianoroll,\n        yInit: (this.height - 200),\n        sceneHeight: 200,\n        pianorolls : [\n            {\n                height: 200,\n                timeWidth: 10,\n                lineInterval: 5000,\n                noteHeight: 10\n            },\n        ]\n    });\n\n\tvar doubleRollV = new DoubleRoll.DoubleRoll({\n        stageView : stageView,\n    \tlogger: logger,\n        ws: wsPianoroll,\n        orientation: 'vertical',\n        sceneHeight: 768-200,\n        pianorolls : [\n            {\n                height: 200,\n                timeWidth: 60,\n                lineInterval: 5000,\n                noteHeight: 5,\n            },\n        ]\n    });\n\n\tvar annotsRoll = new AnnotsRoll.AnnotsRoll({\n    \tstageView : stageView,\n        logger: logger,\n        ws: wsAnnot,\n        parentContainer: doubleRollV.stage,\n        xInit: 1024 - 200 - 200,\n        yInit: 768-200,\n        width: 200 + 200,\n        height: 768-200,\n        widthRoll: 200,\n        framerate: doubleRollV.framerate,\n        pixelsPerSecond: Math.floor(1024 / 60),\n        annotColors: this.annotCategories\n    });\n\n\tvar limiters = new PIXI.Graphics()\n\t\t.lineStyle(1, 0x646464)\n\t\t.moveTo(annotsRoll.container.x, annotsRoll.container.y)\n\t\t.lineTo(annotsRoll.container.x, annotsRoll.container.y - annotsRoll.height)\n\t\t.moveTo(annotsRoll.container.x + annotsRoll.widthRoll, annotsRoll.container.y)\n\t\t.lineTo(annotsRoll.container.x + annotsRoll.widthRoll, annotsRoll.container.y - annotsRoll.height)\n\t\t.moveTo(0, this.height - 200)\n\t\t.lineTo(this.width, this.height - 200)\n\t\t.drawRect(0, 0, this.width -1, this.height -1)\n\t\t.beginFill(0xECECEC)\n\t\t.drawRect(1024 - 200, 0, 200, 768-200)\n\t\t.endFill();\n\tthis.container.addChild(limiters);\n\n//\tvar doubleRollV = new DoubleRoll.DoubleRoll({});\n\n\tthis.init = function(){\n\n\t}\n\n\tthis.start = function() {\n    };\n\n    this.refresh = function() {\n    };\n\n    this.stop = function(){\n    };\n\n    return this;\n\n}\n\nmodule.exports = {\n\tAnnotsVizView: AnnotsVizView\n};\n","/**\n* scripts/doubleroll.js\n*\n* This is the starting point for your application.\n* Take a look at http://browserify.org/ for more info\n*/\n\n/* global document: false */\n\n'use strict';\n\n\nvar PIXI = require('pixi');\nvar _ = require('lodash');\nvar PianoRoll = require('./pianoroll.js');\n\nvar defaultConfig = {\n    orientation: 'horizontal',\n    logger: undefined,\n    sceneWidth: 1024,\n    pianorolls : [\n      {\n        height: 435,\n        timeWidth: 10,\n        lineInterval: 5000,\n        noteHeight: undefined\n      },\n      {\n        height: 645,\n        timeWidth: 60,\n        lineInterval: 5000,\n        noteHeight: undefined\n      },\n    ],\n    framerate: 25,\n    offsetMusic: false,\n    sceneBgColor: 0xFFFFFF,\n    lineColor: 0x444444,\n    lineFillColor: 0xFFFF00,\n    noteColors: [0xB90000, 0x4BDD71, 0xAF931E, 0x1C28BA, 0x536991],\n    noteHeight: undefined,\n    zeroShift: 0.9,\n    timeWidth: 60,\n    lineInterval: 5000,\n//    wsUri: undefined,\n//    eventCode: undefined\n\n};\n\nfunction DoubleRoll(options) {\n\n    var _this = this;\n    var opts = _(options).defaults(defaultConfig).value();\n\n    var orientation = opts.orientation;\n    var isHorizontal = (orientation !== 'vertical');\n\n    this.logger = opts.logger;\n    this.lineColor = opts.lineColor;\n    this.lineFillColor = opts.lineFillColor;\n    this.framerate = opts.framerate;\n    this.offsetMusic = opts.offsetMusic;\n    this.noteColors = opts.noteColors;\n\n    var noteHeight = opts.noteHeight;\n    var sceneBgColor = opts.sceneBgColor;\n    var sceneHeight = opts.sceneHeight || _(opts.pianorolls).reduce(function(s,p) { return s + p.height; }, 0);\n    var timeWidth = opts.timeWidth;\n    var lineInterval = opts.lineInterval;\n    var offsetMusic = opts.offsetMusic;\n\n    var sceneWidth = opts.sceneWidth;\n    var stageView = opts.stageView;\n\n    var zeroShift = opts.zeroShift;\n\n    var ws = opts.ws;\n\n    var colorsReg = {};\n\n    this.container = new PIXI.DisplayObjectContainer();\n    this.container.x = Math.floor(sceneWidth*zeroShift);\n    this.container.y = 0;\n    \n    stageView.registerComponent(this);\n\n    var pianorollList = [];\n\n    var pianorollOptions = {\n        parentContainer: this.container,\n        orientation: orientation,\n        xInit: 0,\n        width: sceneWidth,\n        noteColors: this.noteColors,\n        colorsReg: colorsReg,\n        lineColor: this.lineColor,\n        lineInterval: lineInterval,\n        offsetMusic: offsetMusic,\n    };\n\n    var yInit = opts.yInit || 0;\n    var linesDown = true;\n    _(opts.pianorolls).forEach(function(prDef, i) {\n        var prNoteHeight = noteHeight || prDef.noteHeight || prDef.height / 128;\n        var prTimeWidth = prDef.timeWidth || timeWidth;\n        pianorollList.push(new PianoRoll(_({\n            yInit: yInit,\n            height: prDef.height,\n            linesDown: linesDown,\n            pixelsPerSecond: Math.floor(sceneWidth / prTimeWidth),\n            noteHeight: prNoteHeight,\n            lineInterval: prDef.lineInterval\n        }).defaults(pianorollOptions).value()));\n        yInit += prDef.height;\n        linesDown = !linesDown;\n\n        if(i<(opts.pianorolls.length-1)) {\n            var lineGraphics = new PIXI.Graphics()\n                .beginFill(_this.lineFillColor)\n                .lineStyle(1, _this.lineColor)\n                .moveTo(Math.floor(sceneWidth*zeroShift), yInit)\n                .lineTo(-sceneWidth - Math.floor(sceneWidth*zeroShift), yInit)\n                .endFill();\n            _this.container.addChild(lineGraphics);\n        }\n    });\n\n    if(!isHorizontal) {\n        this.container.rotation = Math.PI/2;\n        this.container.y = sceneHeight;\n        this.container.x = sceneWidth;\n    }\n\n\n    this.init = function() {\n\n    \tws.message(function(data) {\n            _this.addNotes(data);\n        });\n\n    };\n\n\n    this.addNotes = function(data) {\n\n        pianorollList.forEach(function(c) {\n            c.addNoteRaw(data);\n        });\n    };\n\n    this.refresh = function() {\n        pianorollList.forEach(function(c) {\n            c.move();\n        });\n    };\n\n    // Init page and intervals\n    var startTs;\n\n    this.start = function() {\n\n        startTs = Date.now();\n        pianorollList.forEach(function(c) {\n            c.start();\n        });\n    };\n\n    this.stop = function() {\n    \t\n        pianorollList.forEach(function(c) {\n            c.stop();\n        });\n    };\n\n\n    this.log = function(m) {\n        if(this.logger) {\n            this.logger.log(m);\n        }\n    };\n\n\n\n    return this;\n}\n\nmodule.exports = {\n    DoubleRoll: DoubleRoll\n};\n","/**\n* js/wswrapper.js\n*\n* simple logger service\n*\n*/\n\n/* global document: false */\n\n'use strict';\n\nfunction HtmlLogger(doLog, container) {\n\n    var logContainer = container;\n    if(typeof(container) === 'string') {\n        logContainer = document.getElementById(container);\n    }\n    if(!doLog) {\n        document.body.removeChild(logContainer);\n        logContainer = undefined;\n    }\n\n\n    this.log = function(msg) {\n        if(doLog && logContainer) {\n            logContainer.innerHTML += msg + '\\n';\n            logContainer.scrollTop = logContainer.scrollHeight;\n        }\n    };\n}\n\nfunction ConsoleLogger(doLog) {\n\n    this.log = function(msg) {\n        if(doLog) {\n            console.log(msg);\n        }\n    }\n\n}\n\nmodule.exports = {\n    HtmlLogger: HtmlLogger,\n    ConsoleLogger: ConsoleLogger\n};\n","/**\n* js/pianoroll.js\n*\n* pianoroll basic component\n*\n*/\n\n'use strict';\n\n\nvar PIXI = require('pixi');\nvar randomColor = require('randomColor');\nvar _ = require('lodash');\n\nvar NTP_EPOCH_DELTA = 2208988800; //c.f. RFC 868\n\nfunction PianoRoll(options) {\n    var _this = this;\n    this.container = new PIXI.DisplayObjectContainer();\n    this.container.x = options.xInit;\n    this.container.y = options.yInit;\n    options.parentContainer.addChild(this.container);\n\n    var orientation = options.orientation;\n    var isHorizontal = (orientation !== 'vertical');\n\n    this.linesDown = options.linesDown;\n    this.height = options.height;\n    this.pixelsPerSecond = options.pixelsPerSecond;\n    this.width = options.width;\n    this.noteColors = options.noteColors;\n    this.colorsReg = options.colorsReg || {};\n    this.lineColor = options.lineColor;\n    this.lineInterval = options.lineInterval;\n    this.offsetMusic = options.offsetMusic || false;\n    this.noteHeight = options.noteHeight;\n    this.noteDict = {};\n    this.startTs = options.startTs || Date.now();\n\n    var started = false;\n\n    var isHidden = function(child) {\n        // TODO: the origin point is an approximation. Should refine this\n        var globalPos = child.toGlobal(new PIXI.Point(0,0));\n        return ((globalPos.x + child.width) < 0) || ((globalPos.y + child.height) < 0) ;\n    };\n\n    //TODO: I do not like the \"regColor\" object. This should not be global, but local\n    this.getColor = function(canal) {\n        var color = this.colorsReg[canal];\n        if(typeof(color) === 'undefined') {\n            var colorsRegSize = Object.keys(this.colorsReg).length;\n            if(colorsRegSize < this.noteColors.length) {\n                color = this.colorsReg[canal] = this.noteColors[colorsRegSize];\n            }\n            else {\n                color = this.colorsReg[canal] = parseInt(randomColor({ luminosity: 'light', hue: 'random', format:'hex'}).replace(/^#/, ''), 16);\n            }\n        }\n        return color;\n    };\n\n    this.getNoteRect = function(x, y, color, alpha, width, height) {\n        var graphics = new PIXI.Graphics();\n        graphics.beginFill(color, alpha);\n        graphics.drawRect(0, 0, width, height);\n        graphics.endFill();\n        graphics.x = x;\n        graphics.y = y;\n        graphics.width = width;\n        graphics.height = height;\n        return graphics;\n    };\n\n    this.addNoteRaw = function(data) {\n    \tconsole.log(data);\n        var note = data.content[3];\n        var velocity = data.content[4];\n        var ts = (data.content[0] - NTP_EPOCH_DELTA)*1000;\n        var channel = data.content[2];\n        var sessionTs = data.content[1];\n\n        this.addNote(note, ts, sessionTs, velocity, channel, 0);\n    };\n\n    this.addNote = function(note, startTime, sessionTs, velocity, channel, duration) {\n\n        var ts = startTime;\n        if(this.offsetMusic) {\n            ts = this.startTs + sessionTs;\n        }\n\n        var noteDuration = duration;\n        var noteVelocity = velocity;\n        var graphics;\n        if(!duration) {\n            if(typeof this.noteDict[channel]==='undefined'){\n                this.noteDict[channel] = {};\n            }\n            if(velocity===0) {\n                if(typeof this.noteDict[channel][note] !== 'undefined') {\n                    var noteDef = this.noteDict[channel][note];\n                    delete this.noteDict[channel][note];\n                    noteDuration = sessionTs - noteDef.sessionTs;\n                    graphics = noteDef.graphics;\n                    noteVelocity = noteDef.velocity;\n                    ts = noteDef.ts;\n                }\n            }\n            else {\n                noteDuration = Date.now() - ts;\n                this.noteDict[channel][note] = { ts: ts, velocity: velocity, sessionTs: sessionTs};\n            }\n        }\n\n\n        if(!this.offsetMusic || velocity===0) {\n\n            var width = noteDuration * this.pixelsPerSecond / 1000;\n            if(!graphics) {\n                var x = (ts-this.startTs) * this.pixelsPerSecond / 1000;\n                if((x+width) <  (Math.abs(this.container.x) - this.width)) {\n                    // not visible. do nothing\n                    return;\n                }\n                var y = Math.floor((128-note+0.5) * this.height / 128 - (this.noteHeight/2));\n                var color = this.getColor(channel);\n                var alpha = (noteVelocity / 128);\n\n                graphics = this.getNoteRect(x, y, color, alpha, width, this.noteHeight);\n                this.container.addChild(graphics);\n            }\n            else {\n                graphics.width = width;\n            }\n\n            if(!duration && velocity) {\n                this.noteDict[channel][note].graphics = graphics;\n            }\n        }\n    };\n\n    this.addLine = function(ts){\n\n        if(typeof(ts) === 'undefined') {\n            ts = new Date();\n        }\n        var x = -this.container.x;\n        var y = this.linesDown ? this.height - 20 : 0;\n\n        var graphics = new PIXI.Graphics()\n            .beginFill(0xFFFF00)\n            .lineStyle(1, this.lineColor)\n            .moveTo(0, 0)\n            .lineTo(0, 20)\n            .endFill();\n        graphics.x = x;\n        graphics.y = y;\n        this.container.addChild(graphics);\n        // Add text\n        //var totalSec = lineNb * this.lineInterval / 1000;\n        var hours = ts.getHours();\n        var minutes =ts.getMinutes();\n        var seconds = ts.getSeconds();\n        var timeStr = (hours < 10 ? '0' + hours : hours) + ':' + (minutes < 10 ? '0' + minutes : minutes) + ':' + (seconds  < 10 ? '0' + seconds : seconds);\n\n        var fontObj = { font: '10pt Arial', fill: '#444444' };\n        var t = new PIXI.Text(timeStr, fontObj);\n        if(isHorizontal) {\n            t.x = x + 2;\n            t.y = this.linesDown ? this.height - 15 : 2;\n        }\n        else {\n            t.rotation = -Math.PI/2;\n            t.x = x ;\n            t.y = this.linesDown ? this.height - 2 : t.width + 2;\n        }\n        this.container.addChild(t);\n    };\n\n    this.moveTo = function(diffTime){\n        var oldX = this.container.x;\n        this.container.x = Math.floor(diffTime*this.pixelsPerSecond);\n        var deltaX = Math.abs(oldX-this.container.x);\n        _.forOwn(this.noteDict, function(channelDict) {\n            _.forOwn(channelDict, function(noteDef) {\n                if(noteDef.graphics) {\n                    noteDef.graphics.width = noteDef.graphics.width + deltaX;\n                }\n            });\n        });\n    };\n\n    this.move = function() {\n        var diff = (this.startTs - Date.now())/1000;\n        this.moveTo(diff);\n    };\n\n    this.removePassedObjets = function(){\n        var childrenToRemove = [];\n        _(_this.container.children).forEach(function(child) {\n            return typeof(child) === 'undefined' ||\n                (isHidden(child) && childrenToRemove.push(child));\n        });\n        childrenToRemove.forEach(function(child) {\n            _this.container.removeChild(child);\n        });\n    };\n\n    this.start = function() {\n        if(!started) {\n            this.startTs = Date.now();\n            this.addLine();\n            started = true;\n        }\n        this.verticalLinesInterval = setInterval(function() { _this.addLine(); }, this.lineInterval);\n        this.cleanInterval = setInterval(function () { _this.removePassedObjets(); }, 1000 * this.width / this.pixelsPerSecond );\n    };\n\n    this.stop = function() {\n        //window.clearInterval(this.moveInterval);\n        clearInterval(this.verticalLinesInterval);\n        clearInterval(this.cleanInterval);\n    };\n\n\n}\n\nmodule.exports = PianoRoll;\n","/**\n* scripts/stageview.js\n*\n* This is the starting point for your application.\n* Take a look at http://browserify.org/ for more info\n*/\n\n/* global document: false */\n\n'use strict';\n\n\nvar PIXI = require('pixi');\nvar _ = require('lodash');\n\nvar defaultConfig = {\n    externalRefresh: false,\n    logger: undefined,\n    sceneWidth: 1024,\n    sceneHeight: 768,\n    framerate: 25,\n    sceneBgColor: 0xFFFFFF,\n    canvasContainer: 'canvasContainer',\n};\n\nfunction StageView(options) {\n\n    var _this = this;\n    var opts = _(options).defaults(defaultConfig).value();\n\n    var externalRefresh = opts.externalRefresh;\n\n    this.logger = opts.logger;\n    this.framerate = opts.framerate;\n    var sceneBgColor = opts.sceneBgColor;\n    var sceneWidth = opts.sceneWidth;\n    var sceneHeight = opts.sceneHeight;\n    var canvasContainer = opts.canvasContainer;\n    var timeContainer = [];\n    var components = []; \n    \n    //create an new instance of a pixi stage\n    this.stage = new PIXI.Stage(sceneBgColor);\n    //create a renderer instance.\n    var renderer = PIXI.autoDetectRenderer(sceneWidth, sceneHeight);\n    \t\n    this.init = function() {\n\n        if(typeof(canvasContainer) === 'string') {\n            canvasContainer = document.getElementById(canvasContainer);\n        }\n        if(typeof(timeContainer) === 'string') {\n            timeContainer = document.getElementById(timeContainer);\n        }\n\n        canvasContainer.appendChild(renderer.view);\n        \n        components.forEach(function(c){\n    \t\tc.init();\n    \t});\n    };\n    \n    this.registerTimeContainer = function(container) {\n    \ttimeContainer.push(container);\n    };\n    \n    this.registerComponent = function(component) {\n    \tcomponents.push(component);\n    \tthis.stage.addChild(component.container);\n    };\n\n    this.refresh = function() {\n    \tcomponents.forEach(function(c){\n    \t\tc.refresh();\n    \t});\n        renderer.render(this.stage);\n    };\n\n    // Init page and intervals\n    var refreshInterval;\n\n    this.start = function() {\n\n        if(!externalRefresh) {\n            refreshInterval = setInterval(function() {_this.refresh();}, 1000/this.framerate);\n        }\n        \n        components.forEach(function(c){\n    \t\tc.start();\n    \t});\n    };\n\n    this.stop = function() {\n        if(!externalRefresh) {\n            clearInterval(refreshInterval);\n        }\n        clearInterval(refreshTimeInterval);\n        \n        components.forEach(function(c){\n    \t\tc.stop();\n    \t});\n    };\n\n\n    this.log = function(m) {\n        if(this.logger) {\n            this.logger.log(m);\n        }\n    };\n\n\n    return this;\n}\n\nmodule.exports = {\n    StageView: StageView\n};\n","/**\n* js/utils.js\n*\n* basic tools\n*\n*/\n\n'use strict';\n\nfunction formatTime (ts) {\n\tvar hours = Math.floor( (ts/1000) / 3600 ) % 24;\n\tvar minutes = Math.floor( (ts/1000) / 60 ) % 60;\n\tvar seconds = Math.floor( (ts/1000) % 60);\n\treturn ((hours < 10 ? '0' + hours : hours) + ':' + (minutes < 10 ? '0' + minutes : minutes) + ':' + (seconds  < 10 ? '0' + seconds : seconds));\n}\n\n\nmodule.exports = {\n\tformatTime: formatTime\n};\n","/**\n* js/wswrapper.js\n*\n* simple webservice wrapper to register callbacks on onmessage\n*\n*/\n\n/* global WebSocket: false */\n\n'use strict';\n\nfunction WsWrapper(wsurl, logger) {\n\n    var url = wsurl;\n    var sock = new WebSocket(url);\n    var loggerObj = logger;\n\n    var log = function(msg) {\n        if(loggerObj) {\n            loggerObj.log(msg);\n        }\n    };\n\n    var handlers = [];\n\n    sock.onopen = function() {\n        log('Connected to ' + url);\n    };\n\n    sock.onclose = function(e) {\n        log('Connection closed (wasClean = ' + e.wasClean + ', code = ' + e.code + ', reason = \\'' + e.reason + '\\')');\n        sock = null;\n    };\n\n    sock.onmessage = function(e) {\n        log('received ' + e.data);\n        var data = JSON.parse(e.data);\n        handlers.forEach(function(handler) {\n            handler(data);\n        });\n    };\n\n    this.message = function(handler) {\n        if(handler) {\n            handlers.push(handler);\n        }\n    };\n\n}\n\nmodule.exports = {\n    WsWrapper: WsWrapper\n};\n"]}