From 70856b216ee41c6cf7d6f9e30359c2dfd25f2d77 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89tienne=20T=C3=A9treault-Pinard?= Date: Fri, 10 Jun 2016 15:29:09 -0400 Subject: [PATCH 01/24] introducing the 'mapbox' base plot module --- package.json | 1 + src/plot_api/plot_config.js | 3 + src/plots/mapbox/constants.js | 26 ++ src/plots/mapbox/index.js | 133 +++++++++ src/plots/mapbox/layers.js | 173 ++++++++++++ src/plots/mapbox/layout_attributes.js | 169 ++++++++++++ src/plots/mapbox/layout_defaults.js | 78 ++++++ src/plots/mapbox/mapbox.js | 377 ++++++++++++++++++++++++++ 8 files changed, 960 insertions(+) create mode 100644 src/plots/mapbox/constants.js create mode 100644 src/plots/mapbox/index.js create mode 100644 src/plots/mapbox/layers.js create mode 100644 src/plots/mapbox/layout_attributes.js create mode 100644 src/plots/mapbox/layout_defaults.js create mode 100644 src/plots/mapbox/mapbox.js diff --git a/package.json b/package.json index 3f4d2fae81b..f90e2a675ac 100644 --- a/package.json +++ b/package.json @@ -70,6 +70,7 @@ "gl-select-box": "^1.0.1", "gl-spikes2d": "^1.0.1", "gl-surface3d": "^1.2.3", + "mapbox-gl": "^0.18.0", "mouse-change": "^1.1.1", "mouse-wheel": "^1.0.2", "ndarray": "^1.0.16", diff --git a/src/plot_api/plot_config.js b/src/plot_api/plot_config.js index ee3b93ea6ce..d5709b395b9 100644 --- a/src/plot_api/plot_config.js +++ b/src/plot_api/plot_config.js @@ -87,6 +87,9 @@ module.exports = { // URL to topojson files used in geo charts topojsonURL: 'https://cdn.plot.ly/', + // Mapbox access token (required to plot mapbox trace types) + mapboxAccessToken: null, + // Turn all console logging on or off (errors will be thrown) // This should ONLY be set via Plotly.setPlotConfig logging: false diff --git a/src/plots/mapbox/constants.js b/src/plots/mapbox/constants.js new file mode 100644 index 00000000000..f5b9ae82709 --- /dev/null +++ b/src/plots/mapbox/constants.js @@ -0,0 +1,26 @@ +/** +* Copyright 2012-2016, 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'; + + +module.exports = { + styleUrlPrefix: 'mapbox://styles/mapbox/', + styleUrlSuffix: 'v9', + + noAccessTokenErrorMsg: [ + 'Missing Mapbox access token.', + 'Mapbox trace type require a Mapbox access token to be registered.', + 'For example:', + ' Plotly.plot(gd, data, layout, { mapboxAccessToken: \'my-access-token\' });', + 'More info here: https://www.mapbox.com/help/define-access-token/' + ].join('\n'), + + mapOnErrorMsg: 'Mapbox error.' +}; diff --git a/src/plots/mapbox/index.js b/src/plots/mapbox/index.js new file mode 100644 index 00000000000..5faf2f5c3d5 --- /dev/null +++ b/src/plots/mapbox/index.js @@ -0,0 +1,133 @@ +/** +* Copyright 2012-2016, 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 mapboxgl = require('mapbox-gl'); + +var Plots = require('../plots'); +var xmlnsNamespaces = require('../../constants/xmlns_namespaces'); + +var createMapbox = require('./mapbox'); +var constants = require('./constants'); + + +exports.name = 'mapbox'; + +exports.attr = 'subplot'; + +exports.idRoot = 'mapbox'; + +exports.idRegex = /^mapbox([2-9]|[1-9][0-9]+)?$/; + +exports.attrRegex = /^mapbox([2-9]|[1-9][0-9]+)?$/; + +exports.attributes = { + subplot: { + valType: 'subplotid', + role: 'info', + dflt: 'mapbox', + description: [ + 'Sets a reference between this trace\'s data coordinates and', + 'a mapbox subplot.', + 'If *mapbox* (the default value), the data refer to `layout.mapbox`.', + 'If *mapbox2*, the data refer to `layout.mapbox2`, and so on.' + ].join(' ') + } +}; + +exports.layoutAttributes = require('./layout_attributes'); + +exports.supplyLayoutDefaults = require('./layout_defaults'); + +exports.plot = function plotMapbox(gd) { + + if(!gd._context.mapboxAccessToken) { + throw new Error(constants.noAccessTokenErrorMsg); + } + else { + mapboxgl.accessToken = gd._context.mapboxAccessToken; + } + + var fullLayout = gd._fullLayout, + calcData = gd.calcdata, + mapboxIds = Plots.getSubplotIds(fullLayout, 'mapbox'); + + for(var i = 0; i < mapboxIds.length; i++) { + var id = mapboxIds[i], + subplotCalcData = getSubplotCalcData(calcData, id), + mapbox = fullLayout[id]._subplot; + + if(!mapbox) { + mapbox = createMapbox({ + gd: gd, + container: fullLayout._glcontainer.node(), + id: id, + fullLayout: fullLayout, + staticPlot: gd._context.staticPlot + }); + + fullLayout[id]._subplot = mapbox; + } + + mapbox.plot(subplotCalcData, fullLayout, gd._promises); + } +}; + +exports.clean = function(newFullData, newFullLayout, oldFullData, oldFullLayout) { + var oldMapboxKeys = Plots.getSubplotIds(oldFullLayout, 'mapbox'); + + for(var i = 0; i < oldMapboxKeys.length; i++) { + var oldMapboxKey = oldMapboxKeys[i]; + + if(!newFullLayout[oldMapboxKey] && !!oldFullLayout[oldMapboxKey]._subplot) { + oldFullLayout[oldMapboxKey]._subplot.destroy(); + } + } +}; + +exports.toSVG = function(gd) { + var fullLayout = gd._fullLayout, + subplotIds = Plots.getSubplotIds(fullLayout, 'mapbox'), + size = fullLayout._size; + + for(var i = 0; i < subplotIds.length; i++) { + var opts = fullLayout[subplotIds[i]], + domain = opts.domain, + mapbox = opts._subplot; + + var imageData = mapbox.toImage('png'); + var image = fullLayout._glimages.append('svg:image'); + + image.attr({ + xmlns: xmlnsNamespaces.svg, + 'xlink:href': imageData, + x: size.l + size.w * domain.x[0], + y: size.t + size.h * (1 - domain.y[1]), + width: size.w * (domain.x[1] - domain.x[0]), + height: size.h * (domain.y[1] - domain.y[0]), + preserveAspectRatio: 'none' + }); + + mapbox.destroy(); + } +}; + +function getSubplotCalcData(calcData, id) { + var subplotCalcData = []; + + for(var i = 0; i < calcData.length; i++) { + var calcTrace = calcData[i], + trace = calcTrace[0].trace; + + if(trace.subplot === id) subplotCalcData.push(calcTrace); + } + + return subplotCalcData; +} diff --git a/src/plots/mapbox/layers.js b/src/plots/mapbox/layers.js new file mode 100644 index 00000000000..6e326ac6473 --- /dev/null +++ b/src/plots/mapbox/layers.js @@ -0,0 +1,173 @@ +/** +* Copyright 2012-2016, 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 Lib = require('../../lib'); + + +function MapboxLayer(mapbox, index, opts) { + this.mapbox = mapbox; + this.map = mapbox.map; + + this.uid = mapbox.uid + '-' + 'layer' + index; + + this.idSource = this.uid + '-source'; + this.idLayer = this.uid + '-layer'; + + // some state variable to check if a remove/add step is needed + this.sourceType = null; + this.source = null; + this.layerType = null; + this.below = null; + + // IMPORTANT: must create source before layer to not cause errors + this.updateSource(opts); + this.updateLayer(opts); +} + +var proto = MapboxLayer.prototype; + +proto.update = function update(opts) { + if(this.needsNewSource(opts)) { + + // IMPORTANT: must delete layer before source to not cause errors + this.updateLayer(opts); + this.updateSource(opts); + } + else if(this.needsNewLayer(opts)) { + this.updateLayer(opts); + } + + var paintOpts = convertPaintOpts(opts); + + if(isVisible(opts)) { + this.mapbox.setOptions(this.idLayer, 'setPaintProperty', paintOpts); + } +}; + +proto.needsNewSource = function(opts) { + return ( + this.sourceType !== opts.sourcetype || + this.source !== opts.source + ); +}; + +proto.needsNewLayer = function(opts) { + return ( + this.layerType !== opts.type || + this.below !== opts.below + ); +}; + +proto.updateSource = function(opts) { + var map = this.map; + + if(map.getSource(this.idSource)) map.removeSource(this.idSource); + + this.sourceType = opts.sourcetype; + this.source = opts.source; + + if(!isVisible(opts)) return; + + var sourceOpts = convertSourceOpts(opts); + + map.addSource(this.idSource, sourceOpts); +}; + +proto.updateLayer = function(opts) { + var map = this.map; + + if(map.getLayer(this.idLayer)) map.removeLayer(this.idLayer); + + this.layerType = opts.type; + + if(!isVisible(opts)) return; + + map.addLayer({ + id: this.idLayer, + source: this.idSource, + 'source-layer': opts.sourcelayer || '', + type: opts.type + }, opts.below); + + // the only way to make a layer invisible is to remove it + var layoutOpts = { visibility: 'visible' }; + this.mapbox.setOptions(this.idLayer, 'setLayoutProperty', layoutOpts); +}; + +proto.dispose = function dispose() { + var map = this.map; + + map.removeLayer(this.idLayer); + map.removeSource(this.idSource); +}; + +function isVisible(opts) { + var source = opts.source; + + // For some weird reason Lib.isPlainObject fails + // to detect `source` as a plain object in nw.js 0.12. + + return ( + typeof source === 'object' || + (typeof source === 'string' && source.length > 0) + ); +} + +function convertPaintOpts(opts) { + var paintOpts = {}; + + switch(opts.type) { + + case 'line': + Lib.extendFlat(paintOpts, { + 'line-width': opts.line.width, + 'line-color': opts.line.color, + 'line-opacity': opts.opacity + }); + break; + + case 'fill': + Lib.extendFlat(paintOpts, { + 'fill-color': opts.fillcolor, + 'fill-outline-color': opts.line.color, + 'fill-opacity': opts.opacity + + // no way to pass line.width at the moment + }); + break; + } + + return paintOpts; +} + +function convertSourceOpts(opts) { + var sourceType = opts.sourcetype, + source = opts.source, + sourceOpts = { type: sourceType }, + isSourceAString = (typeof source === 'string'), + field; + + if(sourceType === 'geojson') field = 'data'; + else if(sourceType === 'vector') { + field = isSourceAString ? 'url' : 'tiles'; + } + + sourceOpts[field] = source; + + return sourceOpts; +} + +module.exports = function createMapboxLayer(mapbox, index, opts) { + var mapboxLayer = new MapboxLayer(mapbox, index, opts); + mapboxLayer.update(opts); + + return mapboxLayer; +}; diff --git a/src/plots/mapbox/layout_attributes.js b/src/plots/mapbox/layout_attributes.js new file mode 100644 index 00000000000..f02f616e3f8 --- /dev/null +++ b/src/plots/mapbox/layout_attributes.js @@ -0,0 +1,169 @@ +/** +* Copyright 2012-2016, 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 scatterMapboxAttrs = require('../../traces/scattermapbox/attributes'); +var defaultLine = require('../../components/color').defaultLine; +var extendFlat = require('../../lib').extendFlat; + +var lineAttrs = scatterMapboxAttrs.line; + + +module.exports = { + domain: { + x: { + valType: 'info_array', + role: 'info', + items: [ + {valType: 'number', min: 0, max: 1}, + {valType: 'number', min: 0, max: 1} + ], + dflt: [0, 1], + description: [ + 'Sets the horizontal domain of this subplot', + '(in plot fraction).' + ].join(' ') + }, + y: { + valType: 'info_array', + role: 'info', + items: [ + {valType: 'number', min: 0, max: 1}, + {valType: 'number', min: 0, max: 1} + ], + dflt: [0, 1], + description: [ + 'Sets the vertical domain of this subplot', + '(in plot fraction).' + ].join(' ') + } + }, + + style: { + valType: 'string', + values: ['basic', 'streets', 'outdoors', 'light', 'dark', 'satellite', 'satellite-streets'], + dflt: 'basic', + role: 'style', + description: [ + 'Sets the Mapbox map style.', + 'Either input the defaults Mapbox names or the URL to a custom style.' + ].join(' ') + }, + center: { + lon: { + valType: 'number', + dflt: 0, + role: 'info', + description: 'Sets the longitude of the center of the map (in degrees East).' + }, + lat: { + valType: 'number', + dflt: 0, + role: 'info', + description: 'Sets the latitude of the center of the map (in degrees North).' + } + }, + zoom: { + valType: 'number', + dflt: 1, + role: 'info', + description: 'Sets the zoom level of the map.' + }, + bearing: { + valType: 'number', + dflt: 0, + role: 'info', + description: 'Sets the bearing angle of the map (in degrees).' + }, + pitch: { + valType: 'number', + dflt: 0, + role: 'info', + description: 'Sets the pitch angle of the map (in degrees).' + }, + + layers: { + _isLinkedToArray: true, + + sourcetype: { + valType: 'enumerated', + values: ['geojson', 'vector'], + dflt: 'geojson', + role: 'info', + description: [ + 'Sets the source type for this layer.', + 'Support for *raster*, *image* and *video* source types is coming soon.' + ].join(' ') + }, + + source: { + valType: 'any', + role: 'info', + description: [ + 'Sets the source data for this layer.', + 'Source can be either a URL,', + 'a geojson object (with `sourcetype` set to *geojson*)', + 'or an array of tile URLS (with `sourcetype` set to *vector*).' + ].join(' ') + }, + + sourcelayer: { + valType: 'string', + dflt: '', + role: 'info', + description: [ + 'Specifies the layer to use from a vector tile source.', + 'Required for *vector* source type that supports multiple layers.' + ].join(' ') + }, + + type: { + valType: 'enumerated', + values: ['line', 'fill'], + dflt: 'line', + role: 'info', + description: [ + 'Sets the layer type.', + 'Support for *raster*, *background* types is coming soon.' + ].join(' ') + }, + + below: { + valType: 'string', + dflt: '', + role: 'info', + description: [ + 'Determines if the layer will be inserted', + 'before the layer with the specified ID.', + 'If omitted or set to \'\',', + 'the layer will be inserted above every existing layer.' + ].join(' ') + }, + + line: { + color: extendFlat({}, lineAttrs.color, { + dflt: defaultLine + }), + width: lineAttrs.width + }, + + fillcolor: scatterMapboxAttrs.fillcolor, + + opacity: { + valType: 'number', + min: 0, + max: 1, + dflt: 1, + role: 'info', + description: 'Sets the opacity of the layer.' + } + } + +}; diff --git a/src/plots/mapbox/layout_defaults.js b/src/plots/mapbox/layout_defaults.js new file mode 100644 index 00000000000..0a20ce81f45 --- /dev/null +++ b/src/plots/mapbox/layout_defaults.js @@ -0,0 +1,78 @@ +/** +* Copyright 2012-2016, 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 Lib = require('../../lib'); + +var handleSubplotDefaults = require('../subplot_defaults'); +var layoutAttributes = require('./layout_attributes'); + + +module.exports = function supplyLayoutDefaults(layoutIn, layoutOut, fullData) { + handleSubplotDefaults(layoutIn, layoutOut, fullData, { + type: 'mapbox', + attributes: layoutAttributes, + handleDefaults: handleDefaults, + partition: 'y' + }); +}; + +function handleDefaults(containerIn, containerOut, coerce) { + coerce('style'); + coerce('center.lon'); + coerce('center.lat'); + coerce('zoom'); + coerce('bearing'); + coerce('pitch'); + + handleLayerDefaults(containerIn, containerOut); + + // copy ref to input container to update 'center' and 'zoom' on map move + containerOut._input = containerIn; +} + +function handleLayerDefaults(containerIn, containerOut) { + var layersIn = containerIn.layers || [], + layersOut = containerOut.layers = []; + + var layerIn, layerOut; + + function coerce(attr, dflt) { + return Lib.coerce(layerIn, layerOut, layoutAttributes.layers, attr, dflt); + } + + for(var i = 0; i < layersIn.length; i++) { + layerIn = layersIn[i]; + layerOut = {}; + + var sourceType = coerce('sourcetype'); + coerce('source'); + + if(sourceType === 'vector') coerce('sourcelayer'); + + // maybe add smart default based off 'fillcolor' ??? + var type = coerce('type'); + + var lineColor; + if(type === 'line' || type === 'fill') { + lineColor = coerce('line.color'); + } + + // no way to pass line.width to fill layers + if(type === 'line') coerce('line.width'); + + if(type === 'fill') coerce('fillcolor', lineColor); + + coerce('below'); + coerce('opacity'); + + layersOut.push(layerOut); + } +} diff --git a/src/plots/mapbox/mapbox.js b/src/plots/mapbox/mapbox.js new file mode 100644 index 00000000000..e1db9da2fc0 --- /dev/null +++ b/src/plots/mapbox/mapbox.js @@ -0,0 +1,377 @@ +/** +* Copyright 2012-2016, 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 mapboxgl = require('mapbox-gl'); + +var Fx = require('../cartesian/graph_interact'); +var constants = require('./constants'); +var layoutAttributes = require('./layout_attributes'); +var createMapboxLayer = require('./layers'); + + +function Mapbox(opts) { + this.id = opts.id; + this.gd = opts.gd; + this.container = opts.container; + this.isStatic = opts.staticPlot; + + var fullLayout = opts.fullLayout; + + // unique id for this Mapbox instance + this.uid = fullLayout._uid + '-' + this.id; + + // full mapbox options (N.B. needs to be updated on every updates) + this.opts = fullLayout[this.id]; + + // create framework on instantiation for a smoother first plot call + this.div = null; + this.xaxis = null; + this.yaxis = null; + this.createFramework(fullLayout); + + // state variables used to infer how and what to update + this.map = null; + this.styleUrl = null; + this.traceHash = {}; + this.layerList = []; +} + +var proto = Mapbox.prototype; + +module.exports = function createMapbox(opts) { + var mapbox = new Mapbox(opts); + + return mapbox; +}; + +proto.plot = function(calcData, fullLayout, promises) { + var self = this; + + // feed in new mapbox options + self.opts = fullLayout[this.id]; + + var promise; + + if(!self.map) { + promise = new Promise(function(resolve, reject) { + self.createMap(calcData, fullLayout, resolve, reject); + }); + } + else { + promise = new Promise(function(resolve, reject) { + self.updateMap(calcData, fullLayout, resolve, reject); + }); + } + + promises.push(promise); +}; + +proto.createMap = function(calcData, fullLayout, resolve, reject) { + var self = this, + gd = self.gd, + opts = self.opts; + + // mapbox doesn't have a way to get the current style URL; do it ourselves + var styleUrl = self.styleUrl = convertStyleUrl(opts.style); + + var map = self.map = new mapboxgl.Map({ + container: self.div, + + style: styleUrl, + center: convertCenter(opts.center), + zoom: opts.zoom, + bearing: opts.bearing, + pitch: opts.pitch, + + interactive: !self.isStatic, + preserveDrawingBuffer: self.isStatic + }); + + self.rejectOnError(reject); + + map.once('load', function() { + self.updateData(calcData); + self.updateLayout(fullLayout); + + self.resolveOnRender(resolve); + }); + + // keep track of pan / zoom in user layout + map.on('move', function() { + var center = map.getCenter(); + opts._input.center = opts.center = { lon: center.lng, lat: center.lat }; + opts._input.zoom = opts.zoom = map.getZoom(); + }); + + map.on('mousemove', function(evt) { + var bb = self.div.getBoundingClientRect(); + + // some hackery to get Fx.hover to work + + evt.clientX = evt.point.x + bb.left; + evt.clientY = evt.point.y + bb.top; + + evt.target.getBoundingClientRect = function() { return bb; }; + + self.xaxis.p2c = function() { return evt.lngLat.lng; }; + self.yaxis.p2c = function() { return evt.lngLat.lat; }; + + Fx.hover(gd, evt, self.id); + }); + + map.on('click', function() { + Fx.click(gd, { target: true }); + }); + + function unhover() { + Fx.loneUnhover(fullLayout._toppaper); + } + + map.on('dragstart', unhover); + map.on('zoomstart', unhover); + +}; + +proto.updateMap = function(calcData, fullLayout, resolve, reject) { + var self = this, + map = self.map; + + self.rejectOnError(reject); + + var styleUrl = convertStyleUrl(self.opts.style); + + if(self.styleUrl !== styleUrl) { + self.styleUrl = styleUrl; + map.setStyle(styleUrl); + + map.style.once('load', function() { + + // need to rebuild trace layers on reload + // to avoid 'lost event' errors + self.traceHash = {}; + + self.updateData(calcData); + self.updateLayout(fullLayout); + + self.resolveOnRender(resolve); + }); + } + else { + self.updateData(calcData); + self.updateLayout(fullLayout); + + self.resolveOnRender(resolve); + } +}; + +proto.updateData = function(calcData) { + var traceHash = this.traceHash; + + var traceObj, trace, i, j; + + // update or create trace objects + for(i = 0; i < calcData.length; i++) { + var calcTrace = calcData[i]; + + trace = calcTrace[0].trace; + traceObj = traceHash[trace.uid]; + + if(traceObj) traceObj.update(calcTrace); + else { + traceHash[trace.uid] = trace._module.plot(this, calcTrace); + } + } + + // remove empty trace objects + var ids = Object.keys(traceHash); + id_loop: + for(i = 0; i < ids.length; i++) { + var id = ids[i]; + + for(j = 0; j < calcData.length; j++) { + trace = calcData[j][0].trace; + + if(id === trace.uid) continue id_loop; + } + + traceObj = traceHash[id]; + traceObj.dispose(); + delete traceHash[id]; + } +}; + +proto.updateLayout = function(fullLayout) { + var map = this.map, + opts = this.opts; + + map.setCenter(convertCenter(opts.center)); + map.setZoom(opts.zoom); + map.setBearing(opts.bearing); + map.setPitch(opts.pitch); + + this.updateLayers(); + this.updateFramework(fullLayout); + this.map.resize(); +}; + +proto.resolveOnRender = function(resolve) { + var map = this.map; + + map.on('render', function onRender() { + if(map.loaded()) { + map.off('render', onRender); + resolve(); + } + }); +}; + +proto.rejectOnError = function(reject) { + var map = this.map; + + function handler() { + reject(new Error(constants.mapOnErrorMsg)); + } + + map.once('error', handler); + map.once('style.error', handler); + map.once('source.error', handler); + map.once('tile.error', handler); + map.once('layer.error', handler); +}; + +proto.createFramework = function(fullLayout) { + var self = this; + + var div = self.div = document.createElement('div'); + + div.id = self.uid; + div.style.position = 'absolute'; + + self.container.appendChild(div); + + // create mock x/y axes for hover routine + + self.xaxis = { + _id: 'x', + c2p: function(v) { return self.project(v).x; } + }; + + self.yaxis = { + _id: 'y', + c2p: function(v) { return self.project(v).y; } + }; + + self.updateFramework(fullLayout); +}; + +proto.updateFramework = function(fullLayout) { + var domain = fullLayout[this.id].domain, + size = fullLayout._size; + + var style = this.div.style; + + // TODO Is this correct? It seems to get the map zoom level wrong? + + style.width = size.w * (domain.x[1] - domain.x[0]) + 'px'; + style.height = size.h * (domain.y[1] - domain.y[0]) + 'px'; + style.left = size.l + domain.x[0] * size.w + 'px'; + style.top = size.t + (1 - domain.y[1]) * size.h + 'px'; + + this.xaxis._offset = size.l + domain.x[0] * size.w; + this.xaxis._length = size.w * (domain.x[1] - domain.x[0]); + + this.yaxis._offset = size.t + (1 - domain.y[1]) * size.h; + this.yaxis._length = size.h * (domain.y[1] - domain.y[0]); +}; + +proto.updateLayers = function() { + var opts = this.opts, + layers = opts.layers, + layerList = this.layerList, + i; + + // if the layer arrays don't match, + // don't try to be smart, + // delete them all, and start all over. + + if(layers.length !== layerList.length) { + for(i = layerList.length - 1; i > -1; i--) { + layerList[i].dispose(); + layerList.pop(); + } + + for(i = 0; i < layers.length; i++) { + layerList.push(createMapboxLayer(this, i, layers[i])); + } + } + else { + for(i = 0; i < layers.length; i++) { + layerList[i].update(layers[i]); + } + } +}; + +proto.destroy = function() { + this.map.remove(); + this.container.removeChild(this.div); +}; + +proto.toImage = function() { + return this.map.getCanvas().toDataURL(); +}; + +// convenience wrapper to create blank GeoJSON sources +// and avoid 'invalid GeoJSON' errors +proto.createGeoJSONSource = function() { + var blank = { + type: 'Feature', + geometry: { + type: 'Point', + coordinates: [] + } + }; + + return new mapboxgl.GeoJSONSource({data: blank}); +}; + +// convenience wrapper to create set multiple layer +// 'layout' or 'paint options at once. +proto.setOptions = function(id, methodName, opts) { + var map = this.map, + keys = Object.keys(opts); + + for(var i = 0; i < keys.length; i++) { + var key = keys[i]; + + map[methodName](id, key, opts[key]); + } +}; + +// convenience method to project a [lon, lat] array to pixel coords +proto.project = function(v) { + return this.map.project(new mapboxgl.LngLat(v[0], v[1])); +}; + +function convertStyleUrl(style) { + var styleValues = layoutAttributes.style.values; + + // if style is part of the 'official' mapbox values, + // add URL prefix and suffix + if(styleValues.indexOf(style) !== -1) { + return constants.styleUrlPrefix + style + '-' + constants.styleUrlSuffix; + } + + return style; +} + +function convertCenter(center) { + return [center.lon, center.lat]; +} From 39684178450ca1a25671bd2d24b0f0ad82e8eb94 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89tienne=20T=C3=A9treault-Pinard?= Date: Fri, 10 Jun 2016 15:29:33 -0400 Subject: [PATCH 02/24] introducting the 'scattermapbox' trace module --- src/traces/scattermapbox/attributes.js | 117 ++++++++ src/traces/scattermapbox/calc.js | 95 ++++++ src/traces/scattermapbox/convert.js | 393 +++++++++++++++++++++++++ src/traces/scattermapbox/defaults.js | 86 ++++++ src/traces/scattermapbox/hover.js | 91 ++++++ src/traces/scattermapbox/index.js | 34 +++ src/traces/scattermapbox/plot.js | 130 ++++++++ 7 files changed, 946 insertions(+) create mode 100644 src/traces/scattermapbox/attributes.js create mode 100644 src/traces/scattermapbox/calc.js create mode 100644 src/traces/scattermapbox/convert.js create mode 100644 src/traces/scattermapbox/defaults.js create mode 100644 src/traces/scattermapbox/hover.js create mode 100644 src/traces/scattermapbox/index.js create mode 100644 src/traces/scattermapbox/plot.js diff --git a/src/traces/scattermapbox/attributes.js b/src/traces/scattermapbox/attributes.js new file mode 100644 index 00000000000..38bb7d909e6 --- /dev/null +++ b/src/traces/scattermapbox/attributes.js @@ -0,0 +1,117 @@ +/** +* Copyright 2012-2016, 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 scatterGeoAttrs = require('../scattergeo/attributes'); +var scatterAttrs = require('../scatter/attributes'); +var plotAttrs = require('../../plots/attributes'); +var extendFlat = require('../../lib/extend').extendFlat; + +var lineAttrs = scatterGeoAttrs.line; +var markerAttrs = scatterGeoAttrs.marker; + + +module.exports = { + lon: scatterGeoAttrs.lon, + lat: scatterGeoAttrs.lat, + + // locations + // locationmode + + mode: { + valType: 'flaglist', + flags: ['lines', 'markers', 'text'], + dflt: 'markers', + extras: ['none'], + role: 'info', + description: [ + 'Determines the drawing mode for this scatter trace.', + 'If the provided `mode` includes *text* then the `text` elements', + 'appear at the coordinates. Otherwise, the `text` elements', + 'appear on hover.' + ].join(' ') + }, + + text: extendFlat({}, scatterAttrs.text, { + description: [ + 'Sets text elements associated with each (lon,lat) pair', + 'If a single string, the same string appears over', + 'all the data points.', + 'If an array of string, the items are mapped in order to the', + 'this trace\'s (lon,lat) coordinates.' + ].join(' ') + }), + + line: { + color: lineAttrs.color, + width: lineAttrs.width, + + // TODO + dash: lineAttrs.dash + }, + + connectgaps: scatterAttrs.connectgaps, + + marker: { + symbol: { + valType: 'string', + dflt: 'circle', + role: 'style', + arrayOk: true, + description: [ + 'Sets the marker symbol.', + 'Full list: https://www.mapbox.com/maki-icons/', + 'Note that the array `marker.color` and `marker.size`', + 'are only available for *circle* symbols.' + ].join(' ') + }, + opacity: extendFlat({}, markerAttrs.opacity, { + arrayOk: false + }), + size: markerAttrs.size, + sizeref: markerAttrs.sizeref, + sizemin: markerAttrs.sizemin, + sizemode: markerAttrs.sizemode, + color: markerAttrs.color, + colorscale: markerAttrs.colorscale, + cauto: markerAttrs.cauto, + cmax: markerAttrs.cmax, + cmin: markerAttrs.cmin, + autocolorscale: markerAttrs.autocolorscale, + reversescale: markerAttrs.reversescale, + showscale: markerAttrs.showscale + + // line + }, + + fill: { + valType: 'enumerated', + values: ['none', 'toself'], + dflt: 'none', + role: 'style', + description: [ + 'Sets the area to fill with a solid color.', + 'Use with `fillcolor` if not *none*.', + '*toself* connects the endpoints of the trace (or each segment', + 'of the trace if it has gaps) into a closed shape.' + ].join(' ') + }, + fillcolor: scatterAttrs.fillcolor, + + textfont: extendFlat({}, scatterAttrs.textfont, { arrayOk: false }), + textposition: extendFlat({}, scatterAttrs.textposition, { arrayOk: false }), + + hoverinfo: extendFlat({}, plotAttrs.hoverinfo, { + flags: ['lon', 'lat', 'text', 'name'] + }), + + _nestedModules: { + 'marker.colorbar': 'Colorbar' + } +}; diff --git a/src/traces/scattermapbox/calc.js b/src/traces/scattermapbox/calc.js new file mode 100644 index 00000000000..295b6ffec3e --- /dev/null +++ b/src/traces/scattermapbox/calc.js @@ -0,0 +1,95 @@ +/** +* Copyright 2012-2016, 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 isNumeric = require('fast-isnumeric'); + +var Lib = require('../../lib'); +var hasColorscale = require('../../components/colorscale/has_colorscale'); +var makeColorScaleFn = require('../../components/colorscale/make_scale_function'); +var subtypes = require('../scatter/subtypes'); +var calcMarkerColorscale = require('../scatter/marker_colorscale_calc'); +var makeBubbleSizeFn = require('../scatter/make_bubble_size_func'); + + +module.exports = function calc(gd, trace) { + var len = trace.lon.length, + marker = trace.marker; + + var hasMarkers = subtypes.hasMarkers(trace), + hasColorArray = (hasMarkers && Array.isArray(marker.color)), + hasSizeArray = (hasMarkers && Array.isArray(marker.size)), + hasSymbolArray = (hasMarkers && Array.isArray(marker.symbol)), + hasTextArray = Array.isArray(trace.text); + + calcMarkerColorscale(trace); + + var colorFn = hasColorscale(trace, 'marker') ? + makeColorScaleFn(marker.colorscale, marker.cmin, marker.cmax) : + Lib.identity; + + var sizeFn = subtypes.isBubble(trace) ? + makeBubbleSizeFn(trace) : + Lib.identity; + + var calcTrace = [], + cnt = 0; + + // Different than cartesian calc step + // as skip over non-numeric lon, lat pairs. + // This makes the hover and convert calculations simpler. + + for(var i = 0; i < len; i++) { + var lon = trace.lon[i], + lat = trace.lat[i]; + + if(!isNumeric(lon) || !isNumeric(lat)) { + if(cnt > 0) calcTrace[cnt - 1].gapAfter = true; + continue; + } + + var calcPt = {}; + cnt++; + + // coerce numeric strings into numbers + calcPt.lonlat = [+lon, +lat]; + + if(hasMarkers) { + + if(hasColorArray) { + var mc = marker.color[i]; + + calcPt.mc = mc; + calcPt.mcc = colorFn(mc); + } + + if(hasSizeArray) { + var ms = marker.size[i]; + + calcPt.ms = ms; + calcPt.mrc = sizeFn(ms); + } + + if(hasSymbolArray) { + var mx = marker.symbol[i]; + calcPt.mx = (typeof mx === 'string') ? mx : 'circle'; + } + } + + if(hasTextArray) { + var tx = trace.text[i]; + calcPt.tx = (typeof tx === 'string') ? tx : ''; + } + + calcTrace.push(calcPt); + } + + return calcTrace; +}; diff --git a/src/traces/scattermapbox/convert.js b/src/traces/scattermapbox/convert.js new file mode 100644 index 00000000000..b5568a14aa3 --- /dev/null +++ b/src/traces/scattermapbox/convert.js @@ -0,0 +1,393 @@ +/** +* Copyright 2012-2016, 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 Lib = require('../../lib'); +var subTypes = require('../scatter/subtypes'); + +var COLOR_PROP = 'circle-color'; +var SIZE_PROP = 'circle-radius'; + + +module.exports = function convert(calcTrace) { + var trace = calcTrace[0].trace; + + var isVisible = (trace.visible === true), + hasFill = (trace.fill !== 'none'), + hasLines = subTypes.hasLines(trace), + hasMarkers = subTypes.hasMarkers(trace), + hasText = subTypes.hasText(trace), + hasCircles = (hasMarkers && trace.marker.symbol === 'circle'); + + var fill = initContainer(), + line = initContainer(), + circle = initContainer(), + symbol = initContainer(); + + var opts = { + fill: fill, + line: line, + circle: circle, + symbol: symbol + }; + + // early return is not visible + if(!isVisible) return opts; + + // fill layer and line layer use the same coords + var coords; + if(hasFill || hasLines) { + coords = getCoords(calcTrace); + } + + if(hasFill) { + fill.geojson = makeFillGeoJSON(calcTrace, coords); + fill.layout.visibility = 'visible'; + + Lib.extendFlat(fill.paint, { + 'fill-color': trace.fillcolor + }); + } + + if(hasLines) { + line.geojson = makeLineGeoJSON(calcTrace, coords); + line.layout.visibility = 'visible'; + + Lib.extendFlat(line.paint, { + 'line-width': trace.line.width, + 'line-color': trace.line.color, + 'line-opacity': trace.opacity + }); + + // TODO convert line.dash into line-dasharray + } + + if(hasCircles) { + var hash = {}; + hash[COLOR_PROP] = {}; + hash[SIZE_PROP] = {}; + + circle.geojson = makeCircleGeoJSON(calcTrace, hash); + circle.layout.visibility = 'visible'; + + Lib.extendFlat(circle.paint, { + 'circle-opacity': trace.opacity * trace.marker.opacity, + 'circle-color': calcCircleColor(trace, hash), + 'circle-radius': calcCircleRadius(trace, hash) + }); + } + + if(!hasCircles || hasText) { + symbol.geojson = makeSymbolGeoJSON(calcTrace); + + Lib.extendFlat(symbol.layout, { + visibility: 'visible', + 'icon-image': '{symbol}-15', + 'text-field': '{text}' + }); + + if(hasMarkers) { + Lib.extendFlat(symbol.layout, { + 'icon-size': trace.marker.size / 10 + }); + + Lib.extendFlat(symbol.paint, { + 'icon-opacity': trace.opacity * trace.marker.opacity, + + // TODO does not work ?? + 'icon-color': trace.marker.color + }); + } + + if(hasText) { + var textOpts = calcTextOpts(trace); + + Lib.extendFlat(symbol.layout, { + 'text-font': trace.textfont.textfont, + 'text-size': trace.textfont.size, + 'text-anchor': textOpts.anchor, + 'text-offset': textOpts.offset + }); + + Lib.extendFlat(symbol.paint, { + 'text-color': trace.textfont.color, + 'text-opacity': trace.opacity + }); + } + } + + return opts; +}; + +function initContainer() { + return { + geojson: makeBlankGeoJSON(), + layout: { visibility: 'none' }, + paint: {} + }; +} + +function makeBlankGeoJSON() { + return { + type: 'Point', + coordinates: [] + }; +} + +function makeFillGeoJSON(_, coords) { + return { + type: 'Polygon', + coordinates: coords + }; +} + +function makeLineGeoJSON(_, coords) { + return { + type: 'MultiLineString', + coordinates: coords + }; +} + +// N.B. `hash` is mutated here +// +// The `hash` object contains mapping between values +// (e.g. calculated marker.size and marker.color items) +// and their index in the input arrayOk attributes. +// +// GeoJSON features have their 'data-driven' properties set to +// the index of the first value found in the data. +// +// The `hash` object is then converted to mapbox `stops` arrays +// mapping index to value. +// +// The solution prove to be more robust than trying to generate +// `stops` arrays from scale functions. +function makeCircleGeoJSON(calcTrace, hash) { + var trace = calcTrace[0].trace; + + var marker = trace.marker, + hasColorArray = Array.isArray(marker.color), + hasSizeArray = Array.isArray(marker.size); + + // Translate vals in trace arrayOk containers + // into a val-to-index hash object + function translate(props, key, val, index) { + if(!hash[key][val]) hash[key][val] = index; + + props[key] = hash[key][val]; + } + + var features = []; + + for(var i = 0; i < calcTrace.length; i++) { + var calcPt = calcTrace[i]; + + var props = {}; + if(hasColorArray) translate(props, COLOR_PROP, calcPt.mcc, i); + if(hasSizeArray) translate(props, SIZE_PROP, calcPt.mrc, i); + + features.push({ + type: 'Feature', + geometry: { + type: 'Point', + coordinates: calcPt.lonlat + }, + properties: props + }); + } + + return { + type: 'FeatureCollection', + features: features + }; +} + +function makeSymbolGeoJSON(calcTrace) { + var trace = calcTrace[0].trace; + + var marker = trace.marker || {}, + symbol = marker.symbol, + text = trace.text; + + var fillSymbol = (symbol !== 'circle') ? + getFillFunc(symbol) : + blankFillFunc; + + var fillText = subTypes.hasText(trace) ? + getFillFunc(text) : + blankFillFunc; + + var features = []; + + for(var i = 0; i < calcTrace.length; i++) { + var calcPt = calcTrace[i]; + + features.push({ + type: 'Feature', + geometry: { + type: 'Point', + coordinates: calcPt.lonlat + }, + properties: { + symbol: fillSymbol(calcPt.mx), + text: fillText(calcPt.tx) + } + }); + } + + return { + type: 'FeatureCollection', + features: features + }; +} + +function calcCircleColor(trace, hash) { + var marker = trace.marker, + out; + + if(Array.isArray(marker.color)) { + var vals = Object.keys(hash[COLOR_PROP]), + stops = []; + + for(var i = 0; i < vals.length; i++) { + var val = vals[i]; + + stops.push([ hash[COLOR_PROP][val], val ]); + } + + out = { + property: COLOR_PROP, + stops: stops + }; + + } + else { + out = marker.color; + } + + return out; +} + +function calcCircleRadius(trace, hash) { + var marker = trace.marker, + out; + + if(Array.isArray(marker.size)) { + var vals = Object.keys(hash[SIZE_PROP]), + stops = []; + + for(var i = 0; i < vals.length; i++) { + var val = vals[i]; + + stops.push([ hash[SIZE_PROP][val], +val ]); + } + + // stops indices must be sorted + stops.sort(function(a, b) { + return a[0] - b[0]; + }); + + out = { + property: SIZE_PROP, + stops: stops + }; + } + else { + out = marker.size / 2; + } + + return out; +} + +function calcTextOpts(trace) { + var textposition = trace.textposition, + parts = textposition.split(' '), + vPos = parts[0], + hPos = parts[1]; + + // ballpack values + var ms = (trace.marker || {}).size, + xInc = 0.5 + (ms / 15), + yInc = 1.5 + (ms / 15); + + var anchorVals = ['', ''], + offset = [0, 0]; + + switch(vPos) { + case 'top': + anchorVals[0] = 'top'; + offset[1] = -yInc; + break; + case 'bottom': + anchorVals[0] = 'bottom'; + offset[1] = yInc; + break; + } + + switch(hPos) { + case 'left': + anchorVals[1] = 'right'; + offset[0] = -xInc; + break; + case 'right': + anchorVals[1] = 'left'; + offset[0] = xInc; + break; + } + + // Mapbox text-anchor must be one of: + // center, left, right, top, bottom, + // top-left, top-right, bottom-left, bottom-right + + var anchor; + if(anchorVals[0] && anchorVals[1]) anchor = anchorVals.join('-'); + else if(anchorVals[0]) anchor = anchorVals[0]; + else if(anchorVals[1]) anchor = anchorVals[1]; + else anchor = 'center'; + + return { anchor: anchor, offset: offset }; +} + +function getCoords(calcTrace) { + var trace = calcTrace[0].trace, + connectgaps = trace.connectgaps; + + var coords = [], + lineString = []; + + for(var i = 0; i < calcTrace.length; i++) { + var calcPt = calcTrace[i]; + + lineString.push(calcPt.lonlat); + + if(!connectgaps && calcPt.gapAfter && lineString.length > 0) { + coords.push(lineString); + lineString = []; + } + } + + coords.push(lineString); + + return coords; +} + +function getFillFunc(attr) { + if(Array.isArray(attr)) { + return function(v) { return v; }; + } + else if(attr) { + return function() { return attr; }; + } + else { + return blankFillFunc; + } +} + +function blankFillFunc() { return ''; } diff --git a/src/traces/scattermapbox/defaults.js b/src/traces/scattermapbox/defaults.js new file mode 100644 index 00000000000..8368ddabede --- /dev/null +++ b/src/traces/scattermapbox/defaults.js @@ -0,0 +1,86 @@ +/** +* Copyright 2012-2016, 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 Lib = require('../../lib'); + +var subTypes = require('../scatter/subtypes'); +var handleMarkerDefaults = require('../scatter/marker_defaults'); +var handleLineDefaults = require('../scatter/line_defaults'); +var handleTextDefaults = require('../scatter/text_defaults'); +var handleFillColorDefaults = require('../scatter/fillcolor_defaults'); + +var attributes = require('./attributes'); +var scatterAttrs = require('../scatter/attributes'); + + +module.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout) { + function coerce(attr, dflt) { + return Lib.coerce(traceIn, traceOut, attributes, attr, dflt); + } + + function coerceMarker(attr, dflt) { + var attrs = (attr.indexOf('.line') === -1) ? attributes : scatterAttrs; + + // use 'scatter' attributes for 'marker.line.' attr, + // so that we can reuse the scatter marker defaults + + return Lib.coerce(traceIn, traceOut, attrs, attr, dflt); + } + + var len = handleLonLatDefaults(traceIn, traceOut, coerce); + if(!len) { + traceOut.visible = false; + return; + } + + coerce('text'); + coerce('mode'); + + if(subTypes.hasLines(traceOut)) { + handleLineDefaults(traceIn, traceOut, defaultColor, coerce); + coerce('connectgaps'); + } + + if(subTypes.hasMarkers(traceOut)) { + handleMarkerDefaults(traceIn, traceOut, defaultColor, layout, coerceMarker); + + // array marker.size and marker.color are only supported with circles + + var marker = traceOut.marker; + + if(marker.symbol !== 'circle') { + if(Array.isArray(marker.size)) marker.size = marker.size[0]; + if(Array.isArray(marker.color)) marker.color = marker.color[0]; + } + } + + if(subTypes.hasText(traceOut)) { + handleTextDefaults(traceIn, traceOut, layout, coerce); + } + + coerce('fill'); + if(traceOut.fill !== 'none') { + handleFillColorDefaults(traceIn, traceOut, defaultColor, coerce); + } + + coerce('hoverinfo', (layout._dataLength === 1) ? 'lon+lat+text' : undefined); +}; + +function handleLonLatDefaults(traceIn, traceOut, coerce) { + var lon = coerce('lon') || []; + var lat = coerce('lat') || []; + var len = Math.min(lon.length, lat.length); + + if(len < lon.length) traceOut.lon = lon.slice(0, len); + if(len < lat.length) traceOut.lat = lat.slice(0, len); + + return len; +} diff --git a/src/traces/scattermapbox/hover.js b/src/traces/scattermapbox/hover.js new file mode 100644 index 00000000000..9bb9ea630c1 --- /dev/null +++ b/src/traces/scattermapbox/hover.js @@ -0,0 +1,91 @@ +/** +* Copyright 2012-2016, 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 Fx = require('../../plots/cartesian/graph_interact'); +var getTraceColor = require('../scatter/get_trace_color'); + + +module.exports = function hoverPoints(pointData, xval, yval) { + var cd = pointData.cd, + trace = cd[0].trace, + xa = pointData.xa, + ya = pointData.ya; + + // compute winding number about [-180, 180] globe + var winding = (xval >= 0) ? + Math.floor((xval + 180) / 360) : + Math.ceil((xval - 180) / 360); + + // shift longitude to [-180, 180] to determine closest point + var lonShift = winding * 360; + var xval2 = xval - lonShift; + + function distFn(d) { + var lonlat = d.lonlat, + dx = Math.abs(xa.c2p(lonlat) - xa.c2p([xval2, lonlat[1]])), + dy = Math.abs(ya.c2p(lonlat) - ya.c2p([lonlat[0], yval])), + rad = Math.max(3, d.mrc || 0); + + return Math.max(Math.sqrt(dx * dx + dy * dy) - rad, 1 - 3 / rad); + } + + Fx.getClosest(cd, distFn, pointData); + + // skip the rest (for this trace) if we didn't find a close point + if(pointData.index === false) return; + + var di = cd[pointData.index], + lonlat = di.lonlat, + lonlatShifted = [lonlat[0] + lonShift, lonlat[1]]; + + // shift labels back to original winded globe + var xc = xa.c2p(lonlatShifted), + yc = ya.c2p(lonlatShifted), + rad = di.mrc || 1; + + pointData.x0 = xc - rad; + pointData.x1 = xc + rad; + pointData.y0 = yc - rad; + pointData.y1 = yc + rad; + + pointData.color = getTraceColor(trace, di); + pointData.extraText = getExtraText(trace, di); + + return [pointData]; +}; + +function getExtraText(trace, di) { + var hoverinfo = trace.hoverinfo.split('+'), + isAll = (hoverinfo.indexOf('all') !== -1), + hasLon = (hoverinfo.indexOf('lon') !== -1), + hasLat = (hoverinfo.indexOf('lat') !== -1); + + var lonlat = di.lonlat, + text = []; + + // TODO should we use a mock axis to format hover? + // If so, we'll need to make precision be zoom-level dependent + function format(v) { + return v + '\u00B0'; + } + + if(isAll || (hasLon && hasLat)) { + text.push('(' + format(lonlat[0]) + ', ' + format(lonlat[1]) + ')'); + } + else if(hasLon) text.push('lon: ' + format(lonlat[0])); + else if(hasLat) text.push('lat: ' + format(lonlat[1])); + + if(isAll || hoverinfo.indexOf('text') !== -1) { + text.push(di.tx || trace.text); + } + + return text.join('
'); +} diff --git a/src/traces/scattermapbox/index.js b/src/traces/scattermapbox/index.js new file mode 100644 index 00000000000..bb0a5af7c2b --- /dev/null +++ b/src/traces/scattermapbox/index.js @@ -0,0 +1,34 @@ +/** +* Copyright 2012-2016, 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 ScatterMapbox = {}; + +ScatterMapbox.attributes = require('./attributes'); +ScatterMapbox.supplyDefaults = require('./defaults'); +ScatterMapbox.colorbar = require('../scatter/colorbar'); +ScatterMapbox.calc = require('./calc'); +ScatterMapbox.hoverPoints = require('./hover'); +ScatterMapbox.plot = require('./plot'); + +ScatterMapbox.moduleType = 'trace'; +ScatterMapbox.name = 'scattermapbox'; +ScatterMapbox.basePlotModule = require('../../plots/mapbox'); +ScatterMapbox.categories = ['mapbox', 'gl', 'symbols', 'markerColorscale', 'showLegend']; +ScatterMapbox.meta = { + hrName: 'scatter_mapbox', + description: [ + 'The data visualized as scatter point, lines or marker symbols', + 'on a Mapbox GL geographic map', + 'is provided by longitude/latitude pairs in `lon` and `lat`.' + ].join(' ') +}; + +module.exports = ScatterMapbox; diff --git a/src/traces/scattermapbox/plot.js b/src/traces/scattermapbox/plot.js new file mode 100644 index 00000000000..18fc54ebdb1 --- /dev/null +++ b/src/traces/scattermapbox/plot.js @@ -0,0 +1,130 @@ +/** +* Copyright 2012-2016, 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 convert = require('./convert'); + + +function ScatterMapbox(mapbox, uid) { + this.mapbox = mapbox; + this.map = mapbox.map; + + this.uid = uid; + + this.idSourceFill = uid + '-source-fill'; + this.idSourceLine = uid + '-source-line'; + this.idSourceCircle = uid + '-source-circle'; + this.idSourceSymbol = uid + '-source-symbol'; + + this.idLayerFill = uid + '-layer-fill'; + this.idLayerLine = uid + '-layer-line'; + this.idLayerCircle = uid + '-layer-circle'; + this.idLayerSymbol = uid + '-layer-symbol'; + + this.sourceFill = mapbox.createGeoJSONSource(); + this.map.addSource(this.idSourceFill, this.sourceFill); + + this.sourceLine = mapbox.createGeoJSONSource(); + this.map.addSource(this.idSourceLine, this.sourceLine); + + this.sourceCircle = mapbox.createGeoJSONSource(); + this.map.addSource(this.idSourceCircle, this.sourceCircle); + + this.sourceSymbol = mapbox.createGeoJSONSource(); + this.map.addSource(this.idSourceSymbol, this.sourceSymbol); + + this.map.addLayer({ + id: this.idLayerFill, + source: this.idSourceFill, + type: 'fill' + }); + + this.map.addLayer({ + id: this.idLayerLine, + source: this.idSourceLine, + type: 'line' + }); + + this.map.addLayer({ + id: this.idLayerCircle, + source: this.idSourceCircle, + type: 'circle' + }); + + this.map.addLayer({ + id: this.idLayerSymbol, + source: this.idSourceSymbol, + type: 'symbol' + }); + + // We could merge the 'fill' source with the 'line' source and + // the 'circle' source with the 'symbol' source if ever having + // for up-to 4 sources per 'scattermapbox' traces becomes a problem. +} + +var proto = ScatterMapbox.prototype; + +proto.update = function update(calcTrace) { + var mapbox = this.mapbox; + + var opts = convert(calcTrace); + + mapbox.setOptions(this.idLayerFill, 'setLayoutProperty', opts.fill.layout); + mapbox.setOptions(this.idLayerLine, 'setLayoutProperty', opts.line.layout); + mapbox.setOptions(this.idLayerCircle, 'setLayoutProperty', opts.circle.layout); + mapbox.setOptions(this.idLayerSymbol, 'setLayoutProperty', opts.symbol.layout); + + if(isVisible(opts.fill)) { + this.sourceFill.setData(opts.fill.geojson); + mapbox.setOptions(this.idLayerFill, 'setPaintProperty', opts.fill.paint); + } + + if(isVisible(opts.line)) { + this.sourceLine.setData(opts.line.geojson); + mapbox.setOptions(this.idLayerLine, 'setPaintProperty', opts.line.paint); + } + + if(isVisible(opts.circle)) { + this.sourceCircle.setData(opts.circle.geojson); + mapbox.setOptions(this.idLayerCircle, 'setPaintProperty', opts.circle.paint); + } + + if(isVisible(opts.symbol)) { + this.sourceSymbol.setData(opts.symbol.geojson); + mapbox.setOptions(this.idLayerSymbol, 'setPaintProperty', opts.symbol.paint); + } +}; + +proto.dispose = function dispose() { + var map = this.map; + + map.removeLayer(this.idLayerFill); + map.removeLayer(this.idLayerLine); + map.removeLayer(this.idLayerCircle); + map.removeLayer(this.idLayerSymbol); + + map.removeSource(this.idSourceFill); + map.removeSource(this.idSourceLine); + map.removeSource(this.idSourceCircle); + map.removeSource(this.idSourceSymbol); +}; + +function isVisible(layerOpts) { + return layerOpts.layout.visibility === 'visible'; +} + +module.exports = function createScatterMapbox(mapbox, calcTrace) { + var trace = calcTrace[0].trace; + + var scatterMapbox = new ScatterMapbox(mapbox, trace.uid); + scatterMapbox.update(calcTrace); + + return scatterMapbox; +}; From 364874437e23d189069d258b78221a86c644edd7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89tienne=20T=C3=A9treault-Pinard?= Date: Fri, 10 Jun 2016 15:32:46 -0400 Subject: [PATCH 03/24] add 'mapbox' to layout attributes --- src/plots/layout_attributes.js | 3 ++- test/jasmine/tests/plotschema_test.js | 2 +- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/src/plots/layout_attributes.js b/src/plots/layout_attributes.js index 030f99eca75..cd1c7d42bf7 100644 --- a/src/plots/layout_attributes.js +++ b/src/plots/layout_attributes.js @@ -187,6 +187,7 @@ module.exports = { 'annotations': 'Annotations', 'shapes': 'Shapes', 'images': 'Images', - 'ternary': 'ternary' + 'ternary': 'ternary', + 'mapbox': 'mapbox' } }; diff --git a/test/jasmine/tests/plotschema_test.js b/test/jasmine/tests/plotschema_test.js index 1bf548db041..68377342c16 100644 --- a/test/jasmine/tests/plotschema_test.js +++ b/test/jasmine/tests/plotschema_test.js @@ -91,7 +91,7 @@ describe('plot schema', function() { it('all subplot objects should contain _isSubplotObj', function() { var IS_SUBPLOT_OBJ = '_isSubplotObj', - astrs = ['xaxis', 'yaxis', 'scene', 'geo', 'ternary'], + astrs = ['xaxis', 'yaxis', 'scene', 'geo', 'ternary', 'mapbox'], list = []; // check if the subplot objects have '_isSubplotObj' From 625457874a3490e5789042fd3358ca3ddf774624 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89tienne=20T=C3=A9treault-Pinard?= Date: Fri, 10 Jun 2016 15:33:57 -0400 Subject: [PATCH 04/24] make sure that non-svg plot types go through calc on restyle, - N.B. 'docalc' is more conservative then 'doplot' --- src/plot_api/plot_api.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/plot_api/plot_api.js b/src/plot_api/plot_api.js index 3d16e72fbe2..bb89d82e1e7 100644 --- a/src/plot_api/plot_api.js +++ b/src/plot_api/plot_api.js @@ -1648,7 +1648,7 @@ Plotly.restyle = function restyle(gd, astr, val, traces) { // to not go through a full replot var doPlotWhiteList = ['cartesian', 'pie', 'ternary']; fullLayout._basePlotModules.forEach(function(_module) { - if(doPlotWhiteList.indexOf(_module.name) === -1) doplot = true; + if(doPlotWhiteList.indexOf(_module.name) === -1) docalc = true; }); // make a new empty vals array for undoit From 6a73378ff40d4d2137c91459c8b8206c245a3246 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89tienne=20T=C3=A9treault-Pinard?= Date: Fri, 10 Jun 2016 15:34:13 -0400 Subject: [PATCH 05/24] handle mapbox.layers relayouts --- src/plot_api/plot_api.js | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/src/plot_api/plot_api.js b/src/plot_api/plot_api.js index bb89d82e1e7..5b991a0e8f1 100644 --- a/src/plot_api/plot_api.js +++ b/src/plot_api/plot_api.js @@ -2286,6 +2286,19 @@ Plotly.relayout = function relayout(gd, astr, val) { Images.supplyLayoutDefaults(gd.layout, gd._fullLayout); Images.draw(gd); } + else if(p.parts[0] === 'mapbox' && p.parts[1] === 'layers') { + Lib.extendDeepAll(gd.layout, Lib.objectFromPath(ai, vi)); + + // append empty container to mapbox.layers + // so that relinkPrivateKeys does not complain + + var fullLayers = (gd._fullLayout.mapbox || {}).layers || []; + var diff = (p.parts[2] + 1) - fullLayers.length; + + for(i = 0; i < diff; i++) fullLayers.push({}); + + doplot = true; + } // alter gd.layout else { // check whether we can short-circuit a full redraw From 3e79f0d25ff8c75d0e371929373e66838983ed5b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89tienne=20T=C3=A9treault-Pinard?= Date: Fri, 10 Jun 2016 15:35:37 -0400 Subject: [PATCH 06/24] add 'pretest' tasks, - that setups build files containing mapbox crendentials so that test runners can load them seamlessly. --- CONTRIBUTING.md | 12 ++++++++++++ package.json | 1 + tasks/pretest.js | 38 ++++++++++++++++++++++++++++++++++++ tasks/util/constants.js | 3 +++ tasks/util/shortcut_paths.js | 3 ++- 5 files changed, 56 insertions(+), 1 deletion(-) create mode 100644 tasks/pretest.js diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index d1ebcf3e86b..7af01ba4806 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -157,6 +157,18 @@ which shows the baseline image, the generated image, the diff and the json mocks To view the results of a run on CircleCI, download the `build/test_images/` and `build/test_images_diff/` artifacts into your local repo and then run `npm run start-image_viewer`. +### Note on testing our `mapbox-gl` integration + +Creating `mapbox-gl` graphs requires an +[`accessToken`](https://www.mapbox.com/help/define-access-token/). To make sure +that mapbox image and jasmine tests run properly, locate your Mapbox access +token and run: + + +```bash +export MAPBOX_ACCESS_TOKEN="" && npm run pretest +``` + ## Repo organization diff --git a/package.json b/package.json index f90e2a675ac..32a285e2a7b 100644 --- a/package.json +++ b/package.json @@ -29,6 +29,7 @@ "watch": "node tasks/watch_plotly.js", "lint": "eslint . || true", "lint-fix": "eslint . --fix", + "pretest": "node tasks/pretest.js", "test-jasmine": "karma start test/jasmine/karma.conf.js", "citest-jasmine": "karma start test/jasmine/karma.ciconf.js", "test-image": "./tasks/test_image.sh", diff --git a/tasks/pretest.js b/tasks/pretest.js new file mode 100644 index 00000000000..b15d6598b97 --- /dev/null +++ b/tasks/pretest.js @@ -0,0 +1,38 @@ +var fs = require('fs'); +var constants = require('./util/constants'); +var mapboxAccessToken = process.env.MAPBOX_ACCESS_TOKEN; + + +if(!mapboxAccessToken) { + throw new Error([ + 'MAPBOX_ACCESS_TOKEN not found!!!', + 'Please export your mapbox access token into and try again.' + ].join('\n')); +} + +// Create a credentials json file, +// to be required in jasmine test suites and test dashboard +var credentials = JSON.stringify({ + MAPBOX_ACCESS_TOKEN: mapboxAccessToken +}, null, 2); + +fs.writeFile(constants.pathToCredentials, credentials, function(err) { + if(err) throw err; +}); + +// Create a 'set plot config' file, +// to be included in the image test index +var setPlotConfig = [ + '\'use strict\';', + '', + '/* global Plotly:false */', + '', + 'Plotly.setPlotConfig({', + ' mapboxAccessToken: \'' + mapboxAccessToken + '\'', + '});', + '' +].join('\n'); + +fs.writeFile(constants.pathToSetPlotConfig, setPlotConfig, function(err) { + if(err) throw err; +}); diff --git a/tasks/util/constants.js b/tasks/util/constants.js index fb78cc0c79b..f4a190e6192 100644 --- a/tasks/util/constants.js +++ b/tasks/util/constants.js @@ -51,6 +51,9 @@ module.exports = { pathToJasmineTests: path.join(pathToRoot, 'test/jasmine/tests'), pathToJasmineBundleTests: path.join(pathToRoot, 'test/jasmine/bundle_tests'), + pathToCredentials: path.join(pathToBuild, 'credentials.json'), + pathToSetPlotConfig: path.join(pathToBuild, 'set_plot_config.js'), + uglifyOptions: { fromString: true, mangle: true, diff --git a/tasks/util/shortcut_paths.js b/tasks/util/shortcut_paths.js index 99a26d9751c..d998590bd3b 100644 --- a/tasks/util/shortcut_paths.js +++ b/tasks/util/shortcut_paths.js @@ -11,7 +11,8 @@ var constants = require('./constants'); var shortcutsConfig = { '@src': constants.pathToSrc, '@lib': constants.pathToLib, - '@mocks': constants.pathToTestImageMocks + '@mocks': constants.pathToTestImageMocks, + '@build': constants.pathToBuild }; module.exports = transformTools.makeRequireTransform('requireTransform', From 3ea7436a2092e8e75a99aa998e485f9a3c108a1f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89tienne=20T=C3=A9treault-Pinard?= Date: Fri, 10 Jun 2016 15:36:27 -0400 Subject: [PATCH 07/24] set mapbox crendentials in test dashboard and image test index --- devtools/test_dashboard/devtools.js | 8 ++++++++ test/image/index.html | 1 + 2 files changed, 9 insertions(+) diff --git a/devtools/test_dashboard/devtools.js b/devtools/test_dashboard/devtools.js index 50ad7a4d041..ea5b7b71636 100644 --- a/devtools/test_dashboard/devtools.js +++ b/devtools/test_dashboard/devtools.js @@ -4,6 +4,7 @@ var Fuse = require('fuse.js'); var mocks = require('../../build/test_dashboard_mocks.json'); +var credentials = require('../../build/credentials.json'); // put d3 in window scope var d3 = window.d3 = Plotly.d3; @@ -14,8 +15,15 @@ var Tabs = { // Set plot config options setPlotConfig: function() { Plotly.setPlotConfig({ + // use local topojson files topojsonURL: '../../dist/topojson/', + + // register mapbox access token + // run `npm run preset` if you haven't yet + mapboxAccessToken: credentials.MAPBOX_ACCESS_TOKEN, + + // show all logs in console logging: 2 }); }, diff --git a/test/image/index.html b/test/image/index.html index efa5c6d2edc..e7d04e93247 100644 --- a/test/image/index.html +++ b/test/image/index.html @@ -5,6 +5,7 @@ + From 3b2c2e2c94c973bdd89f4f82cb8ca91d3675617e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89tienne=20T=C3=A9treault-Pinard?= Date: Fri, 10 Jun 2016 15:37:26 -0400 Subject: [PATCH 08/24] run pretest on circleci, - note that a MAPBOX_ACCESS_TOKEN env variable has been set on the CircleCI plotly.js project. --- circle.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/circle.yml b/circle.yml index e0186360ab4..9cead3726f3 100644 --- a/circle.yml +++ b/circle.yml @@ -15,6 +15,7 @@ dependencies: - docker pull plotly/testbed:latest post: - npm run cibuild + - npm run pretest - docker run -d --name mytestbed -v $PWD:/var/www/streambed/image_server/plotly.js -p 9010:9010 plotly/testbed:latest - sudo ./tasks/run_in_testbed.sh mytestbed "cp -f test/image/index.html ../server_app/index.html" - wget --server-response --spider --tries=8 --retry-connrefused http://localhost:9010/ping From a47704c8391cc7be0468a667329a3962016876f9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89tienne=20T=C3=A9treault-Pinard?= Date: Fri, 10 Jun 2016 15:39:01 -0400 Subject: [PATCH 09/24] tmp commit: register scattermapbox in main index file, - this commit will be remove before the first release as some mapbox cannot be tested on CircleCI yet. --- lib/index.js | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/lib/index.js b/lib/index.js index 631fed56656..2015047f1e3 100644 --- a/lib/index.js +++ b/lib/index.js @@ -30,7 +30,9 @@ Core.register([ require('./scattergeo'), require('./choropleth'), require('./scattergl'), - require('./scatterternary') + require('./scatterternary'), + + require('../src/traces/scattermapbox') ]); module.exports = Core; From f300d276deb9974411222791f6727953a4ae42f5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89tienne=20T=C3=A9treault-Pinard?= Date: Fri, 10 Jun 2016 15:39:39 -0400 Subject: [PATCH 10/24] add test jasmine for the mapbox base plot module --- test/jasmine/tests/mapbox_test.js | 720 ++++++++++++++++++++++++++++++ 1 file changed, 720 insertions(+) create mode 100644 test/jasmine/tests/mapbox_test.js diff --git a/test/jasmine/tests/mapbox_test.js b/test/jasmine/tests/mapbox_test.js new file mode 100644 index 00000000000..fbfe945c549 --- /dev/null +++ b/test/jasmine/tests/mapbox_test.js @@ -0,0 +1,720 @@ +var Plotly = require('@lib'); +var Lib = require('@src/lib'); + +var constants = require('@src/plots/mapbox/constants'); +var supplyLayoutDefaults = require('@src/plots/mapbox/layout_defaults'); + +var d3 = require('d3'); +var createGraphDiv = require('../assets/create_graph_div'); +var destroyGraphDiv = require('../assets/destroy_graph_div'); +var mouseEvent = require('../assets/mouse_event'); +var customMatchers = require('../assets/custom_matchers'); + +var MAPBOX_ACCESS_TOKEN = require('@build/credentials.json').MAPBOX_ACCESS_TOKEN; +var TRANSITION_DELAY = 500; + +var noop = function() {}; + +Plotly.setPlotConfig({ + mapboxAccessToken: MAPBOX_ACCESS_TOKEN +}); + + +describe('mapbox defaults', function() { + 'use strict'; + + var layoutIn, layoutOut, fullData; + + beforeEach(function() { + layoutOut = { font: { color: 'red' } }; + + // needs a ternary-ref in a trace in order to be detected + fullData = [{ type: 'scattermapbox', subplot: 'mapbox' }]; + }); + + it('should fill empty containers', function() { + layoutIn = {}; + + supplyLayoutDefaults(layoutIn, layoutOut, fullData); + expect(layoutIn).toEqual({ mapbox: {} }); + }); + + it('should copy ref to input container in full (for updating on map move)', function() { + var mapbox = { style: 'light '}; + + layoutIn = { mapbox: mapbox }; + + supplyLayoutDefaults(layoutIn, layoutOut, fullData); + expect(layoutOut.mapbox._input).toBe(mapbox); + }); + + it('should fill layer containers', function() { + layoutIn = { + mapbox: { + layers: [{}, {}] + } + }; + + supplyLayoutDefaults(layoutIn, layoutOut, fullData); + expect(layoutOut.mapbox.layers[0].sourcetype).toEqual('geojson'); + expect(layoutOut.mapbox.layers[1].sourcetype).toEqual('geojson'); + }); + + it('should coerce \'sourcelayer\' only for *vector* \'sourcetype\'', function() { + layoutIn = { + mapbox: { + layers: [{ + sourcetype: 'vector', + sourcelayer: 'layer0' + }, { + sourcetype: 'geojson', + sourcelayer: 'layer0' + }] + } + }; + + supplyLayoutDefaults(layoutIn, layoutOut, fullData); + expect(layoutOut.mapbox.layers[0].sourcelayer).toEqual('layer0'); + expect(layoutOut.mapbox.layers[1].sourcelayer).toBeUndefined(); + }); + + it('should only coerce relevant layer style attributes', function() { + layoutIn = { + mapbox: { + layers: [{ + sourcetype: 'vector', + type: 'line', + line: { + color: 'red', + width: 3 + }, + fillcolor: 'blue' + }, { + sourcetype: 'geojson', + type: 'fill', + line: { + color: 'red', + width: 3 + }, + fillcolor: 'blue' + }] + } + }; + + supplyLayoutDefaults(layoutIn, layoutOut, fullData); + + expect(layoutOut.mapbox.layers[0].line.color).toEqual('red'); + expect(layoutOut.mapbox.layers[0].line.width).toEqual(3); + expect(layoutOut.mapbox.layers[0].fillcolor).toBeUndefined(); + + expect(layoutOut.mapbox.layers[1].line.color).toEqual('red'); + expect(layoutOut.mapbox.layers[1].line.width).toBeUndefined(); + expect(layoutOut.mapbox.layers[1].fillcolor).toEqual('blue'); + }); +}); + +describe('mapbox credentials', function() { + 'use strict'; + + var dummyToken = 'asfdsa124331wersdsa1321q3'; + var gd; + + beforeEach(function() { + gd = createGraphDiv(); + + Plotly.setPlotConfig({ + mapboxAccessToken: null + }); + }); + + afterEach(function() { + Plotly.purge(gd); + destroyGraphDiv(); + + Plotly.setPlotConfig({ + mapboxAccessToken: MAPBOX_ACCESS_TOKEN + }); + }); + + it('should throw error if token is not registered', function() { + expect(function() { + Plotly.plot(gd, [{ + type: 'scattermapbox', + lon: [10, 20, 30], + lat: [10, 20, 30] + }]); + }).toThrow(new Error(constants.noAccessTokenErrorMsg)); + }); + + it('should throw error if token is invalid', function(done) { + Plotly.plot(gd, [{ + type: 'scattermapbox', + lon: [10, 20, 30], + lat: [10, 20, 30] + }], {}, { + mapboxAccessToken: dummyToken + }).catch(function(err) { + expect(err).toEqual(new Error(constants.mapOnErrorMsg)); + done(); + }); + }); +}); + +describe('mapbox plots', function() { + 'use strict'; + + var mock = require('@mocks/mapbox_0.json'), + gd; + + var pointPos = [579, 276], + blankPos = [650, 120]; + + beforeAll(function() { + jasmine.addMatchers(customMatchers); + }); + + beforeEach(function(done) { + gd = createGraphDiv(); + + var mockCopy = Lib.extendDeep({}, mock); + + Plotly.plot(gd, mockCopy.data, mockCopy.layout).then(done); + }); + + afterEach(function() { + Plotly.purge(gd); + destroyGraphDiv(); + }); + + it('should be able to toggle trace visibility', function(done) { + var modes = ['line', 'circle']; + + expect(countVisibleTraces(gd, modes)).toEqual(2); + + Plotly.restyle(gd, 'visible', false).then(function() { + expect(gd._fullLayout.mapbox).toBeUndefined(); + + return Plotly.restyle(gd, 'visible', true); + }).then(function() { + expect(countVisibleTraces(gd, modes)).toEqual(2); + + return Plotly.restyle(gd, 'visible', 'legendonly', [1]); + }).then(function() { + expect(countVisibleTraces(gd, modes)).toEqual(1); + + return Plotly.restyle(gd, 'visible', true); + }).then(function() { + expect(countVisibleTraces(gd, modes)).toEqual(2); + + done(); + }); + }); + + it('should be able to delete and add traces', function(done) { + var modes = ['line', 'circle']; + + expect(countVisibleTraces(gd, modes)).toEqual(2); + + Plotly.deleteTraces(gd, [0]).then(function() { + expect(countVisibleTraces(gd, modes)).toEqual(1); + + var trace = { + type: 'scattermapbox', + mode: 'markers+lines', + lon: [-10, -20, -10], + lat: [-10, 20, -10] + }; + + return Plotly.addTraces(gd, [trace]); + }).then(function() { + expect(countVisibleTraces(gd, modes)).toEqual(2); + + var trace = { + type: 'scattermapbox', + mode: 'markers+lines', + lon: [10, 20, 10], + lat: [10, -20, 10] + }; + + return Plotly.addTraces(gd, [trace]); + }).then(function() { + expect(countVisibleTraces(gd, modes)).toEqual(3); + + return Plotly.deleteTraces(gd, [0, 1, 2]); + }).then(function() { + expect(gd._fullLayout.mapbox).toBeUndefined(); + + done(); + }); + }); + + it('should be able to restyle', function(done) { + function assertMarkerColor(expectations) { + return new Promise(function(resolve) { + setTimeout(function() { + var colors = getStyle(gd, 'circle', 'circle-color'); + + expectations.forEach(function(expected, i) { + expect(colors[i]).toBeCloseToArray(expected); + }); + + resolve(); + }, TRANSITION_DELAY); + }); + } + + assertMarkerColor([ + [0.121, 0.466, 0.705, 1], + [1, 0.498, 0.0549, 1] + ]) + .then(function() { + return Plotly.restyle(gd, 'marker.color', 'green'); + }) + .then(function() { + return assertMarkerColor([ + [0, 0.5019, 0, 1], + [0, 0.5019, 0, 1] + ]); + }) + .then(function() { + return Plotly.restyle(gd, 'marker.color', 'red', [1]); + }) + .then(function() { + return assertMarkerColor([ + [0, 0.5019, 0, 1], + [1, 0, 0, 1] + ]); + }) + .then(done); + }); + + it('should be able to relayout', function(done) { + function assertLayout(style, center, zoom, dims) { + var mapInfo = getMapInfo(gd); + + expect(mapInfo.style.name).toEqual(style); + expect([mapInfo.center.lng, mapInfo.center.lat]) + .toBeCloseToArray(center); + expect(mapInfo.zoom).toBeCloseTo(zoom); + + var divStyle = mapInfo.div.style; + var expectedDims = ['left', 'top', 'width', 'height'].map(function(p) { + return parseFloat(divStyle[p]); + }); + + expect(expectedDims).toBeCloseToArray(dims); + } + + assertLayout('Mapbox Dark', [-4.710, 19.475], 1.234, [80, 100, 908, 270]); + + Plotly.relayout(gd, 'mapbox.center', { lon: 0, lat: 0 }).then(function() { + assertLayout('Mapbox Dark', [0, 0], 1.234, [80, 100, 908, 270]); + + return Plotly.relayout(gd, 'mapbox.zoom', '6'); + }).then(function() { + assertLayout('Mapbox Dark', [0, 0], 6, [80, 100, 908, 270]); + + return Plotly.relayout(gd, 'mapbox.style', 'light'); + }).then(function() { + assertLayout('Mapbox Light', [0, 0], 6, [80, 100, 908, 270]); + + return Plotly.relayout(gd, 'mapbox.domain.x', [0, 0.5]); + }).then(function() { + assertLayout('Mapbox Light', [0, 0], 6, [80, 100, 454, 270]); + + return Plotly.relayout(gd, 'mapbox.domain.y[0]', 0.5); + }).then(function() { + assertLayout('Mapbox Light', [0, 0], 6, [80, 100, 454, 135]); + + done(); + }); + }); + + it('should be able to add, update and remove layers', function(done) { + var mockWithLayers = require('@mocks/mapbox_layers'); + + var layer0 = Lib.extendDeep({}, mockWithLayers.layout.mapbox.layers[0]), + layer1 = Lib.extendDeep({}, mockWithLayers.layout.mapbox.layers[1]); + + var mapUpdate = { + 'mapbox.zoom': mockWithLayers.layout.mapbox.zoom, + 'mapbox.center.lon': mockWithLayers.layout.mapbox.center.lon, + 'mapbox.center.lat': mockWithLayers.layout.mapbox.center.lat + }; + + var styleUpdate0 = { + 'mapbox.layers[0].fillcolor': 'red', + 'mapbox.layers[0].line.color': 'blue', + 'mapbox.layers[0].opacity': 0.3 + }; + + var styleUpdate1 = { + 'mapbox.layers[1].line.width': 3, + 'mapbox.layers[1].line.color': 'blue', + 'mapbox.layers[1].opacity': 0.6 + }; + + function countVisibleLayers(gd) { + var mapInfo = getMapInfo(gd); + + var sourceLen = mapInfo.layoutSources.length, + layerLen = mapInfo.layoutLayers.length; + + if(sourceLen !== layerLen) return null; + + return layerLen; + } + + function assertLayerStyle(gd, expectations, index) { + var mapInfo = getMapInfo(gd), + layers = mapInfo.layers, + layerNames = mapInfo.layoutLayers; + + var layer = layers[layerNames[index]]; + + return new Promise(function(resolve) { + setTimeout(function() { + Object.keys(expectations).forEach(function(k) { + expect(layer.paint[k]).toEqual(expectations[k]); + }); + resolve(); + }, TRANSITION_DELAY); + }); + } + + expect(countVisibleLayers(gd)).toEqual(0); + + Plotly.relayout(gd, 'mapbox.layers[0]', layer0).then(function() { + expect(countVisibleLayers(gd)).toEqual(1); + + return Plotly.relayout(gd, 'mapbox.layers[1]', layer1); + }).then(function() { + expect(countVisibleLayers(gd)).toEqual(2); + + return Plotly.relayout(gd, mapUpdate); + }).then(function() { + expect(countVisibleLayers(gd)).toEqual(2); + + return Plotly.relayout(gd, styleUpdate0); + }).then(function() { + expect(countVisibleLayers(gd)).toEqual(2); + + return assertLayerStyle(gd, { + 'fill-color': [1, 0, 0, 1], + 'fill-outline-color': [0, 0, 1, 1], + 'fill-opacity': 0.3 + }, 0); + }).then(function() { + expect(countVisibleLayers(gd)).toEqual(2); + + return Plotly.relayout(gd, styleUpdate1); + }).then(function() { + expect(countVisibleLayers(gd)).toEqual(2); + + return assertLayerStyle(gd, { + 'line-width': 3, + 'line-color': [0, 0, 1, 1], + 'line-opacity': 0.6 + }, 1); + }).then(function() { + expect(countVisibleLayers(gd)).toEqual(2); + + return Plotly.relayout(gd, 'mapbox.layers[1]', 'remove'); + }).then(function() { + expect(countVisibleLayers(gd)).toEqual(1); + + return Plotly.relayout(gd, 'mapbox.layers[0]', 'remove'); + }).then(function() { + expect(countVisibleLayers(gd)).toEqual(0); + + done(); + }); + }); + + it('should be able to update traces', function(done) { + function assertDataPts(lengths) { + var lines = getGeoJsonData(gd, 'lines'), + markers = getGeoJsonData(gd, 'markers'); + + lines.forEach(function(obj, i) { + expect(obj.coordinates[0].length).toEqual(lengths[i]); + }); + + markers.forEach(function(obj, i) { + expect(obj.features.length).toEqual(lengths[i]); + }); + } + + assertDataPts([3, 3]); + + var update = { + lon: [[10, 20]], + lat: [[-45, -20]] + }; + + Plotly.restyle(gd, update, [1]).then(function() { + assertDataPts([3, 2]); + + var update = { + lon: [ [10, 20], [30, 40, 20] ], + lat: [ [-10, 20], [10, 20, 30] ] + }; + + return Plotly.extendTraces(gd, update, [0, 1]); + }).then(function() { + assertDataPts([5, 5]); + + done(); + }); + }); + + it('should display to hover labels on mouse over', function(done) { + function assertMouseMove(pos, len) { + return _mouseEvent('mousemove', pos, function() { + var hoverLabels = d3.select('.hoverlayer').selectAll('g'); + + expect(hoverLabels.size()).toEqual(len); + }); + } + + assertMouseMove(blankPos, 0).then(function() { + return assertMouseMove(pointPos, 1); + }).then(done); + }); + + it('should respond to hover interactions by', function(done) { + var hoverCnt = 0, + unhoverCnt = 0; + + var hoverData, unhoverData; + + gd.on('plotly_hover', function(eventData) { + hoverCnt++; + hoverData = eventData.points[0]; + }); + + gd.on('plotly_unhover', function(eventData) { + unhoverCnt++; + unhoverData = eventData.points[0]; + }); + + _mouseEvent('mousemove', blankPos, function() { + expect(hoverData).toBe(undefined, 'not firing on blank points'); + expect(unhoverData).toBe(undefined, 'not firing on blank points'); + }) + .then(function() { + return _mouseEvent('mousemove', pointPos, function() { + expect(hoverData).not.toBe(undefined, 'firing on data points'); + expect(Object.keys(hoverData)).toEqual([ + 'data', 'fullData', 'curveNumber', 'pointNumber', + 'x', 'y', 'xaxis', 'yaxis' + ], 'returning the correct event data keys'); + expect(hoverData.curveNumber).toEqual(0, 'returning the correct curve number'); + expect(hoverData.pointNumber).toEqual(0, 'returning the correct point number'); + }); + }) + .then(function() { + return _mouseEvent('mousemove', blankPos, function() { + expect(unhoverData).not.toBe(undefined, 'firing on data points'); + expect(Object.keys(unhoverData)).toEqual([ + 'data', 'fullData', 'curveNumber', 'pointNumber', + 'x', 'y', 'xaxis', 'yaxis' + ], 'returning the correct event data keys'); + expect(unhoverData.curveNumber).toEqual(0, 'returning the correct curve number'); + expect(unhoverData.pointNumber).toEqual(0, 'returning the correct point number'); + }); + }) + .then(function() { + expect(hoverCnt).toEqual(1); + expect(unhoverCnt).toEqual(1); + + done(); + }); + }); + + it('should respond to click interactions by', function(done) { + var ptData; + + gd.on('plotly_click', function(eventData) { + ptData = eventData.points[0]; + }); + + function _click(pos, cb) { + var promise = _mouseEvent('mousemove', pos, noop).then(function() { + return _mouseEvent('mousedown', pos, noop); + }).then(function() { + return _mouseEvent('click', pos, cb); + }); + + return promise; + } + + _click(blankPos, function() { + expect(ptData).toBe(undefined, 'not firing on blank points'); + }) + .then(function() { + return _click(pointPos, function() { + expect(ptData).not.toBe(undefined, 'firing on data points'); + expect(Object.keys(ptData)).toEqual([ + 'data', 'fullData', 'curveNumber', 'pointNumber', + 'x', 'y', 'xaxis', 'yaxis' + ], 'returning the correct event data keys'); + expect(ptData.curveNumber).toEqual(0, 'returning the correct curve number'); + expect(ptData.pointNumber).toEqual(0, 'returning the correct point number'); + }); + }) + .then(done); + }); + + it('should respond drag / scroll interactions', function(done) { + function _drag(p0, p1, cb) { + var promise = _mouseEvent('mousemove', p0, noop).then(function() { + return _mouseEvent('mousedown', p0, noop); + }).then(function() { + return _mouseEvent('mousemove', p1, noop); + }).then(function() { + return _mouseEvent('mouseup', p1, cb); + }); + + return promise; + } + + function assertLayout(center, zoom) { + var mapInfo = getMapInfo(gd), + layout = gd.layout.mapbox; + + expect([mapInfo.center.lng, mapInfo.center.lat]) + .toBeCloseToArray(center); + expect(mapInfo.zoom).toBeCloseTo(zoom); + + expect([layout.center.lon, layout.center.lat]) + .toBeCloseToArray(center); + expect(layout.zoom).toBeCloseTo(zoom); + } + + assertLayout([-4.710, 19.475], 1.234); + + var p1 = [pointPos[0] + 50, pointPos[1] - 20]; + + _drag(pointPos, p1, function() { + assertLayout([-19.651, 13.751], 1.234); + }) + .then(done); + + // TODO test scroll + + }); + + function getMapInfo(gd) { + var subplot = gd._fullLayout.mapbox._subplot, + map = subplot.map; + + var sources = map.style.sources, + layers = map.style._layers, + uid = subplot.uid; + + var traceSources = Object.keys(sources).filter(function(k) { + return k.indexOf('-source-') !== -1; + }); + + var traceLayers = Object.keys(layers).filter(function(k) { + return k.indexOf('-layer-') !== -1; + }); + + var layoutSources = Object.keys(sources).filter(function(k) { + return k.indexOf(uid) !== -1; + }); + + var layoutLayers = Object.keys(layers).filter(function(k) { + return k.indexOf(uid) !== -1; + }); + + return { + map: map, + div: subplot.div, + sources: sources, + layers: layers, + traceSources: traceSources, + traceLayers: traceLayers, + layoutSources: layoutSources, + layoutLayers: layoutLayers, + center: map.getCenter(), + zoom: map.getZoom(), + style: map.getStyle() + }; + } + + function countVisibleTraces(gd, modes) { + var mapInfo = getMapInfo(gd), + cnts = []; + + // 'modes' are the ScatterMapbox layers names + // e.g. 'fill', 'line', 'circle', 'symbol' + + modes.forEach(function(mode) { + var cntPerMode = 0; + + mapInfo.traceLayers.forEach(function(l) { + var info = mapInfo.layers[l]; + + if(l.indexOf(mode) === -1) return; + if(info.layout.visibility === 'visible') cntPerMode++; + }); + + cnts.push(cntPerMode); + }); + + var cnt = cnts.reduce(function(a, b) { + return (a === b) ? a : null; + }); + + // returns null if not all counter per mode are the same, + // returns the counter if all are the same. + + return cnt; + } + + function getStyle(gd, mode, prop) { + var mapInfo = getMapInfo(gd), + values = []; + + mapInfo.traceLayers.forEach(function(l) { + var info = mapInfo.layers[l]; + + if(l.indexOf(mode) === -1) return; + + values.push(info.paint[prop]); + }); + + return values; + } + + function getGeoJsonData(gd, mode) { + var mapInfo = getMapInfo(gd), + out = []; + + mapInfo.traceSources.forEach(function(s) { + var info = mapInfo.sources[s]; + + if(s.indexOf(mode) === -1) return; + + out.push(info._data); + }); + + return out; + } + + function _mouseEvent(type, pos, cb) { + var DELAY = 100; + + return new Promise(function(resolve) { + mouseEvent(type, pos[0], pos[1]); + + setTimeout(function() { + cb(); + resolve(); + }, DELAY); + }); + } + +}); From 9255ca17bc7db673193024150b416e07af194307 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89tienne=20T=C3=A9treault-Pinard?= Date: Fri, 10 Jun 2016 15:39:53 -0400 Subject: [PATCH 11/24] add tests for the scattermapbox trace module --- test/jasmine/tests/scattermapbox_test.js | 523 +++++++++++++++++++++++ 1 file changed, 523 insertions(+) create mode 100644 test/jasmine/tests/scattermapbox_test.js diff --git a/test/jasmine/tests/scattermapbox_test.js b/test/jasmine/tests/scattermapbox_test.js new file mode 100644 index 00000000000..1c7d83c92b9 --- /dev/null +++ b/test/jasmine/tests/scattermapbox_test.js @@ -0,0 +1,523 @@ +var Plotly = require('@lib'); +var Plots = require('@src/plots/plots'); +var Lib = require('@src/lib'); + +var ScatterMapbox = require('@src/traces/scattermapbox'); +var convert = require('@src/traces/scattermapbox/convert'); + +var createGraphDiv = require('../assets/create_graph_div'); +var destroyGraphDiv = require('../assets/destroy_graph_div'); +var customMatchers = require('../assets/custom_matchers'); + +Plotly.setPlotConfig({ + mapboxAccessToken: require('@build/credentials.json').MAPBOX_ACCESS_TOKEN +}); + + +describe('scattermapbox defaults', function() { + 'use strict'; + + function _supply(traceIn) { + var traceOut = { visible: true }, + defaultColor = '#444', + layout = { _dataLength: 1 }; + + ScatterMapbox.supplyDefaults(traceIn, traceOut, defaultColor, layout); + + return traceOut; + } + + it('should truncate \'lon\' if longer than \'lat\'', function() { + var fullTrace = _supply({ + lon: [1, 2, 3], + lat: [2, 3] + }); + + expect(fullTrace.lon).toEqual([1, 2]); + expect(fullTrace.lat).toEqual([2, 3]); + }); + + it('should truncate \'lat\' if longer than \'lon\'', function() { + var fullTrace = _supply({ + lon: [1, 2, 3], + lat: [2, 3, 3, 5] + }); + + expect(fullTrace.lon).toEqual([1, 2, 3]); + expect(fullTrace.lat).toEqual([2, 3, 3]); + }); + + it('should set \'visible\' to false if \'lat\' and/or \'lon\' has zero length', function() { + var fullTrace = _supply({ + lon: [1, 2, 3], + lat: [] + }); + + expect(fullTrace.visible).toEqual(false); + + fullTrace = _supply({ + lon: null, + lat: [1, 2, 3] + }); + + expect(fullTrace.visible).toEqual(false); + }); + + it('should set \'marker.color\' and \'marker.size\' to first item if symbol is set to \'circle\'', function() { + var base = { + mode: 'markers', + lon: [1, 2, 3], + lat: [2, 3, 3], + marker: { + color: ['red', 'green', 'blue'], + size: [10, 20, 30] + } + }; + + var fullTrace = _supply(Lib.extendDeep({}, base, { + marker: { symbol: 'monument' } + })); + + expect(fullTrace.marker.color).toEqual('red'); + expect(fullTrace.marker.size).toEqual(10); + + fullTrace = _supply(Lib.extendDeep({}, base, { + marker: { symbol: ['monument', 'music', 'harbor'] } + })); + + expect(fullTrace.marker.color).toEqual('red'); + expect(fullTrace.marker.size).toEqual(10); + + fullTrace = _supply(Lib.extendDeep({}, base, { + marker: { symbol: 'circle' } + })); + + expect(fullTrace.marker.color).toEqual(['red', 'green', 'blue']); + expect(fullTrace.marker.size).toEqual([10, 20, 30]); + }); +}); + +describe('scattermapbox calc', function() { + 'use strict'; + + function _calc(trace) { + var gd = { data: [trace] }; + + Plots.supplyDefaults(gd); + + var fullTrace = gd._fullData[0]; + return ScatterMapbox.calc(gd, fullTrace); + } + + var base = { type: 'scattermapbox' }; + + it('should place lon/lat data in lonlat pairs', function() { + var calcTrace = _calc(Lib.extendFlat({}, base, { + lon: [10, 20, 30], + lat: [20, 30, 10] + })); + + expect(calcTrace).toEqual([ + { lonlat: [10, 20] }, + { lonlat: [20, 30] }, + { lonlat: [30, 10] } + ]); + }); + + it('should coerce numeric strings lon/lat data into numbers', function() { + var calcTrace = _calc(Lib.extendFlat({}, base, { + lon: [10, 20, '30', '40'], + lat: [20, '30', 10, '50'] + })); + + expect(calcTrace).toEqual([ + { lonlat: [10, 20] }, + { lonlat: [20, 30] }, + { lonlat: [30, 10] }, + { lonlat: [40, 50] } + ]); + }); + + it('should keep track of gaps in data', function() { + var calcTrace = _calc(Lib.extendFlat({}, base, { + lon: [null, 10, null, null, 20, '30', null, '40', null, 10], + lat: [10, 20, '30', null, 10, '50', null, 60, null, null] + })); + + expect(calcTrace).toEqual([ + { lonlat: [10, 20], gapAfter: true }, + { lonlat: [20, 10] }, + { lonlat: [30, 50], gapAfter: true }, + { lonlat: [40, 60], gapAfter: true } + ]); + }); + + it('should fill array text (base case)', function() { + var calcTrace = _calc(Lib.extendFlat({}, base, { + lon: [10, 20, 30], + lat: [20, 30, 10], + text: ['A', 'B', 'C'] + })); + + expect(calcTrace).toEqual([ + { lonlat: [10, 20], tx: 'A' }, + { lonlat: [20, 30], tx: 'B' }, + { lonlat: [30, 10], tx: 'C' } + ]); + }); + + it('should fill array text (invalid entry case)', function() { + var calcTrace = _calc(Lib.extendFlat({}, base, { + lon: [10, 20, 30], + lat: [20, 30, 10], + text: ['A', 'B', null] + })); + + expect(calcTrace).toEqual([ + { lonlat: [10, 20], tx: 'A' }, + { lonlat: [20, 30], tx: 'B' }, + { lonlat: [30, 10], tx: '' } + ]); + }); + + it('should fill array marker attributes (base case)', function() { + var calcTrace = _calc(Lib.extendFlat({}, base, { + lon: [10, 20, null, 30], + lat: [20, 30, null, 10], + marker: { + color: ['red', 'blue', 'green', 'yellow'], + size: [10, 20, 8, 10] + } + })); + + expect(calcTrace).toEqual([ + { lonlat: [10, 20], mc: 'red', ms: 10, mcc: 'red', mrc: 5 }, + { lonlat: [20, 30], mc: 'blue', ms: 20, mcc: 'blue', mrc: 10, gapAfter: true }, + { lonlat: [30, 10], mc: 'yellow', ms: 10, mcc: 'yellow', mrc: 5 } + ]); + }); + + it('should fill array marker attributes (invalid scale case)', function() { + var calcTrace = _calc(Lib.extendFlat({}, base, { + lon: [10, 20, null, 30], + lat: [20, 30, null, 10], + marker: { + color: [0, null, 5, 10], + size: [10, NaN, 8, 10], + colorscale: [ + [0, 'blue'], [0.5, 'red'], [1, 'green'] + ] + } + })); + + expect(calcTrace).toEqual([ + { lonlat: [10, 20], mc: 0, ms: 10, mcc: 'rgb(0, 0, 255)', mrc: 5 }, + { lonlat: [20, 30], mc: null, ms: NaN, mcc: '#444', mrc: 0, gapAfter: true }, + { lonlat: [30, 10], mc: 10, ms: 10, mcc: 'rgb(0, 128, 0)', mrc: 5 } + ]); + }); + + it('should fill marker attributes (symbol case)', function() { + var calcTrace = _calc(Lib.extendFlat({}, base, { + lon: [10, 20, null, 30], + lat: [20, 30, null, 10], + marker: { + symbol: ['monument', 'music', 'harbor', null] + } + })); + + expect(calcTrace).toEqual([ + { lonlat: [10, 20], mx: 'monument' }, + { lonlat: [20, 30], mx: 'music', gapAfter: true }, + { lonlat: [30, 10], mx: 'circle' } + ]); + }); +}); + +describe('scattermapbox convert', function() { + 'use strict'; + + function _convert(trace) { + var gd = { data: [trace] }; + + Plots.supplyDefaults(gd); + + var fullTrace = gd._fullData[0]; + var calcTrace = ScatterMapbox.calc(gd, fullTrace); + calcTrace[0].trace = fullTrace; + + return convert(calcTrace); + } + + var base = { + type: 'scattermapbox', + lon: [10, '20', 30, 20, null, 20, 10], + lat: [20, 20, '10', null, 10, 10, 20] + }; + + it('for markers + circle bubbles traces, should', function() { + var opts = _convert(Lib.extendFlat({}, base, { + mode: 'markers', + marker: { + symbol: 'circle', + size: [10, 20, null, 10, '10'], + color: [10, null, '30', 20, 10] + } + })); + + assertVisibility(opts, ['none', 'none', 'visible', 'none']); + + expect(opts.circle.paint['circle-color']).toEqual({ + property: 'circle-color', + stops: [ + [0, 'rgb(220, 220, 220)'], [1, '#444'], [2, 'rgb(178, 10, 28)'] + ] + }, 'have correct circle-color stops'); + + expect(opts.circle.paint['circle-radius']).toEqual({ + property: 'circle-radius', + stops: [ [0, 5], [1, 10], [2, 0] ] + }, 'have correct circle-radius stops'); + + var circleProps = opts.circle.geojson.features.map(function(f) { + return f.properties; + }); + + // N.B repeated values have same geojson props + expect(circleProps).toEqual([ + { 'circle-color': 0, 'circle-radius': 0 }, + { 'circle-color': 1, 'circle-radius': 1 }, + { 'circle-color': 2, 'circle-radius': 2 }, + { 'circle-color': 1, 'circle-radius': 2 }, + { 'circle-color': 1, 'circle-radius': 2 } + ], 'have correct geojson feature properties'); + }); + + it('fill + markers + lines traces, should', function() { + var opts = _convert(Lib.extendFlat({}, base, { + mode: 'markers+lines', + marker: { symbol: 'circle' }, + fill: 'toself' + })); + + assertVisibility(opts, ['visible', 'visible', 'visible', 'none']); + + var lineCoords = [[ + [10, 20], [20, 20], [30, 10] + ], [ + [20, 10], [10, 20] + ]]; + + expect(opts.fill.geojson.coordinates).toEqual(lineCoords, 'have correct fill coords'); + expect(opts.line.geojson.coordinates).toEqual(lineCoords, 'have correct line coords'); + + var circleCoords = opts.circle.geojson.features.map(function(f) { + return f.geometry.coordinates; + }); + + expect(circleCoords).toEqual([ + [10, 20], [20, 20], [30, 10], [20, 10], [10, 20] + ], 'have correct circle coords'); + }); + + it('for markers + non-circle traces, should', function() { + var opts = _convert(Lib.extendFlat({}, base, { + mode: 'markers', + marker: { symbol: 'monument' } + })); + + assertVisibility(opts, ['none', 'none', 'none', 'visible']); + + var symbolProps = opts.symbol.geojson.features.map(function(f) { + return [f.properties.symbol, f.properties.text]; + }); + + var expected = opts.symbol.geojson.features.map(function() { + return ['monument', '']; + }); + + expect(symbolProps).toEqual(expected, 'have correct geojson properties'); + }); + + it('for text + lines traces, should', function() { + var opts = _convert(Lib.extendFlat({}, base, { + mode: 'lines+text', + connectgaps: true, + text: ['A', 'B', 'C', 'D', 'E', 'F'] + })); + + assertVisibility(opts, ['none', 'visible', 'none', 'visible']); + + var lineCoords = [[ + [10, 20], [20, 20], [30, 10], [20, 10], [10, 20] + ]]; + + expect(opts.line.geojson.coordinates).toEqual(lineCoords, 'have correct line coords'); + + var actualText = opts.symbol.geojson.features.map(function(f) { + return f.properties.text; + }); + + expect(actualText).toEqual(['A', 'B', 'C', 'F', '']); + }); + + it('should correctly convert \'textposition\' to \'text-anchor\' and \'text-offset\'', function() { + var specs = { + 'top left': ['top-right', [-1.5, -2.5]], + 'top center': ['top', [0, -2.5]], + 'top right': ['top-left', [1.5, -2.5]], + 'middle left': ['right', [-1.5, 0]], + 'middle center': ['center', [0, 0]], + 'middle right': ['left', [1.5, 0]], + 'bottom left': ['bottom-right', [-1.5, 2.5]], + 'bottom center': ['bottom', [0, 2.5]], + 'bottom right': ['bottom-left', [1.5, 2.5]] + }; + + Object.keys(specs).forEach(function(k) { + var spec = specs[k]; + + var opts = _convert(Lib.extendFlat({}, base, { + textposition: k, + mode: 'text+markers', + marker: { size: 15 }, + text: ['A', 'B', 'C'] + })); + + expect([ + opts.symbol.layout['text-anchor'], + opts.symbol.layout['text-offset'] + ]).toEqual(spec, '(case ' + k + ')'); + }); + }); + + function assertVisibility(opts, expectations) { + var actual = ['fill', 'line', 'circle', 'symbol'].map(function(l) { + return opts[l].layout.visibility; + }); + + var msg = 'set layer visibility properly'; + + expect(actual).toEqual(expectations, msg); + } +}); + +describe('scattermapbox hover', function() { + 'use strict'; + + var hoverPoints = ScatterMapbox.hoverPoints; + + var gd; + + beforeAll(function(done) { + jasmine.addMatchers(customMatchers); + + gd = createGraphDiv(); + + var data = [{ + type: 'scattermapbox', + lon: [10, 20, 30], + lat: [10, 20, 30], + text: ['A', 'B', 'C'] + }]; + + Plotly.plot(gd, data, { autosize: true }).then(done); + }); + + afterAll(function() { + Plotly.purge(gd); + destroyGraphDiv(); + }); + + function getPointData(gd) { + var cd = gd.calcdata, + mapbox = gd._fullLayout.mapbox._subplot; + + return { + index: false, + distance: 20, + cd: cd[0], + trace: cd[0][0].trace, + xa: mapbox.xaxis, + ya: mapbox.yaxis + }; + } + + it('should generate hover label info (base case)', function() { + var xval = 11, + yval = 11; + + var out = hoverPoints(getPointData(gd), xval, yval)[0]; + + expect(out.index).toEqual(0); + expect([out.x0, out.x1, out.y0, out.y1]).toBeCloseToArray([ + 444.444, 446.444, 105.410, 107.410 + ]); + expect(out.extraText).toEqual('(10°, 10°)
A'); + expect(out.color).toEqual('#1f77b4'); + }); + + it('should generate hover label info (positive winding case)', function() { + var xval = 11 + 720, + yval = 11; + + var out = hoverPoints(getPointData(gd), xval, yval)[0]; + + expect(out.index).toEqual(0); + expect([out.x0, out.x1, out.y0, out.y1]).toBeCloseToArray([ + 2492.444, 2494.444, 105.410, 107.410 + ]); + expect(out.extraText).toEqual('(10°, 10°)
A'); + expect(out.color).toEqual('#1f77b4'); + }); + + it('should generate hover label info (negative winding case)', function() { + var xval = 11 - 1080, + yval = 11; + + var out = hoverPoints(getPointData(gd), xval, yval)[0]; + + expect(out.index).toEqual(0); + expect([out.x0, out.x1, out.y0, out.y1]).toBeCloseToArray([ + -2627.555, -2625.555, 105.410, 107.410 + ]); + expect(out.extraText).toEqual('(10°, 10°)
A'); + expect(out.color).toEqual('#1f77b4'); + }); + + it('should generate hover label info (hoverinfo: \'lon\' case)', function(done) { + Plotly.restyle(gd, 'hoverinfo', 'lon').then(function() { + var xval = 11, + yval = 11; + + var out = hoverPoints(getPointData(gd), xval, yval)[0]; + + expect(out.extraText).toEqual('lon: 10°'); + done(); + }); + }); + + it('should generate hover label info (hoverinfo: \'lat\' case)', function(done) { + Plotly.restyle(gd, 'hoverinfo', 'lat').then(function() { + var xval = 11, + yval = 11; + + var out = hoverPoints(getPointData(gd), xval, yval)[0]; + + expect(out.extraText).toEqual('lat: 10°'); + done(); + }); + }); + + it('should generate hover label info (hoverinfo: \'text\' case)', function(done) { + Plotly.restyle(gd, 'hoverinfo', 'text').then(function() { + var xval = 11, + yval = 11; + + var out = hoverPoints(getPointData(gd), xval, yval)[0]; + + expect(out.extraText).toEqual('A'); + done(); + }); + }); +}); From b6e473487d2306bb26fdd43a71138c4519df7eaf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89tienne=20T=C3=A9treault-Pinard?= Date: Fri, 10 Jun 2016 15:40:59 -0400 Subject: [PATCH 12/24] exclude mapbox jasmine tests on CircleCI, - as FF launched by karma can't create a webgl context on CircleCI. --- test/jasmine/karma.ciconf.js | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/test/jasmine/karma.ciconf.js b/test/jasmine/karma.ciconf.js index e735ef639ad..38f63ccac97 100644 --- a/test/jasmine/karma.ciconf.js +++ b/test/jasmine/karma.ciconf.js @@ -17,7 +17,9 @@ function func(config) { func.defaultConfig.exclude = [ 'tests/gl_plot_interact_test.js', 'tests/gl_plot_interact_basic_test.js', - 'tests/gl2d_scatterplot_contour_test.js' + 'tests/gl2d_scatterplot_contour_test.js', + 'tests/mapbox_test.js', + 'tests/scattermapbox_test.js' ]; // if true, Karma captures browsers, runs the tests and exits From 7167a9fe7f3f5feaa1028fda9bce41903acb63a9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89tienne=20T=C3=A9treault-Pinard?= Date: Fri, 10 Jun 2016 15:41:19 -0400 Subject: [PATCH 13/24] add mapbox image tests --- test/image/baselines/mapbox_0.png | Bin 0 -> 86646 bytes test/image/baselines/mapbox_angles.png | Bin 0 -> 127885 bytes test/image/baselines/mapbox_bubbles.png | Bin 0 -> 59410 bytes test/image/baselines/mapbox_connectgaps.png | Bin 0 -> 105638 bytes test/image/baselines/mapbox_custom-style.png | Bin 0 -> 274134 bytes test/image/baselines/mapbox_fill.png | Bin 0 -> 49406 bytes test/image/baselines/mapbox_layers.png | Bin 0 -> 229849 bytes test/image/baselines/mapbox_symbol-text.png | Bin 0 -> 66671 bytes test/image/mocks/mapbox_0.json | 53 ++ test/image/mocks/mapbox_angles.json | 90 +++ test/image/mocks/mapbox_bubbles.json | 85 +++ test/image/mocks/mapbox_connectgaps.json | 70 +++ test/image/mocks/mapbox_custom-style.json | 70 +++ test/image/mocks/mapbox_fill.json | 102 ++++ test/image/mocks/mapbox_layers.json | 553 +++++++++++++++++++ test/image/mocks/mapbox_symbol-text.json | 70 +++ 16 files changed, 1093 insertions(+) create mode 100644 test/image/baselines/mapbox_0.png create mode 100644 test/image/baselines/mapbox_angles.png create mode 100644 test/image/baselines/mapbox_bubbles.png create mode 100644 test/image/baselines/mapbox_connectgaps.png create mode 100644 test/image/baselines/mapbox_custom-style.png create mode 100644 test/image/baselines/mapbox_fill.png create mode 100644 test/image/baselines/mapbox_layers.png create mode 100644 test/image/baselines/mapbox_symbol-text.png create mode 100644 test/image/mocks/mapbox_0.json create mode 100644 test/image/mocks/mapbox_angles.json create mode 100644 test/image/mocks/mapbox_bubbles.json create mode 100644 test/image/mocks/mapbox_connectgaps.json create mode 100644 test/image/mocks/mapbox_custom-style.json create mode 100644 test/image/mocks/mapbox_fill.json create mode 100644 test/image/mocks/mapbox_layers.json create mode 100644 test/image/mocks/mapbox_symbol-text.json diff --git a/test/image/baselines/mapbox_0.png b/test/image/baselines/mapbox_0.png new file mode 100644 index 0000000000000000000000000000000000000000..9b869bac3ecd70dab0ea6a5696d6f6207bee582d GIT binary patch literal 86646 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 literal 0 HcmV?d00001 diff --git a/test/image/baselines/mapbox_angles.png b/test/image/baselines/mapbox_angles.png new file mode 100644 index 0000000000000000000000000000000000000000..a3c0606f57b40bdb44f605ad55f64f862d7d2666 GIT binary patch literal 127885 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�Y6$#Ki@%@T~&{iMb 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 I|Jncl0IF(4VgLXD literal 0 HcmV?d00001 diff --git a/test/image/baselines/mapbox_bubbles.png b/test/image/baselines/mapbox_bubbles.png new file mode 100644 index 0000000000000000000000000000000000000000..11b5e21aa7096ab3c2c1a497f74233878d8b2e5c GIT binary patch literal 59410 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 N*S>r%|Eyi;e*su;^WFde literal 0 HcmV?d00001 diff --git a/test/image/baselines/mapbox_connectgaps.png b/test/image/baselines/mapbox_connectgaps.png new file mode 100644 index 0000000000000000000000000000000000000000..9fee51670db2662b033f64b13a997d8957bf2807 GIT binary patch literal 105638 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 literal 0 HcmV?d00001 diff --git a/test/image/baselines/mapbox_custom-style.png b/test/image/baselines/mapbox_custom-style.png new file mode 100644 index 0000000000000000000000000000000000000000..ba20f14f01e6a260b76cd60b672df23e32ab8d6d GIT binary patch literal 274134 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