1 (function ($) { |
|
2 $.fn._vs.strata = { |
|
3 |
|
4 stratas: [], |
|
5 |
|
6 // Create stratas |
|
7 init:function(_this) { |
|
8 |
|
9 if(_this.settings.chart.type!='StackedAreaChart') { |
|
10 |
|
11 _this.strata.create_strata(_this); |
|
12 return; |
|
13 } |
|
14 settings = _this.settings; |
|
15 |
|
16 // No strata or empty strata, so nothing happens |
|
17 if( (typeof(settings.data.strata) != 'function') && (typeof(settings.data.strata) == "undefined" || settings.data.strata.length == 0)) { // || settings.data.strata.length == 0) { |
|
18 |
|
19 for (var i=0; i<settings.data.model.length; i++) { |
|
20 |
|
21 var defaultStrata = { |
|
22 label: settings.data.model[i].label+"_"+i, |
|
23 category: i, |
|
24 value: function(t, s) { return 0;}, |
|
25 } |
|
26 _this.strata.stratas[i] = [defaultStrata]; |
|
27 }; |
|
28 |
|
29 _this.strata.create_strata(_this); |
|
30 return; |
|
31 } |
|
32 |
|
33 if(typeof settings.data.strata != 'function') { |
|
34 |
|
35 // Serialized function in JSON |
|
36 if(typeof(settings.data.strata == "object") && typeof(settings.data.strata[0]) != "undefined" && (typeof settings.data.strata[0][0].value != "undefined") && typeof(settings.data.strata[0][0].value == "string")) { |
|
37 |
|
38 var NB_STRATA = settings.data.strata[0].length; |
|
39 |
|
40 // Create default strata object |
|
41 for (var i=0; i<settings.data.model.length; i++) { |
|
42 _this.strata.stratas[i] = []; |
|
43 // Create default strata object |
|
44 for (var n=0; n<NB_STRATA; n++) { |
|
45 (function(a,b) { |
|
46 var t=null; |
|
47 if( (typeof settings.data.strata[a] !="undefined") && (typeof settings.data.strata[a][b] !="undefined") && (typeof settings.data.strata[a][b].texture!="undefined")) |
|
48 t = settings.data.strata[a][b].texture; |
|
49 var defaultStrata = {}; |
|
50 |
|
51 defaultStrata = { |
|
52 label: settings.data.model[i].label+"_"+a, |
|
53 category: a, |
|
54 texture: t, |
|
55 value: function() { r=eval("f="+settings.data.strata[a][b].value); return r();} |
|
56 } |
|
57 |
|
58 |
|
59 _this.strata.stratas[a].push(defaultStrata); |
|
60 })(i,n); |
|
61 } |
|
62 } |
|
63 _this.strata.create_strata(_this); |
|
64 |
|
65 return; |
|
66 } |
|
67 |
|
68 if(typeof(settings.data.strata[0]) != "undefined" && typeof(settings.data.strata[0][0]) != "undefined" && typeof(settings.data.strata[0][0].initValue != "undefined" ) ) { |
|
69 |
|
70 for (var c=0; c<settings.data.model.length; c++) { |
|
71 var defaultStrata = { |
|
72 label: settings.data.model[c].label+"_"+c, |
|
73 category: i, |
|
74 value: function(t, s) { |
|
75 if(t.selectAll("category", s)) { |
|
76 |
|
77 return settings.data.strata[s][0].initValue+t.selectAll("category", s).attr("state").filter(function(d) {if(d==2) return d}).length; |
|
78 } else |
|
79 return settings.data.strata[s][0].initValue; |
|
80 }, |
|
81 } |
|
82 _this.strata.stratas[c] = [defaultStrata]; |
|
83 }; |
|
84 _this.strata.create_strata(_this); |
|
85 return; |
|
86 |
|
87 } else if(settings.data.strata[0].length == 0) { // Default bar chart |
|
88 |
|
89 // Create default strata object |
|
90 for (var i=0; i<settings.data.model.length; i++) { |
|
91 |
|
92 var defaultStrata = { |
|
93 label: settings.data.model[i].label+"_"+i, |
|
94 category: i, |
|
95 value: function(t, s) { |
|
96 if(t.selectAll("category", s)) { |
|
97 return t.selectAll("category", s).attr("state").filter(function(d) {if(d==2) return d}).length; |
|
98 } else |
|
99 return 0; |
|
100 }, |
|
101 } |
|
102 _this.strata.stratas[i] = [defaultStrata]; |
|
103 }; |
|
104 _this.strata.create_strata(_this); |
|
105 return; |
|
106 |
|
107 } else { |
|
108 |
|
109 var NB_STRATA = settings.data.strata[0].length; |
|
110 settings.data.strata_param = settings.data.strata; |
|
111 |
|
112 function fstrata() { |
|
113 var a = Array(); |
|
114 for(var s=0; s<mySettings.data.model.length; s++) |
|
115 a.push(fstratum(s)); |
|
116 return a; |
|
117 } |
|
118 |
|
119 function fstratum(a) { |
|
120 |
|
121 var b = Array(NB_STRATA); |
|
122 for(var r=0; r<b.length; r++) |
|
123 b[r] = Array(); |
|
124 |
|
125 if(typeof _this != "undefined") { |
|
126 |
|
127 var tokens = _this.selectAll("category", s).attr("state").filter(function(d) {if(d==2) return d}).length; |
|
128 |
|
129 for(var k=0; k<tokens.length; k++) { |
|
130 var tk = tokens[k]; |
|
131 |
|
132 |
|
133 for(var r=0; r<b.length; r++) { |
|
134 |
|
135 if(tk < _this.settings.stream.now-2*(r) && tk >= _this.settings.stream.now-2*(r+1)) |
|
136 b[b.length-r-1].push(tk) |
|
137 } |
|
138 } |
|
139 |
|
140 } |
|
141 var res = Array(); |
|
142 |
|
143 for(var j=0; j<NB_STRATA; j++) { |
|
144 var val = b[j].length; |
|
145 (function(v) { |
|
146 res.push({value: function() { return v; }, label:"Strata "+j, category:a}) // b[j].length |
|
147 })(val); |
|
148 |
|
149 } |
|
150 return res; |
|
151 } |
|
152 |
|
153 _this.settings.data.strata = function() {return fstrata()}; |
|
154 _this.strata.stratas = _this.settings.data.strata(); |
|
155 _this.strata.create_strata(_this); |
|
156 return; |
|
157 } |
|
158 |
|
159 } |
|
160 |
|
161 if((typeof settings.data.strata == 'function') || settings.data.strata[0].length > 0 || _this.strata.stratas.length>0) { |
|
162 |
|
163 // Strata have been defined, put them in the internal object |
|
164 if(typeof settings.data.strata == 'function' || (settings.data.strata[0].length > 0 && typeof(settings.data.strata[0])=="object")) { |
|
165 |
|
166 // Strata have been defined as functions |
|
167 if(typeof settings.data.strata == 'function') { |
|
168 _this.strata.stratas = settings.data.strata(); |
|
169 |
|
170 } else if(typeof settings.data.strata[0].value == 'function') { |
|
171 |
|
172 for (var i=0; i<settings.data.model.length; i++) { |
|
173 |
|
174 var defaultStrata = { |
|
175 label: settings.data.model[i].label+"_"+i, |
|
176 category: i, |
|
177 initValue: settings.data.model[i].value, |
|
178 value: function(t, s) { |
|
179 return settings.data.strata[i]; |
|
180 }, |
|
181 } |
|
182 |
|
183 _this.strata.stratas[i] = [defaultStrata]; |
|
184 |
|
185 } |
|
186 |
|
187 } else { // Numerical values as strata |
|
188 |
|
189 for (var i=0; i<settings.data.model.length; i++) { |
|
190 var defaultStrata = { |
|
191 label: settings.data.model[i].label+"_"+i, |
|
192 |
|
193 category: i, |
|
194 initValue: settings.data.model[i].value, |
|
195 |
|
196 value: function(t, s) { |
|
197 if(typeof(t.selectAll("category", s).length) == "undefined") |
|
198 return this.initValue; |
|
199 if(t.selectAll("category", s)) { |
|
200 return this.initValue+t.selectAll("category", s).attr("state").filter(function(d) {if(d==2) return d}).length; |
|
201 } else |
|
202 return 0; |
|
203 }, |
|
204 } |
|
205 |
|
206 _this.strata.stratas[i] = [defaultStrata]; |
|
207 }; |
|
208 } |
|
209 } |
|
210 _this.strata.create_strata(_this); |
|
211 } |
|
212 // _this.strata.update(_this); |
|
213 }, |
|
214 |
|
215 // select stratas |
|
216 selectAll:function(_this,key,value){ |
|
217 result = [] |
|
218 result.attr = function(key,value,param){ |
|
219 var r=[] |
|
220 result.forEach(function(i){ |
|
221 q = i.attr(key,value,param) |
|
222 r.push(q) |
|
223 }) |
|
224 return r |
|
225 } |
|
226 |
|
227 if(typeof(value) == "undefined" && typeof(key) == "undefined"){ |
|
228 return this.stratas |
|
229 }else{ |
|
230 for (var i = _this.strata.stratas.length - 1; i >= 0; i--) { |
|
231 if(_this.strata.stratas[i].attr(key) == value){ |
|
232 result.push(_this.strata.stratas[i]) |
|
233 break; |
|
234 } |
|
235 } |
|
236 } |
|
237 if(typeof(result[0])=="undefined"){ |
|
238 return false |
|
239 }else{ |
|
240 return result[0]; |
|
241 } |
|
242 }, |
|
243 |
|
244 // Create stratas |
|
245 add:function(_this,setting){ |
|
246 |
|
247 var strata = function (){} |
|
248 strata.myobj = setting |
|
249 |
|
250 strata.attr = function(key,value,param){ |
|
251 if(typeof(value) == "undefined"){ |
|
252 if(typeof(this[key])!="undefined"){ |
|
253 return this[key]() |
|
254 }else{ |
|
255 return this.myobj[key] |
|
256 } |
|
257 }else{ |
|
258 if(typeof(this[key])!="undefined"){ |
|
259 this[key](value,param) |
|
260 }else{ |
|
261 this.myobj[key]=value |
|
262 } |
|
263 } |
|
264 return this |
|
265 } |
|
266 return strata |
|
267 }, |
|
268 |
|
269 // remove stratas |
|
270 remove:function(_this,key,value){ |
|
271 |
|
272 }, |
|
273 |
|
274 // Returns n layers |
|
275 strata_layers: function (_this, n, m, p) { |
|
276 |
|
277 // Scales for setting up the strata layers |
|
278 var sn = d3.scale.linear().domain([1, m-2]).range([Math.PI/2, 2*Math.PI-Math.PI/2]); |
|
279 var logscale = d3.scale.pow().exponent(10).domain([0, m]).range([0,1]); |
|
280 |
|
281 return d3.range(n).map(function(i) { |
|
282 // For customs layers |
|
283 var r = 5*Math.random(); |
|
284 |
|
285 return d3.range(m).map(function(j) { |
|
286 |
|
287 if(_this.settings.sedimentation.aggregation.strataType=="sin") { |
|
288 if(i==1) return 20; |
|
289 var x = 5+r*5*Math.sin(sn(j))+(i*50); |
|
290 if(x<0) return -x; else return x; |
|
291 } else if(_this.settings.sedimentation.aggregation.strataType=="log") { |
|
292 return i+1; |
|
293 //return logscale(j);//logscale(i); |
|
294 } else { |
|
295 if(typeof(p)=='undefined') |
|
296 p=0; |
|
297 return _this.strata.stratas[p][i].value(_this, p); |
|
298 } |
|
299 }).map(stream_index); |
|
300 }); |
|
301 function stream_index(d, i) { |
|
302 return {x: i, y: Math.max(0, d)}; |
|
303 } |
|
304 }, |
|
305 // Strata creation |
|
306 create_strata: function(_this) { |
|
307 |
|
308 if(_this.settings.chart.type=='StackedAreaChart') { |
|
309 |
|
310 // Local variables for clearer code |
|
311 var w = _this.settings.chart.width/_this.settings.data.model.length, |
|
312 h = _this.settings.sedimentation.aggregation.height; |
|
313 var color = _this.token.colorRange; |
|
314 |
|
315 if(typeof _this.settings.options.canvasFirst != "undefined" && _this.settings.options.canvasFirst == false) { |
|
316 |
|
317 // Create a .vis element that overlays the canvas |
|
318 var vis = d3.select("#"+_this.settings.DOMelement.id) |
|
319 .insert("div", ":first-child") |
|
320 .style("position", "absolute") |
|
321 .attr("class", "vis") |
|
322 .style("z-index", 10) |
|
323 .append("svg") |
|
324 .attr("width", _this.settings.width) |
|
325 .attr("height", _this.settings.height) |
|
326 .append("g") |
|
327 .attr("transform", "translate(" + _this.settings.chart.x + "," + _this.settings.chart.y + ")"); |
|
328 } else { |
|
329 |
|
330 var vis = d3.select("#"+_this.settings.DOMelement.id) |
|
331 .append("div") |
|
332 .attr("class", "vis") |
|
333 .style("z-index", 10) |
|
334 .append("svg") |
|
335 .attr("width", _this.settings.width) |
|
336 .attr("height", _this.settings.height) |
|
337 .append("g") |
|
338 .attr("transform", "translate(" + _this.settings.chart.x + "," + _this.settings.chart.y + ")"); |
|
339 } |
|
340 |
|
341 var sn = _this.strata.stratas[0].length, // number of layers |
|
342 sm = 20; // number of samples per layer |
|
343 smx = sm - 1, smy = 0; |
|
344 |
|
345 |
|
346 var sum_strata = _this.strata.stratas.map( |
|
347 function(d, i) { |
|
348 for(var v=0, res=0; v<d.length; v++) |
|
349 res+=d[v].value(_this, i); |
|
350 return res; |
|
351 }); |
|
352 |
|
353 |
|
354 var y = d3.scale.linear() |
|
355 .domain([0, Math.max(d3.max(sum_strata), _this.settings.sedimentation.aggregation.maxData)]) |
|
356 .range([0, _this.settings.sedimentation.aggregation.height]); |
|
357 |
|
358 // Create a group layer that contains all the future strata groups .gpath |
|
359 var g = vis.selectAll("g.gcol") |
|
360 .data(_this.strata.stratas, function(d) {return [d];}) |
|
361 .enter() |
|
362 .append("g") |
|
363 .attr("transform", function(d, i) { |
|
364 |
|
365 var align = _this.settings.sedimentation.aggregation.height; |
|
366 if(_this.settings.sedimentation.aggregation.invertStrata) { |
|
367 align =2*_this.settings.sedimentation.aggregation.height-y(sum_strata[i]); |
|
368 } |
|
369 return "translate("+(i*w)+", "+(_this.settings.chart.height-align)+")"; |
|
370 }).attr("class", function(d,i) { return "gcol col_"+i;});; |
|
371 |
|
372 // Group path for each strata group |
|
373 var gpath = g.selectAll(".gpath") |
|
374 .data(function(d, i) { |
|
375 var sd = d3.layout.stack().offset("expand")(_this.strata.strata_layers(_this, d.length, sm, i)); |
|
376 smy = d3.max(sd, function(d) { |
|
377 return d3.max(d, function(d) { |
|
378 return d.y0 + d.y; |
|
379 }); |
|
380 }); |
|
381 sd.map(function(d) {d.map(function(d) {d.col=i;return d;});}); // Put col # in data |
|
382 return sd; |
|
383 }) |
|
384 .enter().append("g").attr("class", "gpath"); |
|
385 |
|
386 |
|
387 // Rectangular strata |
|
388 var area = d3.svg.area() |
|
389 .x(function(d) { return _this.settings.chart.spacer+d.x * (w-2*_this.settings.chart.spacer) / smx; }) |
|
390 .y0(function(d) { return (h - d.y0 * d.offshit); }) |
|
391 .y1(function(d) { return (h - (d.y + d.y0) * d.offshit ); }); |
|
392 |
|
393 var pathlayer = gpath.append("path") |
|
394 .attr("d", function(d,i) { |
|
395 |
|
396 _this.chartUpdate(i, -y(sum_strata[i])-(h-_this.settings.chart.height)); |
|
397 hh = 0;//_this.settings.chart.height-_this.chart.getPosition(_this)[d[0].col].y; |
|
398 d.map(function(dd) { |
|
399 dd.offshit = hh; |
|
400 return dd; |
|
401 }); |
|
402 return area(d); |
|
403 }); |
|
404 |
|
405 // Customize layers with color and texture |
|
406 pathlayer.style("fill", function(d,i) { |
|
407 if(_this.strata.stratas[d[0].col][i].texture!=null) { |
|
408 return "url(#RectanglePattern_"+d[0].col+"_"+i+")"; |
|
409 } else { |
|
410 return d3.rgb(color(d[0].col)) |
|
411 .darker(_this.strata.stratas[d[0].col].length/2-(i+1)/2); // The more away from the token, the darker |
|
412 } |
|
413 }) |
|
414 .attr("class", function(d,i) { return "gcol col_"+d[0].col+" layer_"+i;}); |
|
415 |
|
416 // Textures |
|
417 var patternWidth = w/1; |
|
418 var patternHeight = patternWidth; |
|
419 |
|
420 if(typeof _this.settings.data.strata != "undefined") { |
|
421 for(var s=0; s<_this.settings.data.strata.length; s++) { |
|
422 for(var l=0; l<_this.settings.data.strata[s].length; l++) { |
|
423 if(_this.settings.data.strata[s][l].texture!=null) { |
|
424 |
|
425 var pattern = vis.append('pattern') |
|
426 .attr('id','RectanglePattern_'+s+"_"+l) |
|
427 .attr('height', patternHeight) |
|
428 .attr('width', patternWidth) |
|
429 .attr('patternTransform', 'translate(0, 0) scale('+_this.settings.data.strata[s][l].texture.size+', '+_this.settings.data.strata[s][l].texture.size+') rotate(0)') |
|
430 .attr('patternUnits','userSpaceOnUse'); |
|
431 |
|
432 pattern.append('image') |
|
433 .attr('x', 0) |
|
434 .attr('y', 0) |
|
435 .attr('height', patternHeight) |
|
436 .attr('width', patternWidth) |
|
437 .attr('xlink:href', function() { return _this.settings.data.strata[s][l].texture.url;}); |
|
438 } |
|
439 } |
|
440 } |
|
441 } |
|
442 } else if(_this.settings.chart.type=='CircleLayout') { |
|
443 |
|
444 |
|
445 // strata |
|
446 var svg = d3.select("#"+_this.settings.DOMelement.id) |
|
447 .append("div") |
|
448 .attr("class", "vis")//.style("margin-top", "-"+_this.settings.height+"px") |
|
449 .attr("width", _this.settings.width) |
|
450 .attr("height", _this.settings.height) |
|
451 .append("svg") |
|
452 .attr("width", _this.settings.width) |
|
453 .attr("height", _this.settings.height); |
|
454 |
|
455 // bubble chart |
|
456 if(typeof(_this.settings.chart.treeLayout)!="undefined") { |
|
457 |
|
458 for(var i=0; i<_this.settings.data.model.length; i++) { |
|
459 var data =_this.settings.data.strata[i]; |
|
460 var color = function(s) { return _this.token.colorRange(i)}; |
|
461 _this.strata.create_pie_chart(_this, data, svg, data[0].value, color, |
|
462 ((i+1/2))*_this.settings.chart.width/(_this.settings.data.model.length)+_this.settings.chart.x, |
|
463 _this.settings.chart.y+_this.settings.chart.height/6); |
|
464 } |
|
465 } else { |
|
466 var data =_this.settings.data.strata.map(function(d) { return {value:d[0].value};}); |
|
467 var color = _this.token.colorRange; |
|
468 _this.strata.create_pie_chart(_this, data, svg, _this.settings.chart.radius, color, |
|
469 _this.settings.chart.x+_this.settings.chart.width/2, |
|
470 _this.settings.chart.y+_this.settings.chart.height/2); |
|
471 } |
|
472 } |
|
473 }, |
|
474 create_pie_chart: function(_this, data, svg, r, color, posx, posy) { |
|
475 |
|
476 var w = _this.settings.width/_this.settings.data.model.length, |
|
477 h = _this.settings.sedimentation.aggregation.height;//_this.settings.height; |
|
478 |
|
479 var x = d3.scale.linear() |
|
480 .domain([0, _this.settings.data.strata.length-1]) |
|
481 .range([0, _this.settings.width]); |
|
482 |
|
483 |
|
484 var y = d3.scale.linear() |
|
485 .domain([0, d3.max(data, function(d) {return d.value; })]) |
|
486 .rangeRound([0, h]); |
|
487 |
|
488 // CIRCLE |
|
489 var wp = _this.settings.width, |
|
490 hp = _this.settings.height, |
|
491 hhp = _this.settings.sedimentation.aggregation.height; |
|
492 //Math.min(w, hh) / 2, |
|
493 labelr = r + 30, // radius for label anchor |
|
494 donut = d3.layout.pie().sort(null), |
|
495 arc = d3.svg.arc().innerRadius(0).outerRadius(r); |
|
496 |
|
497 var id=Math.random(); |
|
498 svg.append("g.arcs_"+id) |
|
499 .attr("class", "arcs_"+id); |
|
500 |
|
501 var garcs = svg.selectAll(".arcs") |
|
502 .data(donut(data.map(function(d, i) { return d.value}))) |
|
503 .enter().append("svg:g").attr("transform", "translate(" + posx + "," + posy + ")"); |
|
504 |
|
505 var hh=0; |
|
506 |
|
507 // Rectangular strata |
|
508 var area = d3.svg.area() |
|
509 .x(function(d) { return _this.settings.chart.spacer+d.x * (w-2*_this.settings.chart.spacer) / smx; }) |
|
510 .y0(function(d) { return (h - d.y0 * hh); }) //hh/smy |
|
511 .y1(function(d) { return (h - (d.y + d.y0) * hh ); }); //hh/smy |
|
512 |
|
513 var arcs = garcs.append("path") |
|
514 .attr("fill", function(d, i) { return color(i); }) |
|
515 .attr("d", function(d,i) { |
|
516 |
|
517 return arc(d); |
|
518 |
|
519 }) |
|
520 .each(function(d) { this._current = d; }); |
|
521 |
|
522 |
|
523 }, |
|
524 update: function(_this) { |
|
525 // No strata or empty strata, so nothing happens |
|
526 if(typeof(_this.strata.stratas) == "undefined" || _this.strata.stratas.length == 0) { |
|
527 //TODO: create virtual strata to store all the flocculated ones |
|
528 return; |
|
529 } |
|
530 |
|
531 // If strata are functions, then refresh them |
|
532 if(typeof settings.data.strata == 'function') { |
|
533 _this.strata.stratas = settings.data.strata(); |
|
534 } |
|
535 var sn = _this.strata.stratas[0].length, // number of layers |
|
536 sm = 20; // number of samples per layer |
|
537 smx = sm - 1, smy = 0; |
|
538 |
|
539 // Local variables for clearer code |
|
540 var w = _this.settings.chart.width/_this.settings.data.model.length, |
|
541 h = _this.settings.sedimentation.aggregation.height; |
|
542 var color = _this.token.colorRange; |
|
543 |
|
544 // Rectangular strata |
|
545 var area = d3.svg.area() |
|
546 .x(function(d) { return _this.settings.chart.spacer+d.x * (w-2*_this.settings.chart.spacer) / smx; }) |
|
547 .y0(function(d) { return (h - d.y0 * d.offshit); }) |
|
548 .y1(function(d) { return (h - (d.y + d.y0) * d.offshit ); }); |
|
549 |
|
550 var sum_strata = _this.strata.stratas.map( |
|
551 function(d, i) { |
|
552 for(var v=0, res=0; v<d.length; v++) { |
|
553 res+=d[v].value(_this, i); |
|
554 } |
|
555 return res; |
|
556 }); |
|
557 |
|
558 var y = d3.scale.linear() |
|
559 .domain([0, Math.max(d3.max(sum_strata), _this.settings.sedimentation.aggregation.maxData)]) |
|
560 .range([0, _this.settings.sedimentation.aggregation.height]); |
|
561 |
|
562 var vis = d3.select("#"+_this.settings.DOMelement.id) |
|
563 |
|
564 var g = vis.selectAll("g.gcol") |
|
565 |
|
566 |
|
567 if(_this.settings.sedimentation.aggregation.invertStrata) { |
|
568 g.transition().duration(100).attr("transform", function(d, i) { |
|
569 var align = _this.settings.sedimentation.aggregation.height; |
|
570 align =2*_this.settings.sedimentation.aggregation.height-y(sum_strata[i]); |
|
571 return "translate("+(i*w)+", "+(_this.settings.chart.height-(2*_this.settings.sedimentation.aggregation.height-y(sum_strata[i])))+")"; |
|
572 }); |
|
573 } |
|
574 |
|
575 // Update the group data model |
|
576 var gpath = g.selectAll("path") |
|
577 .data(function(d, i) { |
|
578 var sd = d3.layout.stack().offset("expand")(_this.strata.strata_layers(_this, d.length, sm, i)); |
|
579 |
|
580 smy = d3.max(sd, function(d) { |
|
581 return d3.max(d, function(d) { |
|
582 return d.y0 + d.y; |
|
583 }); |
|
584 }); |
|
585 sd.map(function(d) { |
|
586 d.map(function(d) { |
|
587 d.col=i; |
|
588 return d; |
|
589 }); |
|
590 }); // Put col # in data |
|
591 return sd; |
|
592 }); |
|
593 |
|
594 if(_this.settings.chart.type=='StackedAreaChart') { |
|
595 // Adding strata layers |
|
596 var pathlayer = vis.selectAll("path") |
|
597 .transition().duration(100).attr("d", function(d,i) { |
|
598 |
|
599 if(!_this.settings.sedimentation.aggregation.invertStrata) { |
|
600 _this.chartUpdate(i, -y(sum_strata[i])-(h-_this.settings.chart.height)); |
|
601 hh = _this.settings.chart.height-_this.chart.getPosition(_this)[d[0].col].y; |
|
602 } else { |
|
603 _this.chartUpdate(i, -2*h+_this.settings.chart.height); |
|
604 hh = y(sum_strata[d[0].col]); |
|
605 } |
|
606 d.map(function(dd) { |
|
607 dd.offshit = hh; |
|
608 return dd; |
|
609 }); |
|
610 return area(d); |
|
611 }); |
|
612 } |
|
613 } |
|
614 //return {}; |
|
615 } |
|
616 })(jQuery); |
|