From 91d04c64771832a0b8815ffbe1f0f9920320d94d Mon Sep 17 00:00:00 2001 From: Pamela Dragosh Date: Tue, 14 Feb 2017 19:41:00 -0500 Subject: Initial OpenECOMP policy/engine commit Change-Id: I7dbff37733b661643dd4d1caefa3d7dccc361b6e Signed-off-by: Pamela Dragosh --- .../webapp/app/fusion/external/d3/js/horizon.js | 192 +++++++++++++++++++++ 1 file changed, 192 insertions(+) create mode 100644 ecomp-sdk-app/src/main/webapp/app/fusion/external/d3/js/horizon.js (limited to 'ecomp-sdk-app/src/main/webapp/app/fusion/external/d3/js/horizon.js') diff --git a/ecomp-sdk-app/src/main/webapp/app/fusion/external/d3/js/horizon.js b/ecomp-sdk-app/src/main/webapp/app/fusion/external/d3/js/horizon.js new file mode 100644 index 000000000..d84c65679 --- /dev/null +++ b/ecomp-sdk-app/src/main/webapp/app/fusion/external/d3/js/horizon.js @@ -0,0 +1,192 @@ +(function() { + d3.horizon = function() { + var bands = 1, // between 1 and 5, typically + mode = "offset", // or mirror + interpolate = "linear", // or basis, monotone, step-before, etc. + x = d3_horizonX, + y = d3_horizonY, + w = 960, + h = 40, + duration = 0; + + var color = d3.scale.linear() + .domain([-1, 0, 1]) + .range(["#d62728", "#fff", "#1f77b4"]); + + // For each small multiple… + function horizon(g) { + g.each(function(d, i) { + var g = d3.select(this), + n = 2 * bands + 1, + xMin = Infinity, + xMax = -Infinity, + yMax = -Infinity, + x0, // old x-scale + y0, // old y-scale + id; // unique id for paths + + // Compute x- and y-values along with extents. + var data = d.map(function(d, i) { + var xv = x.call(this, d, i), + yv = y.call(this, d, i); + if (xv < xMin) xMin = xv; + if (xv > xMax) xMax = xv; + if (-yv > yMax) yMax = -yv; + if (yv > yMax) yMax = yv; + return [xv, yv]; + }); + + // Compute the new x- and y-scales, and transform. + var x1 = d3.scale.linear().domain([xMin, xMax]).range([0, w]), + y1 = d3.scale.linear().domain([0, yMax]).range([0, h * bands]), + t1 = d3_horizonTransform(bands, h, mode); + + // Retrieve the old scales, if this is an update. + if (this.__chart__) { + x0 = this.__chart__.x; + y0 = this.__chart__.y; + t0 = this.__chart__.t; + id = this.__chart__.id; + } else { + x0 = x1.copy(); + y0 = y1.copy(); + t0 = t1; + id = ++d3_horizonId; + } + + // We'll use a defs to store the area path and the clip path. + var defs = g.selectAll("defs") + .data([null]); + + // The clip path is a simple rect. + defs.enter().append("defs").append("clipPath") + .attr("id", "d3_horizon_clip" + id) + .append("rect") + .attr("width", w) + .attr("height", h); + + defs.select("rect").transition() + .duration(duration) + .attr("width", w) + .attr("height", h); + + // We'll use a container to clip all horizon layers at once. + g.selectAll("g") + .data([null]) + .enter().append("g") + .attr("clip-path", "url(#d3_horizon_clip" + id + ")"); + + // Instantiate each copy of the path with different transforms. + var path = g.select("g").selectAll("path") + .data(d3.range(-1, -bands - 1, -1).concat(d3.range(1, bands + 1)), Number); + + var d0 = d3_horizonArea + .interpolate(interpolate) + .x(function(d) { return x0(d[0]); }) + .y0(h * bands) + .y1(function(d) { return h * bands - y0(d[1]); }) + (data); + + var d1 = d3_horizonArea + .x(function(d) { return x1(d[0]); }) + .y1(function(d) { return h * bands - y1(d[1]); }) + (data); + + path.enter().append("path") + .style("fill", color) + .attr("transform", t0) + .attr("d", d0); + + path.transition() + .duration(duration) + .style("fill", color) + .attr("transform", t1) + .attr("d", d1); + + path.exit().transition() + .duration(duration) + .attr("transform", t1) + .attr("d", d1) + .remove(); + + // Stash the new scales. + this.__chart__ = {x: x1, y: y1, t: t1, id: id}; + }); + d3.timer.flush(); + } + + horizon.duration = function(x) { + if (!arguments.length) return duration; + duration = +x; + return horizon; + }; + + horizon.bands = function(x) { + if (!arguments.length) return bands; + bands = +x; + color.domain([-bands, 0, bands]); + return horizon; + }; + + horizon.mode = function(x) { + if (!arguments.length) return mode; + mode = x + ""; + return horizon; + }; + + horizon.colors = function(x) { + if (!arguments.length) return color.range(); + color.range(x); + return horizon; + }; + + horizon.interpolate = function(x) { + if (!arguments.length) return interpolate; + interpolate = x + ""; + return horizon; + }; + + horizon.x = function(z) { + if (!arguments.length) return x; + x = z; + return horizon; + }; + + horizon.y = function(z) { + if (!arguments.length) return y; + y = z; + return horizon; + }; + + horizon.width = function(x) { + if (!arguments.length) return w; + w = +x; + return horizon; + }; + + horizon.height = function(x) { + if (!arguments.length) return h; + h = +x; + return horizon; + }; + + return horizon; + }; + + var d3_horizonArea = d3.svg.area(), + d3_horizonId = 0; + + function d3_horizonX(d) { + return d[0]; + } + + function d3_horizonY(d) { + return d[1]; + } + + function d3_horizonTransform(bands, h, mode) { + return mode == "offset" + ? function(d) { return "translate(0," + (d + (d < 0) - bands) * h + ")"; } + : function(d) { return (d < 0 ? "scale(1,-1)" : "") + "translate(0," + (d - bands) * h + ")"; }; + } +})(); -- cgit 1.2.3-korg