/**

* Copyright 2012-2015, Plotly, Inc.

* All rights reserved.

*

* This source code is licensed under the MIT license found in the

* LICENSE file in the root directory of this source tree.

*/

'use strict';

var Plotly = require('../plotly');

var Events = require('../lib/events');

var manageModeBar = require('../components/modebar/manage');

var d3 = require('d3');

var m4FromQuat = require('gl-mat4/fromQuat');

var isNumeric = require('fast-isnumeric');

var plots = Plotly.Plots;

/**

* Main plot-creation function

*

* Note: will call makePlotFramework if necessary to create the framework

*

* @param {string id or DOM element} gd

* the id or DOM element of the graph container div

* @param {array of objects} data

* array of traces, containing the data and display information for each trace

* @param {object} layout

* object describing the overall display of the plot,

* all the stuff that doesn't pertain to any individual trace

* @param {object} config

* configuration options (see ./plot_config.js for more info)

*

*/

Plotly.plot = function(gd, data, layout, config) {

Plotly.Lib.markTime('in plot');

gd = getGraphDiv(gd);

/*

* Events.init is idempotent and bails early if gd has already been init'd

*/

Events.init(gd);

var okToPlot = Events.triggerHandler(gd, 'plotly_beforeplot', [data, layout, config]);

if(okToPlot===false) return;

// if there's no data or layout, and this isn't yet a plotly plot

// container, log a warning to help plotly.js users debug

if(!data && !layout && !Plotly.Lib.isPlotDiv(gd)) {

console.log('Warning: calling Plotly.plot as if redrawing ' +

'but this container doesn\'t yet have a plot.', gd);

}

// transfer configuration options to gd until we move over to

// a more OO like model

setPlotContext(gd, config);

if(!layout) layout = {};

// hook class for plots main container (in case of plotly.js

// this won't be #embedded-graph or .js-tab-contents)

d3.select(gd).classed('js-plotly-plot', true);

// off-screen getBoundingClientRect testing space,

// in #js-plotly-tester (and stored as gd._tester)

// so we can share cached text across tabs

Plotly.Drawing.makeTester(gd);

// collect promises for any async actions during plotting

// any part of the plotting code can push to gd._promises, then

// before we move to the next step, we check that they're all

// complete, and empty out the promise list again.

gd._promises = [];

// if there is already data on the graph, append the new data

// if you only want to redraw, pass a non-array for data

var graphwasempty = ((gd.data||[]).length===0 && Array.isArray(data));

if(Array.isArray(data)) {

cleanData(data, gd.data);

if(graphwasempty) gd.data=data;

else gd.data.push.apply(gd.data,data);

// for routines outside graph_obj that want a clean tab

// (rather than appending to an existing one) gd.empty

// is used to determine whether to make a new tab

gd.empty=false;

}

if(!gd.layout || graphwasempty) gd.layout = cleanLayout(layout);

// if the user is trying to drag the axes, allow new data and layout

// to come in but don't allow a replot.

if(gd._dragging) {

// signal to drag handler that after everything else is done

// we need to replot, because something has changed

gd._replotPending = true;

return;

} else {

// we're going ahead with a replot now

gd._replotPending = false;

}

plots.supplyDefaults(gd);

// Polar plots

if(data && data[0] && data[0].r) return plotPolar(gd, data, layout);

// so we don't try to re-call Plotly.plot from inside

// legend and colorbar, if margins changed

gd._replotting = true;

var hasData = gd._fullData.length>0;

// Make or remake the framework (ie container and axes) if we need to

// note: if they container already exists and has data,

// the new layout gets ignored (as it should)

// but if there's no data there yet, it's just a placeholder...

// then it should destroy and remake the plot

if (hasData) {

var subplots = Plotly.Axes.getSubplots(gd).join(''),

oldSubplots = Object.keys(gd._fullLayout._plots || {}).join('');

if(gd.framework!==makePlotFramework || graphwasempty || (oldSubplots!==subplots)) {

gd.framework = makePlotFramework;

makePlotFramework(gd);

}

}

else if(graphwasempty) makePlotFramework(gd);

var fullLayout = gd._fullLayout;

// prepare the data and find the autorange

// generate calcdata, if we need to

// to force redoing calcdata, just delete it before calling Plotly.plot

var recalc = !gd.calcdata || gd.calcdata.length!==(gd.data||[]).length;

if(recalc) {

doCalcdata(gd);

if(gd._context.doubleClick!==false || gd._context.displayModeBar!==false) {

Plotly.Axes.saveRangeInitial(gd);

}

}

// in case it has changed, attach fullData traces to calcdata

for (var i = 0; i < gd.calcdata.length; i++) {

gd.calcdata[i][0].trace = gd._fullData[i];

}

/*

* start async-friendly code - now we're actually drawing things

*/

var oldmargins = JSON.stringify(fullLayout._size);

// draw anything that can affect margins.

// currently this is legend and colorbars

function marginPushers() {

var calcdata = gd.calcdata;

var i, cd, trace;

Plotly.Legend.draw(gd);

for (i = 0; i < calcdata.length; i++) {

cd = calcdata[i];

trace = cd[0].trace;

if (trace.visible !== true || !trace._module.colorbar) {

plots.autoMargin(gd, 'cb'+trace.uid);

}

else trace._module.colorbar(gd, cd);

}

plots.doAutoMargin(gd);

return plots.previousPromises(gd);

}

function marginPushersAgain() {

// in case the margins changed, draw margin pushers again

var seq = JSON.stringify(fullLayout._size)===oldmargins ?

[] : [marginPushers, layoutStyles];

return Plotly.Lib.syncOrAsync(seq.concat(Plotly.Fx.init),gd);

}

function positionAndAutorange() {

if(!recalc) return;

var subplots = plots.getSubplotIds(fullLayout, 'cartesian'),

modules = gd._modules;

// position and range calculations for traces that

// depend on each other ie bars (stacked or grouped)

// and boxes (grouped) push each other out of the way

var subplotInfo, _module;

for(var i = 0; i < subplots.length; i++) {

subplotInfo = fullLayout._plots[subplots[i]];

for(var j = 0; j < modules.length; j++) {

_module = modules[j];

if(_module.setPositions) _module.setPositions(gd, subplotInfo);

}

}

Plotly.Lib.markTime('done with bar/box adjustments');

// calc and autorange for errorbars

Plotly.ErrorBars.calc(gd);

Plotly.Lib.markTime('done Plotly.ErrorBars.calc');

// TODO: autosize extra for text markers

return Plotly.Lib.syncOrAsync([

Plotly.Shapes.calcAutorange,

Plotly.Annotations.calcAutorange,

doAutoRange

], gd);

}

function doAutoRange() {

var axList = Plotly.Axes.list(gd, '', true);

for(var i = 0; i < axList.length; i++) {

Plotly.Axes.doAutoRange(axList[i]);

}

}

function drawAxes() {

// draw ticks, titles, and calculate axis scaling (._b, ._m)

return Plotly.Axes.doTicks(gd, 'redraw');

}

function drawData() {

// Now plot the data

var calcdata = gd.calcdata,

subplots = plots.getSubplotIds(fullLayout, 'cartesian'),

modules = gd._modules;

var i, j, cd, trace, uid, subplot, subplotInfo,

cdSubplot, cdError, cdModule, module;

function getCdSubplot(calcdata, subplot) {

var cdSubplot = [];

var i, cd, trace;

for (i = 0; i < calcdata.length; i++) {

cd = calcdata[i];

trace = cd[0].trace;

if (trace.xaxis+trace.yaxis === subplot) cdSubplot.push(cd);

}

return cdSubplot;

}

function getCdModule(cdSubplot, module) {

var cdModule = [];

var i, cd, trace;

for (i = 0; i < cdSubplot.length; i++) {

cd = cdSubplot[i];

trace = cd[0].trace;

if (trace._module===module && trace.visible===true) cdModule.push(cd);

}

return cdModule;

}

// clean up old scenes that no longer have associated data

// will this be a performance hit?

// ... until subplot of different type play better together

if(gd._fullLayout._hasGL3D) plotGl3d(gd);

if(gd._fullLayout._hasGeo) plotGeo(gd);

if(gd._fullLayout._hasGL2D) plotGl2d(gd);

// in case of traces that were heatmaps or contour maps

// previously, remove them and their colorbars explicitly

for (i = 0; i < calcdata.length; i++) {

cd = calcdata[i];

trace = cd[0].trace;

if (trace.visible !== true || !trace._module.colorbar) {

uid = trace.uid;

fullLayout._paper.selectAll('.hm'+uid+',.contour'+uid+',.cb'+uid+',#clip'+uid)

.remove();

}

}

for (i = 0; i < subplots.length; i++) {

subplot = subplots[i];

subplotInfo = gd._fullLayout._plots[subplot];

cdSubplot = getCdSubplot(calcdata, subplot);

cdError = [];

// remove old traces, then redraw everything

// TODO: use enter/exit appropriately in the plot functions

// so we don't need this - should sometimes be a big speedup

if(subplotInfo.plot) subplotInfo.plot.selectAll('g.trace').remove();

for(j = 0; j < modules.length; j++) {

module = modules[j];

if(!module.plot) continue;

// plot all traces of this type on this subplot at once

cdModule = getCdModule(cdSubplot, module);

module.plot(gd, subplotInfo, cdModule);

Plotly.Lib.markTime('done ' + (cdModule[0] && cdModule[0][0].trace.type));

// collect the traces that may have error bars

if(cdModule[0] && cdModule[0][0].trace && plots.traceIs(cdModule[0][0].trace, 'errorBarsOK')) {

cdError = cdError.concat(cdModule);

}

}

// finally do all error bars at once

if(gd._fullLayout._hasCartesian) {

Plotly.ErrorBars.plot(gd, subplotInfo, cdError);

Plotly.Lib.markTime('done ErrorBars');

}

}

// now draw stuff not on subplots (ie, pies)

// TODO: gotta be a better way to handle this

var cdPie = getCdModule(calcdata, Plotly.Pie);

if(cdPie.length) Plotly.Pie.plot(gd, cdPie);

// styling separate from drawing

plots.style(gd);

Plotly.Lib.markTime('done plots.style');

// show annotations and shapes

Plotly.Shapes.drawAll(gd);

Plotly.Annotations.drawAll(gd);

// source links

plots.addLinks(gd);

return plots.previousPromises(gd);

}

function cleanUp() {

// now we're REALLY TRULY done plotting...

// so mark it as done and let other procedures call a replot

gd._replotting = false;

Plotly.Lib.markTime('done plot');

gd.emit('plotly_afterplot');

}

var donePlotting = Plotly.Lib.syncOrAsync([

plots.previousPromises,

marginPushers,

layoutStyles,

marginPushersAgain,

positionAndAutorange,

drawAxes,

drawData

], gd, cleanUp);

// even if everything we did was synchronous, return a promise

// so that the caller doesn't care which route we took

return (donePlotting && donePlotting.then) ?

donePlotting : Promise.resolve();

};

// Get the container div: we store all variables for this plot as

// properties of this div

// some callers send this in by DOM element, others by id (string)

function getGraphDiv(gd) {

var gdElement;

if(typeof gd === 'string') {

gdElement = document.getElementById(gd);

if(gdElement === null) {

throw new Error('No DOM element with id \'' + gd + '\' exists on the page.');

}

return gdElement;

}

else if(gd===null || gd===undefined) {

throw new Error('DOM element provided is null or undefined');

}

return gd; // otherwise assume that gd is a DOM element

}

function opaqueSetBackground(gd, bgColor) {

gd._fullLayout._paperdiv.style('background', 'white');

Plotly.defaultConfig.setBackground(gd, bgColor);

}

function setPlotContext(gd, config) {

if(!gd._context) gd._context = Plotly.Lib.extendFlat({}, Plotly.defaultConfig);

var context = gd._context;

if(config) {

Object.keys(config).forEach(function(key) {

if(key in context) {

if(key === 'setBackground' && config[key] === 'opaque') {

context[key] = opaqueSetBackground;

}

else context[key] = config[key];

}

});

// map plot3dPixelRatio to plotGlPixelRatio for backward compatibility

if(config.plot3dPixelRatio && !context.plotGlPixelRatio) {

context.plotGlPixelRatio = context.plot3dPixelRatio;

}

}

//staticPlot forces a bunch of others:

if(context.staticPlot) {

context.editable = false;

context.autosizable = false;

context.scrollZoom = false;

context.doubleClick = false;

context.showTips = false;

context.showLink = false;

context.displayModeBar = false;

}

}

function plotGl3d(gd) {

var fullLayout = gd._fullLayout,

fullData = gd._fullData,

sceneIds = plots.getSubplotIds(fullLayout, 'gl3d');

var i, sceneId, fullSceneData, scene, sceneOptions;

fullLayout._paperdiv.style({

width: fullLayout.width + 'px',

height: fullLayout.height + 'px'

});

gd._context.setBackground(gd, fullLayout.paper_bgcolor);

for (i = 0; i < sceneIds.length; i++) {

sceneId = sceneIds[i];

fullSceneData = plots.getSubplotData(fullData, 'gl3d', sceneId);

scene = fullLayout[sceneId]._scene; // ref. to corresp. Scene instance

// If Scene is not instantiated, create one!

if(scene === undefined) {

sceneOptions = {

container: gd.querySelector('.gl-container'),

id: sceneId,

staticPlot: gd._context.staticPlot,

plotGlPixelRatio: gd._context.plotGlPixelRatio

};

scene = new Plotly.Scene(sceneOptions, fullLayout);

fullLayout[sceneId]._scene = scene; // set ref to Scene instance

}

scene.plot(fullSceneData, fullLayout, gd.layout); // takes care of business

}

}

function plotGeo(gd) {

var fullLayout = gd._fullLayout,

fullData = gd._fullData,

geoIds = plots.getSubplotIds(fullLayout, 'geo');

var i, geoId, fullGeoData, geo;

// if 'plotly-geo-assets.js' is not included,

// initialize object to keep reference to every loaded topojson

if(window.PlotlyGeoAssets === undefined) {

window.PlotlyGeoAssets = { topojson : {} };

}

for (i = 0; i < geoIds.length; i++) {

geoId = geoIds[i];

fullGeoData = plots.getSubplotData(fullData, 'geo', geoId);

geo = fullLayout[geoId]._geo;

// If geo is not instantiated, create one!

if(geo === undefined) {

geo = new Plotly.Geo(

{

id: geoId,

container: fullLayout._geocontainer.node(),

topojsonURL: gd._context.topojsonURL

},

fullLayout

);

fullLayout[geoId]._geo = geo;

}

geo.plot(fullGeoData, fullLayout, gd._promises);

}

}

function plotGl2d(gd) {

var fullLayout = gd._fullLayout,

fullData = gd._fullData,

subplotIds = plots.getSubplotIds(fullLayout, 'gl2d');

for(var i = 0; i < subplotIds.length; i++) {

var subplotId = subplotIds[i],

subplotObj = fullLayout._plots[subplotId],

fullSubplotData = plots.getSubplotData(fullData, 'gl2d', subplotId);

var scene;

// ref. to corresp. Scene instance

scene = subplotObj._scene2d;

// If Scene is not instantiated, create one!

if(scene === undefined) {

scene = new Plotly.Scene2D({

container: gd.querySelector('.gl-container'),

id: subplotId,

staticPlot: gd._context.staticPlot,

plotGlPixelRatio: gd._context.plotGlPixelRatio

},

fullLayout

);

// set ref to Scene instance

subplotObj._scene2d = scene;

}

scene.plot(fullSubplotData, fullLayout, gd.layout);

}

}

function plotPolar(gd, data, layout) {

// build or reuse the container skeleton

var plotContainer = d3.select(gd).selectAll('.plot-container')

.data([0]);

plotContainer.enter()

.insert('div', ':first-child')

.classed('plot-container plotly', true);

var paperDiv = plotContainer.selectAll('.svg-container')

.data([0]);

paperDiv.enter().append('div')

.classed('svg-container',true)

.style('position','relative');

// empty it everytime for now

paperDiv.html('');

// fulfill gd requirements

if(data) gd.data = data;

if(layout) gd.layout = layout;

Plotly.micropolar.manager.fillLayout(gd);

if(gd._fullLayout.autosize === 'initial' && gd._context.autosizable) {

plotAutoSize(gd,{});

gd._fullLayout.autosize = layout.autosize = true;

}

// resize canvas

paperDiv.style({

width: gd._fullLayout.width + 'px',

height: gd._fullLayout.height + 'px'

});

// instantiate framework

gd.framework = Plotly.micropolar.manager.framework(gd);

// plot

gd.framework({data: gd.data, layout: gd.layout}, paperDiv.node());

// set undo point

gd.framework.setUndoPoint();

// get the resulting svg for extending it

var polarPlotSVG = gd.framework.svg();

// editable title

var opacity = 1;

var txt = gd._fullLayout.title;

if(txt === '' || !txt) opacity = 0;

var placeholderText = 'Click to enter title';

var titleLayout = function() {

this.call(Plotly.util.convertToTspans);

//TODO: html/mathjax

//TODO: center title

};

var title = polarPlotSVG.select('.title-group text')

.call(titleLayout);

if(gd._context.editable){

title.attr({'data-unformatted': txt});

if(!txt || txt === placeholderText){

opacity = 0.2;

title.attr({'data-unformatted': placeholderText})

.text(placeholderText)

.style({opacity: opacity})

.on('mouseover.opacity',function() {

d3.select(this).transition().duration(100)

.style('opacity',1);

})

.on('mouseout.opacity',function() {

d3.select(this).transition().duration(1000)

.style('opacity',0);

});

}

var setContenteditable = function() {

this.call(Plotly.util.makeEditable)

.on('edit', function(text){

gd.framework({layout: {title: text}});

this.attr({'data-unformatted': text})

.text(text)

.call(titleLayout);

this.call(setContenteditable);

})

.on('cancel', function() {

var txt = this.attr('data-unformatted');

this.text(txt).call(titleLayout);

});

};

title.call(setContenteditable);

}

gd._context.setBackground(gd, gd._fullLayout.paper_bgcolor);

plots.addLinks(gd);

return Promise.resolve();

}

function cleanLayout(layout) {

// make a few changes to the layout right away

// before it gets used for anything

// backward compatibility and cleanup of nonstandard options

var i, j;

if(!layout) layout = {};

// cannot have (x|y)axis1, numbering goes axis, axis2, axis3...

if(layout.xaxis1) {

if(!layout.xaxis) layout.xaxis = layout.xaxis1;

delete layout.xaxis1;

}

if(layout.yaxis1) {

if(!layout.yaxis) layout.yaxis = layout.yaxis1;

delete layout.yaxis1;

}

var axList = Plotly.Axes.list({_fullLayout: layout});

for(i = 0; i < axList.length; i++) {

var ax = axList[i];

if(ax.anchor && ax.anchor !== 'free') {

ax.anchor = Plotly.Axes.cleanId(ax.anchor);

}

if(ax.overlaying) ax.overlaying = Plotly.Axes.cleanId(ax.overlaying);

// old method of axis type - isdate and islog (before category existed)

if(!ax.type) {

if(ax.isdate) ax.type='date';

else if(ax.islog) ax.type='log';

else if(ax.isdate===false && ax.islog===false) ax.type='linear';

}

if(ax.autorange==='withzero' || ax.autorange==='tozero') {

ax.autorange = true;

ax.rangemode = 'tozero';

}

delete ax.islog;

delete ax.isdate;

delete ax.categories; // replaced by _categories

// prune empty domain arrays made before the new nestedProperty

if(emptyContainer(ax, 'domain')) delete ax.domain;

// autotick -> tickmode

if(ax.autotick !== undefined) {

if(ax.tickmode === undefined) {

ax.tickmode = ax.autotick ? 'auto' : 'linear';

}

delete ax.autotick;

}

}

if(layout.annotations !== undefined && !Array.isArray(layout.annotations)) {

console.log('annotations must be an array');

delete layout.annotations;

}

var annotationsLen = (layout.annotations || []).length;

for(i = 0; i < annotationsLen; i++) {

var ann = layout.annotations[i];

if(ann.ref) {

if(ann.ref==='paper') {

ann.xref = 'paper';

ann.yref = 'paper';

}

else if(ann.ref==='data') {

ann.xref = 'x';

ann.yref = 'y';

}

delete ann.ref;

}

cleanAxRef(ann, 'xref');

cleanAxRef(ann, 'yref');

}

if(layout.shapes !== undefined && !Array.isArray(layout.shapes)) {

console.log('shapes must be an array');

delete layout.shapes;

}

var shapesLen = (layout.shapes||[]).length;

for(i = 0; i < shapesLen; i++) {

var shape = layout.shapes[i];

cleanAxRef(shape, 'xref');

cleanAxRef(shape, 'yref');

}

var legend = layout.legend;

if(legend) {

// check for old-style legend positioning (x or y is +/- 100)

if(legend.x > 3) {

legend.x = 1.02;

legend.xanchor = 'left';

}

else if(legend.x < -2) {

legend.x = -0.02;

legend.xanchor = 'right';

}

if(legend.y > 3) {

legend.y = 1.02;

legend.yanchor = 'bottom';

}

else if(legend.y < -2) {

legend.y = -0.02;

legend.yanchor = 'top';

}

}

/*

* Moved from rotate -> orbit for dragmode

*/

if (layout.dragmode === 'rotate') layout.dragmode = 'orbit';

// cannot have scene1, numbering goes scene, scene2, scene3...

if(layout.scene1) {

if(!layout.scene) layout.scene = layout.scene1;

delete layout.scene1;

}

/*

* Clean up Scene layouts

*/

var sceneIds = plots.getSubplotIds(layout, 'gl3d');

var scene, cameraposition, rotation,

radius, center, mat, eye;

for (i = 0; i < sceneIds.length; i++) {

scene = layout[sceneIds[i]];

/*

* Clean old Camera coords

*/

cameraposition = scene.cameraposition;

if (Array.isArray(cameraposition) && cameraposition[0].length === 4) {

rotation = cameraposition[0];

center = cameraposition[1];

radius = cameraposition[2];

mat = m4FromQuat([], rotation);

eye = [];

for (j = 0; j < 3; ++j) {

eye[j] = center[i] + radius * mat[2 + 4 * j];

}

scene.camera = {

eye: {x: eye[0], y: eye[1], z: eye[2]},

center: {x: center[0], y: center[1], z: center[2]},

up: {x: mat[1], y: mat[5], z: mat[9]}

};

delete scene.cameraposition;

}

}

// sanitize rgb(fractions) and rgba(fractions) that old tinycolor

// supported, but new tinycolor does not because they're not valid css

Plotly.Lib.markTime('finished rest of cleanLayout, starting color');

Plotly.Color.clean(layout);

Plotly.Lib.markTime('finished cleanLayout color.clean');

return layout;

}

function cleanAxRef(container, attr) {

var valIn = container[attr],

axLetter = attr.charAt(0);

if(valIn && valIn !== 'paper') {

container[attr] = Plotly.Axes.cleanId(valIn, axLetter);

}

}

function cleanData(data, existingData) {

// make a few changes to the data right away

// before it gets used for anything

/*

* Enforce unique IDs

*/

var suids = [], // seen uids --- so we can weed out incoming repeats

uids = data.concat(Array.isArray(existingData) ? existingData : [])

.filter( function(trace) { return 'uid' in trace; } )

.map( function(trace) { return trace.uid; });

for(var tracei = 0; tracei < data.length; tracei++) {

var trace = data[tracei];

// assign uids to each trace and detect collisions.

if (!('uid' in trace) || suids.indexOf(trace.uid) !== -1) {

var newUid, i;

for(i=0; i<100; i++) {

newUid = Plotly.Lib.randstr(uids);

if(suids.indexOf(newUid)===-1) break;

}

trace.uid = Plotly.Lib.randstr(uids);

uids.push(trace.uid);

}

// keep track of already seen uids, so that if there are

// doubles we force the trace with a repeat uid to

// acquire a new one

suids.push(trace.uid);

// BACKWARD COMPATIBILITY FIXES

// use xbins to bin data in x, and ybins to bin data in y

if(trace.type==='histogramy' && 'xbins' in trace && !('ybins' in trace)) {

trace.ybins = trace.xbins;

delete trace.xbins;

}

// error_y.opacity is obsolete - merge into color

if(trace.error_y && 'opacity' in trace.error_y) {

var dc = Plotly.Color.defaults,

yeColor = trace.error_y.color ||

(plots.traceIs(trace, 'bar') ? Plotly.Color.defaultLine : dc[tracei % dc.length]);

trace.error_y.color = Plotly.Color.addOpacity(

Plotly.Color.rgb(yeColor),

Plotly.Color.opacity(yeColor) * trace.error_y.opacity);

delete trace.error_y.opacity;

}

// convert bardir to orientation, and put the data into

// the axes it's eventually going to be used with

if('bardir' in trace) {

if(trace.bardir==='h' && (plots.traceIs(trace, 'bar') ||

trace.type.substr(0,9)==='histogram')) {

trace.orientation = 'h';

swapXYData(trace);

}

delete trace.bardir;

}

// now we have only one 1D histogram type, and whether

// it uses x or y data depends on trace.orientation

if(trace.type==='histogramy') swapXYData(trace);

if(trace.type==='histogramx' || trace.type==='histogramy') {

trace.type = 'histogram';

}

// scl->scale, reversescl->reversescale

if('scl' in trace) {

trace.colorscale = trace.scl;

delete trace.scl;

}

if('reversescl' in trace) {

trace.reversescale = trace.reversescl;

delete trace.reversescl;

}

// axis ids x1 -> x, y1-> y

if(trace.xaxis) trace.xaxis = Plotly.Axes.cleanId(trace.xaxis, 'x');

if(trace.yaxis) trace.yaxis = Plotly.Axes.cleanId(trace.yaxis, 'y');

// scene ids scene1 -> scene

if (trace.scene) {

trace.scene = Plotly.Gl3dLayout.cleanId(trace.scene);

}

if(!plots.traceIs(trace, 'pie')) {

if(Array.isArray(trace.textposition)) {

trace.textposition = trace.textposition.map(cleanTextPosition);

}

else if(trace.textposition) {

trace.textposition = cleanTextPosition(trace.textposition);

}

}

// prune empty containers made before the new nestedProperty

if(emptyContainer(trace, 'line')) delete trace.line;

if('marker' in trace) {

if(emptyContainer(trace.marker, 'line')) delete trace.marker.line;

if(emptyContainer(trace, 'marker')) delete trace.marker;

}

// sanitize rgb(fractions) and rgba(fractions) that old tinycolor

// supported, but new tinycolor does not because they're not valid css

Plotly.Lib.markTime('finished rest of cleanData, starting color');

Plotly.Color.clean(trace);

Plotly.Lib.markTime('finished cleanData color.clean');

}

}

// textposition - support partial attributes (ie just 'top')

// and incorrect use of middle / center etc.

function cleanTextPosition(textposition) {

var posY = 'middle',

posX = 'center';

if(textposition.indexOf('top')!==-1) posY = 'top';

else if(textposition.indexOf('bottom')!==-1) posY = 'bottom';

if(textposition.indexOf('left')!==-1) posX = 'left';

else if(textposition.indexOf('right')!==-1) posX = 'right';

return posY + ' ' + posX;

}

function emptyContainer(outer, innerStr) {

return (innerStr in outer) &&

(typeof outer[innerStr] === 'object') &&

(Object.keys(outer[innerStr]).length === 0);

}

// convenience function to force a full redraw, mostly for use by plotly.js

Plotly.redraw = function(gd) {

gd = getGraphDiv(gd);

if(!Plotly.Lib.isPlotDiv(gd)) {

console.log('This element is not a Plotly Plot', gd);

return;

}

gd.calcdata = undefined;

return Plotly.plot(gd).then(function () {

gd.emit('plotly_redraw');

});

};

/**

* Convenience function to make idempotent plot option obvious to users.

*

* @param gd

* @param {Object[]} data

* @param {Object} layout

* @param {Object} config

*/

Plotly.newPlot = function (gd, data, layout, config) {

gd = getGraphDiv(gd);

plots.purge(gd);

return Plotly.plot(gd, data, layout, config);

};

function doCalcdata(gd) {

var axList = Plotly.Axes.list(gd),

fullData = gd._fullData,

fullLayout = gd._fullLayout;

var i, trace, module, cd;

var calcdata = gd.calcdata = new Array(fullData.length);

// extra helper variables

// firstscatter: fill-to-next on the first trace goes to zero

gd.firstscatter = true;

// how many box plots do we have (in case they're grouped)

gd.numboxes = 0;

// for calculating avg luminosity of heatmaps

gd._hmpixcount = 0;

gd._hmlumcount = 0;

// for sharing colors across pies (and for legend)

fullLayout._piecolormap = {};

fullLayout._piedefaultcolorcount = 0;

// delete category list, if there is one, so we start over

// to be filled in later by ax.d2c

for (i = 0; i < axList.length; i++) {

axList[i]._categories = [];

}

for (i = 0; i < fullData.length; i++) {

trace = fullData[i];

module = trace._module;

cd = [];

if (module && trace.visible === true) {

if (module.calc) cd = module.calc(gd, trace);

}

// make sure there is a first point

// this ensures there is a calcdata item for every trace,

// even if cartesian logic doesn't handle it

if (!Array.isArray(cd) || !cd[0]) cd = [{x: false, y: false}];

// add the trace-wide properties to the first point,

// per point properties to every point

// t is the holder for trace-wide properties

if (!cd[0].t) cd[0].t = {};

cd[0].trace = trace;

Plotly.Lib.markTime('done with calcdata for '+i);

calcdata[i] = cd;

}

}