Mercurial Mercurial > mons / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
annot-server/static/js/annotviz.js
changeset 142 e424eed32f72
parent 130 0a2b4991d48c
child 148 21634b2d7609
equal deleted inserted replaced
141:e6892a30d454 142:e424eed32f72 
    81     var yInit = opts.yInit;
 
    81     var yInit = opts.yInit;
 
    82     var annotStyles = _(opts.annotStyles).defaults(defaultAnnotStyles).value();
 
    82     var annotStyles = _(opts.annotStyles).defaults(defaultAnnotStyles).value();
 
    83     var marginX = 15;
 
    83     var marginX = 15;
 
    84     for(var style in annotStyles) {
 
    84     for(var style in annotStyles) {
 
    85     	if (annotStyles[style].wordWrap === true){
 
    85     	if (annotStyles[style].wordWrap === true){
 
    86     		annotStyles[style].wordWrapWidth = this.widthRoll - marginX; 
    86     		annotStyles[style].wordWrapWidth = this.widthRoll - marginX;
 
    87     	}
 
    87     	}
 
    88     }
 
    88     }
 
    89     var started = false;
 
    89     var started = false;
 
    90     var ws = opts.ws;
 
    90     var ws = opts.ws;
 
    91     var externalRefresh = opts.externalRefresh;
 
    91     var externalRefresh = opts.externalRefresh;
 
    92     var stageView = opts.stageView;
 
    92     var stageView = opts.stageView;
 
    93     var waitInterval;
 
    93     var waitInterval;
 
    94     var wait = 0;
 
    94     var wait = 0;
 
    95     
    95 
    96     stageView.registerComponent(this);
 
    96     stageView.registerComponent(this);
 
    97 
    97 
    98     var isHidden = function(child) {
 
    98     var isHidden = function(child) {
 
    99         // TODO: the origin point is an approximation. Should refine this
 
    99         // TODO: the origin point is an approximation. Should refine this
 
   100         var globalPos = child.toGlobal(new PIXI.Point(0,0));
 
   100         var globalPos = child.toGlobal(new PIXI.Point(0,0));
 
   130         }
 
   130         }
 
   131         if(!resColor) {
 
   131         if(!resColor) {
 
   132             resColor = colorsDef.defaultColor || DEFAULT_ANNOT_COLOR;
 
   132             resColor = colorsDef.defaultColor || DEFAULT_ANNOT_COLOR;
 
   133         }
 
   133         }
 
   134         return resColor;
 
   134         return resColor;
 
   135     }
 
   135     };
 
   136 
   136 
   137     this.addAnnot = function(category, text, user, color, ts){
 
   137     this.addAnnot = function(category, text, user, color, ts){
 
   138 
   138 
   139         var x = 0;
 
   139         var x = 0;
 
   140         var y = (ts-this.startTs) * this.pixelsPerSecond / 1000 + yInit;
 
   140         var y = (ts-this.startTs) * this.pixelsPerSecond / 1000 + yInit;
 
   144         if (wait === 0){
 
   144         if (wait === 0){
 
   145 	        var graphics = new PIXI.Graphics()
 
   145 	        var graphics = new PIXI.Graphics()
 
   146 	            .beginFill(colorHex)
 
   146 	            .beginFill(colorHex)
 
   147 	            .drawRect(x, y, 10, 3)
 
   147 	            .drawRect(x, y, 10, 3)
 
   148 	            .endFill();
 
   148 	            .endFill();
 
   149 	
   149 
   150 	        this.container.addChild(graphics);
 
   150 	        this.container.addChild(graphics);
 
   151 	
   151 
   152 	        var textHeight = 0;
 
   152 	        var textHeight = 0;
 
   153 	        var catLabel = new PIXI.Text(
 
   153 	        var catLabel = new PIXI.Text(
 
   154 	            category,
 
   154 	            category,
 
   155 	            _(annotStyles.label).extend({fill: color}).value()
 
   155 	            _(annotStyles.label).extend({fill: color}).value()
 
   156 	        );
 
   156 	        );
 
   157 	        catLabel.x = x + marginX;
 
   157 	        catLabel.x = x + marginX;
 
   158 	        catLabel.y = y - 23;
 
   158 	        catLabel.y = y - 23;
 
   159 	        this.container.addChild(catLabel);
 
   159 	        this.container.addChild(catLabel);
 
   160 	        textHeight += (catLabel.height - 23 + 2);
 
   160 	        textHeight += (catLabel.height - 23 + 2);
 
   161 	
   161 
   162 	        if(text) {
 
   162 	        if(text) {
 
   163 	            var catText = new PIXI.Text(text, annotStyles.text);
 
   163 	            var catText = new PIXI.Text(text, annotStyles.text);
 
   164 	            catText.x = x + marginX;
 
   164 	            catText.x = x + marginX;
 
   165 	            catText.y = y + textHeight;
 
   165 	            catText.y = y + textHeight;
 
   166 	            this.container.addChild(catText);
 
   166 	            this.container.addChild(catText);
 
   167 	            textHeight += (catText.height + 2);
 
   167 	            textHeight += (catText.height + 2);
 
   168 	        }
 
   168 	        }
 
   169 	
   169 
   170 	        var catUser = new PIXI.Text(user, annotStyles.user);
 
   170 	        var catUser = new PIXI.Text(user, annotStyles.user);
 
   171 	        catUser.x = x + marginX;
 
   171 	        catUser.x = x + marginX;
 
   172 	        catUser.y = y + textHeight;
 
   172 	        catUser.y = y + textHeight;
 
   173 	        this.container.addChild(catUser);
 
   173 	        this.container.addChild(catUser);
 
   174 	        textHeight += (catUser.height + 8);
 
   174 	        textHeight += (catUser.height + 8);
 
   175 	        
   175 
   176 	        if (this.ignoreAnnots === true){
 
   176 	        if (this.ignoreAnnots === true){
 
   177 		        wait = textHeight / this.pixelsPerSecond;
 
   177 		        wait = textHeight / this.pixelsPerSecond;
 
   178 		        waitInterval = setInterval(function() {_this.refreshWait();}, 1000);
 
   178 		        waitInterval = setInterval(function() {_this.refreshWait();}, 1000);
 
   179 	        }
 
   179 	        }
 
   180         }
 
   180         }
 
   200 
   200 
   201     this.move = this.refresh = function() {
 
   201     this.move = this.refresh = function() {
 
   202         var diff = (this.startTs - Date.now())/1000;
 
   202         var diff = (this.startTs - Date.now())/1000;
 
   203         this.moveTo(diff);
 
   203         this.moveTo(diff);
 
   204     };
 
   204     };
 
   205     
   205 
   206     this.refreshWait = function(){
 
   206     this.refreshWait = function(){
 
   207     	wait -= 1;
 
   207     	wait -= 1;
 
   208     	if (wait < 0){
 
   208     	if (wait < 0){
 
   209     		wait = 0;
 
   209     		wait = 0;
 
   210     		clearInterval(waitInterval);
 
   210     		clearInterval(waitInterval);
 
   227         ws.message(function(data) {
 
   227         ws.message(function(data) {
 
   228             _this.addAnnots(data);
 
   228             _this.addAnnots(data);
 
   229         });
 
   229         });
 
   230 
   230 
   231     };
 
   231     };
 
   232     
   232 
   233 
   233 
   234     this.start = function() {
 
   234     this.start = function() {
 
   235         if(!started) {
 
   235         if(!started) {
 
   236             this.startTs = Date.now();
 
   236             this.startTs = Date.now();
 
   237             started = true;
 
   237             started = true;
 
   300     this.height = opts.height;
 
   300     this.height = opts.height;
 
   301     this.intervalHeight = opts.intervalHeight;
 
   301     this.intervalHeight = opts.intervalHeight;
 
   302     this.intervalWidth = opts.intervalWidth;
 
   302     this.intervalWidth = opts.intervalWidth;
 
   303     this.maxCellHeight = opts.maxCellHeight;
 
   303     this.maxCellHeight = opts.maxCellHeight;
 
   304     this.annotCategories = opts.annotCategories;
 
   304     this.annotCategories = opts.annotCategories;
 
   305 	this.startTs = options.startTs || Date.now();
 
   305     this.startTs = options.startTs || Date.now();
 
   306     this.showClockGraphics = opts.showClockGraphics;
 
   306     this.showClockGraphics = opts.showClockGraphics;
 
   307     this.archive = opts.archive;
 
   307     this.archive = opts.archive;
 
   308     
   308 
   309     this.circleX = opts.circleX || (this.width/2);
 
   309     this.circleX = opts.circleX || (this.width/2);
 
   310     this.circleY = opts.circleY || (this.height/2);
 
   310     this.circleY = opts.circleY || (this.height/2);
 
   311     this.radius = opts.radius;
 
   311     this.radius = opts.radius;
 
   312     var perimeter = 2*Math.PI* this.radius;
 
   312     var perimeter = 2*Math.PI* this.radius;
 
   313     this.intervalDuration = (this.intervalWidth * this.duration / perimeter);
 
   313     this.intervalDuration = (this.intervalWidth * this.duration / perimeter);
 
   314     
   314 
   315     var channel = opts.channel;
 
   315     var channel = opts.channel;
 
   316     var eventCode = opts.eventCode;
 
   316     var eventCode = opts.eventCode;
 
   317     var serverUrl = opts.serverUrl;
 
   317     var serverUrl = opts.serverUrl;
 
   318     var maxPages = opts.maxPages;
 
   318     var maxPages = opts.maxPages;
 
   319     
   319 
   320     var totalIndex = Math.floor( perimeter/this.intervalWidth);
 
   320     var totalIndex = Math.floor( perimeter/this.intervalWidth);
 
   321 
   321 
   322     this.cells = []
 
   322     this.cells = [];
 
   323     for (var i=0; i<(perimeter/this.intervalWidth) ; i++){
 
   323     for (var i=0; i<(perimeter/this.intervalWidth) ; i++){
 
   324     	this.cells[i] = [];
 
   324         this.cells[i] = [];
 
   325     	this.cells[i].i = i;
 
   325         this.cells[i].i = i;
 
   326     	this.cells[i].totalAnnots = 0;
 
   326         this.cells[i].totalAnnots = 0;
 
   327     	this.cells[i].categories = {};
 
   327         this.cells[i].categories = {};
 
   328     }
 
   328     }
 
   329 
   329 
   330     var ws = opts.ws;
 
   330     var ws = opts.ws;
 
   331     var stageView = opts.stageView;
 
   331     var stageView = opts.stageView;
 
   332 
   332 
   333     //draw the base - circle and line to locate the scene
 
   333     //draw the base - circle and line to locate the scene
 
   334     var graphics = new PIXI.Graphics();
 
   334     var graphics = new PIXI.Graphics();
 
   335     graphics.lineStyle(2, 0x646464)
 
   335     graphics.lineStyle(2, 0x646464)
 
   336     	.drawCircle(this.circleX, this.circleY, this.radius - 3)
 
   336         .drawCircle(this.circleX, this.circleY, this.radius - 3)
 
   337     	.endFill()
 
   337         .endFill();
 
   338     this.container.addChild(graphics);
 
   338     this.container.addChild(graphics);
 
   339 
   339 
   340     stageView.registerComponent(this);
 
   340     stageView.registerComponent(this);
 
   341 
   341 
   342 	var loadArchives = function() {
 
   342     var loadArchives = function() {
 
   343         //start timeBegin end startTime
 
   343         //start timeBegin end startTime
 
   344         //query -> need channel + eventCode
 
   344         //query -> need channel + eventCode
 
   345         //iterate over data fill cells
 
   345         //iterate over data fill cells
 
   346         var startTs = _this.timeBegin;
 
   346         var startTs = _this.timeBegin;
 
   347         var endTs = _this.startTs;
 
   347         var endTs = Math.min(_this.timeEnd,_this.startTs);
 
       
   348 
       
   349         console.log("START TS",new Date(startTs).toISOString());
 
       
   350         console.log("END TS",new Date(endTs).toISOString());
 
   348 
   351 
   349         var url = serverUrl + '/p/api/v1/annotation';
 
   352         var url = serverUrl + '/p/api/v1/annotation';
 
   350         var filters = [
 
   353         var filters = [
 
   351             { name: 'ts', op: '>', val: new Date(startTs).toISOString()}, //start
 
   354             { name: 'ts', op: '>', val: new Date(startTs).toISOString()}, //start
 
   352             { name: 'ts', op: '<=', val: new Date(endTs).toISOString()}, //end
 
   355             { name: 'ts', op: '<=', val: new Date(endTs).toISOString()}, //end
 
   358 
   361 
   359         var totalPage = 1;
 
   362         var totalPage = 1;
 
   360         var currentPage = 1;
 
   363         var currentPage = 1;
 
   361 
   364 
   362         var processResFunction = function(res) {
 
   365         var processResFunction = function(res) {
 
   363 
   366             //console.log("RES archive", res);
 
   364             if(res) {
 
   367             if(res) {
 
   365                 var data = res.target.json;
 
   368                 var data = res.target.json;
 
   366                 /*jshint -W069 */
 
   369                 /*jshint -W069 */
 
   367                 totalPage = Math.min(maxPages,parseInt(data['total_pages']));
 
   370                 totalPage = Math.min(maxPages,parseInt(data['total_pages']));
 
   368                 data.objects.forEach(function(annotation) {
 
   371                 data.objects.forEach(function(annotation) {
 
   381     };
 
   384     };
 
   382 
   385 
   383     //Add Annotation to the TimeLine
 
   386     //Add Annotation to the TimeLine
 
   384     this.addAnnot = function(data){
 
   387     this.addAnnot = function(data){
 
   385 
   388 
   386     	var ts = Date.parse(data.ts);
 
   389         var ts = Date.parse(data.ts);
 
   387     	var colorsDef;
 
   390         var colorsDef;
 
   388     	_(this.annotCategories).eachRight(function(cdef) {
 
   391         _(this.annotCategories).eachRight(function(cdef) {
 
   389             if(cdef.ts < ts) {
 
   392             if(cdef.ts < ts) {
 
   390                 colorsDef = cdef;
 
   393                 colorsDef = cdef;
 
   391                 return false;
 
   394                 return false;
 
   392             }
 
   395             }
 
   393         });
 
   396         });
 
   394 
   397 
   395     	if (this.timeEnd > ts){
 
   398         if(!colorsDef) {
 
   396 	    	var i = Math.floor((ts - this.timeBegin)/(1000*this.intervalDuration));
 
   399             return;
 
   397 
   400         }
 
   398 	    	if (typeof(this.cells[i].graphics) === 'undefined'){
 
   401 
   399 	    		this.initCell(this.cells[i], colorsDef);
 
   402         if (this.timeEnd > ts){
 
   400 	    	}
 
   403             var i = Math.floor((ts - this.timeBegin)/(1000*this.intervalDuration));
 
   401 
   404 
   402 	    	if (typeof(colorsDef.colors[data.content.category.code]) !== 'undefined'){
 
   405             if (typeof(this.cells[i].graphics) === 'undefined'){
 
   403 	    		var annotCode = data.content.category.code;
 
   406                 this.initCell(this.cells[i], colorsDef);
 
   404 	    	} else {
 
   407             }
 
   405 	    		var annotCode = 'default';
 
   408 
   406 	    	}
 
   409             var annotCode;
 
   407 
   410             if (typeof(colorsDef.colors[data.content.category.code]) !== 'undefined'){
 
   408 			this.cells[i].categories[annotCode].count += 1;
 
   411                 annotCode = data.content.category.code;
 
   409 			this.cells[i].totalAnnots +=1;
 
   412             } else {
 
   410 			this.redrawCell(this.cells[i], colorsDef);
 
   413                 annotCode = 'default';
 
   411     	}
 
   414             }
 
       
   415 
       
   416             this.cells[i].categories[annotCode].count += 1;
 
       
   417             this.cells[i].totalAnnots +=1;
 
       
   418             this.redrawCell(this.cells[i], colorsDef);
 
       
   419         }
 
   412     };
 
   420     };
 
   413 
   421 
   414     this.initClockGraphics = function() {
 
   422     this.initClockGraphics = function() {
 
   415 	    var tBeg = new PIXI.Text(Utils.formatTime(this.timeBegin), { font: '12pt Gothic Standard', fill: '#646464' });
 
   423         var tBeg = new PIXI.Text(Utils.formatTime(this.timeBegin), { font: '12pt Gothic Standard', fill: '#646464' });
 
   416 	    tBeg.x = this.circleX + 15;
 
   424         tBeg.x = this.circleX + 15;
 
   417 	    tBeg.y = this.circleY - this.radius - this.maxCellHeight - 10;
 
   425         tBeg.y = this.circleY - this.radius - this.maxCellHeight - 10;
 
   418 	    this.container.addChild(tBeg);
 
   426         this.container.addChild(tBeg);
 
   419 
   427 
   420 	    var tEnd = new PIXI.Text(Utils.formatTime(this.timeEnd), { font: '12pt Gothic Standard', fill: '#646464' });
 
   428         var tEnd = new PIXI.Text(Utils.formatTime(this.timeEnd), { font: '12pt Gothic Standard', fill: '#646464' });
 
   421 	    tEnd.x = this.circleX - 15 - tEnd.width;
 
   429         tEnd.x = this.circleX - 15 - tEnd.width;
 
   422 	    tEnd.y = this.circleY - this.radius - this.maxCellHeight - 10;
 
   430         tEnd.y = this.circleY - this.radius - this.maxCellHeight - 10;
 
   423 	    this.container.addChild(tEnd);
 
   431         this.container.addChild(tEnd);
 
   424 
   432 
   425 	    var t15 = new PIXI.Text(Utils.formatTime(((this.timeEnd - this.timeBegin)/4) + this.timeBegin), { font: '12pt Gothic Standard', fill: '#646464' });
 
   433         var t15 = new PIXI.Text(Utils.formatTime(((this.timeEnd - this.timeBegin)/4) + this.timeBegin), { font: '12pt Gothic Standard', fill: '#646464' });
 
   426 	    t15.x = this.circleX + this.radius + this.maxCellHeight + 10 ;
 
   434         t15.x = this.circleX + this.radius + this.maxCellHeight + 10 ;
 
   427 	    t15.y = this.circleY - t15.height;
 
   435         t15.y = this.circleY - t15.height;
 
   428 	    t15.rotation = Math.PI /2;
 
   436         t15.rotation = Math.PI /2;
 
   429 	    this.container.addChild(t15);
 
   437         this.container.addChild(t15);
 
   430 
   438 
   431 	    var t30 = new PIXI.Text(Utils.formatTime(((this.timeEnd - this.timeBegin)/2) + this.timeBegin), { font: '12pt Gothic Standard', fill: '#646464' });
 
   439         var t30 = new PIXI.Text(Utils.formatTime(((this.timeEnd - this.timeBegin)/2) + this.timeBegin), { font: '12pt Gothic Standard', fill: '#646464' });
 
   432 	    t30.x = this.circleX - t30.width/2;
 
   440         t30.x = this.circleX - t30.width/2;
 
   433 	    t30.y = this.circleY + this.radius + this.maxCellHeight - 2;
 
   441         t30.y = this.circleY + this.radius + this.maxCellHeight - 2;
 
   434 	    this.container.addChild(t30);
 
   442         this.container.addChild(t30);
 
   435 
   443 
   436 	    var t45 = new PIXI.Text(Utils.formatTime(((this.timeEnd - this.timeBegin)*3/4) + this.timeBegin), { font: '12pt Gothic Standard', fill: '#646464' });
 
   444         var t45 = new PIXI.Text(Utils.formatTime(((this.timeEnd - this.timeBegin)*3/4) + this.timeBegin), { font: '12pt Gothic Standard', fill: '#646464' });
 
   437 	    t45.x = this.circleX - this.radius - this.maxCellHeight - 10 ;
 
   445         t45.x = this.circleX - this.radius - this.maxCellHeight - 10 ;
 
   438 	    t45.y = this.circleY + t15.height;
 
   446         t45.y = this.circleY + t15.height;
 
   439 	    t45.rotation = -Math.PI/2;
 
   447         t45.rotation = -Math.PI/2;
 
   440 	    this.container.addChild(t45);
 
   448         this.container.addChild(t45);
 
   441 	    
   449 
   442 	    var lineV = new PIXI.Graphics();
 
   450         var lineV = new PIXI.Graphics();
 
   443 	    lineV.lineStyle(1, 0x646464)
 
   451         lineV.lineStyle(1, 0x646464)
 
   444 	    	.moveTo(this.circleX, this.circleY - (this.radius/3)/2)
 
   452             .moveTo(this.circleX, this.circleY - (this.radius/3)/2)
 
   445 	    	.lineTo(this.circleX, this.circleY - this.radius - this.maxCellHeight - 10)
 
   453             .lineTo(this.circleX, this.circleY - this.radius - this.maxCellHeight - 10)
 
   446     	.endFill();
 
   454             .endFill();
 
   447 	    this.container.addChild(lineV);
 
   455         this.container.addChild(lineV);
 
   448     }
 
   456     };
 
   449 
   457 
   450     //Draw the cellule
 
   458     //Draw the cellule
 
   451     this.redrawCell = function(cell, colorsDef){
 
   459     this.redrawCell = function(cell, colorsDef){
 
   452     	var y = 0;
 
   460         var y = 0;
 
   453 
   461 
   454         //Check if total height is higher than Max Cell Height
 
   462         //Check if total height is higher than Max Cell Height
 
   455         var heightStep;
 
   463         var heightStep;
 
   456         if ((cell.totalAnnots*this.intervalHeight) > this.maxCellHeight){
 
   464         if ((cell.totalAnnots*this.intervalHeight) > this.maxCellHeight){
 
   457             heightStep = this.maxCellHeight/cell.totalAnnots;
 
   465             heightStep = this.maxCellHeight/cell.totalAnnots;
 
   458         } else {
 
   466         } else {
 
   459             heightStep = this.intervalHeight;
 
   467             heightStep = this.intervalHeight;
 
   460         }
 
   468         }
 
   461 
   469 
   462     	//Draw the rect depending on the height step calculated
 
   470         //Draw the rect depending on the height step calculated
 
   463     	for (var i=0; i< colorsDef.order.length; i++){
 
   471         for (var i=0; i< colorsDef.order.length; i++){
 
   464     		var currentCode = colorsDef.order[i];
 
   472             var currentCode = colorsDef.order[i];
 
   465 			cell.graphics.beginFill(cell.categories[currentCode].color.replace("#", "0x"))
 
   473             cell.graphics.beginFill(cell.categories[currentCode].color.replace('#', '0x'))
 
   466     			.drawRect(0, y, this.intervalWidth-1, -cell.categories[currentCode].count * heightStep)
 
   474                 .drawRect(0, y, this.intervalWidth-1, -cell.categories[currentCode].count * heightStep)
 
   467     			.endFill();
 
   475                 .endFill();
 
   468     		y -= cell.categories[currentCode].count*heightStep;
 
   476             y -= cell.categories[currentCode].count*heightStep;
 
   469     	}
 
   477         }
 
   470     }
 
   478     };
 
   471 
   479 
   472     this.initCell = function(cell, colorsDef){
 
   480     this.initCell = function(cell, colorsDef){
 
   473     	cell.graphics = new PIXI.Graphics();
 
   481         cell.graphics = new PIXI.Graphics();
 
   474     	cell.graphics.position.x = this.circleX + this.radius * Math.sin(cell.i*(360/totalIndex)*(Math.PI/180));
 
   482         cell.graphics.position.x = this.circleX + this.radius * Math.sin(cell.i*(360/totalIndex)*(Math.PI/180));
 
   475     	cell.graphics.position.y = this.circleY - this.radius * Math.cos(cell.i*(360/totalIndex)*(Math.PI/180));
 
   483         cell.graphics.position.y = this.circleY - this.radius * Math.cos(cell.i*(360/totalIndex)*(Math.PI/180));
 
   476     	cell.graphics.rotation = (cell.i)*(360/totalIndex)*(Math.PI/180) + (360/(totalIndex*2))*(Math.PI/180);
 
   484         cell.graphics.rotation = (cell.i)*(360/totalIndex)*(Math.PI/180) + (360/(totalIndex*2))*(Math.PI/180);
 
   477     	this.container.addChild(cell.graphics);
 
   485         this.container.addChild(cell.graphics);
 
   478 
   486 
   479     	for (var category in colorsDef.colors){
 
   487         for (var category in colorsDef.colors){
 
   480     		cell.categories[category] = {
 
   488             cell.categories[category] = {
 
   481 				"count": 0,
 
   489                 'count': 0,
 
   482 				"color": colorsDef.colors[category]
 
   490                 'color': colorsDef.colors[category]
 
   483     		};
 
   491             };
 
   484     	}
 
   492         }
 
   485     	if (typeof(cell.categories['default']) === 'undefined'){
 
   493         if (typeof(cell.categories['default']) === 'undefined'){
 
   486 			cell.categories['default'] = {
 
   494             cell.categories['default'] = {
 
   487 				"count": 0,
 
   495                 'count': 0,
 
   488 				"color": colorsDef.defaultColor
 
   496                 'color': colorsDef.defaultColor
 
   489 			}
 
   497             };
 
   490     	}
 
   498         }
 
   491     }
 
   499     };
 
   492 
   500 
   493     this.init = function() {
 
   501     this.init = function() {
 
   494     	if (!this.archive){
 
   502         if (!this.archive){
 
   495 	        ws.message(function(data) {
 
   503             ws.message(function(data) {
 
   496 	            _this.addAnnot(data);
 
   504                 _this.addAnnot(data);
 
   497 	        });
 
   505             });
 
   498     	}
 
   506         }
 
   499 
   507 
   500     	if (this.showClockGraphics){this.initClockGraphics();}
 
   508         if (this.showClockGraphics){this.initClockGraphics();}
 
   501     };
 
   509     };
 
   502 
   510 
   503 
   511 
   504     this.start = function() {
 
   512     this.start = function() {
 
   505     	this.startTs = Date.now();
 
   513         this.startTs = Date.now();
 
   506         loadArchives();
 
   514         loadArchives();
 
   507     };
 
   515     };
 
   508 
   516 
   509     this.refresh = function() {
 
   517     this.refresh = function() {
 
   510 
   518 
   515 
   523 
   516     return this;
 
   524     return this;
 
   517 }
 
   525 }
 
   518 
   526 
   519 module.exports = {
 
   527 module.exports = {
 
   520 	AnnotsTimeLine: AnnotsTimeLine
 
   528     AnnotsTimeLine: AnnotsTimeLine
 
   521 };
 
   529 };
 
   522 
   530 
   523 },{"./utils.js":9,"lodash":"lodash","pixi":"pixi"}],4:[function(require,module,exports){
 
   531 },{"./utils.js":9,"lodash":"lodash","pixi":"pixi"}],4:[function(require,module,exports){
 
   524 /**
 
   532 /**
 
   525 * js/annotsvizview.js
 
   533 * js/annotsvizview.js
 
   543     width: 1024,
 
   551     width: 1024,
 
   544     height: 768
 
   552     height: 768
 
   545 };
 
   553 };
 
   546 
   554 
   547 function AnnotsVizView(options){
 
   555 function AnnotsVizView(options){
 
   548 	var _this = this;
 
   556     var _this = this;
 
   549     var opts = _(options).defaults(defaultOptions).value();
 
   557     var opts = _(options).defaults(defaultOptions).value();
 
   550 
   558 
   551     this.container = new PIXI.DisplayObjectContainer();
 
   559     this.container = new PIXI.DisplayObjectContainer();
 
   552     this.container.x = opts.xInit;
 
   560     this.container.x = opts.xInit;
 
   553     this.container.y = opts.yInit;
 
   561     this.container.y = opts.yInit;
 
   554 	this.width = opts.width;
 
   562     this.width = opts.width;
 
   555 	this.height= opts.height;
 
   563     this.height= opts.height;
 
   556     this.timeBegin = opts.timeBegin;
 
   564     this.timeBegin = opts.timeBegin;
 
   557     this.timeEnd = opts.timeEnd;
 
   565     this.timeEnd = opts.timeEnd;
 
       
   566 
   558     this.annotCategories = [];
 
   567     this.annotCategories = [];
 
       
   568     this.annotCategoriesDay2 = [];
 
       
   569     this.annotCategoriesDay1 = [];
 
       
   570 
       
   571     var wsPianoroll = opts.wsPianoroll;
 
       
   572     var wsAnnot = opts.wsAnnot;
 
       
   573     var stageView = opts.stageView;
 
       
   574     var currentTime = Date.now() + 3600*1000;
 
       
   575     var channel = opts.channel;
 
       
   576     var serverUrl = opts.serverUrl;
 
   559     
   577     
   560     Utils.getAnnotCategories(opts.urlCategories, this.annotCategories);
 
   578     var eventCode = opts.eventCode;
 
   561     
   579     var eventCodeSessionDay2 = opts.eventCodeSessionDay2;
 
   562 	var wsPianoroll = opts.wsPianoroll;
 
   580 	var eventCodeSessionDay1 = opts.eventCodeSessionDay1;
 
   563 	var wsAnnot = opts.wsAnnot;
 
   581 
   564 	var stageView = opts.stageView;
 
   582 	Utils.getAnnotCategories(opts.urlCategories + eventCode, this.annotCategories);
 
   565 	var currentTime = Date.now() + 3600*1000;
 
   583     Utils.getAnnotCategories(opts.urlCategories + eventCodeSessionDay2, this.annotCategoriesDay2);
 
   566 	var eventCode = opts.eventCode;
 
   584     Utils.getAnnotCategories(opts.urlCategories + eventCodeSessionDay1, this.annotCategoriesDay1);
 
   567     var channel = opts.channel;
 
   585 
   568 
   586     stageView.registerComponent(this);
 
   569 	stageView.registerComponent(this);
 
   587 
   570 
   588     var currentDay = new AnnotsTimeLine.AnnotsTimeLine({
 
   571 	var timeLineDay2 = new AnnotsTimeLine.AnnotsTimeLine({
 
       
   572     	stageView : stageView,
 
   589     	stageView : stageView,
 
   573         logger: logger,
 
   590         logger: logger,
 
   574         ws: new annotviz.WsWrapper(wsUriAnnotation, logger),
 
   591         ws: wsAnnot,
 
   575         xInit: 0,
 
   592         xInit: 0,
 
   576         yInit: 0,
 
   593         yInit: 0,
 
   577         width: 1024 - 200 - 200,
 
   594         width: 1024 - 200 - 200,
 
   578         height: 768-200,
 
   595         height: 768-200,
 
   579         timeBegin: this.timeBegin,
 
   596         timeBegin: this.timeBegin,
 
   582         intervalHeight: 10,
 
   599         intervalHeight: 10,
 
   583         maxCellHeight: 70,
 
   600         maxCellHeight: 70,
 
   584         radius: 200,
 
   601         radius: 200,
 
   585         eventCode: eventCode,
 
   602         eventCode: eventCode,
 
   586         channel: channel,
 
   603         channel: channel,
 
       
   604         serverUrl: serverUrl,
 
   587         annotCategories: this.annotCategories
 
   605         annotCategories: this.annotCategories
 
   588     });
 
   606     });
 
   589 	
   607 	
   590     //Archive day 1
 
   608 	//Archive day 2
 
       
   609     var timeLineDay2 = new AnnotsTimeLine.AnnotsTimeLine({
 
       
   610     	stageView : stageView,
 
       
   611         xInit: 0,
 
       
   612         yInit: 0,
 
       
   613         width: 1024 - 200 - 200,
 
       
   614         height: 768-200,
 
       
   615         timeBegin: Date.parse("2015-01-23T09:30:00+01:00"),
 
       
   616         timeEnd: Date.parse("2015-01-23T18:30:00+01:00"),
 
       
   617         circleX: currentDay.circleX,
 
       
   618         circleY: currentDay.circleY,
 
       
   619         intervalWidth: (currentDay.radius*2/3)* currentDay.intervalWidth / currentDay.radius,
 
       
   620         intervalHeight: (currentDay.intervalHeight * (currentDay.radius - currentDay.radius*2/3))/ currentDay.maxCellHeight,
 
       
   621         maxCellHeight: (currentDay.radius - currentDay.radius*2/3)/2,
 
       
   622         radius: currentDay.radius*2/3,
 
       
   623         annotCategories: this.annotCategoriesDay2,
 
       
   624         eventCode: eventCodeSessionDay2,
 
       
   625         channel: channel,
 
       
   626         serverUrl: serverUrl,
 
       
   627         showClockGraphics:false,
 
       
   628         archive: true
 
       
   629     });
 
       
   630 	
       
   631 	//Archive day 1
 
   591     var timeLineDay1 = new AnnotsTimeLine.AnnotsTimeLine({
 
   632     var timeLineDay1 = new AnnotsTimeLine.AnnotsTimeLine({
 
   592     	stageView : stageView,
 
   633     	stageView : stageView,
 
   593         archive: true,
 
       
   594         xInit: 0,
 
   634         xInit: 0,
 
   595         yInit: 0,
 
   635         yInit: 0,
 
   596         width: 1024 - 200 - 200,
 
   636         width: 1024 - 200 - 200,
 
   597         height: 768-200,
 
   637         height: 768-200,
 
   598         timeBegin: Date.parse("2015-01-22T09:30:00+01:00"),
 
   638         timeBegin: Date.parse("2015-01-22T09:30:00+01:00"),
 
   599         timeEnd: Date.parse("2015-01-22T18:30:00+01:00"),
 
   639         timeEnd: Date.parse("2015-01-22T18:30:00+01:00"),
 
   600         circleX: timeLineDay2.circleX,
 
   640         circleX: currentDay.circleX,
 
   601         circleY: timeLineDay2.circleY,
 
   641         circleY: currentDay.circleY,
 
   602         intervalWidth: (timeLineDay2.radius*2/3)* timeLineDay2.intervalWidth / timeLineDay2.radius,
 
   642         intervalWidth: (currentDay.radius*2/3)* currentDay.intervalWidth / currentDay.radius,
 
   603         intervalHeight: (timeLineDay2.intervalHeight * (timeLineDay2.radius - timeLineDay2.radius*2/3))/ timeLineDay2.maxCellHeight,
 
   643         intervalHeight: (currentDay.intervalHeight * (currentDay.radius - currentDay.radius/3))/ currentDay.maxCellHeight,
 
   604         maxCellHeight: (timeLineDay2.radius - timeLineDay2.radius*2/3)/4,
 
   644         maxCellHeight: (currentDay.radius*2/3 - currentDay.radius/3)/4,
 
   605         radius: timeLineDay2.radius*2/3,
 
   645         radius: currentDay.radius/3,
 
   606         annotCategories: this.annotCategories,
 
   646         annotCategories: this.annotCategoriesDay1,
 
   607         eventCode: eventCode,
 
   647         eventCode: eventCodeSessionDay1,
 
   608         channel: channel,
 
   648         channel: channel,
 
   609         showClockGraphics:false
 
   649         serverUrl: serverUrl,
 
       
   650         showClockGraphics:false,
 
       
   651         archive: true,
 
   610     });
 
   652     });
 
   611     
   653 
   612     var currentTimeText = new PIXI.Text("-- : -- : --", { font: '18pt Gothic Standard', fill: '#646464' });
 
   654     var currentTimeText = new PIXI.Text("-- : -- : --", { font: '18pt Gothic Standard', fill: '#646464' });
 
   613     currentTimeText.x = timeLineDay2.circleX - currentTimeText.width/2;
 
   655     currentTimeText.x = timeLineDay2.circleX - currentTimeText.width/2;
 
   614     currentTimeText.y = timeLineDay2.circleY - currentTimeText.height/2;
 
   656     currentTimeText.y = timeLineDay2.circleY - currentTimeText.height/2;
 
   615     this.container.addChild(currentTimeText);
 
   657     this.container.addChild(currentTimeText);
 
   616 
   658 
   617     var timeLineDay3 = new PIXI.Graphics();
 
   659     var doubleRollH = new DoubleRoll.DoubleRoll({
 
   618     timeLineDay3.lineStyle(1, 0x646464)
 
       
   619     	.drawCircle(timeLineDay2.circleX, timeLineDay2.circleY, timeLineDay2.radius/3)
 
       
   620     	.endFill()
 
       
   621     this.container.addChild(timeLineDay3);
 
       
   622     
       
   623 	var doubleRollH = new DoubleRoll.DoubleRoll({
 
       
   624         stageView : stageView,
 
   660         stageView : stageView,
 
   625     	logger: logger,
 
   661         logger: logger,
 
   626         ws: wsPianoroll,
 
   662         ws: wsPianoroll,
 
   627         yInit: (this.height - 200),
 
   663         yInit: (this.height - 200),
 
   628         sceneHeight: 200,
 
   664         sceneHeight: 200,
 
   629         pianorolls : [
 
   665         pianorolls : [
 
   630             {
 
   666             {
 
   634                 noteHeight: 10
 
   670                 noteHeight: 10
 
   635             },
 
   671             },
 
   636         ]
 
   672         ]
 
   637     });
 
   673     });
 
   638 
   674 
   639 	var doubleRollV = new DoubleRoll.DoubleRoll({
 
   675     var doubleRollV = new DoubleRoll.DoubleRoll({
 
   640         stageView : stageView,
 
   676         stageView : stageView,
 
   641     	logger: logger,
 
   677         logger: logger,
 
   642         ws: wsPianoroll,
 
   678         ws: wsPianoroll,
 
   643         orientation: 'vertical',
 
   679         orientation: 'vertical',
 
   644         sceneHeight: 768-200,
 
   680         sceneHeight: 768-200,
 
   645         pianorolls : [
 
   681         pianorolls : [
 
   646             {
 
   682             {
 
   650                 noteHeight: 5,
 
   686                 noteHeight: 5,
 
   651             },
 
   687             },
 
   652         ]
 
   688         ]
 
   653     });
 
   689     });
 
   654 
   690 
   655 	var annotsRoll = new AnnotsRoll.AnnotsRoll({
 
   691     var annotsRoll = new AnnotsRoll.AnnotsRoll({
 
   656     	stageView : stageView,
 
   692         stageView : stageView,
 
   657         logger: logger,
 
   693         logger: logger,
 
   658         ws: wsAnnot,
 
   694         ws: wsAnnot,
 
   659         parentContainer: doubleRollV.stage,
 
   695         parentContainer: doubleRollV.stage,
 
   660         xInit: 1024 - 200 - 200,
 
   696         xInit: 1024 - 200 - 200,
 
   661         yInit: 768-200,
 
   697         yInit: 768-200,
 
   665         framerate: doubleRollV.framerate,
 
   701         framerate: doubleRollV.framerate,
 
   666         pixelsPerSecond: Math.floor(1024 / 60),
 
   702         pixelsPerSecond: Math.floor(1024 / 60),
 
   667         annotColors: this.annotCategories
 
   703         annotColors: this.annotCategories
 
   668     });
 
   704     });
 
   669 
   705 
   670 	var limiters = new PIXI.Graphics()
 
   706     var limiters = new PIXI.Graphics()
 
   671 		.lineStyle(1, 0x646464)
 
   707         .lineStyle(1, 0x646464)
 
   672 		.moveTo(annotsRoll.container.x, annotsRoll.container.y)
 
   708         .moveTo(annotsRoll.container.x, annotsRoll.container.y)
 
   673 		.lineTo(annotsRoll.container.x, annotsRoll.container.y - annotsRoll.height)
 
   709         .lineTo(annotsRoll.container.x, annotsRoll.container.y - annotsRoll.height)
 
   674 		.moveTo(annotsRoll.container.x + annotsRoll.widthRoll, annotsRoll.container.y)
 
   710         .moveTo(annotsRoll.container.x + annotsRoll.widthRoll, annotsRoll.container.y)
 
   675 		.lineTo(annotsRoll.container.x + annotsRoll.widthRoll, annotsRoll.container.y - annotsRoll.height)
 
   711         .lineTo(annotsRoll.container.x + annotsRoll.widthRoll, annotsRoll.container.y - annotsRoll.height)
 
   676 		.moveTo(0, this.height - 200)
 
   712         .moveTo(0, this.height - 200)
 
   677 		.lineTo(this.width, this.height - 200)
 
   713         .lineTo(this.width, this.height - 200)
 
   678 		.drawRect(0, 0, this.width -1, this.height -1)
 
   714         .drawRect(0, 0, this.width -1, this.height -1)
 
   679 		.beginFill(0xECECEC)
 
   715         .beginFill(0xECECEC)
 
   680 		.drawRect(1024 - 200, 0, 200, 768-200)
 
   716         .drawRect(1024 - 200, 0, 200, 768-200)
 
   681 		.endFill();
 
   717         .endFill();
 
   682 	this.container.addChild(limiters);
 
   718     this.container.addChild(limiters);
 
   683 
   719 
   684 	this.init = function(){
 
   720     this.init = function(){
 
   685 	};
 
   721     };
 
   686 
   722 
   687 	this.updateTime = function(){
 
   723     this.updateTime = function(){
 
   688         currentTimeText.setText(Utils.formatTime(Date.now()));
 
   724         currentTimeText.setText(Utils.formatTime(Date.now()));
 
   689     };
 
   725     };
 
   690 
   726 
   691     var refreshTimeInterval;
 
   727     var refreshTimeInterval;
 
   692     
   728 
   693 	this.start = function() {
 
   729     this.start = function() {
 
   694 		refreshTimeInterval = setInterval(function() {_this.updateTime();}, 1000);
 
   730         refreshTimeInterval = setInterval(function() {_this.updateTime();}, 1000);
 
   695     };
 
   731     };
 
   696 
   732 
   697     this.refresh = function() {
 
   733     this.refresh = function() {
 
   698     };
 
   734     };
 
   699 
   735 
   703     return this;
 
   739     return this;
 
   704 
   740 
   705 }
 
   741 }
 
   706 
   742 
   707 module.exports = {
 
   743 module.exports = {
 
   708 	AnnotsVizView: AnnotsVizView
 
   744     AnnotsVizView: AnnotsVizView
 
   709 };
 
   745 };
 
   710 
   746 
   711 },{"./annotsroll.js":2,"./annotstimeline.js":3,"./doubleroll.js":5,"./utils.js":9,"lodash":"lodash","pixi":"pixi"}],5:[function(require,module,exports){
 
   747 },{"./annotsroll.js":2,"./annotstimeline.js":3,"./doubleroll.js":5,"./utils.js":9,"lodash":"lodash","pixi":"pixi"}],5:[function(require,module,exports){
 
   712 /**
 
   748 /**
 
   713 * scripts/doubleroll.js
 
   749 * scripts/doubleroll.js
 
   714 *
 
   750 *
 
   715 * This is the starting point for your application.
 
   751 * This is the starting point for your application.
 
   716 * Take a look at http://browserify.org/ for more info
 
   752 * Take a look at http://browserify.org/ for more info
 
   717 */
 
   753 */
 
   718 
   754 
   719 /* global document: false */
 
       
   720 
       
   721 'use strict';
 
   755 'use strict';
 
   722 
   756 
   723 
   757 
   724 var PIXI = require('pixi');
 
   758 var PIXI = require('pixi');
 
   725 var _ = require('lodash');
 
   759 var _ = require('lodash');
 
   726 var PianoRoll = require('./pianoroll.js');
 
   760 var PianoRoll = require('./pianoroll');
 
   727 
   761 
   728 var defaultConfig = {
 
   762 var defaultConfig = {
 
   729     orientation: 'horizontal',
 
   763     orientation: 'horizontal',
 
   730     logger: undefined,
 
   764     logger: undefined,
 
   731     sceneWidth: 1024,
 
   765     sceneWidth: 1024,
 
   772     this.framerate = opts.framerate;
 
   806     this.framerate = opts.framerate;
 
   773     this.offsetMusic = opts.offsetMusic;
 
   807     this.offsetMusic = opts.offsetMusic;
 
   774     this.noteColors = opts.noteColors;
 
   808     this.noteColors = opts.noteColors;
 
   775 
   809 
   776     var noteHeight = opts.noteHeight;
 
   810     var noteHeight = opts.noteHeight;
 
   777     var sceneBgColor = opts.sceneBgColor;
 
       
   778     var sceneHeight = opts.sceneHeight || _(opts.pianorolls).reduce(function(s,p) { return s + p.height; }, 0);
 
   811     var sceneHeight = opts.sceneHeight || _(opts.pianorolls).reduce(function(s,p) { return s + p.height; }, 0);
 
   779     var timeWidth = opts.timeWidth;
 
   812     var timeWidth = opts.timeWidth;
 
   780     var lineInterval = opts.lineInterval;
 
   813     var lineInterval = opts.lineInterval;
 
   781     var offsetMusic = opts.offsetMusic;
 
   814     var offsetMusic = opts.offsetMusic;
 
   782 
   815 
   790     var colorsReg = {};
 
   823     var colorsReg = {};
 
   791 
   824 
   792     this.container = new PIXI.DisplayObjectContainer();
 
   825     this.container = new PIXI.DisplayObjectContainer();
 
   793     this.container.x = Math.floor(sceneWidth*zeroShift);
 
   826     this.container.x = Math.floor(sceneWidth*zeroShift);
 
   794     this.container.y = 0;
 
   827     this.container.y = 0;
 
   795     
   828 
   796     stageView.registerComponent(this);
 
   829     stageView.registerComponent(this);
 
   797 
   830 
   798     var pianorollList = [];
 
   831     var pianorollList = [];
 
   799 
   832 
   800     var pianorollOptions = {
 
   833     var pianorollOptions = {
 
   875             c.start();
 
   908             c.start();
 
   876         });
 
   909         });
 
   877     };
 
   910     };
 
   878 
   911 
   879     this.stop = function() {
 
   912     this.stop = function() {
 
   880     	
   913 
   881         pianorollList.forEach(function(c) {
 
   914         pianorollList.forEach(function(c) {
 
   882             c.stop();
 
   915             c.stop();
 
   883         });
 
   916         });
 
   884     };
 
   917     };
 
   885 
   918 
   897 
   930 
   898 module.exports = {
 
   931 module.exports = {
 
   899     DoubleRoll: DoubleRoll
 
   932     DoubleRoll: DoubleRoll
 
   900 };
 
   933 };
 
   901 
   934 
   902 },{"./pianoroll.js":7,"lodash":"lodash","pixi":"pixi"}],6:[function(require,module,exports){
 
   935 },{"./pianoroll":7,"lodash":"lodash","pixi":"pixi"}],6:[function(require,module,exports){
 
   903 /**
 
   936 /**
 
   904 * js/wswrapper.js
 
   937 * js/wswrapper.js
 
   905 *
 
   938 *
 
   906 * simple logger service
 
   939 * simple logger service
 
   907 *
 
   940 *
 
   935 
   968 
   936     this.log = function(msg) {
 
   969     this.log = function(msg) {
 
   937         if(doLog) {
 
   970         if(doLog) {
 
   938             console.log(msg);
 
   971             console.log(msg);
 
   939         }
 
   972         }
 
   940     }
 
   973     };
 
   941 
   974 
   942 }
 
   975 }
 
   943 
   976 
   944 module.exports = {
 
   977 module.exports = {
 
   945     HtmlLogger: HtmlLogger,
 
   978     HtmlLogger: HtmlLogger,
 
  1054                     noteVelocity = noteDef.velocity;
 
  1087                     noteVelocity = noteDef.velocity;
 
  1055                     ts = noteDef.ts;
 
  1088                     ts = noteDef.ts;
 
  1056                 }
 
  1089                 }
 
  1057             }
 
  1090             }
 
  1058             else {
 
  1091             else {
 
  1059                 noteDuration = Date.now() - ts;
 
  1092                 noteDuration = Math.abs(Date.now() - ts);
 
  1060                 this.noteDict[channel][note] = { ts: ts, velocity: velocity, sessionTs: sessionTs};
 
  1093                 this.noteDict[channel][note] = { ts: ts, velocity: velocity, sessionTs: sessionTs};
 
  1061             }
 
  1094             }
 
  1062         }
 
  1095         }
 
  1063 
  1096 
  1064 
  1097 
  1214     var sceneBgColor = opts.sceneBgColor;
 
  1247     var sceneBgColor = opts.sceneBgColor;
 
  1215     var sceneWidth = opts.sceneWidth;
 
  1248     var sceneWidth = opts.sceneWidth;
 
  1216     var sceneHeight = opts.sceneHeight;
 
  1249     var sceneHeight = opts.sceneHeight;
 
  1217     var canvasContainer = opts.canvasContainer;
 
  1250     var canvasContainer = opts.canvasContainer;
 
  1218     var timeContainer = [];
 
  1251     var timeContainer = [];
 
  1219     var components = []; 
  1252     var components = [];
 
  1220     
  1253 
  1221     //create an new instance of a pixi stage
 
  1254     //create an new instance of a pixi stage
 
  1222     this.stage = new PIXI.Stage(sceneBgColor);
 
  1255     this.stage = new PIXI.Stage(sceneBgColor);
 
  1223     //create a renderer instance.
 
  1256     //create a renderer instance.
 
  1224     var renderer = PIXI.autoDetectRenderer(sceneWidth, sceneHeight);
 
  1257     var renderer = PIXI.autoDetectRenderer(sceneWidth, sceneHeight);
 
  1225     	
  1258 
  1226     this.init = function() {
 
  1259     this.init = function() {
 
  1227 
  1260 
  1228         if(typeof(canvasContainer) === 'string') {
 
  1261         if(typeof(canvasContainer) === 'string') {
 
  1229             canvasContainer = document.getElementById(canvasContainer);
 
  1262             canvasContainer = document.getElementById(canvasContainer);
 
  1230         }
 
  1263         }
 
  1231         if(typeof(timeContainer) === 'string') {
 
  1264         if(typeof(timeContainer) === 'string') {
 
  1232             timeContainer = document.getElementById(timeContainer);
 
  1265             timeContainer = document.getElementById(timeContainer);
 
  1233         }
 
  1266         }
 
  1234 
  1267 
  1235         canvasContainer.appendChild(renderer.view);
 
  1268         canvasContainer.appendChild(renderer.view);
 
  1236         
  1269 
  1237         components.forEach(function(c){
 
  1270         components.forEach(function(c){
 
  1238     		c.init();
 
  1271     		c.init();
 
  1239     	});
 
  1272     	});
 
  1240     };
 
  1273     };
 
  1241     
  1274 
  1242     this.registerTimeContainer = function(container) {
 
  1275     this.registerTimeContainer = function(container) {
 
  1243     	timeContainer.push(container);
 
  1276     	timeContainer.push(container);
 
  1244     };
 
  1277     };
 
  1245     
  1278 
  1246     this.registerComponent = function(component) {
 
  1279     this.registerComponent = function(component) {
 
  1247     	components.push(component);
 
  1280     	components.push(component);
 
  1248     	this.stage.addChild(component.container);
 
  1281     	this.stage.addChild(component.container);
 
  1249     };
 
  1282     };
 
  1250 
  1283 
  1261     this.start = function() {
 
  1294     this.start = function() {
 
  1262 
  1295 
  1263         if(!externalRefresh) {
 
  1296         if(!externalRefresh) {
 
  1264             refreshInterval = setInterval(function() {_this.refresh();}, 1000/this.framerate);
 
  1297             refreshInterval = setInterval(function() {_this.refresh();}, 1000/this.framerate);
 
  1265         }
 
  1298         }
 
  1266         
  1299 
  1267         components.forEach(function(c){
 
  1300         components.forEach(function(c){
 
  1268     		c.start();
 
  1301     		c.start();
 
  1269     	});
 
  1302     	});
 
  1270     };
 
  1303     };
 
  1271 
  1304 
  1272     this.stop = function() {
 
  1305     this.stop = function() {
 
  1273         if(!externalRefresh) {
 
  1306         if(!externalRefresh) {
 
  1274             clearInterval(refreshInterval);
 
  1307             clearInterval(refreshInterval);
 
  1275         }
 
  1308         }
 
  1276         clearInterval(refreshTimeInterval);
 
       
  1277         
  1309         
  1278         components.forEach(function(c){
 
  1310         components.forEach(function(c){
 
  1279     		c.stop();
 
  1311     		c.stop();
 
  1280     	});
 
  1312     	});
 
  1281     };
 
  1313     };
 
  1300 * js/utils.js
 
  1332 * js/utils.js
 
  1301 *
 
  1333 *
 
  1302 * basic tools
 
  1334 * basic tools
 
  1303 *
 
  1335 *
 
  1304 */
 
  1336 */
 
       
  1337 /*jshint bitwise: false*/
 
       
  1338 /*jshint camelcase: false */
 
  1305 
  1339 
  1306 'use strict';
 
  1340 'use strict';
 
  1307 
  1341 
  1308 var PIXI = require('pixi');
 
  1342 var PIXI = require('pixi');
 
  1309 var _ = require('lodash');
 
  1343 var _ = require('lodash');
 
  1310 var moment = require('moment');
 
  1344 var moment = require('moment');
 
  1311 
  1345 
  1312 function formatTime (ts) {
 
  1346 function formatTime (ts) {
 
  1313 	return moment(ts).format("HH:mm:ss");
 
  1347     return moment(ts).format('HH:mm:ss');
 
  1314 }
 
  1348 }
 
  1315 
  1349 
  1316 function colorToHex(c) {
 
  1350 function colorToHex(c) {
 
  1317 	var m = /rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)/.exec(c);
 
  1351     var m = /rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)/.exec(c);
 
  1318 	return m ? '#' + (1 << 24 | m[1] << 16 | m[2] << 8 | m[3]).toString(16).substr(1) : c;
 
  1352     return m ? '#' + (1 << 24 | m[1] << 16 | m[2] << 8 | m[3]).toString(16).substr(1) : c;
 
  1319 }
 
  1353 }
 
  1320 
  1354 
  1321 function getAnnotCategories(urlCategories, annotCategories) {
 
  1355 function getAnnotCategories(urlCategories, annotCategories) {
 
  1322 
  1356 
  1323     var jsonLoader = new PIXI.JsonLoader(urlCategories, true);
 
  1357     var jsonLoader = new PIXI.JsonLoader(urlCategories, true);
 
  1324 
  1358 
  1325     jsonLoader.on('loaded', function(res) {
 
  1359     jsonLoader.on('loaded', function(res) {
 
  1326         var data = res.target.json;
 
  1360         var data = res.target.json;
 
  1327 
  1361 
  1328         while(annotCategories.length > 0) {
 
  1362         while(annotCategories.length > 0) {
 
  1329         	annotCategories.pop();
 
  1363             annotCategories.pop();
 
  1330         }
 
  1364         }
 
  1331 
  1365 
  1332         data.sessions.forEach(function(session) {
 
  1366         data.sessions.forEach(function(session) {
 
  1333             var annotCat = {
 
  1367             var annotCat = {
 
  1334                 ts: session.start_ts === null ? new Date(0) : Date.parse(session.start_ts),
 
  1368                 ts: session.start_ts === null ? new Date(0) : Date.parse(session.start_ts),
 
  1335                 colors: {}
 
  1369                 colors: {}
 
  1336             }
 
  1370             };
 
  1337             var categoriesJson = session.categories_json;
 
  1371             var categoriesJson = session.categories_json;
 
  1338             annotCat.order = categoriesJson.order;
 
  1372             annotCat.order = categoriesJson.order;
 
  1339             if (typeof(annotCat.order['default']) === 'undefined'){
 
  1373             if (typeof(annotCat.order['default']) === 'undefined'){
 
  1340             	annotCat.order.push('default');
 
  1374                 annotCat.order.push('default');
 
  1341             }
 
  1375             }
 
  1342 			var catList = _.clone(categoriesJson.categories);
 
  1376             var catList = _.clone(categoriesJson.categories);
 
  1343 			while(catList.length > 0) {
 
  1377             while(catList.length > 0) {
 
  1344 				var cat = catList.pop();
 
  1378                 var cat = catList.pop();
 
  1345 				if(cat.code) {
 
  1379                 if(cat.code) {
 
  1346 					annotCat.colors[cat.code] = colorToHex(cat.color);
 
  1380                     annotCat.colors[cat.code] = colorToHex(cat.color);
 
  1347 				}
 
  1381                 }
 
  1348 				if(cat.subcategories) {
 
  1382                 if(cat.subcategories) {
 
  1349 					catList = catList.concat(cat.subcategories);
 
  1383                     catList = catList.concat(cat.subcategories);
 
  1350 				}
 
  1384                 }
 
  1351 			}
 
  1385             }
 
  1352             categoriesJson.categories.forEach(function(cat) {
 
  1386             categoriesJson.categories.forEach(function(cat) {
 
  1353 				if(cat.code) {
 
  1387                 if(cat.code) {
 
  1354                 	annotCat.colors[cat.code] = colorToHex(cat.color);
 
  1388                     annotCat.colors[cat.code] = colorToHex(cat.color);
 
  1355 				}
 
  1389                 }
 
  1356             });
 
  1390             });
 
  1357             annotCat.defaultColor = categoriesJson.defaultColor || "#536991";
 
  1391             annotCat.defaultColor = categoriesJson.defaultColor || '#536991';
 
  1358             annotCategories.push(annotCat);
 
  1392             annotCategories.push(annotCat);
 
  1359         });
 
  1393         });
 
  1360     });
 
  1394     });
 
  1361 
  1395 
  1362     jsonLoader.load();
 
  1396     jsonLoader.load();
 
  1363 
  1397 
  1364 }
 
  1398 }
 
  1365 
  1399 
  1366 module.exports = {
 
  1400 module.exports = {
 
  1367 	formatTime: formatTime,
 
  1401     formatTime: formatTime,
 
  1368 	getAnnotCategories: getAnnotCategories,
 
  1402     getAnnotCategories: getAnnotCategories,
 
  1369 	colorToHex: colorToHex
 
  1403     colorToHex: colorToHex
 
  1370 };
 
  1404 };
 
  1371 
  1405 
  1372 },{"lodash":"lodash","moment":"moment","pixi":"pixi"}],10:[function(require,module,exports){
 
  1406 },{"lodash":"lodash","moment":"moment","pixi":"pixi"}],10:[function(require,module,exports){
 
  1373 /**
 
  1407 /**
 
  1374 * js/wswrapper.js
 
  1408 * js/wswrapper.js
 
  1424     WsWrapper: WsWrapper
 
  1458     WsWrapper: WsWrapper
 
  1425 };
 
  1459 };
 
  1426 
  1460 
  1427 },{}]},{},[1])(1)
 
  1461 },{}]},{},[1])(1)
 
  1428 });
 
  1462 });
 
  1429 //# 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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vQA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1LA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;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;;ACpOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;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;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;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');\nvar utils = require('./utils');\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    .extend(utils)\n    .value();\n","/**\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    ignoreAnnots:false\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 = opts.startTs || Date.now();\n    this.ignoreAnnots = opts.ignoreAnnots;\n\n    var yInit = opts.yInit;\n    var annotStyles = _(opts.annotStyles).defaults(defaultAnnotStyles).value();\n    var marginX = 15;\n    for(var style in annotStyles) {\n    \tif (annotStyles[style].wordWrap === true){\n    \t\tannotStyles[style].wordWrapWidth = this.widthRoll - marginX; \n    \t}\n    }\n    var started = false;\n    var ws = opts.ws;\n    var externalRefresh = opts.externalRefresh;\n    var stageView = opts.stageView;\n    var waitInterval;\n    var wait = 0;\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            if(cdef.ts < ts) {\n                colorsDef = cdef.colors;\n                return false;\n            }\n        });\n        var resColor;\n        if(colorsDef) {\n            resColor = colorsDef[code];\n        }\n        if(!resColor) {\n            resColor = colorsDef.defaultColor || DEFAULT_ANNOT_COLOR;\n        }\n        return resColor;\n    }\n\n    this.addAnnot = function(category, text, user, color, ts){\n\n        var x = 0;\n        var y = (ts-this.startTs) * this.pixelsPerSecond / 1000 + yInit;\n\n        var colorHex = parseInt(color.replace(/^#/, ''), 16);\n\n        if (wait === 0){\n\t        var graphics = new PIXI.Graphics()\n\t            .beginFill(colorHex)\n\t            .drawRect(x, y, 10, 3)\n\t            .endFill();\n\t\n\t        this.container.addChild(graphics);\n\t\n\t        var textHeight = 0;\n\t        var catLabel = new PIXI.Text(\n\t            category,\n\t            _(annotStyles.label).extend({fill: color}).value()\n\t        );\n\t        catLabel.x = x + marginX;\n\t        catLabel.y = y - 23;\n\t        this.container.addChild(catLabel);\n\t        textHeight += (catLabel.height - 23 + 2);\n\t\n\t        if(text) {\n\t            var catText = new PIXI.Text(text, annotStyles.text);\n\t            catText.x = x + marginX;\n\t            catText.y = y + textHeight;\n\t            this.container.addChild(catText);\n\t            textHeight += (catText.height + 2);\n\t        }\n\t\n\t        var catUser = new PIXI.Text(user, annotStyles.user);\n\t        catUser.x = x + marginX;\n\t        catUser.y = y + textHeight;\n\t        this.container.addChild(catUser);\n\t        textHeight += (catUser.height + 8);\n\t        \n\t        if (this.ignoreAnnots === true){\n\t\t        wait = textHeight / this.pixelsPerSecond;\n\t\t        waitInterval = setInterval(function() {_this.refreshWait();}, 1000);\n\t        }\n        }\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.refreshWait = function(){\n    \twait -= 1;\n    \tif (wait < 0){\n    \t\twait = 0;\n    \t\tclearInterval(waitInterval);\n    \t}\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\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    serverUrl: 'http://127.0.0.1:8080',\n    channel: 'ANNOT',\n    maxPages: 1000,\n    showClockGraphics: true,\n    archive: false\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\tthis.startTs = options.startTs || Date.now();\n    this.showClockGraphics = opts.showClockGraphics;\n    this.archive = opts.archive;\n    \n    this.circleX = opts.circleX || (this.width/2);\n    this.circleY = opts.circleY || (this.height/2);\n    this.radius = opts.radius;\n    var perimeter = 2*Math.PI* this.radius;\n    this.intervalDuration = (this.intervalWidth * this.duration / perimeter);\n    \n    var channel = opts.channel;\n    var eventCode = opts.eventCode;\n    var serverUrl = opts.serverUrl;\n    var maxPages = opts.maxPages;\n    \n    var totalIndex = Math.floor( perimeter/this.intervalWidth);\n\n    this.cells = []\n    for (var i=0; i<(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\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.endFill()\n    this.container.addChild(graphics);\n\n    stageView.registerComponent(this);\n\n\tvar loadArchives = function() {\n        //start timeBegin end startTime\n        //query -> need channel + eventCode\n        //iterate over data fill cells\n        var startTs = _this.timeBegin;\n        var endTs = _this.startTs;\n\n        var url = serverUrl + '/p/api/v1/annotation';\n        var filters = [\n            { name: 'ts', op: '>', val: new Date(startTs).toISOString()}, //start\n            { name: 'ts', op: '<=', val: new Date(endTs).toISOString()}, //end\n            { name: 'channel', op: '==', val: channel}, //channel\n            { name: 'event_code', op: '==', val: eventCode} //eventcode\n        ];\n\n        url = url + '?q=' + JSON.stringify({filters:filters});\n\n        var totalPage = 1;\n        var currentPage = 1;\n\n        var processResFunction = function(res) {\n\n            if(res) {\n                var data = res.target.json;\n                /*jshint -W069 */\n                totalPage = Math.min(maxPages,parseInt(data['total_pages']));\n                data.objects.forEach(function(annotation) {\n                    _this.addAnnot(annotation);\n                });\n            }\n            if(currentPage <= totalPage) {\n                var jsonLoader = new PIXI.JsonLoader(url+'&page='+currentPage, true);\n                jsonLoader.on('loaded', processResFunction);\n                jsonLoader.load();\n                currentPage++;\n            }\n        };\n        processResFunction();\n\n    };\n\n    //Add Annotation to the TimeLine\n    this.addAnnot = function(data){\n\n    \tvar ts = Date.parse(data.ts);\n    \tvar colorsDef;\n    \t_(this.annotCategories).eachRight(function(cdef) {\n            if(cdef.ts < ts) {\n                colorsDef = cdef;\n                return false;\n            }\n        });\n\n    \tif (this.timeEnd > ts){\n\t    \tvar i = Math.floor((ts - this.timeBegin)/(1000*this.intervalDuration));\n\n\t    \tif (typeof(this.cells[i].graphics) === 'undefined'){\n\t    \t\tthis.initCell(this.cells[i], colorsDef);\n\t    \t}\n\n\t    \tif (typeof(colorsDef.colors[data.content.category.code]) !== 'undefined'){\n\t    \t\tvar annotCode = data.content.category.code;\n\t    \t} else {\n\t    \t\tvar annotCode = 'default';\n\t    \t}\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], colorsDef);\n    \t}\n    };\n\n    this.initClockGraphics = 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\t    \n\t    var lineV = new PIXI.Graphics();\n\t    lineV.lineStyle(1, 0x646464)\n\t    \t.moveTo(this.circleX, this.circleY - (this.radius/3)/2)\n\t    \t.lineTo(this.circleX, this.circleY - this.radius - this.maxCellHeight - 10)\n    \t.endFill();\n\t    this.container.addChild(lineV);\n    }\n\n    //Draw the cellule\n    this.redrawCell = function(cell, colorsDef){\n    \tvar y = 0;\n\n        //Check if total height is higher than Max Cell Height\n        var heightStep;\n        if ((cell.totalAnnots*this.intervalHeight) > this.maxCellHeight){\n            heightStep = this.maxCellHeight/cell.totalAnnots;\n        } else {\n            heightStep = this.intervalHeight;\n        }\n\n    \t//Draw the rect depending on the height step calculated\n    \tfor (var i=0; i< colorsDef.order.length; i++){\n    \t\tvar currentCode = colorsDef.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.initCell = function(cell, colorsDef){\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    \tfor (var category in colorsDef.colors){\n    \t\tcell.categories[category] = {\n\t\t\t\t\"count\": 0,\n\t\t\t\t\"color\": colorsDef.colors[category]\n    \t\t};\n    \t}\n    \tif (typeof(cell.categories['default']) === 'undefined'){\n\t\t\tcell.categories['default'] = {\n\t\t\t\t\"count\": 0,\n\t\t\t\t\"color\": colorsDef.defaultColor\n\t\t\t}\n    \t}\n    }\n\n    this.init = function() {\n    \tif (!this.archive){\n\t        ws.message(function(data) {\n\t            _this.addAnnot(data);\n\t        });\n    \t}\n\n    \tif (this.showClockGraphics){this.initClockGraphics();}\n    };\n\n\n    this.start = function() {\n    \tthis.startTs = Date.now();\n        loadArchives();\n    };\n\n    this.refresh = function() {\n\n    };\n\n    this.stop = function(){\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');\nvar Utils = require('./utils.js');\n\nvar defaultOptions = {\n    xInit: 0,\n    yInit: 0,\n    width: 1024,\n    height: 768\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.timeBegin = opts.timeBegin;\n    this.timeEnd = opts.timeEnd;\n    this.annotCategories = [];\n    \n    Utils.getAnnotCategories(opts.urlCategories, this.annotCategories);\n    \n\tvar wsPianoroll = opts.wsPianoroll;\n\tvar wsAnnot = opts.wsAnnot;\n\tvar stageView = opts.stageView;\n\tvar currentTime = Date.now() + 3600*1000;\n\tvar eventCode = opts.eventCode;\n    var channel = opts.channel;\n\n\tstageView.registerComponent(this);\n\n\tvar timeLineDay2 = 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: this.timeBegin,\n        timeEnd: this.timeEnd,\n        intervalWidth: 6,\n        intervalHeight: 10,\n        maxCellHeight: 70,\n        radius: 200,\n        eventCode: eventCode,\n        channel: channel,\n        annotCategories: this.annotCategories\n    });\n\t\n    //Archive day 1\n    var timeLineDay1 = new AnnotsTimeLine.AnnotsTimeLine({\n    \tstageView : stageView,\n        archive: true,\n        xInit: 0,\n        yInit: 0,\n        width: 1024 - 200 - 200,\n        height: 768-200,\n        timeBegin: Date.parse(\"2015-01-22T09:30:00+01:00\"),\n        timeEnd: Date.parse(\"2015-01-22T18:30:00+01:00\"),\n        circleX: timeLineDay2.circleX,\n        circleY: timeLineDay2.circleY,\n        intervalWidth: (timeLineDay2.radius*2/3)* timeLineDay2.intervalWidth / timeLineDay2.radius,\n        intervalHeight: (timeLineDay2.intervalHeight * (timeLineDay2.radius - timeLineDay2.radius*2/3))/ timeLineDay2.maxCellHeight,\n        maxCellHeight: (timeLineDay2.radius - timeLineDay2.radius*2/3)/4,\n        radius: timeLineDay2.radius*2/3,\n        annotCategories: this.annotCategories,\n        eventCode: eventCode,\n        channel: channel,\n        showClockGraphics:false\n    });\n    \n    var currentTimeText = new PIXI.Text(\"-- : -- : --\", { font: '18pt Gothic Standard', fill: '#646464' });\n    currentTimeText.x = timeLineDay2.circleX - currentTimeText.width/2;\n    currentTimeText.y = timeLineDay2.circleY - currentTimeText.height/2;\n    this.container.addChild(currentTimeText);\n\n    var timeLineDay3 = new PIXI.Graphics();\n    timeLineDay3.lineStyle(1, 0x646464)\n    \t.drawCircle(timeLineDay2.circleX, timeLineDay2.circleY, timeLineDay2.radius/3)\n    \t.endFill()\n    this.container.addChild(timeLineDay3);\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\tthis.init = function(){\n\t};\n\n\tthis.updateTime = function(){\n        currentTimeText.setText(Utils.formatTime(Date.now()));\n    };\n\n    var refreshTimeInterval;\n    \n\tthis.start = function() {\n\t\trefreshTimeInterval = setInterval(function() {_this.updateTime();}, 1000);\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        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\nvar PIXI = require('pixi');\nvar _ = require('lodash');\nvar moment = require('moment');\n\nfunction formatTime (ts) {\n\treturn moment(ts).format(\"HH:mm:ss\");\n}\n\nfunction colorToHex(c) {\n\tvar m = /rgba?\\(\\s*(\\d+)\\s*,\\s*(\\d+)\\s*,\\s*(\\d+)/.exec(c);\n\treturn m ? '#' + (1 << 24 | m[1] << 16 | m[2] << 8 | m[3]).toString(16).substr(1) : c;\n}\n\nfunction getAnnotCategories(urlCategories, annotCategories) {\n\n    var jsonLoader = new PIXI.JsonLoader(urlCategories, true);\n\n    jsonLoader.on('loaded', function(res) {\n        var data = res.target.json;\n\n        while(annotCategories.length > 0) {\n        \tannotCategories.pop();\n        }\n\n        data.sessions.forEach(function(session) {\n            var annotCat = {\n                ts: session.start_ts === null ? new Date(0) : Date.parse(session.start_ts),\n                colors: {}\n            }\n            var categoriesJson = session.categories_json;\n            annotCat.order = categoriesJson.order;\n            if (typeof(annotCat.order['default']) === 'undefined'){\n            \tannotCat.order.push('default');\n            }\n\t\t\tvar catList = _.clone(categoriesJson.categories);\n\t\t\twhile(catList.length > 0) {\n\t\t\t\tvar cat = catList.pop();\n\t\t\t\tif(cat.code) {\n\t\t\t\t\tannotCat.colors[cat.code] = colorToHex(cat.color);\n\t\t\t\t}\n\t\t\t\tif(cat.subcategories) {\n\t\t\t\t\tcatList = catList.concat(cat.subcategories);\n\t\t\t\t}\n\t\t\t}\n            categoriesJson.categories.forEach(function(cat) {\n\t\t\t\tif(cat.code) {\n                \tannotCat.colors[cat.code] = colorToHex(cat.color);\n\t\t\t\t}\n            });\n            annotCat.defaultColor = categoriesJson.defaultColor || \"#536991\";\n            annotCategories.push(annotCat);\n        });\n    });\n\n    jsonLoader.load();\n\n}\n\nmodule.exports = {\n\tformatTime: formatTime,\n\tgetAnnotCategories: getAnnotCategories,\n\tcolorToHex: colorToHex\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"]}
 
  1463 //# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["node_modules/browserify/node_modules/browser-pack/_prelude.js","./app/js/main.js","/Users/rougeronj/workspace/mons/client/annotviz/app/js/annotsroll.js","/Users/rougeronj/workspace/mons/client/annotviz/app/js/annotstimeline.js","/Users/rougeronj/workspace/mons/client/annotviz/app/js/annotsvizview.js","/Users/rougeronj/workspace/mons/client/annotviz/app/js/doubleroll.js","/Users/rougeronj/workspace/mons/client/annotviz/app/js/logger.js","/Users/rougeronj/workspace/mons/client/annotviz/app/js/pianoroll.js","/Users/rougeronj/workspace/mons/client/annotviz/app/js/stageview.js","/Users/rougeronj/workspace/mons/client/annotviz/app/js/utils.js","/Users/rougeronj/workspace/mons/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;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1LA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;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;;ACpOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;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');\nvar utils = require('./utils');\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    .extend(utils)\n    .value();\n","/**\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    ignoreAnnots:false\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 = opts.startTs || Date.now();\n    this.ignoreAnnots = opts.ignoreAnnots;\n\n    var yInit = opts.yInit;\n    var annotStyles = _(opts.annotStyles).defaults(defaultAnnotStyles).value();\n    var marginX = 15;\n    for(var style in annotStyles) {\n    \tif (annotStyles[style].wordWrap === true){\n    \t\tannotStyles[style].wordWrapWidth = this.widthRoll - marginX;\n    \t}\n    }\n    var started = false;\n    var ws = opts.ws;\n    var externalRefresh = opts.externalRefresh;\n    var stageView = opts.stageView;\n    var waitInterval;\n    var wait = 0;\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            if(cdef.ts < ts) {\n                colorsDef = cdef.colors;\n                return false;\n            }\n        });\n        var resColor;\n        if(colorsDef) {\n            resColor = colorsDef[code];\n        }\n        if(!resColor) {\n            resColor = colorsDef.defaultColor || DEFAULT_ANNOT_COLOR;\n        }\n        return resColor;\n    };\n\n    this.addAnnot = function(category, text, user, color, ts){\n\n        var x = 0;\n        var y = (ts-this.startTs) * this.pixelsPerSecond / 1000 + yInit;\n\n        var colorHex = parseInt(color.replace(/^#/, ''), 16);\n\n        if (wait === 0){\n\t        var graphics = new PIXI.Graphics()\n\t            .beginFill(colorHex)\n\t            .drawRect(x, y, 10, 3)\n\t            .endFill();\n\n\t        this.container.addChild(graphics);\n\n\t        var textHeight = 0;\n\t        var catLabel = new PIXI.Text(\n\t            category,\n\t            _(annotStyles.label).extend({fill: color}).value()\n\t        );\n\t        catLabel.x = x + marginX;\n\t        catLabel.y = y - 23;\n\t        this.container.addChild(catLabel);\n\t        textHeight += (catLabel.height - 23 + 2);\n\n\t        if(text) {\n\t            var catText = new PIXI.Text(text, annotStyles.text);\n\t            catText.x = x + marginX;\n\t            catText.y = y + textHeight;\n\t            this.container.addChild(catText);\n\t            textHeight += (catText.height + 2);\n\t        }\n\n\t        var catUser = new PIXI.Text(user, annotStyles.user);\n\t        catUser.x = x + marginX;\n\t        catUser.y = y + textHeight;\n\t        this.container.addChild(catUser);\n\t        textHeight += (catUser.height + 8);\n\n\t        if (this.ignoreAnnots === true){\n\t\t        wait = textHeight / this.pixelsPerSecond;\n\t\t        waitInterval = setInterval(function() {_this.refreshWait();}, 1000);\n\t        }\n        }\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.refreshWait = function(){\n    \twait -= 1;\n    \tif (wait < 0){\n    \t\twait = 0;\n    \t\tclearInterval(waitInterval);\n    \t}\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\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    serverUrl: 'http://127.0.0.1:8080',\n    channel: 'ANNOT',\n    maxPages: 1000,\n    showClockGraphics: true,\n    archive: false\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    this.startTs = options.startTs || Date.now();\n    this.showClockGraphics = opts.showClockGraphics;\n    this.archive = opts.archive;\n\n    this.circleX = opts.circleX || (this.width/2);\n    this.circleY = opts.circleY || (this.height/2);\n    this.radius = opts.radius;\n    var perimeter = 2*Math.PI* this.radius;\n    this.intervalDuration = (this.intervalWidth * this.duration / perimeter);\n\n    var channel = opts.channel;\n    var eventCode = opts.eventCode;\n    var serverUrl = opts.serverUrl;\n    var maxPages = opts.maxPages;\n\n    var totalIndex = Math.floor( perimeter/this.intervalWidth);\n\n    this.cells = [];\n    for (var i=0; i<(perimeter/this.intervalWidth) ; i++){\n        this.cells[i] = [];\n        this.cells[i].i = i;\n        this.cells[i].totalAnnots = 0;\n        this.cells[i].categories = {};\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        .drawCircle(this.circleX, this.circleY, this.radius - 3)\n        .endFill();\n    this.container.addChild(graphics);\n\n    stageView.registerComponent(this);\n\n    var loadArchives = function() {\n        //start timeBegin end startTime\n        //query -> need channel + eventCode\n        //iterate over data fill cells\n        var startTs = _this.timeBegin;\n        var endTs = Math.min(_this.timeEnd,_this.startTs);\n\n        console.log(\"START TS\",new Date(startTs).toISOString());\n        console.log(\"END TS\",new Date(endTs).toISOString());\n\n        var url = serverUrl + '/p/api/v1/annotation';\n        var filters = [\n            { name: 'ts', op: '>', val: new Date(startTs).toISOString()}, //start\n            { name: 'ts', op: '<=', val: new Date(endTs).toISOString()}, //end\n            { name: 'channel', op: '==', val: channel}, //channel\n            { name: 'event_code', op: '==', val: eventCode} //eventcode\n        ];\n\n        url = url + '?q=' + JSON.stringify({filters:filters});\n\n        var totalPage = 1;\n        var currentPage = 1;\n\n        var processResFunction = function(res) {\n            //console.log(\"RES archive\", res);\n            if(res) {\n                var data = res.target.json;\n                /*jshint -W069 */\n                totalPage = Math.min(maxPages,parseInt(data['total_pages']));\n                data.objects.forEach(function(annotation) {\n                    _this.addAnnot(annotation);\n                });\n            }\n            if(currentPage <= totalPage) {\n                var jsonLoader = new PIXI.JsonLoader(url+'&page='+currentPage, true);\n                jsonLoader.on('loaded', processResFunction);\n                jsonLoader.load();\n                currentPage++;\n            }\n        };\n        processResFunction();\n\n    };\n\n    //Add Annotation to the TimeLine\n    this.addAnnot = function(data){\n\n        var ts = Date.parse(data.ts);\n        var colorsDef;\n        _(this.annotCategories).eachRight(function(cdef) {\n            if(cdef.ts < ts) {\n                colorsDef = cdef;\n                return false;\n            }\n        });\n\n        if(!colorsDef) {\n            return;\n        }\n\n        if (this.timeEnd > ts){\n            var i = Math.floor((ts - this.timeBegin)/(1000*this.intervalDuration));\n\n            if (typeof(this.cells[i].graphics) === 'undefined'){\n                this.initCell(this.cells[i], colorsDef);\n            }\n\n            var annotCode;\n            if (typeof(colorsDef.colors[data.content.category.code]) !== 'undefined'){\n                annotCode = data.content.category.code;\n            } else {\n                annotCode = 'default';\n            }\n\n            this.cells[i].categories[annotCode].count += 1;\n            this.cells[i].totalAnnots +=1;\n            this.redrawCell(this.cells[i], colorsDef);\n        }\n    };\n\n    this.initClockGraphics = function() {\n        var tBeg = new PIXI.Text(Utils.formatTime(this.timeBegin), { font: '12pt Gothic Standard', fill: '#646464' });\n        tBeg.x = this.circleX + 15;\n        tBeg.y = this.circleY - this.radius - this.maxCellHeight - 10;\n        this.container.addChild(tBeg);\n\n        var tEnd = new PIXI.Text(Utils.formatTime(this.timeEnd), { font: '12pt Gothic Standard', fill: '#646464' });\n        tEnd.x = this.circleX - 15 - tEnd.width;\n        tEnd.y = this.circleY - this.radius - this.maxCellHeight - 10;\n        this.container.addChild(tEnd);\n\n        var t15 = new PIXI.Text(Utils.formatTime(((this.timeEnd - this.timeBegin)/4) + this.timeBegin), { font: '12pt Gothic Standard', fill: '#646464' });\n        t15.x = this.circleX + this.radius + this.maxCellHeight + 10 ;\n        t15.y = this.circleY - t15.height;\n        t15.rotation = Math.PI /2;\n        this.container.addChild(t15);\n\n        var t30 = new PIXI.Text(Utils.formatTime(((this.timeEnd - this.timeBegin)/2) + this.timeBegin), { font: '12pt Gothic Standard', fill: '#646464' });\n        t30.x = this.circleX - t30.width/2;\n        t30.y = this.circleY + this.radius + this.maxCellHeight - 2;\n        this.container.addChild(t30);\n\n        var t45 = new PIXI.Text(Utils.formatTime(((this.timeEnd - this.timeBegin)*3/4) + this.timeBegin), { font: '12pt Gothic Standard', fill: '#646464' });\n        t45.x = this.circleX - this.radius - this.maxCellHeight - 10 ;\n        t45.y = this.circleY + t15.height;\n        t45.rotation = -Math.PI/2;\n        this.container.addChild(t45);\n\n        var lineV = new PIXI.Graphics();\n        lineV.lineStyle(1, 0x646464)\n            .moveTo(this.circleX, this.circleY - (this.radius/3)/2)\n            .lineTo(this.circleX, this.circleY - this.radius - this.maxCellHeight - 10)\n            .endFill();\n        this.container.addChild(lineV);\n    };\n\n    //Draw the cellule\n    this.redrawCell = function(cell, colorsDef){\n        var y = 0;\n\n        //Check if total height is higher than Max Cell Height\n        var heightStep;\n        if ((cell.totalAnnots*this.intervalHeight) > this.maxCellHeight){\n            heightStep = this.maxCellHeight/cell.totalAnnots;\n        } else {\n            heightStep = this.intervalHeight;\n        }\n\n        //Draw the rect depending on the height step calculated\n        for (var i=0; i< colorsDef.order.length; i++){\n            var currentCode = colorsDef.order[i];\n            cell.graphics.beginFill(cell.categories[currentCode].color.replace('#', '0x'))\n                .drawRect(0, y, this.intervalWidth-1, -cell.categories[currentCode].count * heightStep)\n                .endFill();\n            y -= cell.categories[currentCode].count*heightStep;\n        }\n    };\n\n    this.initCell = function(cell, colorsDef){\n        cell.graphics = new PIXI.Graphics();\n        cell.graphics.position.x = this.circleX + this.radius * Math.sin(cell.i*(360/totalIndex)*(Math.PI/180));\n        cell.graphics.position.y = this.circleY - this.radius * Math.cos(cell.i*(360/totalIndex)*(Math.PI/180));\n        cell.graphics.rotation = (cell.i)*(360/totalIndex)*(Math.PI/180) + (360/(totalIndex*2))*(Math.PI/180);\n        this.container.addChild(cell.graphics);\n\n        for (var category in colorsDef.colors){\n            cell.categories[category] = {\n                'count': 0,\n                'color': colorsDef.colors[category]\n            };\n        }\n        if (typeof(cell.categories['default']) === 'undefined'){\n            cell.categories['default'] = {\n                'count': 0,\n                'color': colorsDef.defaultColor\n            };\n        }\n    };\n\n    this.init = function() {\n        if (!this.archive){\n            ws.message(function(data) {\n                _this.addAnnot(data);\n            });\n        }\n\n        if (this.showClockGraphics){this.initClockGraphics();}\n    };\n\n\n    this.start = function() {\n        this.startTs = Date.now();\n        loadArchives();\n    };\n\n    this.refresh = function() {\n\n    };\n\n    this.stop = function(){\n    };\n\n    return this;\n}\n\nmodule.exports = {\n    AnnotsTimeLine: 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');\nvar Utils = require('./utils.js');\n\nvar defaultOptions = {\n    xInit: 0,\n    yInit: 0,\n    width: 1024,\n    height: 768\n};\n\nfunction AnnotsVizView(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.width = opts.width;\n    this.height= opts.height;\n    this.timeBegin = opts.timeBegin;\n    this.timeEnd = opts.timeEnd;\n\n    this.annotCategories = [];\n    this.annotCategoriesDay2 = [];\n    this.annotCategoriesDay1 = [];\n\n    var wsPianoroll = opts.wsPianoroll;\n    var wsAnnot = opts.wsAnnot;\n    var stageView = opts.stageView;\n    var currentTime = Date.now() + 3600*1000;\n    var channel = opts.channel;\n    var serverUrl = opts.serverUrl;\n    \n    var eventCode = opts.eventCode;\n    var eventCodeSessionDay2 = opts.eventCodeSessionDay2;\n\tvar eventCodeSessionDay1 = opts.eventCodeSessionDay1;\n\n\tUtils.getAnnotCategories(opts.urlCategories + eventCode, this.annotCategories);\n    Utils.getAnnotCategories(opts.urlCategories + eventCodeSessionDay2, this.annotCategoriesDay2);\n    Utils.getAnnotCategories(opts.urlCategories + eventCodeSessionDay1, this.annotCategoriesDay1);\n\n    stageView.registerComponent(this);\n\n    var currentDay = new AnnotsTimeLine.AnnotsTimeLine({\n    \tstageView : stageView,\n        logger: logger,\n        ws: wsAnnot,\n        xInit: 0,\n        yInit: 0,\n        width: 1024 - 200 - 200,\n        height: 768-200,\n        timeBegin: this.timeBegin,\n        timeEnd: this.timeEnd,\n        intervalWidth: 6,\n        intervalHeight: 10,\n        maxCellHeight: 70,\n        radius: 200,\n        eventCode: eventCode,\n        channel: channel,\n        serverUrl: serverUrl,\n        annotCategories: this.annotCategories\n    });\n\t\n\t//Archive day 2\n    var timeLineDay2 = new AnnotsTimeLine.AnnotsTimeLine({\n    \tstageView : stageView,\n        xInit: 0,\n        yInit: 0,\n        width: 1024 - 200 - 200,\n        height: 768-200,\n        timeBegin: Date.parse(\"2015-01-23T09:30:00+01:00\"),\n        timeEnd: Date.parse(\"2015-01-23T18:30:00+01:00\"),\n        circleX: currentDay.circleX,\n        circleY: currentDay.circleY,\n        intervalWidth: (currentDay.radius*2/3)* currentDay.intervalWidth / currentDay.radius,\n        intervalHeight: (currentDay.intervalHeight * (currentDay.radius - currentDay.radius*2/3))/ currentDay.maxCellHeight,\n        maxCellHeight: (currentDay.radius - currentDay.radius*2/3)/2,\n        radius: currentDay.radius*2/3,\n        annotCategories: this.annotCategoriesDay2,\n        eventCode: eventCodeSessionDay2,\n        channel: channel,\n        serverUrl: serverUrl,\n        showClockGraphics:false,\n        archive: true\n    });\n\t\n\t//Archive day 1\n    var timeLineDay1 = new AnnotsTimeLine.AnnotsTimeLine({\n    \tstageView : stageView,\n        xInit: 0,\n        yInit: 0,\n        width: 1024 - 200 - 200,\n        height: 768-200,\n        timeBegin: Date.parse(\"2015-01-22T09:30:00+01:00\"),\n        timeEnd: Date.parse(\"2015-01-22T18:30:00+01:00\"),\n        circleX: currentDay.circleX,\n        circleY: currentDay.circleY,\n        intervalWidth: (currentDay.radius*2/3)* currentDay.intervalWidth / currentDay.radius,\n        intervalHeight: (currentDay.intervalHeight * (currentDay.radius - currentDay.radius/3))/ currentDay.maxCellHeight,\n        maxCellHeight: (currentDay.radius*2/3 - currentDay.radius/3)/4,\n        radius: currentDay.radius/3,\n        annotCategories: this.annotCategoriesDay1,\n        eventCode: eventCodeSessionDay1,\n        channel: channel,\n        serverUrl: serverUrl,\n        showClockGraphics:false,\n        archive: true,\n    });\n\n    var currentTimeText = new PIXI.Text(\"-- : -- : --\", { font: '18pt Gothic Standard', fill: '#646464' });\n    currentTimeText.x = timeLineDay2.circleX - currentTimeText.width/2;\n    currentTimeText.y = timeLineDay2.circleY - currentTimeText.height/2;\n    this.container.addChild(currentTimeText);\n\n    var doubleRollH = new DoubleRoll.DoubleRoll({\n        stageView : stageView,\n        logger: 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    var doubleRollV = new DoubleRoll.DoubleRoll({\n        stageView : stageView,\n        logger: 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    var annotsRoll = new AnnotsRoll.AnnotsRoll({\n        stageView : 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    var limiters = new PIXI.Graphics()\n        .lineStyle(1, 0x646464)\n        .moveTo(annotsRoll.container.x, annotsRoll.container.y)\n        .lineTo(annotsRoll.container.x, annotsRoll.container.y - annotsRoll.height)\n        .moveTo(annotsRoll.container.x + annotsRoll.widthRoll, annotsRoll.container.y)\n        .lineTo(annotsRoll.container.x + annotsRoll.widthRoll, annotsRoll.container.y - annotsRoll.height)\n        .moveTo(0, this.height - 200)\n        .lineTo(this.width, this.height - 200)\n        .drawRect(0, 0, this.width -1, this.height -1)\n        .beginFill(0xECECEC)\n        .drawRect(1024 - 200, 0, 200, 768-200)\n        .endFill();\n    this.container.addChild(limiters);\n\n    this.init = function(){\n    };\n\n    this.updateTime = function(){\n        currentTimeText.setText(Utils.formatTime(Date.now()));\n    };\n\n    var refreshTimeInterval;\n\n    this.start = function() {\n        refreshTimeInterval = setInterval(function() {_this.updateTime();}, 1000);\n    };\n\n    this.refresh = function() {\n    };\n\n    this.stop = function(){\n    };\n\n    return this;\n\n}\n\nmodule.exports = {\n    AnnotsVizView: 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'use strict';\n\n\nvar PIXI = require('pixi');\nvar _ = require('lodash');\nvar PianoRoll = require('./pianoroll');\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 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\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        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 = Math.abs(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\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        \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/*jshint bitwise: false*/\n/*jshint camelcase: false */\n\n'use strict';\n\nvar PIXI = require('pixi');\nvar _ = require('lodash');\nvar moment = require('moment');\n\nfunction formatTime (ts) {\n    return moment(ts).format('HH:mm:ss');\n}\n\nfunction colorToHex(c) {\n    var m = /rgba?\\(\\s*(\\d+)\\s*,\\s*(\\d+)\\s*,\\s*(\\d+)/.exec(c);\n    return m ? '#' + (1 << 24 | m[1] << 16 | m[2] << 8 | m[3]).toString(16).substr(1) : c;\n}\n\nfunction getAnnotCategories(urlCategories, annotCategories) {\n\n    var jsonLoader = new PIXI.JsonLoader(urlCategories, true);\n\n    jsonLoader.on('loaded', function(res) {\n        var data = res.target.json;\n\n        while(annotCategories.length > 0) {\n            annotCategories.pop();\n        }\n\n        data.sessions.forEach(function(session) {\n            var annotCat = {\n                ts: session.start_ts === null ? new Date(0) : Date.parse(session.start_ts),\n                colors: {}\n            };\n            var categoriesJson = session.categories_json;\n            annotCat.order = categoriesJson.order;\n            if (typeof(annotCat.order['default']) === 'undefined'){\n                annotCat.order.push('default');\n            }\n            var catList = _.clone(categoriesJson.categories);\n            while(catList.length > 0) {\n                var cat = catList.pop();\n                if(cat.code) {\n                    annotCat.colors[cat.code] = colorToHex(cat.color);\n                }\n                if(cat.subcategories) {\n                    catList = catList.concat(cat.subcategories);\n                }\n            }\n            categoriesJson.categories.forEach(function(cat) {\n                if(cat.code) {\n                    annotCat.colors[cat.code] = colorToHex(cat.color);\n                }\n            });\n            annotCat.defaultColor = categoriesJson.defaultColor || '#536991';\n            annotCategories.push(annotCat);\n        });\n    });\n\n    jsonLoader.load();\n\n}\n\nmodule.exports = {\n    formatTime: formatTime,\n    getAnnotCategories: getAnnotCategories,\n    colorToHex: colorToHex\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"]}
mons