diff --git a/lib/index.js b/lib/index.js index 8c1b11fff73..f287b9533b8 100644 --- a/lib/index.js +++ b/lib/index.js @@ -34,6 +34,7 @@ Plotly.register([ require('./pointcloud'), require('./heatmapgl'), require('./parcoords'), + require('./table'), require('./scattermapbox'), diff --git a/lib/table.js b/lib/table.js new file mode 100644 index 00000000000..96a16d9f31c --- /dev/null +++ b/lib/table.js @@ -0,0 +1,11 @@ +/** +* Copyright 2012-2017, 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 = require('../src/traces/table'); diff --git a/src/lib/gup.js b/src/lib/gup.js new file mode 100644 index 00000000000..1090252c7f3 --- /dev/null +++ b/src/lib/gup.js @@ -0,0 +1,34 @@ +/** +* Copyright 2012-2017, 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 identity = require('./identity'); + +function wrap(d) {return [d];} + +module.exports = { + + // The D3 data binding concept and the General Update Pattern promotes the idea of + // traversing into the scenegraph by using the `.data(fun, keyFun)` call. + // The `fun` is most often a `repeat`, ie. the elements beneath a `` element need + // access to the same data, or a `descend`, which fans a scenegraph node into a bunch of + // of elements, e.g. points, lines, rows, requiring an array as input. + // The role of the `keyFun` is to identify what elements are being entered/exited/updated, + // otherwise D3 reverts to using a plain index which would screw up `transition`s. + keyFun: function(d) {return d.key;}, + repeat: wrap, + descend: identity, + + // Plotly.js uses a convention of storing the actual contents of the `calcData` as the + // element zero of a container array. These helpers are just used for clarity as a + // newcomer to the codebase may not know what the `[0]` is, and whether there can be further + // elements (not atm). + wrap: wrap, + unwrap: function(d) {return d[0];} +}; diff --git a/src/lib/index.js b/src/lib/index.js index 25eff611e5c..03c3f1abb6d 100644 --- a/src/lib/index.js +++ b/src/lib/index.js @@ -135,6 +135,20 @@ lib.pauseEvent = function(e) { return false; }; +/** + * SVG painter's algo worked around with reinsertion + */ +lib.raiseToTop = function raiseToTop(elem) { + elem.parentNode.appendChild(elem); +}; + +/** + * cancel a possibly pending transition; returned selection may be used by caller + */ +lib.cancelTransition = function(selection) { + return selection.transition().duration(0); +}; + // constrain - restrict a number v to be between v0 and v1 lib.constrain = function(v, v0, v1) { if(v0 > v1) return Math.max(v1, Math.min(v0, v)); diff --git a/src/traces/parcoords/parcoords.js b/src/traces/parcoords/parcoords.js index 237ea08e384..4027c1ea7d2 100644 --- a/src/traces/parcoords/parcoords.js +++ b/src/traces/parcoords/parcoords.js @@ -89,7 +89,6 @@ function ordinalScale(dimension) { } function unitToColorScale(cscale) { - var colorStops = cscale.map(function(d) {return d[0];}); var colorStrings = cscale.map(function(d) {return d[1];}); var colorTuples = colorStrings.map(function(c) {return d3.rgb(c);}); diff --git a/src/traces/sankey/render.js b/src/traces/sankey/render.js index ba2e5eae09d..bf0151798b9 100644 --- a/src/traces/sankey/render.js +++ b/src/traces/sankey/render.js @@ -317,7 +317,7 @@ function attachDragHandler(sankeyNode, sankeyLink, callbacks) { .on('dragstart', function(d) { if(d.arrangement === 'fixed') return; - this.parentNode.appendChild(this); // bring element to top (painter's algo) + Lib.raiseToTop(this); d.interactionState.dragInProgress = d.node; saveCurrentDragPosition(d.node); if(d.interactionState.hovered) { diff --git a/src/traces/table/attributes.js b/src/traces/table/attributes.js new file mode 100644 index 00000000000..d3539862da2 --- /dev/null +++ b/src/traces/table/attributes.js @@ -0,0 +1,278 @@ +/** +* Copyright 2012-2017, 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 annAttrs = require('../../components/annotations/attributes'); +var extendFlat = require('../../lib/extend').extendFlat; + +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 `table` trace', + '(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 `table` trace', + '(in plot fraction).' + ].join(' ') + } + }, + + columnwidth: { + valType: 'number', + arrayOk: true, + dflt: null, + role: 'style', + description: 'The width of cells.' + }, + + columnorder: { + valType: 'data_array', + role: 'info', + description: [ + 'Specifies the rendered order of the data columns; for example, a value `2` at position `0`', + 'means that column index `0` in the data will be rendered as the', + 'third column, as columns have an index base of zero.' + ].join(' ') + }, + + header: { + + values: { + valType: 'data_array', + role: 'info', + dflt: [], + description: [ + 'Dimension values. `values[n]` represents the value of the `n`th point in the dataset,', + 'therefore the `values` vector for all dimensions must be the same (longer vectors', + 'will be truncated). Each value must be a finite number.' + ].join(' ') + }, + + format: { + valType: 'data_array', + role: 'info', + dflt: [], + description: [ + 'Sets the cell value formatting rule using d3 formatting mini-language', + 'which is similar to those of Python. See', + 'https://github.com/d3/d3-format/blob/master/README.md#locale_format' + ].join(' ') + }, + + prefix: { + valType: 'string', + arrayOk: true, + dflt: null, + role: 'style', + description: 'Prefix for cell values.' + }, + + suffix: { + valType: 'string', + arrayOk: true, + dflt: null, + role: 'style', + description: 'Suffix for cell values.' + }, + + height: { + valType: 'number', + dflt: 28, + role: 'style', + description: 'The height of cells.' + }, + + align: extendFlat({}, annAttrs.align, {arrayOk: true}), + valign: extendFlat({}, annAttrs.valign, {arrayOk: true}), + + line: { + width: { + valType: 'number', + arrayOk: true, + role: 'style' + }, + color: { + valType: 'color', + arrayOk: true, + role: 'style' + } + }, + + fill: { + color: { + valType: 'color', + arrayOk: true, + role: 'style', + description: [ + 'Sets the cell fill color. It accepts either a specific color', + ' or an array of colors.' + ].join('') + } + }, + + font: { + family: { + valType: 'string', + arrayOk: true, + role: 'style', + noBlank: true, + strict: true, + description: [ + 'HTML font family - the typeface that will be applied by the web browser.', + 'The web browser will only be able to apply a font if it is available on the system', + 'which it operates. Provide multiple font families, separated by commas, to indicate', + 'the preference in which to apply fonts if they aren\'t available on the system.', + 'The plotly service (at https://plot.ly or on-premise) generates images on a server,', + 'where only a select number of', + 'fonts are installed and supported.', + 'These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*,', + '*Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*,', + '*PT Sans Narrow*, *Raleway*, *Times New Roman*.' + ].join(' ') + }, + size: { + valType: 'number', + arrayOk: true, + role: 'style' + }, + color: { + valType: 'color', + arrayOk: true, + role: 'style' + } + } + }, + + cells: { + + values: { + valType: 'data_array', + role: 'info', + dflt: [], + description: [ + 'Dimension values. `values[n]` represents the value of the `n`th point in the dataset,', + 'therefore the `values` vector for all dimensions must be the same (longer vectors', + 'will be truncated). Each value must be a finite number.' + ].join(' ') + }, + + format: { + valType: 'data_array', + role: 'info', + dflt: [], + description: [ + 'Sets the cell value formatting rule using d3 formatting mini-language', + 'which is similar to those of Python. See', + 'https://github.com/d3/d3-format/blob/master/README.md#locale_format' + ].join(' ') + }, + + prefix: { + valType: 'string', + arrayOk: true, + dflt: null, + role: 'style', + description: 'Prefix for cell values.' + }, + + suffix: { + valType: 'string', + arrayOk: true, + dflt: null, + role: 'style', + description: 'Suffix for cell values.' + }, + + height: { + valType: 'number', + dflt: 20, + role: 'style', + description: 'The height of cells.' + }, + + align: extendFlat({}, annAttrs.align, {arrayOk: true}), + valign: extendFlat({}, annAttrs.valign, {arrayOk: true}), + + line: { + width: { + valType: 'number', + arrayOk: true, + role: 'style' + }, + color: { + valType: 'color', + arrayOk: true, + role: 'style' + } + }, + + fill: { + color: { + valType: 'color', + arrayOk: true, + role: 'style', + description: [ + 'Sets the cell fill color. It accepts either a specific color', + ' or an array of colors.' + ].join('') + } + }, + + font: { + family: { + valType: 'string', + arrayOk: true, + role: 'style', + noBlank: true, + strict: true, + description: [ + 'HTML font family - the typeface that will be applied by the web browser.', + 'The web browser will only be able to apply a font if it is available on the system', + 'which it operates. Provide multiple font families, separated by commas, to indicate', + 'the preference in which to apply fonts if they aren\'t available on the system.', + 'The plotly service (at https://plot.ly or on-premise) generates images on a server,', + 'where only a select number of', + 'fonts are installed and supported.', + 'These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*,', + '*Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*,', + '*PT Sans Narrow*, *Raleway*, *Times New Roman*.' + ].join(' ') + }, + size: { + valType: 'number', + arrayOk: true, + role: 'style' + }, + color: { + valType: 'color', + arrayOk: true, + role: 'style' + } + } + } +}; diff --git a/src/traces/table/base_plot.js b/src/traces/table/base_plot.js new file mode 100644 index 00000000000..c68e3de2dbd --- /dev/null +++ b/src/traces/table/base_plot.js @@ -0,0 +1,30 @@ +/** +* Copyright 2012-2017, 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 Plots = require('../../plots/plots'); +var tablePlot = require('./plot'); + +exports.name = 'table'; + +exports.attr = 'type'; + +exports.plot = function(gd) { + var calcData = Plots.getSubplotCalcData(gd.calcdata, 'table', 'table'); + if(calcData.length) tablePlot(gd, calcData); +}; + +exports.clean = function(newFullData, newFullLayout, oldFullData, oldFullLayout) { + var hadTable = (oldFullLayout._has && oldFullLayout._has('table')); + var hasTable = (newFullLayout._has && newFullLayout._has('table')); + + if(hadTable && !hasTable) { + oldFullLayout._paperdiv.selectAll('.table').remove(); + } +}; diff --git a/src/traces/table/calc.js b/src/traces/table/calc.js new file mode 100644 index 00000000000..a2fc81bb524 --- /dev/null +++ b/src/traces/table/calc.js @@ -0,0 +1,131 @@ +/** +* Copyright 2012-2017, 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 c = require('./constants'); +var wrap = require('../../lib/gup').wrap; +var extendFlat = require('../../lib/extend').extendFlat; + +module.exports = function calc(gd, trace) { + var domain = trace.domain; + var groupWidth = Math.floor(gd._fullLayout._size.w * (domain.x[1] - domain.x[0])); + var groupHeight = Math.floor(gd._fullLayout._size.h * (domain.y[1] - domain.y[0])); + var headerRowHeights = trace.header.values[0].map(function() {return trace.header.height;}); + var rowHeights = trace.cells.values[0].map(function() {return trace.cells.height;}); + var headerHeight = headerRowHeights.reduce(function(a, b) {return a + b;}, 0); + var scrollHeight = groupHeight - headerHeight; + var minimumFillHeight = scrollHeight + c.uplift; + var anchorToRowBlock = makeAnchorToRowBlock(rowHeights, minimumFillHeight); + var anchorToHeaderRowBlock = makeAnchorToRowBlock(headerRowHeights, headerHeight); + var headerRowBlocks = makeRowBlock(anchorToHeaderRowBlock, []); + var rowBlocks = makeRowBlock(anchorToRowBlock, headerRowBlocks); + var uniqueKeys = {}; + var columnOrder = trace._fullInput.columnorder; + var columnWidths = trace.header.values.map(function(d, i) { + return Array.isArray(trace.columnwidth) ? + trace.columnwidth[Math.min(i, trace.columnwidth.length - 1)] : + isFinite(trace.columnwidth) && trace.columnwidth !== null ? trace.columnwidth : 1; + }); + var totalColumnWidths = columnWidths.reduce(function(p, n) {return p + n;}, 0); + + // fit columns in the available vertical space as there's no vertical scrolling now + columnWidths = columnWidths.map(function(d) {return d / totalColumnWidths * groupWidth;}); + + var calcdata = { + key: trace.index, + translateX: domain.x[0] * gd._fullLayout._size.w, + translateY: gd._fullLayout._size.h - domain.y[1] * gd._fullLayout._size.h, + size: gd._fullLayout._size, + width: groupWidth, + height: groupHeight, + columnOrder: columnOrder, // will be mutated on column move, todo use in callback + groupHeight: groupHeight, + rowBlocks: rowBlocks, + headerRowBlocks: headerRowBlocks, + scrollY: 0, // will be mutated on scroll + cells: trace.cells, + headerCells: trace.header, + gdColumns: trace.header.values.map(function(d) {return d[0];}), + gdColumnsOriginalOrder: trace.header.values.map(function(d) {return d[0];}), + prevPages: [0, 0], + scrollbarState: {scrollbarScrollInProgress: false}, + columns: trace.header.values.map(function(label, i) { + var foundKey = uniqueKeys[label]; + uniqueKeys[label] = (foundKey || 0) + 1; + var key = label + '__' + uniqueKeys[label]; + return { + key: key, + label: label, + specIndex: i, + xIndex: columnOrder[i], + xScale: xScale, + x: undefined, // initialized below + calcdata: undefined, // initialized below + columnWidth: columnWidths[i] + }; + }) + }; + + calcdata.columns.forEach(function(col) { + col.calcdata = calcdata; + col.x = xScale(col); + }); + + return wrap(calcdata); +}; + +function xScale(d) { + return d.calcdata.columns.reduce(function(prev, next) { + return next.xIndex < d.xIndex ? prev + next.columnWidth : prev; + }, 0); +} + +function makeRowBlock(anchorToRowBlock, auxiliary) { + var blockAnchorKeys = Object.keys(anchorToRowBlock); + return blockAnchorKeys.map(function(k) {return extendFlat({}, anchorToRowBlock[k], {auxiliaryBlocks: auxiliary});}); +} + +function makeAnchorToRowBlock(rowHeights, minimumFillHeight) { + + var anchorToRowBlock = {}; + var currentRowHeight; + var currentAnchor = 0; + var currentBlockHeight = 0; + var currentBlock = makeIdentity(); + var currentFirstRowIndex = 0; + var blockCounter = 0; + for(var i = 0; i < rowHeights.length; i++) { + currentRowHeight = rowHeights[i]; + currentBlock.rows.push({ + rowIndex: i, + rowHeight: currentRowHeight + }); + currentBlockHeight += currentRowHeight; + if(currentBlockHeight >= minimumFillHeight || i === rowHeights.length - 1) { + anchorToRowBlock[currentAnchor] = currentBlock; + currentBlock.key = blockCounter++; + currentBlock.firstRowIndex = currentFirstRowIndex; + currentBlock.lastRowIndex = i; + currentBlock = makeIdentity(); + currentAnchor += currentBlockHeight; + currentFirstRowIndex = i + 1; + currentBlockHeight = 0; + } + } + + return anchorToRowBlock; +} + +function makeIdentity() { + return { + firstRowIndex: null, + lastRowIndex: null, + rows: [] + }; +} diff --git a/src/traces/table/constants.js b/src/traces/table/constants.js new file mode 100644 index 00000000000..9746babad1d --- /dev/null +++ b/src/traces/table/constants.js @@ -0,0 +1,33 @@ +/** +* Copyright 2012-2017, 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 = { + maxDimensionCount: 60, + overdrag: 45, + cellPad: 8, + latexCheck: /^\$.*\$$/, + wrapSplitCharacter: ' ', + wrapSpacer: ' ', + lineBreaker: '
', + uplift: 5, + goldenRatio: 1.618, + columnTitleOffset: 28, + columnExtentOffset: 10, + transitionEase: 'cubic-out', + transitionDuration: 100, + releaseTransitionEase: 'elastic', + releaseTransitionDuration: 300, + scrollbarWidth: 8, + scrollbarCaptureWidth: 18, + scrollbarOffset: 5, + scrollbarHideDelay: 1000, + scrollbarHideDuration: 1000, + clipView: false +}; diff --git a/src/traces/table/defaults.js b/src/traces/table/defaults.js new file mode 100644 index 00000000000..78ddd608a44 --- /dev/null +++ b/src/traces/table/defaults.js @@ -0,0 +1,66 @@ +/** +* Copyright 2012-2017, 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 attributes = require('./attributes'); + +function defaultColumnOrder(traceIn, coerce) { + var specifiedColumnOrder = traceIn.columnorder || []; + var commonLength = traceIn.header.values.length; + var truncated = specifiedColumnOrder.slice(0, commonLength); + var sorted = truncated.slice().sort(function(a, b) {return a - b;}); + var oneStepped = truncated.map(function(d) {return sorted.indexOf(d);}); + for(var i = oneStepped.length; i < commonLength; i++) { + oneStepped.push(i); + } + coerce('columnorder', oneStepped); +} + +module.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout) { + function coerce(attr, dflt) { + return Lib.coerce(traceIn, traceOut, attributes, attr, dflt); + } + + var fontDflt = { + family: layout.font.family, + size: layout.font.size, + color: layout.font.color + }; + + coerce('domain.x'); + coerce('domain.y'); + + coerce('columnwidth'); + defaultColumnOrder(traceIn, coerce); + + coerce('cells.values'); + coerce('cells.format'); + coerce('cells.align'); + coerce('cells.valign'); + coerce('cells.prefix'); + coerce('cells.suffix'); + coerce('cells.height'); + coerce('cells.line.width'); + coerce('cells.line.color'); + coerce('cells.fill.color'); + Lib.coerceFont(coerce, 'cells.font', fontDflt); + + coerce('header.values'); + coerce('header.format'); + coerce('header.align'); + coerce('header.valign'); + coerce('header.prefix'); + coerce('header.suffix'); + coerce('header.height'); + coerce('header.line.width'); + coerce('header.line.color'); + coerce('header.fill.color'); + Lib.coerceFont(coerce, 'header.font', fontDflt); +}; diff --git a/src/traces/table/index.js b/src/traces/table/index.js new file mode 100644 index 00000000000..16367c46537 --- /dev/null +++ b/src/traces/table/index.js @@ -0,0 +1,30 @@ +/** +* Copyright 2012-2017, 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 Table = {}; + +Table.attributes = require('./attributes'); +Table.supplyDefaults = require('./defaults'); +Table.calc = require('./calc'); +Table.plot = require('./plot'); + +Table.moduleType = 'trace'; +Table.name = 'table'; +Table.basePlotModule = require('./base_plot'); +Table.categories = []; +Table.meta = { + description: [ + 'Table view for multidimensional exploratory data analysis.', + 'The samples are specified in `dimensions`.', + 'The colors are set in `line.color`.' + ].join(' ') +}; + +module.exports = Table; diff --git a/src/traces/table/plot.js b/src/traces/table/plot.js new file mode 100644 index 00000000000..a98339dbc21 --- /dev/null +++ b/src/traces/table/plot.js @@ -0,0 +1,887 @@ +/** +* Copyright 2012-2017, 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 c = require('./constants'); +var d3 = require('d3'); +var gup = require('../../lib/gup'); +var Drawing = require('../../components/drawing'); +var extendFlat = require('../../lib/extend').extendFlat; +var svgUtil = require('../../lib/svg_text_utils'); +var raiseToTop = require('../../lib').raiseToTop; +var cancelEeaseColumn = require('../../lib').cancelTransition; + +module.exports = function plot(gd, calcdata) { + + if(c.clipView) { + gd._fullLayout._paper.attr('height', 2000); + } + + var table = gd._fullLayout._paper.selectAll('.table') + .data(calcdata.map(gup.unwrap), gup.keyFun); + + table.exit().remove(); + + table.enter() + .append('g') + .classed('table', true) + .attr('overflow', 'visible') + .style('box-sizing', 'content-box') + .style('position', 'absolute') + .style('left', 0) + .style('overflow', 'visible') + .style('shape-rendering', 'crispEdges') + .style('pointer-events', 'all'); // todo restore 'none' + + table + .attr('width', function(d) {return d.width + d.size.l + d.size.r;}) + .attr('height', function(d) {return d.height + d.size.t + d.size.b;}) + .attr('transform', function(d) { + return 'translate(' + d.translateX + ',' + d.translateY + ')'; + }); + + var tableControlView = table.selectAll('.tableControlView') + .data(gup.repeat, gup.keyFun); + + tableControlView.enter() + .append('g') + .classed('tableControlView', true) + .style('box-sizing', 'content-box') + .on('mousemove', function() {tableControlView.call(renderScrollbarKit, gd);}) + .on('mousewheel', function(d) { + if(d.scrollbarState.wheeling) return; + d.scrollbarState.wheeling = true; + d3.event.stopPropagation(); + d3.event.preventDefault(); + makeDragRow(gd, tableControlView, null, d.scrollY + d3.event.deltaY)(d); + d.scrollbarState.wheeling = false; + }) + .call(renderScrollbarKit, gd); + + tableControlView + .attr('transform', function(d) {return 'translate(' + d.size.l + ' ' + d.size.t + ')';}); + + if(!c.clipView) { + tableControlView.attr('clip-path', function(d) {return 'url(#scrollAreaBottomClip_' + d.key + ')';}); + } + + var yColumn = tableControlView.selectAll('.yColumn') + .data(function(vm) {return vm.columns;}, gup.keyFun); + + yColumn.enter() + .append('g') + .classed('yColumn', true); + + yColumn + .attr('transform', function(d) {return 'translate(' + d.x + ' 0)';}) + .call(d3.behavior.drag() + .origin(function(d) { + var movedColumn = d3.select(this); + easeColumn(movedColumn, d, -c.uplift); + raiseToTop(this); + d.calcdata.columnDragInProgress = true; + renderScrollbarKit(tableControlView, gd); + return d; + }) + .on('drag', function(d) { + var movedColumn = d3.select(this); + var getter = function(dd) {return (d === dd ? d3.event.x : dd.x) + dd.columnWidth / 2;}; + d.x = Math.max(-c.overdrag, Math.min(d.calcdata.width + c.overdrag - d.columnWidth, d3.event.x)); + var newOrder = yColumn.data().sort(function(a, b) {return getter(a) - getter(b);}); + newOrder.forEach(function(dd, i) { + dd.xIndex = i; + dd.x = d === dd ? dd.x : dd.xScale(dd); + }); + + yColumn.filter(function(dd) {return d !== dd;}) + .transition() + .ease(c.transitionEase) + .duration(c.transitionDuration) + .attr('transform', function(d) {return 'translate(' + d.x + ' 0)';}); + movedColumn + .call(cancelEeaseColumn) + .attr('transform', 'translate(' + d.x + ' -' + c.uplift + ' )'); + }) + .on('dragend', function(d) { + var movedColumn = d3.select(this); + var p = d.calcdata; + d.x = d.xScale(d); + d.calcdata.columnDragInProgress = false; + easeColumn(movedColumn, d, 0); + columnMoved(gd, calcdata, p.key, p.columns.map(function(dd) {return dd.xIndex;})); + }) + ); + + if(!c.clipView) { + yColumn.attr('clip-path', function(d) {return 'url(#columnBoundaryClippath_' + d.specIndex + ')';}); + } + + var columnBlock = yColumn.selectAll('.columnBlock') + .data(splitToPanels, gup.keyFun); + + columnBlock.enter() + .append('g') + .classed('columnBlock', true) + .attr('id', function(d) {return d.key;}) + .style('user-select', 'none'); + + columnBlock + .style('cursor', function(d) { + return d.dragHandle ? 'ew-resize' : d.calcdata.scrollbarState.barWiggleRoom ? 'ns-resize' : 'default'; + }); + + var cellsColumnBlock = columnBlock.filter(cellsBlock); + + cellsColumnBlock + .call(d3.behavior.drag() + .origin(function(d) { + d3.event.stopPropagation(); + return d; + }) + .on('drag', makeDragRow(gd, tableControlView, -1)) + .on('dragend', function() { + // fixme emit plotly notification + }) + ); + + // initial rendering: header is rendered first, as it may may have async LaTeX (show header first) + // but blocks are _entered_ the way they are due to painter's algo (header on top) + renderColumnCellTree(gd, tableControlView, columnBlock.filter(headerBlock), columnBlock); + renderColumnCellTree(gd, tableControlView, columnBlock.filter(cellsBlock), columnBlock); + + var scrollAreaClip = tableControlView.selectAll('.scrollAreaClip') + .data(gup.repeat, gup.keyFun); + + scrollAreaClip.enter() + .append(c.clipView ? 'g' : 'clipPath') + .classed('scrollAreaClip', true) + .attr('id', function(d) { return 'scrollAreaBottomClip_' + d.key;}); + + var scrollAreaClipRect = scrollAreaClip.selectAll('.scrollAreaClipRect') + .data(gup.repeat, gup.keyFun); + + scrollAreaClipRect.enter() + .append('rect') + .classed('scrollAreaClipRect', true) + .attr('x', -c.overdrag) + .attr('y', -c.uplift) + .attr('stroke', 'orange') + .attr('stroke-width', 2) + .attr('fill', 'none') + .style('pointer-events', 'stroke'); + + scrollAreaClipRect + .attr('width', function(d) {return d.width + 2 * c.overdrag;}) + .attr('height', function(d) {return d.height + c.uplift;}); + + var columnBoundary = yColumn.selectAll('.columnBoundary') + .data(gup.repeat, gup.keyFun); + + columnBoundary.enter() + .append('g') + .classed('columnBoundary', true); + + var columnBoundaryClippath = yColumn.selectAll('.columnBoundaryClippath') + .data(gup.repeat, gup.keyFun); + + // SVG spec doesn't mandate wrapping into a and doesn't seem to cause a speed difference + columnBoundaryClippath.enter() + .append(c.clipView ? 'g' : 'clipPath') + .classed('columnBoundaryClippath', true); + + columnBoundaryClippath + .attr('id', function(d) {return 'columnBoundaryClippath_' + d.specIndex;}); + + var columnBoundaryRect = columnBoundaryClippath.selectAll('.columnBoundaryRect') + .data(gup.repeat, gup.keyFun); + + columnBoundaryRect.enter() + .append('rect') + .classed('columnBoundaryRect', true) + .attr('fill', 'none') + .attr('stroke', 'magenta') + .attr('stroke-width', 2) + .style('pointer-events', 'stroke'); + + columnBoundaryRect + .attr('width', function(d) {return d.columnWidth;}) + .attr('height', function(d) {return d.calcdata.height + c.uplift;}); + + updateBlockYPosition(null, cellsColumnBlock, tableControlView); +}; + +function renderScrollbarKit(tableControlView, gd) { + + function calcTotalHeight(d) { + var blocks = d.rowBlocks; + return firstRowAnchor(blocks, blocks.length - 1) + rowsHeight(blocks[blocks.length - 1], Infinity); + } + + var scrollbarKit = tableControlView.selectAll('.scrollbarKit') + .data(gup.repeat, gup.keyFun); + + scrollbarKit.enter() + .append('g') + .classed('scrollbarKit', true); + + scrollbarKit + .each(function(d) { + var s = d.scrollbarState; + s.totalHeight = calcTotalHeight(d); + s.scrollableAreaHeight = d.groupHeight - headerHeight(d); + s.currentlyVisibleHeight = Math.min(s.totalHeight, s.scrollableAreaHeight); + s.ratio = s.currentlyVisibleHeight / s.totalHeight; + s.barLength = Math.max(s.ratio * s.currentlyVisibleHeight, c.goldenRatio * c.scrollbarWidth); + s.barWiggleRoom = s.currentlyVisibleHeight - s.barLength; + s.wiggleRoom = Math.max(0, s.totalHeight - s.scrollableAreaHeight); + s.topY = s.barWiggleRoom === 0 ? 0 : (d.scrollY / s.wiggleRoom) * s.barWiggleRoom; + s.bottomY = s.topY + s.barLength; + s.dragMultiplier = s.wiggleRoom / s.barWiggleRoom; + }) + .attr('transform', function(d) { + var xPosition = d.width + c.scrollbarWidth / 2 + c.scrollbarOffset; + return 'translate(' + xPosition + ' ' + headerHeight(d) + ')'; + }); + + var scrollbar = scrollbarKit.selectAll('.scrollbar') + .data(gup.repeat, gup.keyFun); + + scrollbar.enter() + .append('g') + .classed('scrollbar', true); + + var scrollbarSlider = scrollbar.selectAll('.scrollbarSlider') + .data(gup.repeat, gup.keyFun); + + scrollbarSlider.enter() + .append('g') + .classed('scrollbarSlider', true); + + scrollbarSlider + .attr('transform', function(d) { + return 'translate(0 ' + d.scrollbarState.topY + ')'; + }); + + var scrollbarGlyph = scrollbarSlider.selectAll('.scrollbarGlyph') + .data(gup.repeat, gup.keyFun); + + scrollbarGlyph.enter() + .append('line') + .classed('scrollbarGlyph', true) + .attr('stroke', 'black') + .attr('stroke-width', c.scrollbarWidth) + .attr('stroke-linecap', 'round') + .attr('y1', c.scrollbarWidth / 2); + + scrollbarGlyph + .attr('y2', function(d) { + return d.scrollbarState.barLength - c.scrollbarWidth / 2; + }) + .attr('stroke-opacity', function(d) { + return d.columnDragInProgress || !d.scrollbarState.barWiggleRoom ? 0 : 0.4; + }); + + // cancel transition: possible pending (also, delayed) transition + scrollbarGlyph + .transition().delay(0).duration(0); + + scrollbarGlyph + .transition().delay(c.scrollbarHideDelay).duration(c.scrollbarHideDuration) + .attr('stroke-opacity', 0); + + var scrollbarCaptureZone = scrollbar.selectAll('.scrollbarCaptureZone') + .data(gup.repeat, gup.keyFun); + + scrollbarCaptureZone.enter() + .append('line') + .classed('scrollbarCaptureZone', true) + .attr('stroke', 'red') + .attr('stroke-width', c.scrollbarCaptureWidth) + .attr('stroke-linecap', 'butt') + .attr('stroke-opacity', c.clipView ? 0.5 : 0) + .attr('y1', 0) + .on('mousedown', function(d) { + var y = d3.event.y; + var bbox = this.getBoundingClientRect(); + var s = d.scrollbarState; + var pixelVal = y - bbox.top; + var inverseScale = d3.scale.linear().domain([0, s.scrollableAreaHeight]).range([0, s.totalHeight]).clamp(true); + if(!(s.topY <= pixelVal && pixelVal <= s.bottomY)) { + makeDragRow(gd, tableControlView, null, inverseScale(pixelVal - s.barLength / 2))(d); + } + }) + .call(d3.behavior.drag() + .origin(function(d) { + d3.event.stopPropagation(); + d.scrollbarState.scrollbarScrollInProgress = true; + return d; + }) + .on('drag', makeDragRow(gd, tableControlView)) + .on('dragend', function() { + // fixme emit Plotly event + }) + ); + + scrollbarCaptureZone + .attr('y2', function(d) { + return d.scrollbarState.scrollableAreaHeight; + }); +} + +function renderColumnCellTree(gd, tableControlView, columnBlock, allColumnBlock) { + // fixme this perf hotspot + // this is performance critical code as scrolling calls it on every revolver switch + // it appears sufficiently fast but there are plenty of low-hanging fruits for performance optimization + + var columnCells = renderColumnCells(columnBlock); + + var columnCell = renderColumnCell(columnCells); + + setFont(columnCell); + + var cellRect = renderCellRect(columnCell); + + sizeAndStyleRect(cellRect); + + var cellTextHolder = renderCellTextHolder(columnCell); + + var cellText = renderCellText(cellTextHolder); + + populateCellText(cellText, tableControlView, allColumnBlock, gd); + + // doing this at the end when text, and text stlying are set + setCellHeightAndPositionY(columnCell); +} + +function renderColumnCells(columnBlock) { + + var columnCells = columnBlock.selectAll('.columnCells') + .data(gup.repeat, gup.keyFun); + + columnCells.enter() + .append('g') + .classed('columnCells', true); + + columnCells.exit() + .remove(); + + return columnCells; +} + +function renderColumnCell(columnCells) { + + var columnCell = columnCells.selectAll('.columnCell') + .data(splitToCells, function(d) {return d.keyWithinBlock;}); + + columnCell.enter() + .append('g') + .classed('columnCell', true); + + columnCell.exit() + .remove(); + + return columnCell; +} + +function renderCellRect(columnCell) { + + var cellRect = columnCell.selectAll('.cellRect') + .data(gup.repeat, function(d) {return d.keyWithinBlock;}); + + cellRect.enter() + .append('rect') + .classed('cellRect', true); + + return cellRect; +} + +function renderCellText(cellTextHolder) { + + var cellText = cellTextHolder.selectAll('.cellText') + .data(gup.repeat, function(d) {return d.keyWithinBlock;}); + + cellText.enter() + .append('text') + .classed('cellText', true); + + return cellText; +} + +function renderCellTextHolder(columnCell) { + + var cellTextHolder = columnCell.selectAll('.cellTextHolder') + .data(gup.repeat, function(d) {return d.keyWithinBlock;}); + + cellTextHolder.enter() + .append('g') + .classed('cellTextHolder', true); + + return cellTextHolder; +} + +function setFont(columnCell) { + columnCell + .each(function(d, i) { + var spec = d.calcdata.cells.font; + var col = d.column.specIndex; + var font = { + size: gridPick(spec.size, col, i), + color: gridPick(spec.color, col, i), + family: gridPick(spec.family, col, i) + }; + Drawing.font(d3.select(this), font); + + d.rowNumber = d.key; + d.align = gridPick(d.calcdata.cells.align, col, i); + d.valign = gridPick(d.calcdata.cells.valign, col, i); + d.cellBorderWidth = gridPick(d.calcdata.cells.line.width, col, i); + d.font = font; + }); +} + +function sizeAndStyleRect(cellRect) { + cellRect + .attr('width', function(d) {return d.column.columnWidth;}) + .attr('stroke-width', function(d) {return d.cellBorderWidth;}) + .attr('stroke', function(d) { + return c.clipView ? + ({header: 'blue', cells1: 'red', cells2: 'green'})[d.column.key] : + gridPick(d.calcdata.cells.line.color, d.column.specIndex, d.rowNumber); + }) + .attr('fill', function(d) { + return d.calcdata.cells.fill ? gridPick(d.calcdata.cells.fill.color, d.column.specIndex, d.rowNumber) : 'none'; + }); +} + +function populateCellText(cellText, tableControlView, allColumnBlock, gd) { + cellText + .text(function(d) { + var col = d.column.specIndex; + var row = d.rowNumber; + var userSuppliedContent = d.value; + var latex = isLatex(userSuppliedContent); + var userBrokenText = (typeof userSuppliedContent !== 'string') || userSuppliedContent.match(/
/i); + var userBrokenText2 = (typeof userSuppliedContent === 'string') && userSuppliedContent.match(/
/i); + var prefix = latex ? '' : gridPick(d.calcdata.cells.prefix, col, row) || ''; + var suffix = latex ? '' : gridPick(d.calcdata.cells.suffix, col, row) || ''; + var format = latex ? null : gridPick(d.calcdata.cells.format, col, row) || null; + var prefixSuffixedText = prefix + (format ? d3.format(format)(d.value) : d.value) + suffix; + d.latex = latex; + d.mayHaveMarkup = (typeof userSuppliedContent === 'string') && userSuppliedContent.match(/[<>]/); + var hasWrapSplitCharacter; + var hwsc = function(prefixSuffixedText) {return prefixSuffixedText.indexOf(c.wrapSplitCharacter) !== -1;}; + d.wrappingNeeded = !d.wrapped && !userBrokenText && !latex && (hasWrapSplitCharacter = hwsc(prefixSuffixedText)); + d.cellHeightMayIncrease = userBrokenText2 || latex || d.mayHaveMarkup || (hasWrapSplitCharacter === void(0) ? hwsc(prefixSuffixedText) : hasWrapSplitCharacter); + var textToRender; + if(d.wrappingNeeded) { + var hrefPreservedText = c.wrapSplitCharacter === ' ' ? prefixSuffixedText.replace(/]/) ? '_keybuster_' + Math.random() : ''; + return { + // keyWithinBlock: /*fromTo[0] + */i, // optimized future version - no busting + // keyWithinBlock: fromTo[0] + i, // initial always-unoptimized version - janky scrolling with 5+ columns + keyWithinBlock: i + buster, // current compromise: regular content is very fast; async content is possible + key: fromTo[0] + i, + column: d, + calcdata: d.calcdata, + page: d.page, + rowBlocks: d.rowBlocks, + value: v + }; + }); +} + +function rowFromTo(d) { + var rowBlock = d.rowBlocks[d.page]; + // fixme rowBlock truthiness check is due to ugly hack of placing 2nd panel as d.page = -1 + var rowFrom = rowBlock ? rowBlock.rows[0].rowIndex : 0; + var rowTo = rowBlock ? rowFrom + rowBlock.rows.length : 0; + return [rowFrom, rowTo]; +} + +function headerHeight(d) { + var headerBlocks = d.rowBlocks[0].auxiliaryBlocks; + return headerBlocks.reduce(function(p, n) {return p + rowsHeight(n, Infinity);}, 0); +} + +function findPagesAndCacheHeights(blocks, scrollY, scrollHeight) { + + var pages = []; + var pTop = 0; + + for(var blockIndex = 0; blockIndex < blocks.length; blockIndex++) { + + var block = blocks[blockIndex]; + var blockRows = block.rows; + var rowsHeight = 0; + for(var i = 0; i < blockRows.length; i++) { + rowsHeight += blockRows[i].rowHeight; + } + + // caching allRowsHeight on the block - it's safe as this function is always called from within the code part + // that handles increases to row heights + block.allRowsHeight = rowsHeight; + + var pBottom = pTop + rowsHeight; + var windowTop = scrollY; + var windowBottom = windowTop + scrollHeight; + if(windowTop < pBottom && windowBottom > pTop) { + pages.push(blockIndex); + } + pTop += rowsHeight; + + // consider this nice final optimization; put it in `for` condition - caveat, currently the + // block.allRowsHeight relies on being invalidated, so enabling this opt may not be safe + // if(pages.length > 1) break; + } + + return pages; +} + +function updateBlockYPosition(gd, cellsColumnBlock, tableControlView) { + // fixme this function is THE performance hotspot + var d = cellsColumnBlock[0][0].__data__; + var blocks = d.rowBlocks; + var calcdata = d.calcdata; + + var bottom = firstRowAnchor(blocks, blocks.length); + var scrollHeight = d.calcdata.groupHeight - headerHeight(d); + var scrollY = calcdata.scrollY = Math.max(0, Math.min(bottom - scrollHeight, calcdata.scrollY)); + + var pages = findPagesAndCacheHeights(blocks, scrollY, scrollHeight); + if(pages.length === 1) { + if(pages[0] === blocks.length - 1) { + pages.unshift(pages[0] - 1); + } else { + pages.push(pages[0] + 1); + } + } + + // make phased out page jump by 2 while leaving stationary page intact + if(pages[0] % 2) { + pages.reverse(); + } + + cellsColumnBlock + .each(function(d, i) { + // these values will also be needed when a block is translated again due to growing cell height + d.page = pages[i]; + d.scrollY = scrollY; + }); + + cellsColumnBlock + .attr('transform', function(d) { + var yTranslate = firstRowAnchor(d.rowBlocks, d.page) - d.scrollY; + return 'translate(0 ' + yTranslate + ')'; + }); + + // conditionally rerendering panel 0 and 1 + if(gd) { + conditionalPanelRerender(gd, tableControlView, cellsColumnBlock, pages, d.prevPages, d, 0); + conditionalPanelRerender(gd, tableControlView, cellsColumnBlock, pages, d.prevPages, d, 1); + renderScrollbarKit(tableControlView, gd); + } +} + +function makeDragRow(gd, tableControlView, optionalMultiplier, optionalPosition) { + return function dragRow() { + var d = tableControlView.node().__data__; + var multiplier = optionalMultiplier || d.scrollbarState.dragMultiplier; + d.scrollY = optionalPosition === void(0) ? d.scrollY + multiplier * d3.event.dy : optionalPosition; + var cellsColumnBlock = tableControlView.selectAll('.yColumn').selectAll('.columnBlock').filter(cellsBlock); + updateBlockYPosition(gd, cellsColumnBlock, tableControlView); + }; +} + +function conditionalPanelRerender(gd, tableControlView, cellsColumnBlock, pages, prevPages, d, revolverIndex) { + var shouldComponentUpdate = pages[revolverIndex] !== prevPages[revolverIndex]; + if(shouldComponentUpdate) { + window.clearTimeout(d.currentRepaint[revolverIndex]); + d.currentRepaint[revolverIndex] = window.setTimeout(function() { + // setTimeout might lag rendering but yields a smoother scroll, because fast scrolling makes + // some repaints invisible ie. wasteful (DOM work blocks the main thread) + var toRerender = cellsColumnBlock.filter(function(d, i) {return i === revolverIndex && pages[i] !== prevPages[i];}); + renderColumnCellTree(gd, tableControlView, toRerender, toRerender); + prevPages[revolverIndex] = pages[revolverIndex]; + }); + } +} + +function wrapTextMaker(columnBlock, element, tableControlView) { + return function wrapText() { + var cellTextHolder = d3.select(element.parentNode); + cellTextHolder + .each(function(d) { + var fragments = d.fragments; + cellTextHolder.selectAll('tspan.line').each(function(dd, i) { + fragments[i].width = this.getComputedTextLength(); + }); + // last element is only for measuring the separator character, so it's ignored: + var separatorLength = fragments[fragments.length - 1].width; + var rest = fragments.slice(0, -1); + var currentRow = []; + var currentAddition, currentAdditionLength; + var currentRowLength = 0; + var rowLengthLimit = d.column.columnWidth - 2 * c.cellPad; + d.value = ''; + while(rest.length) { + currentAddition = rest.shift(); + currentAdditionLength = currentAddition.width + separatorLength; + if(currentRowLength + currentAdditionLength > rowLengthLimit) { + d.value += currentRow.join(c.wrapSpacer) + c.lineBreaker; + currentRow = []; + currentRowLength = 0; + } + currentRow.push(currentAddition.text); + currentRowLength += currentAdditionLength; + } + if(currentRowLength) { + d.value += currentRow.join(c.wrapSpacer); + } + d.wrapped = true; + }); + + // the pre-wrapped text was rendered only for the text measurements + cellTextHolder.selectAll('tspan.line').remove(); + + // resupply text, now wrapped + populateCellText(cellTextHolder.select('.cellText'), tableControlView, columnBlock); + d3.select(element.parentNode.parentNode).call(setCellHeightAndPositionY); + }; +} + +function updateYPositionMaker(columnBlock, element, tableControlView, gd, d) { + return function updateYPosition() { + if(d.settledY) return; + var cellTextHolder = d3.select(element.parentNode); + var l = getBlock(d); + var rowIndex = d.key - l.firstRowIndex; + + var declaredRowHeight = l.rows[rowIndex].rowHeight; + + var requiredHeight = d.cellHeightMayIncrease ? element.parentNode.getBoundingClientRect().height + 2 * c.cellPad : declaredRowHeight; + + var finalHeight = Math.max(requiredHeight, declaredRowHeight); + var increase = finalHeight - l.rows[rowIndex].rowHeight; + + if(increase) { + + // current row height increased + l.rows[rowIndex].rowHeight = finalHeight; + + columnBlock + .selectAll('.columnCell') + .call(setCellHeightAndPositionY); + + updateBlockYPosition(null, columnBlock.filter(cellsBlock), 0); + + // if d.column.type === 'header', then the scrollbar has to be pushed downward to the scrollable area + // if d.column.type === 'cells', it can still be relevant if total scrolling content height is less than the + // scrollable window, as increases to row heights may need scrollbar updates + renderScrollbarKit(tableControlView, gd); + } + + cellTextHolder + .attr('transform', function() { + // this code block is only invoked for items where d.cellHeightMayIncrease is truthy + var element = this; + var columnCellElement = element.parentNode; + var box = columnCellElement.getBoundingClientRect(); + var rectBox = d3.select(element.parentNode).select('.cellRect').node().getBoundingClientRect(); + var currentTransform = element.transform.baseVal.consolidate(); + var yPosition = rectBox.top - box.top + (currentTransform ? currentTransform.matrix.f : c.cellPad); + return 'translate(' + xPosition(d, d3.select(element.parentNode).select('.cellTextHolder').node().getBoundingClientRect().width) + ' ' + yPosition + ')'; + }); + + d.settledY = true; + }; +} + +function xPosition(d, optionalWidth) { + switch(d.align) { + case 'left': return c.cellPad; + case 'right': return d.column.columnWidth - (optionalWidth || 0) - c.cellPad; + case 'center': return (d.column.columnWidth - (optionalWidth || 0)) / 2; + default: return c.cellPad; + } +} + +function setCellHeightAndPositionY(columnCell) { + columnCell + .attr('transform', function(d) { + var headerHeight = d.rowBlocks[0].auxiliaryBlocks.reduce(function(p, n) {return p + rowsHeight(n, Infinity);}, 0); + var l = getBlock(d); + var rowAnchor = rowsHeight(l, d.key); + var yOffset = rowAnchor + headerHeight; + return 'translate(0 ' + yOffset + ')'; + }) + .selectAll('.cellRect') + .attr('height', function(d) {return getRow(getBlock(d), d.key).rowHeight;}); +} + +function firstRowAnchor(blocks, page) { + var total = 0; + for(var i = page - 1; i >= 0; i--) { + total += allRowsHeight(blocks[i]); + } + return total; +} + +function rowsHeight(rowBlock, key) { + var total = 0; + for(var i = 0; i < rowBlock.rows.length && rowBlock.rows[i].rowIndex < key; i++) { + total += rowBlock.rows[i].rowHeight; + } + return total; +} + +function allRowsHeight(rowBlock) { + var cached = rowBlock.allRowsHeight; + + if(cached !== void(0)) { + return cached; + } + + var total = 0; + for(var i = 0; i < rowBlock.rows.length; i++) { + total += rowBlock.rows[i].rowHeight; + } + rowBlock.allRowsHeight = total; + + return total; +} + +function getBlock(d) {return d.rowBlocks[d.page];} +function getRow(l, i) {return l.rows[i - l.firstRowIndex];} diff --git a/test/image/mocks/gl2d_parcoords_very_large.json b/test/image/mocks/gl2d_parcoords_very_large.json new file mode 100644 index 00000000000..5be3f4bbf7a --- /dev/null +++ b/test/image/mocks/gl2d_parcoords_very_large.json @@ -0,0 +1,94 @@ +{ + + 'layout': { + 'width': 1400, + 'height': 400 + }, + + 'data': [{ + + 'type': 'parcoords', + + 'domain': { + 'x': [0, 1], + 'y': [0, 1] + }, + + 'pad': [80, 80, 80, 80], + + 'line': { + + 'showscale': true, + 'reversescale': true, + 'colorscale': 'Jet', + 'cmin': -4000, + 'cmax': -100, + 'color': [-41, -1317, -164, -1856, -79, -931, -191, -2983, -341, -3846, -278, -3019, -523, -2357, -985, -3447, -211, -2842, -458, -4388, -784, -2563, -935, -2253, -313, -3667, -1479, -1030, -632, -623, -1945, -1324, -1221, -878, -947, -1615, -697, -575, -482, -905, -869, -433, -484, -349, -667, -248, -1135, -888, -1019, -223, -2067, -729, -579, -659, -334, -340, -554, -455, -377, -375, -453, -834, -934, -334, -369, -290, -354, -497, -490, -329, -729, -1794, -151, -1162, -3935, -1013, -509, -825, -997, -320, -680, -422, -785, -542, -563, -489, -1283, -680, -78, -450, -514, -449, -548, -661, -641, -503, -570, -257, -394, -450, -586, -503, -437, -590, -622, -482, -3687, -2394, -773, -1029, -619, -1561, -543, -894, -1037, -705, -208, -325, -693, -652, -855, -642, -317, -435, -310, -329, -380, -371, -610, -406, -310, -1034, -700, -367, -337, -286, -856, -350, -576, -653, -219, -325, -1200, -49, -2664, -856, -344, -520, -766, -286, -291, -1334, -591, -346, -320, -342, -393, -503, -316, -280, -256, -307, -606, -269, -302, -443, -297, -272, -281, -288, -287, -302, -414, -312, -1196, -214, -245, -282, -315, -268, -966, -270, -315, -248, -502, -316, -299, -256, -358, -276, -288, -331, -282, -845, -409, -293, -292, -481, -291, -271, -279, -270, -4948, -402, -280, -261, -293, -765, -162, -265, -266, -253, -869, -237, -285, -276, -225, -229, -446, -567, -272, -876, -260, -251, -284, -2709, -263, -3948, -479, -269, -959, -267, -762, -252, -263, -251, -485, -753, -362, -257, -910, -972, -233, -455, -673, -272, -259, -243, -616, -628, -262, -232, -733, -236, -247, -479, -983, -240, -306, -256, -2269, -262, -106, -225, -893, -238, -253, -373, -476, -234, -469, -354, -219, -731, -255, -262, -317, -275, -518, -894, -251, -3278, -1219, -256, -261, -304, -241, -251, -253, -140, -877, -231, -261, -319, -259, -250, -246, -279, -245, -262, -257, -752, -238, -311, -298, -253, -280, -296, -285, -280, -265, -503, -260, -890, -555, -289, -246, -256, -241, -286, -247, -1881, -267, -225, -252, -911, -283, -250, -466, -269, -241, -270, -259, -908, -255, -447, -432, -244, -373, -816, -391, -3466, -1384, -937, -490, -629, -837, -900, -385, -290, -249, -256, -422, -224, -210, -235, -191, -318, -960, -250, -1124, -254, -247, -639, -291, -487, -229, -225, -258, -513, -466, -347, -216, -313, -250, -242, -310, -234, -377, -234, -247, -891, -293, -242, -830, -227, -654, -238, -1341, -487, -263, -246, -240, -219, -717, -247, -730, -385, -226, -257, -238, -259, -246, -253, -418, -259, -247, -468, -270, -273, -228, -518, -262, -1035, -242, -257, -276, -1165, -252, -1456, -416, -1974, -267, -1211, -437, -481, -1143, -252, -321, -234, -891, -705, -667, -246, -771, -907, -978, -80, -272, -285, -1236, -249, -589, -96, -349, -155, -241, -239, -235, -247, -264, -557, -298, -338, -428, -238, -236, -1515, -257, -415, -389, -267, -477, -1628, -237, -248, -265, -237, -304, -229, -297, -238, -236, -243, -265, -461, -1370, -241, -948, -389, -341, -336, -603, -449, -245, -1716, -258, -66, -397, -289, -985, -299, -1063, -260, -428, -254, -254, -566, -264, -258, -911, -1156, -268, -399, -245, -430, -263, -1083, -286, -1307, -442, -217, -268, -1223, -226, -419, -281, -629, -1145, -297, -247, -341, -1003, -414, -1312, -368, -998, -343, -760, -1214, -264, -1336, -932, -1188, -268, -395, -851, -262, -797, -478, -251, -298, -833, -788, -532, -1440, -1135, -444, -913, -1876, -395, -845, -734, -1458, -843, -994, -688, -438, -349, -724, -208, -764, -722, -493, -703, -423, -465, -431, -482, -385, -1141, -1228, -689, -439, -334, -386, -761, -466, -634, -328, -477, -2190, -652, -736, -490, -394, -497, -306, -426, -395, -1566, -297, -452, -328, -271, -341, -340, -279, -363, -346, -340, -323, -462, -341, -334, -1320, -275, -304, -523, -408, -340, -315, -314, -480, -335, -328, -294, -1142, -403, -1115, -416, -155, -254, -412, -468, -873, -752, -332, -324, -731, -344, -551, -514, -303, -335, -81, -320, -286, -371, -313, -289, -282, -294, -348, -345, -758, -1006, -964, -386, -1166, -283, -501, -931, -638, -363, -474, -354, -1394, -314, -324, -365, -385, -293, -951, -316, -1082, -943, -243, -554, -303, -265, -1044, -889, -304, -938, -302, -317, -302, -290, -523, -314, -272, -917, -277, -311, -943, -836, -414, -490, -319, -289, -298, -317, -285, -267, -309, -323, -357, -277, -335, -278, -300, -742, -897, -353, -3626, -284, -287, -418, -343, -1691, -314, -270, -239, -1182, -1260, -329, -273, -311, -283, -935, -469, -256, -281, -272, -222, -1116, -417, -281, -227, -278, -933, -429, -281, -310, -940, -278, -262, -271, -263, -266, -265, -249, -263, -264, -273, -249, -258, -244, -776, -228, -247, -237, -275, -673, -712, -415, -224, -305, -248, -252, -226, -252, -896, -960, -259, -270, -234, -1483, -235, -276, -259, -946, -379, -250, -241, -249, -1238, -247, -1602, -453, -240, -1193, -238, -636, -1053, -258, -245, -1337, -441, -253, -1179, -267, -850, -678, -336, -275, -257, -276, -244, -227, -1657, -294, -932, -359, -256, -496, -1201, -423, -243, -474, -724, -237, -1016, -1814, -269, -214, -1019, -239, -256, -478, -544, -241, -473, -289, -303, -415, -261, -249, -259, -257, -259, -339, -241, -229, -245, -616, -303, -1142, -260, -250, -442, -294, -85, -1252, -1201, -285, -255, -373, -291, -249, -268, -245, -459, -841, -254, -247, -425, -935, -1043, -248, -250, -401, -268, -225, -414, -252, -339, -292, -961, -231, -874, -1041, -1530, -291, -1264, -667, -235, -259, -243, -239, -246, -882, -236, -484, -224, -242, -1247, -543, -247, -1323, -256, -234, -224, -257, -1255, -209, -307, -238, -240, -281, -3366, -639, -676, -303, -234, -255, -229, -751, -265, -232, -232, -239, -479, -264, -243, -314, -344, -1073, -263, -221, -253, -209, -337, -210, -210, -312, -295, -976, -118, -224, -978, -406, -250, -250, -304, -398, -1350, -259, -269, -241, -401, -248, -238, -1325, -248, -248, -269, -276, -850, -247, -216, -291, -1012, -243, -266, -253, -398, -895, -225, -361, -260, -248, -955, -1530, -260, -275, -271, -272, -258, -1096, -280, -262, -227, -247, -607, -245, -262, -240, -242, -248, -245, -403, -268, -253, -246, -241, -243, -243, -419, -246, -81, -257, -372, -252, -237, -249, -261, -246, -236, -252, -262, -252, -310, -238, -241, -271, -818, -236, -277, -238, -255, -238, -261, -239, -219, -249, -244, -200, -235, -263, -379, -372, -270, -260, -234, -713, -1011, -265, -259, -231, -468, -256, -167, -710, -534, -268, -313, -274, -258, -711, -260, -248, -255, -1015, -468, -514, -232, -455, -226, -358, -219, -270, -250, -129, -239, -247, -305, -264, -274, -244, -370, -1115, -230, -1834, -252, -946, -240, -249, -235, -755, -248, -1036, -244, -230, -226, -1166, -629, -311, -253, -900, -245, -907, -268, -251, -309, -248, -307, -241, -238, -820, -236, -285, -751, -232, -250, -236, -246, -754, -977, -925, -277, -894, -240, -224, -246, -56, -500, -249, -791, -1523, -225, -243, -315, -231, -267, -439, -232, -223, -238, -243, -276, -240, -259, -261, -314, -256, -323, -245, -261, -414, -286, -89, -232, -268, -818, -764, -1122, -652, -518, -279, -1081, -241, -262, -234, -171, -992, -274, -444, -321, -248, -884, -714, -231, -258, -215, -825, -246, -530, -282, -438, -259, -260, -374, -627, -578, -603, -794, -965, -227, -237, -224, -431, -242, -236, -245, -492, -242, -779, -242, -219, -246, -224, -364, -265, -188, -1278, -1909, -384, -51, -1974, -36, -225, -573, -878, -292, -213, -2668, -251, -1161, -906, -697, -914, -261, -474, -320, -564, -314, -536, -331, -274, -262, -261, -753, -815, -254, -294, -273, -259, -1798, -226, -297, -222, -258, -791, -1254, -254, -767, -259, -245, -304, -235, -260, -275, -940, -244, -843, -279, -262, -282, -1031, -233, -265, -983, -259, -256, -254, -278, -699, -1391, -1412, -285, -106, -768, -241, -372, -276, -121, -274, -257, -276, -1039, -560, -1277, -260, -267, -547, -239, -118, -423, -239, -1278, -893, -366, -352, -505, -1450, -1063, -233, -710, -500, -227, -239, -937, -784, -564, -231, -601, -281, -509, -256, -229, -264, -589, -1738, -322, -589, -868, -253, -248, -945, -128, -309, -953, -3122, -1375, -227, -251, -250, -255, -1133, -307, -247, -247, -128, -322, -283, -307, -728, -922, -257, -255, -226, -509, -221, -3099, -501, -884, -317, -961, -1064, -738, -216, -252, -933, -988, -369, -322, -324, -234, -433, -677, -386, -301, -544, -3013, -362, -320, -938, -430, -315, -349, -299, -287, -798, -331, -331, -522, -379, -277, -579, -342, -263, -255, -426, -278, -770, -269, -825, -875, -449, -248, -247, -265, -990, -446, -222, -1037, -110, -218, -417, -290, -388, -2178, -247, -522, -3693, -266, -248, -811, -427, -231, -339, -247, -457, -264, -549, -1122, -285, -971, -243, -1121, -277, -575, -447, -297, -670, -262, -500, -747, -214, -611, -727, -601, -1677, -814, -875, -234, -606, -504, -222, -943, -3983, -1216, -352, -199, -975, -3352, -314, -204, -963, -437, -1236, -331, -226, -281, -1188, -331, -658, -539, -318, -441, -291, -244, -294, -276, -267, -879, -258, -259, -261, -841, -408, -569, -796, -228, -308, -278, -287, -463, -522, -439, -301, -275, -780, -557, -260, -427, -302, -266, -268, -164, -314, -932, -290, -497, -309, -1000, -1786, -288, -237, -283, -548, -311, -288, -426, -303, -110, -82, -284, -338, -261, -285, -1551, -98, -283, -478, -4001, -262, -406, -460, -298, -357, -224, -274, -872, -90, -1089, -949, -407, -210, -541, -274, -860, -818, -2829, -240, -265, -235, -929, -574, -365, -599, -312, -377, -914, -322, -234, -251, -300, -247, -236, -240, -503, -217, -258, -258, -234, -906, -239, -262, -747, -253, -1855, -261, -451, -775, -265, -544, -413, -932, -268, -755, -1312, -698, -3463, -766, -383, -265, -509, -262, -297, -684, -407, -232, -1317, -407, -785, -458, -381, -317, -263, -282, -193, -471, -240, -637, -225, -1066, -313, -452, -803, -321, -1316, -245, -253, -1015, -258, -459, -265, -237, -281, -263, -248, -250, -254, -269, -769, -1479, -240, -260, -363, -254, -975, -248, -703, -351, -384, -257, -315, -259, -266, -271, -1136, -243, -278, -400, -905, -361, -642, -456, -362, -257, -242, -264, -1300, -255, -1413, -250, -968, -225, -255, -324, -278, -283, -425, -265, -454, -412, -1002, -316, -281, -243, -252, -1125, -336, -905, -291, -389, -602, -323, -296, -307, -108, -392, -246, -254, -254, -219, -282, -275, -607, -532, -436, -237, -218, -1216, -259, -249, -1838, -268, -215, -203, -265, -287, -808, -913, -1299, -1845, -791, -247, -714, -2586, -1130, -441, -398, -387, -226, -731, -186, -2805, -294, -954, -267, -751, -159, -307, -254, -290, -253, -277, -273, -262, -249, -503, -255, -248, -393, -272, -668, -990, -1045, -306, -244, -982, -788, -775, -1011, -1174, -1431, -141, -429, -285, -236, -217, -240, -1035, -143, -292, -808, -637, -223, -386, -871, -3825, -862, -352, -1761, -609, -906, -605, -300, -326, -438, -964, -467, -790, -249, -238, -1371, -721, -356, -261, -284, -300, -1071, -423, -649, -605, -341, -308, -85, -266, -672, -283, -271, -1070, -412, -293, -1622, -375, -226, -348, -458, -279, -254, -296, -235, -279, -399, -443, -287, -301, -500, -1182, -374, -238, -318, -101, -2923, -80, -427, -279, -267, -933, -812, -243, -822, -255, -263, -270, -259, -282, -229, -275, -250, -271, -236, -363, -182, -1314, -259, -260, -260, -1208, -147, -451, -276, -294, -85, -1024, -255, -312, -1283, -296, -277, -472, -210, -1021, -226, -235, -1046, -1677, -282, -215, -724, -1105, -262, -296, -333, -261, -274, -216, -239, -251, -293, -500, -892, -67, -1020, -971, -585, -889, -83, -210, -1002, -311, -269, -416, -706, -890, -246, -407, -675, -647, -266, -288, -855, -619, -964, -264, -276, -851, -347, -545, -788, -1030, -942, -442, -236, -246, -222, -330, -970, -506, -248, -694, -260, -469, -320, -218, -422, -297, -255, -1382, -251, -267, -1026, -574, -1076, -88, -347, -466, -86, -343, -2118, -423, -955, -470, -445, -935, -347, -308, -426, -289, -242, -582, -296, -249, -289, -273, -255, -300, -292, -409, -305, -883, -1238, -933, -260, -466, -292, -309, -400, -304, -89, -255, -301, -141, -227, -263, -48, -415, -243, -437, -359, -203, -263, -255, -306, -252, -277, -458, -849, -230, -213, -480, -358, -370, -649, -287, -227, -247, -267, -261, -383, -258, -300, -1203, -305, -840, -273, -260, -329, -234, -288, -283, -287, -245, -299, -240, -276, -1009, -183, -251, -329, -452, -265, -472, -710, -1232, -255, -265, -913, -343, -431, -288, -1293, -358, -262, -282, -245, -258, -233, -266, -238, -494, -217, -263, -248, -83, -287, -299, -368, -188, -271, -488, -1314, -244, -879, -276, -876, -408, -104, -237, -416, -97, -259, -545, -216, -1066, -806, -530, -277, -485, -283, -330, -1282, -277, -327, -248, -943, -782, -287, -260, -311, -252, -297, -117, -345, -892, -323, -268, -339, -259, -279, -254, -234, -257, -258, -84, -233, -292, -229, -250, -768, -259, -783, -251, -384, -1574, -459, -345, -259, -987, -244, -242, -279, -317, -266, -249, -1029, -262, -330, -104, -274, -1317, -268, -3084, -264, -546, -248, -322, -276, -261, -1147, -459, -247, -983, -1307, -262, -272, -98, -3188, -260, -1776, -233, -239, -329, -171, -241, -252, -370, -228, -1478, -238, -269, -252, -458, -788, -82, -387, -643, -1383, -860, -239, -250, -954, -252, -405, -261, -778, -369, -245, -339, -263, -270, -565, -235, -243, -283, -1181, -267, -299, -196, -2322, -1029, -579, -2459, -259, -250, -289, -810, -262, -904, -284, -246, -1027, -896, -882, -1115, -405, -685, -1152, -417, -856, -405, -257, -957, -252, -288, -259, -903, -444, -472, -932, -244, -1112, -277, -484, -309, -354, -698, -272, -304, -638, -915, -260, -938, -349, -2327, -795, -222, -2182, -330, -294, -127, -1030, -378, -1591, -277, -1031, -328, -796, -543, -535, -810, -150, -1074, -274, -127, -295, -1071, -405, -237, -1242, -256, -483, -842, -541, -550, -240, -252, -927, -244, -263, -516, -1047, -896, -90, -258, -89, -263, -101, -318, -264, -297, -922, -253, -242, -258, -234, -1071, -288, -302, -239, -264, -254, -234, -575, -216, -259, -623, -267, -256, -1026, -239, -443, -1010, -1410, -1119, -235, -435, -202, -658, -293, -411, -272, -801, -534, -271, -1721, -246, -254, -524, -2910, -357, -535, -243, -483, -1456, -728, -384, -678, -833, -528, -440, -795, -410, -300, -318, -188, -257, -524, -329, -252, -445, -264, -1138, -289, -419, -242, -2986, -303, -444, -319, -681, -1078, -256, -1100, -244, -241, -282, -1034, -267, -603, -1060, -490, -374, -277, -267, -282, -264, -444, -269, -260, -278, -227, -321, -242, -769, -572, -811, -250, -236, -318, -493, -1200, -497, -953, -1612, -448, -495, -1456, -362, -519, -975, -953, -278, -216, -2591, -3872, -130, -368, -940, -309, -547, -264, -39, -620, -343, -897, -1274, -234, -2464, -258, -155, -226, -854, -297, -243, -686, -285, -360, -1256, -275, -455, -285, -221, -240, -267, -268, -276, -374, -248, -699, -275, -1098, -370, -358, -223, -263, -789, -248, -2618, -571, -826, -917, -361, -223, -2277, -257, -725, -1135, -989, -2561, -2975, -470, -677, -429, -1139, -226, -661, -559, -189, -257, -1147, -615, -1260, -286, -106, -609, -617, -754, -602, -333, -945, -492, -1027, -293, -248, -260, -95, -929, -1380, -290, -272, -290, -2285, -570, -429, -648, -635, -1086, -321, -410, -286, -406, -300, -283, -250, -1162, -254, -459, -317, -228, -280, -997, -827, -313, -290, -349, -1027, -524, -303, -1103, -330, -389, -447, -428, -184, -869, -2244, -257, -250, -275, -2377, -368, -889, -320, -1095, -573, -277, -320, -981, -231, -240, -483, -539, -236, -410, -450, -1044, -510, -387, -238, -149, -262, -289, -1478, -1332, -258, -533, -238, -1092, -801, -536, -277, -1104, -324, -603, -558, -545, -390, -536, -338, -345, -346, -1140, -389, -367, -337, -367, -346, -273, -291, -225, -294, -369, -243, -310, -274, -295, -307, -301, -1297, -2212, -274, -97, -248, -269, -616, -347, -462, -322, -236, -434, -495, -286, -262, -229, -92, -301, -309, -262, -272, -278, -293, -288, -238, -235, -292, -267, -303, -1006, -255, -954, -601, -169, -1422, -1413, -437, -830, -257, -215, -1204, -1546] + }, + 'dimensions': [ + { + 'id': 'Block height', + //'constraintrange': [100000, 150000], + 'label': 'Block height', + 'values': [32000, 162666, 32000, 162666, 32000, 162666, 32000, 162666, 32000, 162666, 32000, 162666, 32000, 162666, 32000, 162666, 32000, 162666, 32000, 162666, 32000, 162666, 32000, 162666, 32000, 162666, 86600, 163400, 162600, 90000, 93100, 163000, 140500, 130000, 100700, 164500, 147700, 121700, 107500, 176600, 133600, 111100, 93100, 72400, 130100, 54500, 182600, 160300, 218100, 66500, 95800, 164800, 107200, 101600, 91100, 91100, 78100, 63300, 75700, 69600, 88500, 115800, 195700, 88900, 74800, 65400, 74900, 115300, 91400, 67800, 85300, 171300, 32000, 227900, 163200, 122899, 112300, 101500, 111199, 73300, 120800, 93100, 117200, 118500, 104800, 108500, 146500, 90300, 32000, 93000, 110700, 103500, 93300, 106300, 118500, 93000, 67600, 51400, 89000, 94000, 88200, 109600, 102100, 123600, 81900, 100000, 218100, 223200, 97300, 162100, 97400, 145800, 67400, 156500, 201900, 94300, 67800, 76100, 98300, 112400, 141800, 111400, 74700, 67300, 71100, 68900, 62100, 73800, 85500, 94400, 68300, 79400, 96300, 70400, 67300, 67300, 128400, 80800, 87600, 165900, 35900, 76200, 79000, 38900, 157200, 64400, 67700, 65700, 125800, 59300, 66100, 198700, 96100, 65600, 70300, 69200, 65500, 129300, 62600, 64200, 61800, 60800, 83100, 58800, 69600, 60400, 63500, 63500, 59300, 56600, 77200, 62900, 57300, 68000, 227900, 53099, 59100, 63099, 65900, 60500, 158100, 60199, 66600, 57699, 58900, 62699, 62000, 58600, 78700, 60700, 60400, 66000, 66000, 133300, 60800, 63200, 60400, 68400, 64600, 61400, 61900, 59000, 155600, 53500, 62000, 60599, 63700, 118500, 48000, 57400, 58200, 56800, 62300, 54500, 61300, 62200, 53200, 51600, 88500, 125100, 60800, 61500, 59200, 56300, 60800, 179300, 58300, 199500, 102100, 60800, 183200, 58800, 125000, 56900, 58600, 53700, 56100, 127600, 96100, 56700, 120500, 58600, 53600, 59000, 113800, 59000, 59200, 54500, 135700, 161200, 57300, 53000, 127000, 54600, 55300, 89700, 59400, 54900, 64700, 56200, 127100, 57000, 35400, 51800, 170100, 54000, 56700, 73600, 83200, 53000, 60500, 52699, 51600, 92100, 56600, 57400, 65500, 58400, 97600, 52900, 56700, 207600, 221900, 56500, 57600, 63900, 54700, 56900, 56000, 49700, 51600, 53400, 58500, 65000, 57100, 55900, 56100, 59800, 55300, 57699, 57600, 53200, 53900, 63000, 58400, 57500, 61200, 62699, 61000, 60199, 57600, 128800, 57699, 59900, 94200, 60900, 55100, 56300, 54100, 61400, 55000, 223100, 57699, 52200, 55300, 54000, 61000, 54800, 59500, 59000, 54400, 57800, 57100, 53200, 56300, 58300, 56100, 53900, 55100, 54100, 59500, 188900, 92300, 105500, 67100, 100000, 202500, 101800, 55900, 86800, 55300, 56700, 59400, 51400, 49000, 54600, 49400, 65300, 56800, 55599, 184500, 55000, 55000, 86900, 60100, 89700, 52500, 52500, 55500, 91700, 104600, 67500, 50700, 63300, 55400, 54500, 62600, 52699, 54100, 53400, 54800, 53200, 59900, 74500, 134800, 52400, 105300, 53700, 215200, 101700, 57200, 54400, 60300, 50800, 129400, 55100, 165700, 55000, 51700, 56000, 54000, 56500, 54500, 56000, 78600, 56300, 54700, 59600, 58300, 58800, 52400, 54500, 57100, 119100, 50100, 56500, 58900, 66500, 55599, 225400, 57699, 97200, 57000, 212900, 57300, 101600, 216500, 55400, 65800, 53000, 164200, 124600, 86300, 56000, 95200, 152700, 208299, 32000, 60400, 60700, 196600, 55000, 77200, 37500, 52000, 55300, 54100, 53500, 52800, 55100, 60100, 125000, 62400, 63700, 106900, 54300, 54100, 217500, 56400, 69700, 101000, 57500, 55100, 153500, 53700, 54700, 58099, 53900, 37000, 53200, 62000, 52100, 53900, 54500, 61600, 59700, 218200, 54700, 189200, 55599, 70600, 63700, 107100, 68800, 55700, 56400, 57400, 32000, 83200, 61200, 217900, 62100, 62400, 60900, 60700, 56300, 57600, 105399, 60000, 56700, 221200, 157700, 58200, 58099, 54700, 60900, 61300, 162600, 60900, 224600, 57699, 52699, 59600, 71200, 52100, 57500, 60500, 134900, 67200, 63700, 55000, 65199, 161600, 80300, 70000, 73300, 56200, 68400, 183700, 180100, 56400, 77600, 197800, 215799, 56600, 73300, 57500, 57500, 55199, 54800, 55900, 63300, 106400, 163200, 70800, 71900, 166000, 114100, 100900, 164300, 93600, 150000, 98200, 161400, 200400, 92600, 127600, 97600, 84400, 96600, 55599, 100500, 112000, 110000, 89800, 97700, 84200, 79600, 102400, 84800, 86900, 166600, 91300, 79600, 78100, 85800, 88200, 104200, 76600, 83300, 110800, 75600, 76100, 113800, 86400, 86800, 74800, 77100, 95200, 86900, 172300, 69700, 87500, 79600, 65300, 80800, 82400, 67100, 79400, 78500, 84800, 76100, 47200, 79400, 78200, 220300, 66100, 78300, 85900, 92100, 80800, 74500, 72800, 36200, 75800, 77400, 69600, 62600, 90700, 70700, 93100, 40400, 62600, 94400, 73600, 72000, 138200, 75400, 73300, 170700, 75500, 144500, 76600, 72000, 78200, 33200, 74100, 67900, 35300, 72000, 69900, 68600, 69400, 74300, 73400, 128400, 71800, 217399, 86500, 174200, 67800, 86500, 136800, 125399, 75200, 108000, 72700, 223900, 67300, 73600, 86500, 83800, 70900, 72900, 71300, 71800, 88600, 60300, 77200, 65300, 63300, 68900, 127100, 70700, 223600, 68700, 66000, 70800, 69000, 60599, 65700, 64200, 150700, 65000, 68700, 75800, 154200, 63300, 103400, 70200, 66400, 69200, 71000, 65700, 62300, 70100, 72200, 68700, 64600, 67600, 61800, 68100, 129200, 54900, 77600, 169700, 67100, 64100, 69300, 65700, 64600, 71800, 65199, 61800, 198400, 208800, 72100, 59800, 66200, 62900, 152500, 72200, 57600, 61300, 61900, 54900, 177200, 79500, 60800, 67000, 61100, 155600, 63400, 61500, 65100, 150000, 64500, 56800, 59600, 59000, 63000, 59000, 56700, 59000, 58400, 60700, 56700, 56900, 54900, 54800, 52200, 54700, 54800, 62000, 134700, 115700, 59700, 51500, 66900, 55599, 56400, 52900, 56800, 52900, 58200, 57699, 59100, 53200, 55800, 53300, 60400, 58200, 107500, 55500, 56800, 54400, 56100, 201400, 56600, 176200, 84400, 54100, 214700, 55800, 123699, 173700, 73600, 55199, 169200, 82600, 56500, 62300, 59100, 151900, 122700, 66700, 58200, 56400, 57400, 55000, 56000, 111900, 60400, 149700, 71700, 56600, 93800, 178700, 80900, 54700, 87700, 118900, 52300, 195900, 190200, 58000, 51300, 211300, 54500, 56600, 56900, 111800, 54900, 79400, 69700, 62800, 78600, 57600, 55199, 57000, 56600, 57200, 68600, 53800, 53900, 54900, 122500, 63500, 179300, 57800, 55700, 89400, 61800, 32000, 79000, 214100, 61400, 56000, 54900, 61900, 55100, 58800, 54400, 82600, 176300, 56600, 55100, 59100, 141700, 60100, 54500, 71700, 58900, 58800, 52100, 60000, 56900, 77700, 62600, 57900, 53300, 52400, 59800, 218900, 70700, 218200, 144700, 53300, 57200, 53900, 54000, 55400, 107700, 53800, 121300, 52400, 54600, 199500, 118200, 80900, 202900, 56600, 53400, 52100, 56600, 222600, 50300, 65100, 54200, 54600, 60199, 183700, 134800, 146300, 62500, 52600, 56500, 53099, 180700, 57800, 53500, 52000, 54300, 87300, 57699, 54300, 64400, 68500, 213299, 57300, 51800, 56300, 50000, 67200, 49500, 51100, 63500, 62400, 165500, 49300, 51200, 58099, 77700, 40800, 55000, 63500, 78000, 208000, 56900, 58099, 53900, 83600, 55599, 53800, 86300, 55100, 55700, 58400, 59100, 206600, 55000, 51100, 61600, 187000, 54400, 57699, 55700, 56800, 54000, 52200, 53700, 57100, 55100, 56600, 76700, 56400, 58700, 58200, 58900, 56300, 182300, 59500, 57200, 52300, 54600, 77100, 54300, 57400, 54200, 54200, 55100, 54600, 57400, 57500, 55900, 54900, 54400, 54400, 54600, 82300, 54400, 41600, 56500, 54000, 55900, 53400, 55100, 57300, 55199, 53500, 56300, 57500, 55800, 64600, 53900, 54100, 58500, 49700, 53400, 59500, 53700, 56900, 53700, 57000, 53800, 51100, 55900, 54700, 47900, 53500, 57400, 54700, 88600, 58400, 56900, 53200, 127200, 58900, 57400, 56600, 52600, 121800, 56900, 44700, 120600, 90300, 61300, 60700, 58900, 56800, 120300, 57600, 54700, 56800, 62600, 85700, 86700, 52400, 83900, 51800, 64500, 51100, 59200, 56100, 43000, 53700, 56000, 63600, 56900, 57800, 54100, 53700, 116199, 52200, 73800, 56100, 157600, 54400, 54600, 53300, 68400, 55100, 198900, 54500, 52800, 51600, 225100, 129100, 63800, 55400, 157100, 54300, 53800, 69400, 55700, 72100, 54600, 71900, 54300, 53800, 55700, 53900, 60900, 52300, 53000, 56300, 53400, 54300, 179100, 57500, 54300, 84000, 53300, 53500, 51500, 54300, 37700, 105600, 55100, 53600, 206700, 51700, 54200, 64900, 52600, 57699, 79900, 52500, 51300, 53900, 54100, 59300, 54100, 55800, 57100, 63800, 56800, 65900, 54400, 56900, 79000, 59300, 44200, 53099, 57500, 49300, 123600, 180700, 112500, 97500, 58600, 220400, 54000, 55300, 53500, 51900, 172200, 58600, 99300, 65900, 54800, 52900, 148300, 53099, 65300, 50500, 86100, 54500, 109600, 60400, 90200, 56500, 56500, 73100, 153500, 120900, 118300, 144300, 57100, 52500, 53400, 51300, 98900, 54800, 53400, 54600, 101100, 54500, 136800, 54700, 50500, 55599, 52200, 54000, 57699, 46900, 208800, 105399, 55500, 32100, 174200, 32599, 52100, 104700, 137900, 61300, 46100, 151600, 55700, 191100, 168600, 107500, 59500, 58300, 83100, 65400, 60100, 65300, 73500, 63900, 59600, 58700, 57800, 175200, 159100, 56100, 61600, 57800, 58000, 204800, 52500, 60800, 51200, 56900, 158200, 193900, 56200, 154800, 58500, 54100, 45400, 53500, 57000, 58900, 57600, 55100, 130399, 59800, 57400, 59600, 161700, 52600, 57800, 57600, 57400, 55900, 55500, 59600, 138800, 212200, 102300, 66700, 39800, 128400, 53300, 75600, 59000, 45300, 65100, 55700, 59100, 160900, 111500, 170700, 56600, 57500, 61000, 53300, 42900, 82100, 54700, 197200, 141700, 53800, 72400, 72800, 227900, 183900, 53700, 120700, 92600, 51800, 54100, 57100, 120700, 99900, 52600, 65300, 59900, 112899, 56800, 53300, 57200, 139700, 63500, 65800, 64600, 50500, 55700, 55900, 55800, 45800, 63800, 56400, 151500, 200100, 51100, 56100, 55599, 64500, 192300, 76100, 55300, 55199, 48000, 65800, 66300, 64400, 127100, 54300, 57000, 56100, 52000, 91000, 51800, 206800, 91900, 196200, 65199, 220500, 214899, 85700, 50800, 56000, 57699, 188500, 72100, 67200, 67000, 53000, 86100, 147100, 92600, 63500, 99800, 209400, 32000, 66500, 113699, 86800, 65100, 64000, 62400, 60300, 144700, 73100, 67200, 42100, 78400, 58600, 61800, 67900, 56500, 56400, 59700, 59000, 51900, 60100, 58300, 54900, 67800, 55700, 55599, 58400, 59800, 62400, 51300, 59800, 41700, 51400, 59700, 61700, 56500, 147400, 56500, 98300, 183500, 58200, 56200, 56800, 82700, 52900, 50700, 55700, 53500, 58500, 117100, 180400, 61500, 154900, 54900, 225000, 59900, 123300, 99300, 63000, 136000, 57300, 93900, 127000, 50800, 102700, 133500, 93200, 150900, 113300, 111000, 53300, 85600, 68800, 54000, 181900, 193000, 76500, 70500, 50900, 62100, 113600, 66700, 49800, 182900, 51300, 71000, 67100, 51800, 61300, 68500, 67500, 153900, 98200, 69700, 101100, 61700, 55700, 62800, 61100, 57600, 204200, 57400, 56400, 56800, 188400, 79500, 115600, 46300, 62300, 63200, 60500, 61200, 94900, 59400, 85900, 63800, 61100, 131300, 86500, 59400, 80800, 64100, 58000, 59100, 47300, 67400, 57500, 62400, 95200, 65600, 57600, 171100, 62300, 54100, 60900, 97200, 65000, 45800, 61200, 64300, 43300, 32700, 62100, 69500, 58400, 61600, 223700, 41200, 60800, 91500, 226800, 58200, 89200, 64800, 63200, 71900, 52400, 59600, 52000, 39700, 65600, 148900, 59600, 50000, 136800, 62900, 64100, 58900, 135400, 63099, 58600, 53200, 55599, 117800, 73300, 70900, 72100, 55100, 72400, 67200, 53600, 55000, 63800, 56000, 53600, 54000, 68900, 51200, 57500, 56700, 54700, 56100, 53700, 58200, 135500, 57300, 182200, 57900, 85200, 121100, 58600, 111300, 60199, 55300, 57500, 118400, 222000, 123200, 193400, 131300, 77300, 57800, 70300, 58400, 63099, 118900, 79200, 52800, 74600, 58600, 172100, 86500, 55400, 65300, 57500, 60100, 50000, 110200, 54400, 49600, 51900, 62100, 66100, 63000, 44900, 67200, 59400, 54800, 56200, 179700, 56600, 63900, 56900, 54900, 59800, 58500, 55100, 55000, 56100, 57100, 146400, 83200, 54500, 57600, 53600, 56600, 57200, 56200, 110200, 51700, 87300, 57200, 73700, 57000, 58600, 58700, 177800, 54400, 60599, 58000, 53000, 68400, 147200, 103600, 53900, 56100, 54700, 57699, 155400, 57400, 225799, 56100, 202000, 52100, 55900, 80100, 59300, 59000, 89200, 65300, 86100, 78400, 58900, 63500, 63900, 55000, 55599, 64700, 68200, 53200, 60900, 93600, 132900, 67000, 61400, 64600, 42600, 93500, 54800, 55900, 56100, 54900, 59600, 58800, 137400, 87500, 59300, 54400, 51500, 183200, 57200, 55900, 65000, 58000, 50500, 48700, 58600, 60500, 140700, 122500, 192500, 65300, 122600, 59600, 162700, 106700, 61300, 60599, 57699, 74400, 55100, 49600, 49800, 190300, 80200, 81600, 58000, 128100, 40300, 64900, 81300, 61900, 55199, 59900, 59100, 57000, 55800, 57600, 56300, 68800, 69300, 58800, 145700, 58600, 164700, 61000, 55700, 168000, 139200, 167700, 172000, 65600, 155200, 46200, 84200, 64000, 54000, 51600, 54200, 95000, 47200, 58900, 140400, 53400, 52400, 56500, 51500, 223800, 181600, 65800, 92700, 114800, 169200, 138500, 59300, 60300, 87100, 63600, 83000, 53600, 55300, 53600, 140500, 155100, 66700, 56000, 57699, 60900, 173700, 84700, 86100, 104700, 65700, 61300, 38600, 57500, 59000, 61100, 57100, 57000, 77500, 58800, 173800, 73600, 71200, 69400, 61200, 60400, 55100, 60599, 53800, 58500, 57400, 59200, 58099, 62600, 57699, 168800, 72600, 58800, 65400, 35800, 152500, 32000, 60100, 60300, 57200, 223900, 55900, 54200, 147200, 55700, 57300, 68800, 56800, 60100, 58200, 58600, 56100, 74800, 54500, 70600, 49400, 132700, 56700, 57300, 57000, 189800, 46300, 86100, 58700, 62500, 38900, 74000, 65500, 73200, 188900, 71000, 60199, 81700, 50100, 221900, 52500, 53099, 163500, 61000, 69000, 51800, 51200, 197600, 56600, 61600, 68800, 56900, 59700, 47800, 54600, 54800, 62200, 69300, 52300, 36000, 213600, 56600, 94200, 52500, 39100, 49600, 181000, 64200, 57300, 60100, 169800, 54400, 55400, 62600, 112700, 118500, 58000, 61100, 52600, 85800, 84400, 57600, 58800, 62200, 75200, 95900, 51800, 60100, 56500, 87300, 54300, 56300, 51500, 68300, 56700, 49100, 56800, 127700, 59400, 54100, 66900, 50900, 94900, 62900, 56700, 71300, 55700, 57600, 184300, 100500, 63000, 39000, 69400, 65100, 32000, 69300, 113500, 60000, 80100, 87600, 62100, 216000, 74700, 64300, 65500, 61700, 54100, 135300, 73100, 55100, 61500, 59200, 60900, 63600, 62200, 105800, 63500, 49500, 214600, 63400, 59900, 95600, 62000, 64000, 58099, 63300, 35500, 58700, 63300, 44200, 55599, 56000, 32000, 60199, 57000, 86100, 74700, 49600, 59100, 57400, 65400, 55900, 60700, 53200, 177300, 53200, 52100, 92700, 74300, 73900, 129600, 64500, 52699, 56000, 60800, 58300, 76400, 57000, 65500, 177100, 66800, 49900, 58900, 57300, 66700, 58200, 61600, 62100, 68200, 55199, 64300, 53500, 60199, 60700, 47600, 57000, 94400, 95200, 59600, 61200, 161400, 51800, 56900, 59000, 165500, 69500, 61800, 62600, 205200, 52600, 58800, 61100, 55599, 58600, 53900, 60400, 53400, 115399, 50100, 58700, 56300, 37900, 61800, 63400, 75100, 52400, 59800, 113300, 210700, 55800, 138900, 59600, 185300, 102700, 42100, 54900, 87200, 40900, 58200, 135400, 51700, 62500, 171300, 109000, 59800, 102700, 62600, 77800, 198400, 61200, 65400, 55100, 153700, 165900, 62000, 58600, 71000, 56500, 63099, 40900, 83200, 60599, 73800, 59800, 70900, 58500, 61300, 56300, 55100, 58000, 57800, 38000, 53500, 61800, 53800, 55500, 54300, 56000, 54700, 55700, 71500, 179800, 53500, 64100, 58400, 63700, 55500, 54600, 60800, 64300, 58800, 56600, 186600, 58200, 61500, 35100, 60100, 212399, 58600, 171800, 58300, 96700, 56900, 66400, 60300, 58500, 71300, 65100, 56300, 59600, 196000, 57800, 60000, 42600, 181600, 57300, 195500, 54200, 55400, 61500, 44500, 55000, 56300, 66700, 52699, 143500, 54400, 58400, 56300, 53300, 191900, 38000, 76000, 111000, 198900, 160900, 54500, 55400, 56100, 55000, 81500, 57100, 119400, 74200, 55700, 70200, 57600, 58600, 134700, 53000, 55100, 60199, 224100, 58000, 62500, 56500, 134200, 60300, 73800, 209400, 57000, 55900, 62200, 55900, 57500, 159200, 61200, 55300, 168000, 55700, 55300, 219200, 76600, 128800, 211000, 87500, 58600, 57500, 56300, 202600, 56200, 61100, 56800, 153900, 88400, 97400, 166600, 54900, 220000, 81800, 98600, 66900, 86500, 152300, 59100, 86400, 73100, 55000, 57100, 54800, 65500, 138200, 177700, 51600, 108699, 67000, 61500, 45500, 58500, 55400, 133800, 59200, 213100, 66600, 122100, 97100, 92100, 135300, 49600, 73000, 58200, 51900, 61400, 60700, 58099, 53300, 192600, 55800, 121500, 139700, 40100, 115700, 54300, 56000, 58400, 54400, 57699, 98800, 214800, 161400, 39300, 56900, 41700, 57000, 39600, 65600, 56600, 65900, 219100, 55800, 54300, 56300, 52600, 61100, 60800, 65500, 53700, 57100, 54800, 52500, 46500, 50900, 55199, 46300, 57100, 56300, 58900, 53500, 59800, 217399, 59300, 185900, 43300, 59000, 51700, 133000, 75300, 58000, 57699, 97800, 117400, 57200, 185500, 53800, 56700, 115600, 170200, 65900, 79000, 55199, 100000, 96700, 123699, 76700, 169400, 136700, 71400, 61000, 127400, 58800, 62400, 48400, 44200, 55599, 91600, 67000, 55599, 62800, 58000, 65600, 61700, 59300, 54300, 201700, 62699, 108400, 64100, 71100, 59900, 56300, 227900, 54100, 53900, 61700, 165200, 59100, 115800, 62400, 92400, 55599, 59500, 58800, 60500, 57400, 80700, 58500, 56500, 59800, 60400, 63300, 55199, 118900, 63500, 195000, 54700, 53099, 67100, 55700, 219200, 56900, 70300, 156000, 83600, 95100, 210200, 67000, 48000, 56700, 172100, 59400, 62800, 195400, 133800, 44800, 54900, 57300, 63000, 95000, 57600, 32000, 138600, 71000, 61200, 73500, 53400, 194800, 56900, 49200, 51900, 60300, 60900, 57000, 116100, 61300, 81000, 205000, 57800, 117000, 61300, 51800, 54300, 58600, 57800, 61500, 82400, 55900, 156600, 59300, 227800, 55000, 54400, 52000, 58900, 54100, 55599, 177500, 92500, 57100, 148600, 53400, 52200, 113200, 57300, 87100, 227100, 215200, 195700, 144300, 91500, 148700, 91100, 198200, 52600, 108500, 90700, 68600, 56500, 174600, 103400, 215600, 60500, 41600, 102899, 81100, 121300, 79200, 67400, 64400, 109400, 57000, 61400, 54800, 56300, 41500, 175700, 140300, 61000, 68200, 59700, 84600, 43300, 82600, 112300, 34900, 168200, 71700, 79800, 60800, 79500, 61700, 60800, 54800, 69300, 60100, 64100, 64500, 52100, 58600, 58900, 56200, 65500, 58700, 70400, 216700, 103400, 62699, 64600, 66600, 56300, 66300, 73800, 50500, 170100, 122000, 55300, 56000, 58099, 126500, 52200, 147000, 65900, 193200, 115300, 62600, 65900, 202300, 52800, 53900, 101000, 95000, 53700, 73300, 84400, 227900, 54300, 93200, 60500, 38400, 57300, 61400, 170400, 224500, 57100, 95000, 53400, 208900, 138800, 73200, 59600, 223600, 70400, 111900, 72900, 100500, 76000, 71600, 68000, 71100, 67700, 75900, 74200, 72800, 66500, 69400, 66200, 59400, 61000, 52300, 62900, 71200, 55400, 67000, 59300, 63200, 64500, 65100, 222600, 183400, 59600, 40400, 55599, 58500, 125000, 64700, 115399, 66400, 54500, 81700, 124400, 60500, 56300, 53900, 32000, 64200, 64800, 58300, 56800, 65000, 62800, 62300, 53200, 58300, 61300, 58600, 64400, 58099, 55700, 158400, 155100, 49700, 170000, 213500, 75600, 162300, 59900, 47000, 223600, 187300] + }, + { + 'id': 'Block width', + 'label': 'Block width', + 'range': [0, 700000], + 'values': [268630, 489543, 379086, 600000, 489543, 268630, 600000, 379086, 268630, 489543, 379086, 600000, 489543, 268630, 600000, 379086, 268630, 489543, 379086, 600000, 489543, 268630, 600000, 379086, 268630, 489543, 436900, 373600, 268630, 439000, 381800, 491200, 402800, 381400, 485600, 600000, 372200, 394700, 383800, 401100, 356500, 313200, 487100, 490700, 432299, 530300, 521500, 456700, 333800, 343200, 394000, 328200, 487700, 383600, 317700, 324600, 482900, 515100, 500100, 562700, 486000, 453400, 352900, 331300, 496200, 469099, 472500, 354700, 507700, 509000, 439300, 525300, 347600, 379000, 432800, 378800, 383200, 523800, 600000, 313600, 497700, 411300, 420000, 381100, 342800, 385900, 268630, 495800, 488000, 446400, 397900, 373300, 385700, 396500, 475700, 510600, 586800, 596000, 407600, 439200, 440800, 393100, 274600, 291900, 509799, 432800, 303000, 530600, 515900, 376800, 377400, 553500, 433600, 270800, 288000, 488000, 306800, 418000, 456900, 526300, 524500, 524000, 418800, 442800, 443200, 497200, 427500, 510300, 476000, 382700, 472200, 380400, 472900, 541100, 528200, 441599, 374600, 414099, 437299, 272500, 550000, 417299, 443700, 268630, 545800, 403400, 534400, 557200, 545200, 537400, 464300, 571200, 589400, 564000, 466500, 514500, 433200, 293600, 550100, 466599, 450100, 557200, 489000, 512200, 445600, 531000, 504400, 459799, 528800, 579800, 352900, 520700, 532000, 477900, 395600, 478900, 461300, 481400, 507500, 487200, 522299, 496000, 499600, 485200, 491500, 548300, 526000, 489600, 444000, 500900, 527600, 533200, 450000, 566500, 486300, 500700, 534900, 493000, 481100, 482500, 490900, 510200, 584700, 560700, 492000, 474600, 495300, 594100, 433700, 522500, 513100, 507500, 488100, 506400, 510400, 482700, 500400, 532000, 477700, 369600, 491200, 499400, 489200, 509099, 513600, 479600, 507299, 547600, 415300, 485900, 410400, 507700, 546700, 503300, 503600, 547700, 509200, 522400, 319700, 517200, 473000, 506800, 511400, 559200, 537900, 515300, 487500, 519000, 361100, 270800, 519000, 518200, 508200, 503900, 516500, 508600, 504900, 506500, 505300, 522000, 507500, 521400, 504600, 521400, 418700, 516700, 508400, 515400, 387000, 522299, 557300, 516599, 510600, 383600, 514700, 516700, 515600, 528200, 491500, 517900, 505000, 430300, 425300, 517800, 512600, 511599, 511300, 501599, 519099, 359700, 522400, 510400, 501100, 524600, 516000, 513800, 503100, 517000, 511400, 513700, 504000, 506900, 517000, 535700, 572700, 497900, 501900, 512600, 513800, 515000, 520700, 295100, 509700, 522299, 338800, 521300, 517200, 519500, 520800, 509300, 520700, 356000, 523000, 513600, 525100, 515700, 510000, 528300, 565200, 509300, 515500, 526900, 514200, 522200, 518500, 557400, 565100, 530700, 511100, 538200, 483700, 588800, 285200, 569100, 520800, 406300, 278300, 569500, 513900, 289000, 519600, 513600, 526900, 525500, 530300, 502000, 480000, 518500, 513000, 516900, 507000, 534300, 520400, 488500, 536000, 518900, 519000, 509400, 535500, 533600, 384900, 542700, 517200, 535700, 520500, 517100, 538700, 525900, 524200, 517100, 523600, 512900, 542400, 306800, 544600, 516599, 582200, 519900, 510900, 427200, 521300, 525900, 438200, 523500, 480000, 519600, 325400, 523300, 525200, 526500, 516400, 523800, 525400, 518700, 530800, 526400, 524400, 566400, 519500, 519700, 518400, 580400, 520600, 567600, 585000, 519300, 524300, 520800, 520900, 533400, 529500, 583500, 531400, 450000, 557600, 420700, 402900, 524500, 518700, 521800, 316400, 497100, 518900, 504400, 539400, 507000, 339700, 493800, 496700, 517500, 523400, 524400, 526200, 311300, 519200, 327600, 520400, 524800, 526400, 519200, 485200, 361000, 519300, 574400, 330400, 511800, 511200, 592800, 520900, 390400, 322200, 524600, 513300, 542400, 517200, 527300, 512700, 516100, 570800, 508900, 523500, 543500, 513700, 519700, 469000, 557400, 515000, 511000, 382700, 521400, 497900, 571100, 514099, 461100, 505600, 563300, 509200, 446300, 458000, 518000, 316500, 525600, 515700, 468600, 516300, 515400, 499000, 487500, 486900, 519099, 270200, 290900, 518000, 509900, 519300, 517299, 468700, 582300, 517200, 461100, 558600, 490500, 499099, 507100, 517600, 535200, 512100, 375300, 506100, 502200, 519600, 559900, 531200, 508100, 553600, 510700, 538600, 525200, 286400, 581800, 534900, 503500, 345400, 428300, 539400, 552000, 523400, 516300, 514099, 519200, 515800, 508000, 500400, 374900, 529900, 527100, 600000, 309600, 583500, 600000, 376000, 473900, 484799, 419300, 287200, 596600, 464600, 398900, 383900, 487000, 431900, 490700, 600000, 381100, 515800, 381500, 540900, 539100, 416500, 428800, 439300, 441300, 496000, 550800, 414300, 422100, 598200, 387800, 561100, 364000, 359700, 523400, 455300, 600000, 380400, 424000, 458600, 382500, 401100, 425100, 550500, 436599, 493200, 393200, 437900, 401100, 386300, 432299, 444799, 428200, 368800, 415700, 369900, 413400, 413000, 482100, 436000, 368600, 369300, 401300, 400400, 418300, 432299, 278800, 436100, 411800, 431300, 551100, 406300, 541500, 404200, 547200, 437000, 390200, 417900, 415800, 460600, 434900, 442600, 309300, 452000, 272200, 459700, 423300, 414799, 468900, 429300, 436700, 427400, 438800, 421100, 421700, 434000, 470700, 474799, 521599, 414400, 307300, 416700, 579600, 432400, 566100, 416200, 432500, 483100, 373200, 494799, 507400, 489700, 440800, 389200, 436599, 418000, 446500, 450700, 445200, 594100, 443900, 489000, 493300, 448900, 449700, 406000, 437400, 278100, 453400, 509500, 433000, 431200, 308600, 507500, 452500, 524700, 451700, 468700, 423600, 447200, 472600, 418500, 466000, 457000, 442299, 455000, 458400, 463800, 450900, 452900, 544200, 456500, 521700, 490900, 457200, 502500, 499099, 446800, 597000, 440600, 478700, 428700, 556900, 498300, 442000, 437900, 419000, 486000, 490700, 463000, 505500, 496700, 486200, 528300, 434200, 502600, 502400, 477800, 470500, 533400, 520700, 508400, 346400, 498900, 511300, 486900, 499300, 508100, 545700, 458400, 524300, 504700, 497299, 454300, 501100, 499900, 497800, 506900, 494500, 501000, 515300, 515000, 505300, 520200, 524099, 502600, 483000, 413400, 562300, 511700, 523500, 478800, 514600, 511100, 505500, 505300, 519099, 499600, 506900, 510500, 519900, 512400, 520400, 504500, 500900, 433200, 515900, 500700, 517100, 508200, 505900, 498900, 274800, 523200, 518100, 434600, 491100, 439900, 508300, 338800, 513900, 464600, 524000, 511100, 565900, 503700, 331700, 484200, 533800, 530700, 519799, 544000, 513200, 466100, 484799, 537100, 541300, 513500, 515100, 495600, 580400, 514600, 517000, 519600, 552000, 538400, 399700, 448000, 522100, 503600, 353100, 511300, 515700, 487700, 421700, 509200, 600000, 422400, 523700, 526700, 513000, 521500, 516400, 518100, 513300, 516700, 524400, 499099, 517299, 428600, 514700, 540300, 507500, 517200, 464900, 519099, 512100, 537200, 440900, 507900, 522500, 514799, 513900, 523500, 510100, 525100, 548400, 361100, 512700, 518100, 524400, 588900, 527800, 528500, 341500, 500100, 510300, 516000, 504200, 502900, 424200, 506599, 502700, 511000, 512200, 524099, 595200, 415700, 460400, 361800, 519700, 514300, 527300, 516900, 512900, 532100, 514900, 312800, 510400, 515100, 518500, 383900, 269400, 547800, 515000, 515100, 514300, 518700, 316300, 508700, 503200, 512700, 511599, 515500, 506599, 384900, 362200, 527700, 527500, 515600, 510100, 289800, 517400, 510600, 531900, 513800, 530100, 517600, 522700, 522900, 525700, 376000, 520100, 512100, 513900, 512400, 528600, 521900, 498500, 530200, 514700, 494200, 315900, 527900, 514700, 521599, 521599, 526700, 516400, 507900, 542600, 518600, 521500, 523500, 459700, 513400, 517900, 515400, 521400, 512900, 517600, 522100, 274700, 520800, 511599, 517000, 428600, 520500, 519799, 522800, 526400, 506700, 514000, 513100, 517900, 520200, 517600, 583600, 526800, 524400, 523900, 515900, 523300, 498700, 524200, 519200, 517500, 525100, 549400, 526000, 517200, 516900, 520700, 521000, 521300, 525700, 527200, 519400, 518600, 516900, 519600, 517400, 496300, 527400, 322400, 518300, 519200, 518400, 523400, 523100, 516599, 516100, 517900, 512500, 514600, 519500, 514200, 517600, 520200, 519200, 515200, 520100, 517000, 519600, 509900, 520900, 519799, 519900, 518200, 512400, 517700, 526200, 516700, 519799, 519900, 382200, 518900, 520000, 518200, 488700, 523600, 522299, 522299, 521900, 295200, 511599, 499400, 526900, 572800, 478500, 570100, 520000, 516599, 530600, 509799, 526000, 512000, 491599, 530200, 581800, 525800, 529700, 522200, 598700, 517400, 508500, 510200, 428700, 522200, 507100, 517299, 527600, 534400, 526500, 520700, 486900, 526200, 525600, 514799, 510400, 514900, 529600, 520100, 330400, 520800, 401100, 520600, 516000, 525100, 388800, 404700, 525800, 526400, 480100, 525700, 515300, 391100, 518100, 431599, 527800, 430300, 517400, 518700, 523500, 512400, 514300, 516100, 517299, 508200, 520900, 527200, 296700, 514400, 520100, 289600, 513900, 528000, 522700, 527600, 308500, 415200, 522800, 527500, 402800, 521400, 523300, 518800, 521200, 522200, 547400, 525300, 522800, 518000, 524800, 518300, 518300, 534100, 518400, 530400, 512800, 520500, 524900, 522500, 520200, 537200, 307300, 517200, 527300, 514099, 557900, 521599, 525600, 492800, 533800, 359300, 522299, 546000, 514200, 401500, 475200, 523900, 394000, 517800, 525400, 517600, 382800, 513200, 414900, 519000, 517100, 525300, 421700, 515300, 453800, 522299, 525300, 522200, 297000, 402100, 440400, 462900, 517700, 514200, 522299, 526700, 382000, 513200, 519799, 521000, 436200, 516400, 490400, 514099, 526800, 510600, 513400, 509900, 518900, 512400, 500400, 521700, 517100, 390400, 589900, 327700, 517100, 499799, 565300, 522299, 589000, 495000, 519099, 502299, 433100, 413000, 540000, 503200, 563400, 521599, 553100, 511500, 503200, 558600, 510200, 499799, 510100, 308500, 410700, 518400, 522700, 532000, 502400, 386700, 512700, 538900, 522900, 516300, 396900, 545300, 517400, 393900, 495600, 529600, 552900, 516900, 519300, 521800, 495100, 513500, 583300, 516800, 516300, 526400, 550500, 526300, 517100, 516800, 510400, 525000, 526500, 518200, 414300, 548400, 395800, 447800, 419799, 530100, 532300, 493200, 522600, 373100, 445500, 530000, 520500, 560400, 440000, 297700, 524200, 526100, 518600, 528400, 400700, 503000, 508600, 545500, 555400, 520600, 494900, 473200, 521599, 471700, 509099, 526800, 510800, 525700, 516900, 498300, 595700, 526300, 520600, 525600, 519400, 380300, 514099, 506100, 524000, 321100, 522500, 520000, 520600, 529700, 521800, 510300, 520500, 385100, 522200, 518300, 577600, 588400, 536100, 513100, 518000, 419000, 480700, 392500, 515900, 517400, 353900, 520800, 448300, 511200, 502700, 518500, 512900, 521300, 519799, 535700, 512299, 407000, 517100, 322600, 518700, 297300, 366500, 600000, 515200, 516300, 490700, 408800, 525700, 504300, 509600, 521300, 481400, 359700, 371300, 511900, 504300, 451300, 467600, 507700, 532300, 470600, 516800, 590300, 522000, 526000, 463900, 455600, 518500, 406100, 475600, 529000, 547300, 529000, 531400, 517500, 527800, 526600, 459500, 494200, 500000, 487000, 469000, 511300, 511700, 508600, 504500, 519900, 521700, 522299, 400400, 511100, 513900, 513900, 511100, 408500, 498900, 490600, 559100, 514200, 505500, 506300, 503800, 516599, 524200, 510100, 510600, 505700, 395700, 523100, 506599, 542700, 512700, 366700, 511800, 386800, 397700, 511000, 404200, 518300, 499400, 520500, 511800, 555900, 465500, 268630, 582200, 305800, 500800, 518400, 472200, 512700, 483300, 405400, 573000, 465600, 516500, 476000, 472000, 546000, 496200, 503400, 414000, 516800, 514000, 520800, 523700, 502900, 513900, 515400, 318200, 511500, 469900, 379700, 515300, 504200, 506500, 495500, 523200, 297100, 508100, 525600, 522800, 321100, 507299, 423900, 536700, 394000, 527100, 506900, 515400, 447800, 509900, 490900, 508000, 493400, 523200, 429900, 486800, 522100, 505400, 517299, 506800, 448600, 489000, 496800, 504300, 486200, 500300, 525300, 278500, 501900, 512400, 510400, 530000, 511500, 370200, 507600, 504500, 373400, 485300, 497600, 504200, 501100, 505400, 587500, 373900, 511500, 492299, 560600, 506500, 421500, 506100, 509099, 509300, 508600, 511300, 515200, 376500, 499900, 558600, 500200, 514400, 293900, 470700, 407400, 490100, 375800, 406100, 506100, 520900, 514099, 415600, 506200, 581600, 435400, 512500, 432800, 504200, 513900, 529300, 506000, 507000, 518400, 520600, 515900, 512200, 508200, 517900, 497500, 497100, 523300, 506800, 471000, 500600, 269500, 508100, 512600, 584400, 505900, 425000, 501900, 513300, 526800, 584700, 472500, 287400, 573200, 510700, 492200, 517600, 506300, 502800, 509200, 514400, 508800, 520600, 518200, 515100, 340000, 510500, 521000, 517400, 516800, 519900, 476700, 357200, 514000, 404600, 519300, 514900, 501200, 521200, 559700, 503000, 514500, 518100, 515100, 458600, 519200, 518300, 530500, 501100, 520600, 503800, 521599, 527200, 519300, 534200, 433200, 521599, 512100, 510400, 518500, 511599, 516500, 505600, 594900, 528900, 407600, 510400, 425800, 517100, 508700, 516599, 543700, 520400, 506300, 511599, 523000, 554000, 332400, 379900, 511500, 525100, 513700, 516400, 513600, 503400, 510400, 511200, 352600, 515200, 524000, 382400, 521900, 536300, 445300, 427200, 508700, 523800, 518800, 538100, 470400, 511300, 520900, 518700, 516200, 520700, 526600, 367700, 362200, 507200, 528800, 508200, 380900, 372500, 520300, 521500, 517900, 464000, 525900, 522299, 345600, 597300, 549000, 507000, 508800, 569100, 513400, 511599, 539300, 519700, 517299, 519300, 507600, 523200, 493300, 465700, 577300, 538600, 589000, 460100, 325400, 440200, 552600, 537500, 514200, 528100, 474900, 460000, 463300, 401500, 340400, 340200, 518700, 517400, 560500, 505200, 276800, 510800, 530500, 513100, 515000, 523300, 512000, 510600, 517400, 365200, 596600, 517500, 358600, 515700, 545500, 553000, 505000, 487000, 484700, 349200, 488700, 532400, 436200, 411300, 492600, 477600, 511000, 506500, 517299, 358800, 400700, 555400, 494900, 372200, 507800, 511300, 520300, 542100, 355900, 571500, 552800, 467500, 430700, 339400, 564100, 600000, 478700, 454500, 554800, 458400, 519300, 521700, 484099, 359500, 567700, 535200, 555500, 541900, 520500, 479700, 501100, 533700, 554300, 552300, 379700, 522500, 404900, 508300, 538600, 573200, 532700, 557100, 565900, 518500, 309200, 522100, 538500, 509400, 533200, 539900, 511900, 535400, 519900, 542900, 556800, 523100, 505900, 382700, 527400, 451500, 518400, 479300, 535600, 493100, 516300, 510800, 529600, 274700, 516500, 522400, 470500, 526800, 519300, 401300, 519000, 518900, 441599, 526800, 510100, 349400, 505000, 531900, 461100, 272200, 521500, 514799, 519200, 535000, 424300, 505000, 525600, 510500, 375100, 407500, 408600, 425000, 583700, 420700, 508100, 574900, 513700, 324400, 512299, 522900, 552100, 510800, 418200, 498000, 510900, 444700, 528100, 526300, 504099, 521300, 509500, 565800, 509700, 531100, 512400, 506400, 528700, 368900, 346700, 520300, 599300, 519400, 364400, 520100, 445700, 520200, 531600, 504500, 295700, 500200, 513200, 460600, 547600, 481400, 515700, 518100, 499700, 337200, 330600, 517500, 525300, 479000, 460400, 536200, 470500, 516100, 506500, 482200, 507800, 499600, 519099, 504400, 518800, 331800, 498100, 469400, 486200, 518400, 504099, 518000, 399400, 511000, 512200, 571100, 518000, 524900, 447600, 368500, 511200, 382200, 521000, 513400, 515600, 514300, 529500, 519400, 347900, 516200, 522900, 295600, 464799, 514099, 465600, 512000, 522000, 334300, 401000, 522700, 514200, 513900, 459099, 507700, 510500, 316200, 518900, 550100, 458700, 513200, 480300, 445900, 513400, 519000, 510700, 519000, 448300, 486200, 514400, 441700, 471200, 537400, 381700, 503700, 484799, 485800, 483000, 505100, 496599, 502100, 497800, 518000, 502500, 517100, 363100, 511400, 489600, 484900, 485300, 508000, 419300, 473900, 511800, 505800, 483300, 503700, 501200, 515200, 486100, 589600, 479300, 520400, 517299, 513300, 522100, 451700, 510600, 495600, 434900, 513400, 498600, 527900, 507400, 500300, 489300, 500700, 290900, 432000, 493800, 553300, 327400, 519799, 510100, 501500, 451400, 512400, 504400, 498200, 522200, 517800, 498900, 507200, 508300, 494099, 507400, 485200, 523800, 351500, 529700, 500700, 504500, 386000, 506400, 508300, 491700, 432100, 502800, 357100, 512700, 503000, 560900, 514400, 352000, 333500, 377100, 500500, 450100, 377500, 499799, 303100, 501800, 511000, 356300, 425300, 513500, 418000, 490600, 410700, 543000, 496700, 533000, 520000, 528400, 360400, 504900, 497400, 445000, 508600, 509300, 431700, 387900, 444799, 436200, 496000, 490500, 496900, 499000, 516800, 493000, 498700, 503200, 387400, 512900, 516900, 499400, 519400, 505500, 531300, 510900, 517700, 556400, 538300, 512500, 581200, 497200, 464200, 506200, 515000, 505400, 529900, 506100, 502600, 440800, 505600, 589800, 503100, 504099, 508200, 511700, 497200, 507800, 530800, 495000, 513100, 505600, 500700, 551700, 502600, 501599, 497900, 566800, 511100, 501800, 352200, 562800, 513500, 563100, 503000, 499099, 587700, 512900, 508300, 512700, 591100, 514200, 523800, 511000, 516700, 511900, 514300, 279100, 381800, 511700, 527600, 598300, 434600, 511000, 519900, 522200, 531000, 483500, 519700, 600000, 503700, 505800, 498400, 515800, 516900, 322900, 523700, 511500, 519600, 399600, 518500, 519700, 397500, 484600, 513700, 268630, 315400, 517200, 514500, 505900, 515300, 516000, 473100, 509099, 514500, 301900, 490500, 486900, 380200, 531800, 455000, 425100, 448300, 515200, 527100, 522299, 344700, 514200, 518500, 519099, 497800, 475100, 440200, 459700, 515900, 376300, 304500, 445500, 485800, 375000, 354000, 513200, 309700, 472900, 507299, 516300, 521900, 569700, 546300, 327100, 517900, 578300, 518800, 524000, 386000, 531300, 510600, 378600, 521400, 354000, 520200, 596800, 524200, 557800, 525100, 383600, 433600, 528500, 305900, 526000, 530100, 519200, 523900, 543400, 527400, 310200, 525900, 442000, 404400, 515800, 516599, 558500, 523300, 514200, 479700, 357800, 457800, 380700, 514900, 341800, 524500, 407400, 516300, 532800, 476599, 281100, 520600, 519500, 524300, 527000, 526200, 522400, 488700, 523100, 524200, 536500, 530300, 396000, 514700, 540900, 428100, 531600, 520600, 525500, 525100, 537000, 330700, 552700, 497800, 318000, 537300, 472299, 298100, 377500, 529200, 533300, 531200, 380000, 537300, 583800, 535800, 511200, 379700, 472600, 579400, 444400, 509799, 433500, 430500, 523700, 500600, 277800, 535700, 518500, 530200, 560800, 516200, 522700, 525000, 561000, 531700, 549000, 517200, 522600, 514000, 512200, 516500, 511400, 522600, 519700, 402100, 524900, 339000, 534900, 541700, 546700, 519600, 348100, 527100, 523700, 498600, 535500, 504700, 456200, 509300, 499500, 503600, 517700, 507100, 513500, 520900, 545600, 515300, 525500, 515300, 412700, 550000, 507800, 594700, 275700, 284100, 531200, 524300, 497600, 526100, 424000, 513200, 406100, 520600, 524000, 484600, 590700, 573700, 402900, 521400, 450200, 520500, 366400, 414500, 531300, 404700, 504400, 503100, 531300, 546200, 517299, 348800, 351000, 496900, 513600, 514900, 515200, 393600, 515800, 400400, 521400, 497700, 537300, 484200, 535100, 510100, 426100, 502400, 537200, 305700, 509200, 510900, 516200, 509900, 523000, 490000, 433000, 508700, 337600, 515800, 347200, 507700, 498500, 514099, 498000, 521300, 513600, 467700, 597800, 512600, 535700, 517600, 510400, 361500, 508400, 550900, 367600, 326100, 352700, 579200, 483200, 352800, 434600, 462100, 510700, 564600, 600000, 268630, 519400, 565500, 555200, 466900, 521900, 390200, 552600, 512000, 563600, 513800, 519600, 439900, 383100, 544900, 522200, 525900, 529000, 361000, 420000, 490000, 522000, 410200, 540600, 563200, 493900, 507500, 523200, 600000, 556000, 453800, 507800, 517100, 504300, 532700, 512000, 529500, 501800, 467100, 515700, 526900, 522299, 534600, 511400, 522400, 508400, 554200, 512900, 341500, 455800, 525300, 509400, 524099, 519400, 471200, 597300, 448200, 402800, 519300, 537200, 513000, 532300, 529800, 535000, 522700, 516200, 455400, 429700, 479799, 516400, 359000, 518400, 520400, 427200, 536700, 515900, 576100, 518100, 320200, 297400, 368200, 432600, 571800, 517600, 515400, 534900, 474200, 513300, 530600, 524099, 399500, 497299, 507500, 516500, 362100, 471800, 480600, 538100, 500400, 515800, 518200, 522000, 498000, 538500, 440800, 533600, 514300, 538000, 552600, 556500, 512000, 523900, 514099, 505700, 535800, 505900, 485100, 515300, 503500, 510400, 492200, 462600, 375000, 511599, 384700, 514500, 516400, 414300, 577900, 320200, 513300, 504300, 522200, 308000, 521500, 531300, 499300, 535800, 502600, 509300, 505600, 545000, 453800, 505700, 502000, 526500, 452900, 522100, 510900, 503100, 523600, 526500, 512800, 272000, 427299, 365300, 554800, 590700, 407900, 475500, 575700, 412299, 351000] + }, + { + 'id': 'Cylinder material', + 'label': 'Cylinder material', + 'tickvals': [0, 0.5, 1, 2, 3], + 'ticktext': ['A', 'AB', 'B', 'Y', 'Z'], + 'values': [0, 0, 1, 0.5, 2, 3, 3, 0, 1, 1, 2, 2, 3, 0, 0, 1, 2, 2, 3, 3, 0, 1, 1, 2, 3, 3, 3, 0, 2, 3, 1, 0, 1, 3, 1, 0, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 3, 2, 2, 0, 0, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 2, 1, 1, 2, 0, 3, 0, 2, 2, 0, 2, 0, 2, 2, 0, 2, 2, 2, 2, 0, 0, 2, 2, 0, 2, 2, 2, 0, 2, 0, 0, 0, 2, 0, 1, 0, 0, 3, 1, 1, 3, 0, 0, 2, 2, 0, 2, 2, 2, 2, 3, 2, 2, 3, 2, 0, 2, 2, 2, 0, 2, 2, 2, 3, 2, 0, 2, 0, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 0, 2, 2, 0, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 3, 2, 2, 2, 2, 1, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 0, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 0, 3, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 0, 0, 2, 3, 2, 0, 2, 0, 0, 3, 0, 2, 0, 0, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 1, 2, 3, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 0, 2, 2, 2, 2, 2, 0, 2, 3, 2, 3, 2, 2, 2, 2, 2, 2, 2, 3, 0, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 1, 1, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 0, 2, 2, 2, 0, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 1, 2, 3, 2, 3, 2, 2, 2, 2, 0, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 0, 2, 3, 3, 2, 2, 0, 1, 2, 2, 0, 1, 2, 1, 2, 2, 2, 0, 2, 0, 2, 2, 0, 2, 2, 2, 2, 2, 2, 0, 0, 2, 2, 2, 3, 2, 0, 2, 2, 0, 1, 2, 0, 2, 0, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 0, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 1, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 0, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 1, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 0, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 1, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 1, 2, 2, 2, 2, 2, 2, 3, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 3, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 3, 2, 2, 2, 2, 3, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 3, 2, 0, 0, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 0, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 3, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 3, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 3, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 3, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 0, 2, 1, 2, 2, 2, 0, 2, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 0, 2, 2, 2, 2, 2, 3, 0, 2, 2, 1, 3, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 3, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 3, 2, 2, 2, 3, 2, 2, 3, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 0, 2, 2, 2, 2, 0, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 3, 2, 1, 0, 2, 0, 2, 3, 2, 0, 2, 2, 3, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 3, 3, 2, 3, 2, 3, 2, 2, 2, 2, 2, 3, 2, 2, 2, 3, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 1, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 0, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 1, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 3, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1] + }, + { + 'id': 'Block material', + 'label': 'Block material', + 'tickvals': [0, 1, 2, 3], + 'range': [-1, 4], + 'values': [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 1, 0, 1, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 3, 0, 3, 0, 0, 0, 0, 3, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 3, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 3, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 3, 3, 0, 3, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 3, 0, 0, 2, 0, 0, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 1, 3, 0, 0, 0, 0, 2, 0, 0, 3, 0, 0, 0, 0, 0, 3, 0, 0, 3, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 0, 0, 3, 3, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 3, 0, 2, 0, 0, 0, 0, 0, 2, 1, 3, 0, 0, 0, 2, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 3, 0, 0, 3, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 3, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 3, 0, 0, 0, 0, 3, 0, 3, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 3, 1, 0, 0, 2, 0, 0, 0, 0, 0, 0, 3, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 3, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 3, 0, 0, 1, 0, 0, 3, 3, 3, 0, 0, 0, 0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 3, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 1, 2, 0, 0, 0, 1, 0, 0, 0, 0, 0, 3, 3, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 3, 0, 1, 0, 0, 2, 0, 0, 0, 3, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 3, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 1, 3, 0, 0, 0, 1, 3, 0, 0, 2, 0, 0, 0, 0, 0, 0, 1, 2, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] + }, + { + 'id': 'Total weight', + 'label': 'Total weight', + 'visible': true, + 'values': [160, 1324, 252, 1711, 173, 624, 228, 2474, 371, 3103, 312, 2408, 460, 1727, 754, 2457, 227, 1963, 354, 2797, 377, 1327, 462, 1009, 166, 1415, 1118, 1063, 593, 498, 959, 1331, 1146, 645, 921, 1596, 663, 568, 492, 833, 630, 445, 504, 394, 647, 314, 1039, 829, 911, 282, 925, 681, 581, 506, 368, 373, 628, 538, 418, 419, 478, 884, 847, 369, 410, 344, 396, 501, 510, 379, 733, 1649, 239, 1035, 1839, 967, 514, 875, 794, 414, 664, 447, 839, 540, 636, 499, 1059, 743, 173, 473, 519, 465, 623, 726, 631, 521, 643, 323, 424, 472, 657, 510, 521, 661, 690, 497, 1664, 2162, 828, 1062, 479, 1452, 574, 604, 1069, 766, 268, 369, 755, 644, 811, 636, 363, 375, 359, 378, 336, 413, 680, 431, 361, 493, 761, 412, 386, 339, 628, 390, 648, 611, 323, 369, 555, 142, 2133, 653, 392, 597, 740, 345, 345, 1211, 600, 396, 369, 390, 481, 498, 371, 337, 316, 363, 676, 330, 353, 527, 352, 329, 341, 349, 334, 357, 501, 363, 1066, 284, 307, 338, 367, 327, 901, 330, 367, 311, 543, 370, 355, 318, 398, 335, 346, 382, 337, 807, 365, 349, 350, 415, 346, 330, 337, 330, 2201, 489, 338, 322, 349, 744, 239, 327, 327, 317, 763, 303, 343, 334, 293, 298, 472, 558, 331, 769, 321, 315, 342, 2161, 325, 1667, 493, 328, 878, 328, 737, 315, 325, 317, 529, 727, 390, 320, 953, 729, 300, 538, 663, 333, 320, 309, 596, 591, 325, 300, 709, 303, 312, 501, 737, 306, 360, 320, 1585, 324, 196, 294, 827, 305, 316, 415, 557, 302, 550, 332, 289, 730, 319, 324, 369, 335, 532, 422, 315, 1423, 1091, 320, 323, 358, 307, 314, 317, 218, 414, 299, 323, 371, 322, 314, 311, 338, 310, 324, 319, 674, 305, 366, 356, 316, 338, 352, 343, 339, 327, 497, 323, 780, 427, 346, 311, 319, 307, 343, 312, 1695, 329, 293, 316, 429, 341, 315, 548, 330, 307, 331, 321, 427, 319, 530, 516, 310, 344, 724, 479, 2748, 667, 977, 426, 696, 755, 944, 474, 331, 314, 319, 381, 294, 282, 302, 264, 370, 449, 314, 1029, 318, 312, 706, 349, 508, 297, 293, 322, 531, 480, 396, 286, 367, 315, 308, 365, 302, 467, 302, 313, 421, 351, 295, 792, 296, 651, 305, 1207, 501, 325, 311, 302, 290, 693, 312, 681, 474, 296, 321, 305, 322, 312, 317, 453, 322, 312, 550, 331, 334, 297, 560, 324, 812, 311, 320, 336, 533, 316, 1305, 502, 857, 329, 1089, 521, 495, 1025, 316, 373, 301, 935, 685, 547, 311, 622, 851, 880, 175, 331, 343, 1122, 314, 494, 211, 329, 228, 307, 306, 302, 312, 324, 549, 354, 390, 443, 305, 303, 1364, 320, 352, 412, 328, 522, 1509, 303, 314, 326, 304, 376, 297, 354, 305, 303, 309, 324, 543, 1231, 306, 865, 477, 388, 388, 603, 532, 310, 1249, 321, 162, 431, 346, 880, 355, 789, 320, 383, 317, 317, 571, 324, 321, 810, 1075, 329, 363, 310, 385, 322, 1005, 344, 1169, 526, 286, 328, 558, 295, 505, 339, 608, 526, 352, 312, 391, 933, 448, 590, 411, 463, 391, 697, 1113, 327, 604, 845, 1066, 330, 435, 750, 325, 709, 523, 315, 353, 882, 736, 456, 1111, 1050, 454, 955, 1728, 423, 796, 793, 1348, 761, 970, 668, 459, 386, 783, 276, 820, 708, 501, 764, 445, 492, 464, 496, 419, 967, 1243, 751, 472, 377, 419, 628, 480, 701, 368, 486, 949, 668, 720, 570, 425, 576, 352, 449, 427, 1551, 349, 478, 370, 327, 381, 379, 333, 403, 387, 378, 368, 450, 382, 376, 1184, 330, 349, 416, 435, 381, 362, 362, 426, 379, 372, 345, 841, 432, 952, 441, 238, 313, 437, 392, 763, 719, 376, 370, 679, 387, 531, 591, 352, 377, 174, 366, 340, 383, 361, 341, 335, 346, 392, 390, 731, 477, 861, 419, 1073, 337, 523, 972, 624, 404, 485, 398, 1249, 366, 371, 400, 419, 344, 823, 365, 506, 925, 305, 628, 357, 323, 489, 662, 354, 833, 353, 369, 352, 342, 493, 366, 329, 862, 333, 361, 816, 785, 500, 502, 368, 343, 349, 366, 340, 325, 359, 371, 403, 333, 385, 336, 352, 716, 424, 395, 1525, 338, 342, 504, 392, 808, 362, 327, 300, 1073, 1137, 376, 332, 363, 340, 876, 396, 319, 339, 330, 290, 1026, 452, 339, 286, 336, 873, 514, 339, 363, 883, 334, 324, 331, 324, 324, 326, 313, 324, 325, 332, 313, 321, 309, 692, 296, 312, 303, 333, 649, 697, 374, 294, 357, 313, 316, 294, 316, 422, 450, 321, 331, 302, 713, 303, 335, 321, 916, 350, 313, 307, 313, 1121, 312, 1299, 481, 306, 1072, 304, 622, 970, 310, 310, 980, 472, 317, 535, 328, 898, 661, 386, 335, 320, 337, 309, 293, 1362, 351, 876, 403, 319, 514, 1102, 456, 309, 498, 706, 305, 922, 1655, 330, 284, 915, 305, 319, 522, 546, 307, 502, 341, 358, 450, 324, 314, 322, 320, 321, 388, 307, 297, 310, 605, 358, 1048, 322, 315, 468, 350, 179, 1056, 1079, 342, 319, 345, 348, 314, 329, 311, 488, 775, 318, 312, 510, 884, 776, 313, 304, 488, 329, 294, 501, 315, 381, 348, 450, 299, 414, 481, 1377, 342, 1135, 637, 302, 322, 309, 305, 311, 696, 303, 486, 293, 308, 1131, 541, 295, 1198, 319, 301, 293, 321, 1268, 281, 361, 304, 306, 339, 1439, 618, 644, 359, 302, 319, 297, 690, 327, 299, 300, 305, 503, 326, 309, 367, 392, 964, 325, 291, 317, 281, 386, 282, 281, 366, 351, 906, 198, 294, 733, 442, 350, 315, 359, 435, 1220, 322, 330, 307, 434, 313, 304, 1111, 313, 313, 330, 336, 764, 312, 286, 348, 924, 309, 327, 317, 364, 423, 294, 337, 323, 313, 718, 676, 323, 335, 332, 332, 321, 1004, 340, 324, 296, 312, 512, 311, 324, 306, 308, 313, 310, 367, 330, 317, 311, 307, 308, 309, 451, 312, 169, 320, 462, 316, 304, 314, 324, 311, 303, 316, 324, 316, 364, 305, 307, 332, 628, 303, 336, 305, 318, 305, 323, 305, 289, 314, 309, 274, 302, 326, 469, 404, 331, 323, 301, 690, 755, 327, 322, 299, 470, 319, 246, 692, 551, 327, 369, 334, 321, 694, 322, 313, 319, 758, 494, 536, 300, 483, 295, 407, 289, 330, 314, 212, 306, 312, 360, 326, 335, 310, 461, 1065, 299, 1554, 316, 883, 306, 314, 302, 381, 313, 939, 310, 298, 295, 1040, 613, 365, 317, 842, 311, 427, 322, 315, 358, 313, 356, 307, 305, 727, 303, 343, 674, 300, 314, 303, 311, 694, 456, 434, 320, 422, 307, 293, 311, 149, 510, 314, 704, 1070, 294, 309, 368, 299, 328, 471, 300, 292, 305, 309, 336, 306, 323, 323, 367, 319, 374, 311, 324, 449, 345, 175, 300, 330, 390, 740, 1029, 644, 532, 339, 966, 307, 325, 301, 245, 916, 334, 463, 373, 313, 671, 678, 298, 315, 286, 820, 312, 535, 340, 464, 322, 323, 416, 595, 571, 596, 753, 725, 295, 304, 294, 451, 308, 303, 310, 506, 308, 744, 308, 289, 311, 293, 455, 327, 263, 1153, 1348, 473, 148, 1811, 134, 294, 577, 834, 349, 287, 1848, 316, 1058, 839, 759, 799, 323, 501, 372, 598, 366, 454, 383, 334, 324, 323, 696, 763, 318, 351, 334, 321, 1631, 295, 354, 292, 321, 741, 1141, 318, 722, 320, 311, 303, 302, 323, 335, 442, 310, 807, 338, 324, 341, 958, 301, 327, 458, 321, 319, 318, 337, 670, 1254, 1019, 340, 193, 740, 308, 413, 336, 203, 330, 321, 336, 966, 561, 1178, 323, 329, 582, 306, 202, 455, 305, 1161, 845, 341, 396, 428, 1298, 973, 300, 692, 519, 296, 306, 441, 759, 572, 299, 628, 340, 514, 320, 296, 326, 569, 823, 373, 618, 410, 317, 313, 712, 210, 363, 717, 1324, 1247, 297, 315, 315, 313, 1031, 354, 312, 312, 208, 374, 338, 361, 704, 433, 320, 319, 295, 528, 291, 1356, 520, 802, 369, 856, 954, 612, 286, 316, 440, 901, 413, 373, 375, 301, 462, 645, 414, 356, 554, 2389, 377, 371, 735, 458, 368, 400, 355, 345, 756, 377, 381, 275, 417, 337, 611, 390, 326, 319, 383, 338, 375, 329, 730, 416, 532, 312, 312, 326, 741, 396, 292, 480, 196, 288, 375, 347, 477, 969, 311, 535, 1560, 328, 312, 719, 459, 299, 324, 312, 505, 325, 547, 1029, 342, 908, 308, 999, 336, 568, 466, 353, 645, 324, 518, 722, 285, 613, 699, 610, 1555, 792, 683, 302, 676, 582, 290, 865, 1675, 559, 398, 271, 459, 1523, 366, 276, 882, 488, 562, 381, 295, 339, 543, 381, 623, 551, 367, 459, 348, 309, 350, 335, 328, 792, 320, 323, 324, 767, 443, 567, 380, 290, 362, 337, 345, 483, 560, 467, 356, 334, 749, 631, 321, 460, 356, 328, 329, 241, 366, 703, 346, 515, 362, 465, 841, 344, 304, 341, 560, 364, 355, 381, 357, 194, 176, 341, 386, 322, 342, 1393, 185, 341, 499, 3154, 324, 435, 542, 353, 402, 292, 334, 413, 179, 806, 892, 494, 281, 527, 332, 655, 724, 1253, 300, 326, 302, 701, 570, 408, 669, 360, 466, 795, 373, 301, 316, 355, 312, 303, 307, 434, 287, 321, 321, 300, 686, 306, 324, 716, 316, 875, 323, 479, 751, 326, 547, 371, 438, 329, 734, 1176, 495, 2745, 736, 421, 327, 436, 323, 353, 670, 442, 300, 595, 369, 727, 484, 352, 369, 325, 341, 266, 481, 306, 323, 294, 493, 365, 400, 382, 372, 540, 310, 317, 932, 321, 404, 328, 303, 340, 324, 313, 315, 318, 331, 729, 1063, 306, 322, 339, 317, 455, 312, 693, 332, 416, 320, 362, 322, 327, 331, 1044, 309, 337, 363, 426, 407, 613, 471, 337, 321, 308, 326, 976, 318, 1265, 314, 874, 294, 319, 366, 337, 343, 453, 322, 481, 447, 749, 370, 337, 308, 316, 516, 385, 426, 349, 416, 585, 373, 353, 360, 194, 419, 311, 318, 317, 287, 341, 335, 587, 551, 393, 303, 288, 1113, 322, 313, 863, 329, 285, 276, 327, 345, 769, 956, 1183, 866, 765, 309, 668, 1849, 516, 395, 363, 427, 293, 359, 260, 1235, 339, 465, 329, 725, 242, 361, 302, 347, 318, 337, 333, 325, 313, 544, 318, 304, 436, 332, 638, 741, 969, 362, 309, 909, 751, 721, 934, 535, 1328, 221, 459, 341, 302, 287, 306, 883, 222, 351, 769, 326, 292, 353, 412, 3017, 791, 401, 1250, 603, 839, 584, 358, 381, 465, 455, 495, 609, 313, 305, 1283, 680, 404, 325, 344, 356, 987, 453, 530, 606, 391, 364, 175, 327, 610, 341, 333, 794, 448, 351, 1603, 417, 283, 395, 540, 338, 319, 354, 302, 339, 364, 526, 347, 357, 542, 840, 416, 301, 370, 191, 1251, 174, 512, 338, 329, 828, 721, 309, 777, 319, 325, 325, 322, 341, 293, 336, 314, 321, 303, 408, 257, 955, 322, 323, 323, 1101, 227, 478, 336, 350, 175, 486, 313, 359, 1170, 346, 336, 500, 282, 910, 295, 303, 971, 1226, 335, 285, 653, 1002, 325, 353, 382, 323, 334, 289, 305, 316, 349, 430, 677, 160, 914, 453, 595, 419, 173, 281, 920, 364, 331, 502, 657, 421, 311, 360, 665, 636, 327, 346, 407, 632, 471, 326, 336, 749, 391, 557, 381, 478, 442, 469, 303, 310, 292, 379, 453, 274, 312, 673, 321, 516, 371, 288, 446, 352, 318, 617, 315, 329, 939, 646, 497, 178, 394, 409, 180, 390, 922, 380, 465, 495, 396, 835, 391, 362, 511, 346, 308, 565, 345, 314, 346, 333, 316, 355, 348, 427, 360, 415, 1113, 813, 321, 486, 349, 363, 363, 359, 181, 317, 356, 223, 294, 326, 146, 372, 307, 465, 402, 275, 324, 317, 359, 316, 336, 506, 782, 298, 283, 500, 401, 412, 631, 342, 296, 311, 327, 323, 422, 321, 354, 1106, 357, 399, 333, 322, 380, 298, 345, 340, 340, 310, 354, 307, 336, 470, 258, 315, 361, 473, 326, 553, 666, 1079, 318, 326, 848, 390, 516, 344, 1169, 449, 324, 340, 310, 320, 300, 326, 305, 498, 288, 324, 312, 174, 344, 354, 409, 260, 331, 494, 1185, 309, 835, 336, 801, 428, 190, 303, 446, 185, 321, 532, 286, 493, 746, 536, 336, 499, 340, 373, 1164, 336, 378, 313, 883, 728, 344, 322, 360, 315, 353, 203, 384, 426, 369, 328, 386, 321, 337, 318, 301, 319, 320, 175, 300, 349, 296, 315, 686, 323, 698, 315, 427, 1174, 506, 396, 321, 464, 309, 308, 338, 370, 327, 313, 941, 323, 384, 194, 333, 1186, 329, 1325, 325, 558, 311, 373, 335, 323, 977, 542, 311, 460, 1188, 324, 332, 184, 2534, 322, 1325, 300, 305, 383, 250, 307, 316, 417, 297, 1378, 305, 330, 316, 506, 717, 173, 426, 637, 1256, 803, 305, 314, 718, 317, 439, 324, 755, 411, 310, 386, 325, 331, 550, 302, 309, 341, 1055, 328, 355, 265, 1013, 477, 533, 1710, 322, 315, 346, 719, 324, 844, 342, 311, 700, 424, 419, 998, 442, 664, 1037, 446, 754, 369, 321, 864, 316, 346, 322, 847, 470, 490, 865, 310, 994, 322, 501, 361, 390, 661, 332, 344, 657, 431, 322, 440, 398, 1876, 732, 292, 1528, 380, 351, 209, 476, 467, 1304, 337, 925, 378, 769, 555, 551, 774, 227, 503, 334, 205, 351, 493, 368, 304, 1131, 320, 484, 800, 281, 549, 306, 316, 809, 310, 325, 529, 939, 836, 179, 321, 176, 326, 189, 370, 327, 351, 822, 317, 308, 321, 301, 494, 346, 355, 306, 326, 318, 302, 298, 287, 323, 316, 329, 320, 475, 306, 527, 902, 575, 1023, 309, 520, 273, 723, 341, 373, 334, 854, 534, 333, 1296, 312, 318, 525, 1259, 406, 441, 309, 498, 663, 706, 423, 631, 794, 452, 393, 766, 371, 356, 309, 265, 321, 542, 379, 317, 394, 325, 522, 346, 378, 308, 1310, 358, 457, 372, 698, 799, 319, 978, 310, 307, 339, 959, 328, 598, 491, 509, 463, 337, 328, 340, 326, 475, 330, 323, 337, 290, 375, 308, 747, 310, 736, 315, 303, 369, 536, 1075, 539, 717, 1493, 477, 513, 1314, 409, 494, 454, 881, 337, 278, 2065, 1757, 212, 458, 708, 363, 560, 326, 137, 598, 390, 785, 928, 301, 1965, 321, 232, 295, 751, 354, 307, 674, 343, 398, 1135, 336, 462, 343, 290, 306, 328, 329, 334, 410, 312, 659, 335, 976, 342, 449, 293, 324, 703, 313, 2091, 583, 731, 863, 337, 292, 1122, 320, 784, 1010, 885, 1148, 1264, 492, 644, 454, 1033, 294, 655, 574, 250, 320, 1056, 617, 1132, 344, 192, 611, 686, 732, 672, 382, 449, 500, 474, 350, 314, 324, 182, 856, 1291, 347, 327, 349, 1909, 536, 461, 641, 507, 1004, 369, 445, 344, 441, 356, 341, 315, 855, 315, 404, 370, 297, 339, 465, 732, 366, 349, 396, 918, 534, 359, 508, 380, 357, 388, 465, 257, 805, 975, 321, 315, 335, 1028, 458, 838, 372, 997, 571, 335, 372, 886, 299, 306, 498, 552, 303, 449, 478, 927, 280, 415, 301, 234, 324, 346, 1107, 1192, 321, 548, 305, 983, 763, 455, 337, 985, 372, 600, 476, 555, 429, 612, 387, 391, 394, 530, 429, 410, 387, 412, 395, 333, 348, 294, 350, 413, 308, 361, 334, 350, 361, 355, 1161, 1772, 334, 185, 313, 330, 603, 397, 469, 373, 302, 465, 493, 344, 325, 297, 185, 355, 362, 324, 334, 334, 349, 345, 305, 299, 349, 328, 357, 467, 319, 891, 570, 245, 1310, 1273, 472, 775, 318, 288, 1076, 1412] + }, + { + 'id': 'Assembly total cost', + 'label': 'Assembly total cost', + 'visible': false, + 'values': [1125, 9274, 2735, 16920, 2193, 20704, 4814, 34689, 5565, 46554, 5225, 38887, 9746, 37715, 17798, 55250, 5697, 49083, 11226, 81939, 24258, 62488, 27363, 61924, 12511, 106196, 24444, 7443, 9111, 12527, 50738, 9320, 12291, 17571, 9508, 11176, 9142, 7687, 6724, 11219, 17825, 6506, 6367, 4966, 8495, 3860, 12844, 10688, 13026, 4007, 57281, 9790, 7335, 13748, 5358, 5393, 4401, 3769, 5233, 5058, 6047, 6188, 11899, 5297, 5154, 4406, 5061, 7022, 6358, 4721, 7723, 16745, 2651, 14194, 100772, 10504, 7021, 6131, 16730, 2904, 8334, 5968, 5876, 7394, 4454, 6800, 18376, 5204, 2190, 6146, 7013, 6412, 4361, 5082, 8028, 6484, 4504, 3832, 5687, 6174, 4603, 6913, 3651, 4631, 4833, 6532, 97138, 21918, 5801, 7435, 13138, 14597, 6070, 19943, 7487, 5362, 3945, 4907, 5287, 7937, 9998, 7852, 4820, 9385, 4686, 4751, 8594, 5144, 4760, 5899, 4614, 30326, 5332, 5030, 4759, 4429, 17294, 5192, 4542, 9333, 2261, 4911, 34968, 2179, 34658, 16325, 4811, 4185, 9017, 4224, 4435, 14536, 7129, 4772, 4726, 4840, 3369, 7428, 4504, 4316, 4097, 4399, 4733, 4105, 4597, 3691, 4405, 4245, 4195, 4168, 4694, 4421, 3507, 4615, 14408, 3607, 3956, 4295, 4583, 4138, 11128, 4147, 4602, 3940, 5590, 4505, 4377, 4016, 5191, 4199, 4269, 4686, 4375, 9716, 8664, 4371, 4294, 9779, 4396, 4183, 4247, 4112, 129671, 3426, 4257, 4102, 4386, 8822, 3138, 4040, 4066, 3950, 12502, 3787, 4273, 4238, 3678, 3660, 6006, 7725, 4172, 12580, 4056, 3920, 4249, 35461, 4054, 108185, 6568, 4154, 11735, 4090, 8971, 3943, 4062, 3857, 5408, 8982, 5662, 3974, 6673, 18248, 3739, 3770, 8110, 4129, 4050, 3826, 8314, 9053, 4022, 3718, 8838, 3786, 3874, 6244, 18434, 3815, 4491, 3954, 39629, 4009, 2456, 3643, 10976, 3783, 3946, 5151, 3900, 3730, 3854, 7621, 3597, 7909, 3959, 4022, 4585, 4130, 6699, 27180, 3935, 89225, 14401, 3962, 4022, 4459, 3816, 3938, 3931, 3041, 26734, 3722, 4047, 4583, 3998, 3907, 3887, 4191, 3858, 4033, 3994, 11019, 3777, 4482, 4277, 3968, 4237, 4378, 4264, 4212, 4049, 7410, 4020, 12723, 12452, 4283, 3862, 3953, 3803, 4276, 3866, 18642, 4063, 3648, 3901, 27631, 4251, 3875, 3837, 4109, 3808, 4083, 3993, 27553, 3950, 3715, 3617, 3819, 7947, 11786, 3358, 44432, 38355, 6845, 9723, 4878, 11458, 6609, 3321, 4964, 3884, 3963, 8633, 3627, 3471, 3780, 3359, 4582, 28916, 3896, 12827, 3908, 3865, 4945, 4276, 6296, 3685, 3657, 3948, 6513, 6549, 4829, 3554, 4503, 3893, 3820, 4464, 3720, 3270, 3743, 3861, 27079, 4284, 4335, 9658, 3671, 7768, 3772, 15008, 6611, 4023, 3840, 3957, 3579, 8798, 3870, 9817, 3319, 3647, 3955, 3782, 3981, 3845, 3930, 5570, 3975, 3856, 3851, 4094, 4130, 3676, 5579, 4013, 17649, 3704, 3967, 4152, 34352, 3909, 16007, 3517, 56056, 4041, 14115, 3652, 6567, 13776, 3906, 4618, 3729, 6550, 8592, 12494, 3885, 13919, 10616, 12510, 2200, 4164, 4256, 13850, 3877, 11216, 1477, 7529, 3283, 3802, 3773, 3728, 3868, 4104, 7658, 4381, 4671, 6364, 3789, 3774, 16177, 3965, 9465, 5965, 4054, 5330, 15225, 3764, 3865, 4058, 3775, 3758, 3704, 4368, 3729, 3767, 3828, 4150, 3804, 15268, 3815, 11823, 3345, 4872, 4659, 7489, 3729, 3868, 29343, 3997, 2114, 5553, 4292, 12800, 4382, 19742, 4101, 8777, 3940, 3978, 7211, 4103, 3980, 12415, 12316, 4082, 8375, 3841, 8810, 4128, 11997, 4269, 15031, 3683, 3614, 4116, 35845, 3653, 3538, 4223, 8373, 33766, 4411, 3863, 4728, 11456, 5587, 38362, 5111, 29991, 4825, 10478, 13283, 4010, 38799, 11943, 14042, 4038, 5282, 12235, 4027, 11570, 5328, 3914, 4404, 6180, 10126, 10305, 23044, 12414, 6658, 6690, 17090, 5813, 10147, 5552, 14343, 11440, 9605, 8565, 6188, 5280, 5483, 3629, 5741, 8375, 6864, 5353, 6098, 6015, 5678, 6594, 5520, 15985, 8704, 5263, 5731, 5020, 5553, 13258, 6541, 4909, 5117, 6779, 61602, 6992, 8510, 3993, 5627, 4035, 4817, 6048, 5638, 10862, 4568, 6015, 5021, 4284, 5133, 5166, 4381, 5240, 5107, 5232, 4897, 7559, 5099, 5020, 15005, 4330, 4830, 11538, 5852, 5130, 4805, 4753, 9282, 4965, 4964, 4540, 21046, 5789, 15483, 5931, 2900, 4104, 5939, 10136, 12664, 9245, 4934, 4829, 9958, 5014, 8126, 4141, 4664, 5028, 2236, 4825, 4450, 6349, 4727, 4520, 4438, 4538, 5013, 4969, 9032, 29764, 12658, 5571, 12826, 4427, 6303, 6807, 8189, 5126, 6691, 5004, 15571, 4613, 4841, 5437, 5492, 4572, 13590, 4729, 31885, 9172, 3977, 4397, 4489, 4192, 30894, 17398, 4636, 12650, 4567, 4597, 4625, 4501, 8431, 4569, 4265, 10628, 4315, 4627, 13535, 10198, 3503, 6671, 4717, 4428, 4557, 4727, 4387, 4179, 4651, 4798, 4920, 4306, 4756, 4240, 4542, 8949, 27217, 5130, 100064, 4412, 4353, 3534, 4753, 45902, 4727, 4278, 3988, 13557, 14324, 4833, 4152, 4563, 4299, 10786, 10025, 3990, 4245, 4201, 3703, 12584, 5588, 4231, 4049, 4219, 10855, 3598, 4248, 4530, 10756, 4306, 4004, 4135, 4069, 4192, 4082, 3919, 4071, 4059, 4177, 3922, 3982, 3841, 11321, 3668, 3855, 3796, 4226, 8651, 8405, 8613, 3628, 4544, 3889, 3934, 3673, 3943, 27240, 28881, 4011, 4120, 3737, 40767, 3746, 4190, 4026, 9678, 8023, 3928, 3813, 3904, 13989, 3909, 22474, 5945, 3795, 14047, 3829, 8130, 12089, 4416, 3859, 23854, 5822, 3941, 34877, 4097, 6289, 8372, 4738, 4124, 3961, 4110, 3843, 3763, 22330, 4302, 10698, 5011, 3960, 6460, 13165, 5659, 3833, 6159, 8569, 3728, 12430, 17360, 4081, 3556, 12850, 3802, 3962, 5382, 7233, 3823, 5937, 4512, 4425, 5552, 4024, 3882, 3993, 3970, 3997, 4806, 3793, 3723, 3848, 7973, 4442, 12803, 4020, 3904, 6002, 4338, 2233, 17184, 14084, 4271, 3942, 7932, 4327, 3882, 4098, 3837, 5936, 10801, 3953, 3865, 3573, 10508, 19422, 3855, 4313, 3419, 4098, 3648, 3507, 3942, 5038, 4350, 28905, 3717, 26636, 31080, 16310, 4550, 14594, 8871, 3743, 4000, 3809, 3784, 3870, 15692, 3764, 7100, 3653, 3821, 13999, 7394, 4537, 14574, 3960, 3737, 3643, 3972, 8878, 3501, 4511, 3785, 3810, 4214, 92394, 8440, 8972, 4418, 3717, 3955, 3701, 10342, 4052, 3730, 3688, 3796, 6183, 4046, 3823, 4535, 4834, 13248, 4026, 3616, 3936, 3491, 4754, 3483, 3528, 4498, 4365, 11386, 2894, 3620, 18349, 5466, 2455, 3885, 4448, 5426, 14879, 3993, 4086, 3797, 5588, 3885, 3773, 18127, 3875, 3891, 4095, 4159, 11648, 3866, 3565, 4317, 12171, 3823, 4053, 3922, 8253, 27165, 3649, 7753, 4005, 3871, 17967, 44240, 3984, 4138, 4101, 4124, 3966, 12588, 4194, 4016, 3667, 3851, 11327, 3833, 4023, 3798, 3810, 3874, 3840, 8337, 4063, 3925, 3852, 3812, 3820, 3828, 5671, 3844, 2457, 3964, 3237, 3922, 3762, 3880, 4014, 3866, 3752, 3931, 4022, 3918, 4517, 3779, 3801, 4107, 15710, 3752, 4170, 3771, 3965, 3775, 4004, 3779, 3585, 3903, 3836, 3382, 3748, 4032, 3283, 5534, 4099, 3997, 3732, 8711, 18895, 4040, 3984, 3701, 7008, 3970, 3088, 8520, 6614, 4162, 4436, 4138, 3979, 8524, 4013, 3861, 3965, 18961, 6070, 6394, 3698, 5940, 3645, 4818, 3582, 4120, 3910, 2799, 3779, 3893, 4458, 4022, 4108, 3820, 3227, 10985, 3685, 22218, 3925, 10987, 3806, 3865, 3745, 22845, 3873, 12636, 3830, 3697, 3640, 14144, 8228, 4503, 3912, 10683, 3832, 27508, 4369, 3907, 4705, 3860, 4686, 3807, 3775, 11854, 3763, 4259, 10998, 3715, 3918, 3754, 3837, 10320, 29350, 28013, 4806, 27181, 3783, 3626, 3838, 2197, 6793, 3880, 11481, 28248, 3636, 3818, 4555, 3699, 4061, 5737, 3704, 3612, 3780, 3815, 4160, 3795, 3964, 4006, 4520, 3967, 4631, 3837, 4005, 5551, 4224, 2573, 3722, 4063, 25150, 8949, 12712, 7939, 6700, 4162, 13481, 3801, 3966, 3741, 3298, 11662, 4130, 6268, 4621, 3866, 16793, 9268, 3710, 4199, 3545, 8357, 3845, 7090, 4227, 5999, 3976, 3986, 5145, 8848, 7687, 7778, 9672, 18129, 3671, 3758, 3623, 6176, 3829, 3751, 3839, 6623, 3818, 9382, 3824, 3567, 3876, 3648, 3187, 4050, 3274, 14438, 33701, 3315, 2019, 17972, 1935, 3651, 7236, 10042, 4314, 3418, 46207, 3910, 13235, 11016, 5315, 12999, 4040, 6042, 4600, 6015, 4556, 10560, 4629, 4154, 4057, 4028, 10213, 10194, 3936, 4337, 4100, 4017, 17640, 3666, 4336, 3605, 3985, 10013, 13900, 3940, 9771, 4029, 3830, 6681, 3749, 4002, 4144, 28335, 3851, 9628, 4190, 4020, 4209, 11639, 3714, 4051, 29534, 4001, 3943, 3919, 4181, 8921, 15249, 25498, 4413, 2570, 9094, 3781, 5196, 4153, 2806, 4299, 3944, 4153, 11672, 7329, 13429, 3990, 4059, 5928, 3770, 2724, 5689, 3807, 14139, 10239, 7795, 4983, 10307, 16032, 12418, 3739, 8526, 6457, 3656, 3791, 28264, 8997, 7054, 3697, 6385, 4206, 7040, 3971, 3702, 4031, 8243, 47305, 4623, 6289, 26518, 3919, 3896, 17804, 2868, 4490, 17926, 86514, 14833, 3636, 3919, 3900, 4163, 13083, 4797, 3872, 3870, 2921, 4626, 4389, 4492, 8805, 27930, 3981, 3945, 3652, 6474, 3616, 84260, 6441, 11593, 4576, 12714, 13232, 12893, 3555, 3922, 28141, 12058, 5088, 4661, 4667, 3727, 5861, 9001, 5727, 4432, 6923, 39382, 6197, 4625, 16568, 5855, 4562, 4751, 4391, 4257, 9707, 4869, 4715, 17117, 5311, 4147, 6155, 4805, 4006, 3954, 8680, 4167, 23759, 4134, 11938, 26580, 3728, 3886, 3880, 4065, 18544, 9038, 3609, 30977, 2647, 3585, 8622, 4313, 3341, 60270, 3902, 6742, 101532, 4069, 3902, 11753, 5734, 3706, 7359, 3882, 5163, 4062, 7403, 12706, 4274, 11082, 3834, 13857, 4180, 7733, 6289, 4394, 8664, 4020, 6487, 8926, 3545, 7424, 8967, 7105, 15471, 8990, 15930, 3739, 4733, 4080, 3681, 11600, 109361, 35468, 4939, 3449, 29173, 88421, 4596, 3452, 11753, 4978, 36214, 4717, 3650, 4247, 34932, 4724, 9055, 6852, 4699, 6300, 4318, 3863, 4364, 4208, 4057, 11771, 3994, 3980, 3999, 11116, 5528, 7493, 24623, 3933, 4465, 4205, 4283, 6279, 5729, 5893, 4439, 4200, 9248, 4421, 4061, 5686, 4450, 4066, 4108, 3132, 4617, 17583, 4328, 6506, 4535, 30003, 48630, 4313, 3777, 4245, 6884, 4535, 3881, 8812, 4461, 2683, 2233, 4284, 4820, 4040, 4277, 16571, 2554, 4242, 6285, 51154, 4044, 5770, 3800, 4401, 5008, 3647, 4158, 26583, 2467, 20174, 10786, 3461, 3497, 7861, 4243, 16393, 11861, 76828, 4026, 4071, 3740, 17541, 7580, 5092, 4687, 4720, 3266, 13157, 4661, 3747, 3893, 4432, 3893, 3761, 3795, 9961, 3574, 4001, 3976, 3773, 17165, 3782, 4045, 9144, 3962, 50212, 4029, 5950, 8949, 4070, 7221, 8644, 28169, 4062, 8752, 15000, 15842, 44456, 9155, 5309, 4053, 10116, 4046, 4394, 8316, 5514, 3711, 38351, 8468, 10339, 6030, 8029, 4578, 4029, 4222, 3390, 6727, 3803, 20095, 3644, 31728, 4573, 9131, 24869, 4656, 40536, 3844, 3932, 12001, 3974, 9248, 4031, 3798, 4203, 4056, 3876, 3886, 3939, 4057, 9567, 26598, 3804, 4015, 7758, 3949, 29312, 3902, 8209, 7521, 5578, 3987, 4785, 3995, 4079, 4112, 12730, 3823, 4210, 8367, 27490, 4937, 8779, 6457, 7775, 3957, 3823, 4042, 22441, 3978, 15741, 3913, 12279, 3646, 3940, 5004, 4172, 4199, 5890, 4245, 5994, 5525, 18737, 4526, 4310, 3837, 3909, 33292, 4777, 27477, 4301, 5769, 8151, 4658, 4344, 4495, 2657, 5789, 3851, 3932, 3934, 3683, 4207, 4138, 8298, 6530, 8710, 3782, 3585, 13380, 3997, 3900, 49974, 4074, 3540, 3419, 4076, 4261, 9672, 6695, 14148, 50140, 9092, 3985, 9640, 42657, 33535, 8852, 8334, 5261, 3730, 22730, 3339, 76534, 4819, 28020, 4070, 8981, 2923, 4505, 4593, 4316, 3911, 4185, 4135, 4015, 3895, 5559, 3947, 4231, 5169, 4122, 8906, 18540, 11809, 4399, 3866, 11489, 9502, 10162, 11780, 34617, 14012, 2961, 5785, 4343, 3766, 3585, 3799, 14853, 2997, 4256, 9665, 19975, 3645, 8150, 26579, 49058, 11073, 4814, 31254, 7724, 11033, 8315, 4314, 4509, 5916, 28810, 5994, 15238, 3883, 3771, 13249, 9488, 4866, 3982, 4169, 4354, 12208, 5757, 12358, 7437, 4743, 4418, 2405, 4048, 10157, 4252, 4071, 19869, 5500, 4254, 11221, 5164, 4153, 4884, 3785, 4207, 3912, 4325, 3755, 4161, 8314, 3687, 4203, 4409, 5546, 22831, 5131, 3903, 4589, 2432, 80943, 2199, 3585, 4205, 4049, 12623, 11762, 3815, 9929, 3934, 4023, 4371, 3987, 4218, 3830, 4139, 3910, 4533, 3782, 5007, 3306, 23891, 3988, 4008, 4002, 13496, 3002, 5976, 4142, 4357, 2414, 30186, 4189, 4749, 13952, 4589, 4189, 5993, 3502, 13135, 3665, 3739, 11784, 28602, 4450, 3574, 10675, 13041, 4002, 4349, 4771, 4001, 4159, 3482, 3804, 3884, 4343, 9972, 16927, 2221, 12913, 29211, 7041, 27050, 2402, 3485, 11956, 4511, 4063, 3515, 9775, 27027, 3871, 8808, 8094, 8066, 4060, 4286, 26107, 7034, 28205, 4038, 4148, 12288, 5029, 6825, 24260, 30775, 28412, 5946, 3777, 3890, 3615, 4738, 29181, 16464, 3920, 8606, 4059, 5257, 4640, 3570, 6020, 4387, 3958, 40271, 3907, 4062, 12193, 4527, 31964, 2436, 4879, 9400, 2240, 4846, 59578, 8689, 28097, 6135, 9008, 12433, 5015, 4496, 3579, 4307, 3807, 8084, 4643, 3879, 4300, 4138, 4068, 4424, 4336, 6213, 4457, 26961, 14333, 13269, 4073, 6316, 4332, 4492, 8378, 4443, 2350, 4011, 4427, 2909, 3752, 3989, 1997, 8651, 3891, 5882, 5091, 3443, 4074, 3974, 4512, 3921, 4204, 5164, 10883, 3711, 3570, 6328, 5074, 5141, 8367, 4363, 3678, 3889, 4145, 4042, 5286, 3989, 4476, 13140, 4539, 25758, 4129, 4004, 4694, 3864, 4295, 4277, 4463, 3857, 4439, 3782, 4186, 30163, 3261, 3942, 5408, 6214, 4099, 3875, 9581, 15415, 3965, 4083, 10985, 4853, 3614, 4321, 14442, 3146, 4061, 4248, 3869, 4031, 3748, 4124, 3763, 7007, 3547, 4060, 3906, 2375, 4294, 4412, 5156, 3421, 4143, 6916, 14716, 3866, 10080, 4168, 11257, 6132, 2617, 3796, 5781, 2543, 4022, 7851, 3579, 31698, 10449, 7074, 4179, 6623, 4294, 4985, 14197, 4219, 4643, 3871, 10871, 10158, 4303, 4042, 4687, 3933, 4395, 2669, 5223, 26888, 4835, 4120, 4863, 4033, 4234, 3945, 3787, 4005, 4006, 2384, 3737, 4331, 3717, 3897, 11221, 3970, 11405, 3906, 5170, 26275, 5172, 4725, 4027, 29448, 3856, 3820, 4221, 4553, 4084, 3920, 12274, 4041, 4563, 2432, 4168, 14781, 4089, 84860, 4055, 6853, 3917, 4639, 4187, 4046, 15864, 3795, 3896, 29479, 14289, 4031, 4153, 2588, 41096, 4004, 28909, 3755, 3826, 4556, 3108, 3827, 3932, 4954, 3685, 14009, 3794, 4092, 3929, 5161, 10867, 2372, 5304, 7846, 14855, 10527, 3801, 3892, 17953, 3898, 5557, 4010, 8929, 5144, 3868, 4846, 4033, 4106, 7961, 3734, 3844, 4228, 14218, 4070, 4390, 3578, 64666, 30739, 9257, 42766, 3995, 3910, 4320, 11739, 4026, 10762, 4262, 3868, 21774, 27155, 26769, 13667, 5432, 8575, 13691, 5792, 12304, 8357, 3962, 12225, 3930, 4287, 3987, 10619, 5986, 6403, 11136, 3844, 13668, 4749, 6511, 4570, 5367, 9270, 4129, 5042, 6824, 27699, 3999, 28366, 4786, 30493, 10545, 3619, 38201, 4702, 4334, 2851, 30809, 3274, 21828, 4164, 12971, 4680, 9109, 6845, 6667, 9545, 3102, 31606, 4117, 3017, 4334, 31897, 8413, 3756, 13786, 3943, 7094, 9861, 17684, 7372, 3802, 3923, 13130, 3832, 4035, 6716, 13120, 10771, 2451, 3981, 2509, 4019, 2530, 4595, 4017, 4468, 12432, 3922, 3813, 3969, 3716, 31879, 4280, 4485, 3782, 4025, 3901, 3719, 18455, 3560, 3943, 19801, 4049, 3957, 30692, 3774, 3690, 12946, 43153, 12827, 3480, 3642, 3492, 5065, 4683, 8439, 4097, 5979, 7318, 4074, 27698, 3828, 3955, 7204, 80055, 4851, 11026, 3846, 6536, 41579, 8716, 5304, 9580, 9725, 10335, 8879, 9245, 8502, 4393, 7028, 3207, 3943, 6586, 4696, 3914, 9070, 4049, 33617, 4304, 8600, 3814, 81235, 4422, 6506, 4557, 7048, 19991, 3954, 13795, 3822, 3798, 4260, 11751, 4101, 7718, 31546, 6384, 3247, 4172, 4088, 4228, 4035, 5786, 4094, 3987, 4185, 3877, 4554, 3840, 8856, 17877, 11098, 3877, 3743, 4629, 5448, 14210, 5504, 17927, 15188, 5892, 6491, 15609, 4910, 8230, 29322, 11412, 4175, 3866, 34283, 101349, 2855, 3210, 17724, 4466, 6815, 4038, 1938, 8412, 4895, 12817, 23221, 3737, 32782, 3984, 3123, 3650, 12300, 4338, 3889, 8256, 4272, 5260, 14199, 4117, 6801, 4269, 3612, 3803, 4083, 4070, 4216, 5383, 3891, 9386, 4152, 13778, 7919, 3149, 3636, 4064, 11473, 3886, 34380, 6906, 11939, 10572, 7726, 3639, 58427, 3988, 5494, 13997, 12759, 69547, 82624, 6238, 9041, 5960, 13276, 3667, 7896, 6782, 3844, 3967, 12716, 7470, 14500, 4257, 2617, 7419, 4804, 8821, 4705, 4733, 28271, 6839, 30762, 4321, 3868, 3984, 2542, 11350, 13299, 4292, 4368, 4264, 27377, 8775, 5744, 7910, 12689, 12160, 4769, 5551, 4261, 5514, 4379, 4244, 3879, 21386, 4042, 9266, 4556, 3667, 4165, 29895, 11939, 4558, 4237, 4917, 13036, 6889, 4424, 32664, 4694, 8153, 9377, 5507, 3342, 10823, 62847, 3939, 3912, 4122, 66439, 3210, 10350, 4615, 12868, 7511, 4255, 4616, 12370, 3704, 3788, 6565, 6764, 3760, 5382, 5920, 13436, 16417, 5747, 3951, 2810, 4018, 4297, 24861, 15191, 3990, 6731, 3764, 13253, 9573, 10539, 4175, 13712, 4754, 7612, 10652, 6949, 5321, 4285, 4785, 4906, 4827, 33385, 5270, 5091, 4739, 5003, 4787, 4146, 4299, 3657, 4368, 5066, 3848, 4575, 4150, 4381, 4496, 4471, 14916, 29694, 4159, 2529, 3889, 4098, 8034, 4757, 6803, 4640, 3780, 5750, 7248, 4255, 3991, 3723, 2276, 4447, 4513, 4048, 4071, 4323, 4361, 4313, 3757, 3874, 4314, 4087, 4463, 30169, 3933, 11064, 8721, 3231, 14337, 15420, 5613, 10373, 4057, 3450, 14347, 15572] + }, + { + 'id': 'Assembly penalty weight', + 'label': 'Assembly penalty weight', + 'values': [9, 794, 34, 1409, 17, 536, 39, 7133, 115, 9843, 107, 7017, 273, 5131, 1210, 9032, 82, 7312, 252, 16778, 760, 4349, 891, 4228, 123, 10800, 1593, 467, 260, 226, 2940, 803, 689, 420, 422, 1229, 275, 198, 150, 423, 423, 134, 146, 89, 248, 55, 612, 401, 546, 52, 4208, 307, 194, 257, 91, 93, 178, 133, 99, 98, 131, 345, 461, 90, 96, 69, 91, 160, 148, 81, 274, 1332, 31, 667, 11733, 502, 163, 354, 480, 67, 252, 120, 303, 181, 162, 153, 1142, 251, 17, 131, 165, 135, 162, 222, 230, 154, 198, 58, 109, 132, 189, 159, 102, 167, 218, 147, 11969, 2288, 316, 467, 234, 1025, 169, 497, 435, 265, 49, 82, 252, 234, 372, 229, 79, 127, 76, 82, 105, 97, 207, 115, 75, 1014, 259, 95, 84, 68, 404, 91, 183, 273, 49, 82, 1378, 14, 5405, 769, 86, 168, 308, 67, 69, 818, 200, 87, 79, 86, 100, 174, 77, 66, 58, 74, 206, 62, 73, 129, 71, 63, 65, 67, 71, 72, 116, 76, 696, 46, 55, 66, 77, 61, 460, 62, 77, 55, 146, 77, 71, 58, 93, 64, 68, 82, 66, 364, 113, 69, 69, 145, 69, 62, 65, 62, 19984, 113, 65, 60, 69, 307, 33, 60, 60, 57, 676, 52, 67, 64, 49, 50, 129, 196, 63, 690, 59, 56, 66, 5409, 60, 13549, 146, 62, 466, 61, 305, 56, 60, 56, 138, 299, 102, 58, 406, 1019, 51, 137, 247, 63, 59, 54, 226, 257, 59, 51, 286, 52, 55, 143, 1039, 53, 73, 58, 4807, 59, 22, 49, 411, 52, 57, 98, 129, 51, 143, 90, 47, 284, 57, 59, 77, 63, 162, 849, 56, 8935, 711, 58, 59, 73, 53, 56, 57, 30, 822, 50, 59, 78, 59, 56, 55, 65, 54, 60, 58, 532, 52, 75, 71, 57, 65, 70, 67, 65, 60, 173, 59, 717, 203, 68, 55, 57, 53, 67, 55, 1579, 61, 49, 56, 877, 66, 56, 142, 62, 53, 62, 58, 873, 57, 132, 126, 54, 98, 622, 103, 9106, 1860, 454, 148, 206, 412, 423, 103, 77, 55, 57, 118, 49, 45, 52, 40, 77, 960, 56, 603, 57, 55, 225, 68, 146, 50, 49, 58, 159, 142, 88, 46, 76, 56, 54, 75, 51, 100, 51, 55, 842, 69, 59, 353, 49, 236, 52, 829, 150, 60, 54, 54, 47, 277, 55, 309, 104, 49, 58, 52, 59, 55, 57, 116, 58, 55, 143, 62, 63, 50, 151, 59, 515, 53, 58, 64, 1357, 56, 961, 117, 3664, 61, 696, 128, 147, 639, 56, 79, 51, 342, 268, 245, 55, 311, 413, 505, 17, 63, 67, 713, 55, 199, 17, 89, 34, 53, 53, 51, 55, 60, 192, 71, 84, 130, 52, 52, 1033, 58, 122, 113, 61, 134, 1110, 52, 55, 60, 52, 68, 50, 71, 52, 52, 54, 61, 139, 861, 53, 464, 105, 86, 84, 207, 125, 54, 3281, 58, 15, 108, 68, 523, 71, 1197, 59, 120, 57, 57, 187, 60, 58, 483, 696, 61, 109, 54, 121, 60, 563, 67, 797, 130, 47, 61, 1473, 49, 119, 65, 231, 1307, 71, 55, 85, 491, 114, 1705, 96, 1039, 86, 346, 690, 60, 1724, 462, 677, 61, 106, 664, 59, 590, 134, 56, 71, 355, 338, 168, 1600, 612, 141, 437, 1438, 111, 367, 283, 942, 412, 453, 259, 128, 92, 277, 45, 304, 278, 156, 269, 123, 136, 121, 148, 104, 1063, 676, 257, 125, 85, 105, 301, 142, 232, 85, 150, 4912, 226, 287, 135, 108, 147, 77, 123, 109, 1131, 72, 131, 84, 63, 88, 88, 66, 95, 89, 90, 81, 222, 88, 85, 808, 64, 76, 179, 115, 88, 78, 77, 236, 85, 83, 71, 1381, 113, 1075, 118, 31, 58, 117, 144, 653, 301, 84, 81, 315, 88, 207, 155, 74, 86, 17, 80, 68, 166, 77, 69, 67, 71, 89, 88, 303, 989, 509, 105, 642, 67, 153, 405, 231, 94, 147, 90, 889, 76, 81, 98, 104, 71, 773, 78, 1146, 413, 55, 178, 73, 61, 1077, 421, 74, 503, 73, 77, 73, 69, 255, 76, 63, 420, 65, 76, 752, 363, 112, 151, 78, 68, 72, 78, 67, 61, 75, 80, 91, 65, 84, 65, 72, 292, 847, 91, 11709, 67, 67, 110, 86, 2467, 77, 63, 54, 662, 742, 82, 63, 75, 66, 434, 144, 58, 65, 63, 48, 594, 115, 65, 53, 64, 433, 119, 65, 75, 438, 65, 59, 62, 60, 61, 60, 56, 60, 60, 63, 56, 58, 54, 561, 49, 55, 52, 64, 254, 271, 115, 48, 73, 55, 56, 49, 56, 853, 954, 59, 62, 51, 1951, 52, 64, 59, 430, 100, 56, 53, 55, 717, 55, 1725, 131, 53, 681, 53, 229, 536, 63, 54, 842, 126, 57, 1413, 61, 321, 252, 84, 63, 58, 63, 54, 50, 2153, 69, 432, 92, 57, 151, 677, 118, 54, 140, 279, 52, 519, 1391, 61, 46, 538, 53, 58, 135, 178, 53, 140, 69, 72, 115, 59, 56, 58, 58, 58, 85, 53, 50, 54, 218, 72, 618, 59, 56, 127, 69, 18, 1321, 688, 67, 57, 98, 69, 56, 61, 54, 133, 382, 57, 55, 120, 434, 1165, 55, 60, 108, 61, 49, 114, 56, 86, 69, 957, 50, 814, 1112, 1052, 70, 751, 257, 51, 59, 54, 52, 55, 392, 52, 160, 49, 53, 726, 181, 64, 806, 57, 51, 49, 58, 629, 45, 74, 52, 53, 65, 9789, 237, 263, 72, 51, 57, 50, 337, 60, 51, 50, 53, 143, 60, 54, 76, 87, 580, 60, 48, 57, 44, 84, 45, 45, 75, 70, 470, 26, 48, 1034, 110, 56, 56, 73, 108, 837, 59, 62, 53, 110, 55, 52, 1450, 55, 55, 62, 64, 426, 55, 46, 68, 509, 54, 60, 57, 107, 846, 49, 93, 59, 55, 992, 2282, 59, 63, 62, 62, 58, 577, 65, 59, 49, 55, 208, 54, 59, 53, 53, 55, 54, 109, 61, 57, 55, 53, 54, 54, 116, 55, 19, 58, 98, 56, 52, 56, 59, 55, 52, 56, 59, 56, 75, 52, 53, 62, 758, 52, 64, 52, 57, 52, 59, 52, 47, 56, 54, 42, 51, 60, 101, 101, 62, 59, 51, 274, 1101, 60, 58, 50, 155, 58, 34, 270, 169, 62, 76, 63, 58, 272, 59, 55, 57, 1092, 137, 159, 51, 132, 49, 92, 47, 62, 56, 26, 53, 55, 73, 60, 63, 54, 98, 564, 50, 3025, 56, 444, 53, 55, 52, 564, 55, 537, 54, 50, 49, 667, 228, 75, 57, 409, 54, 869, 63, 56, 76, 55, 75, 53, 52, 623, 52, 66, 534, 51, 56, 52, 54, 337, 989, 902, 72, 848, 53, 48, 55, 15, 157, 55, 586, 1108, 49, 54, 76, 50, 61, 125, 51, 48, 52, 54, 64, 53, 59, 59, 76, 58, 79, 54, 59, 114, 67, 21, 51, 61, 726, 306, 600, 234, 162, 65, 594, 53, 59, 51, 36, 485, 63, 131, 79, 55, 867, 285, 50, 60, 46, 330, 55, 171, 66, 126, 58, 59, 98, 247, 199, 210, 330, 1010, 49, 52, 48, 126, 54, 52, 54, 151, 53, 318, 53, 47, 55, 49, 95, 60, 39, 760, 3499, 103, 13, 1582, 12, 49, 190, 388, 69, 45, 6497, 56, 640, 418, 246, 757, 59, 140, 78, 174, 76, 172, 82, 63, 60, 59, 331, 352, 57, 69, 63, 58, 1417, 49, 70, 48, 58, 336, 732, 57, 319, 58, 54, 72, 52, 59, 63, 918, 54, 363, 64, 59, 66, 515, 51, 60, 1002, 58, 57, 57, 64, 270, 883, 1867, 68, 22, 309, 53, 97, 64, 25, 64, 58, 64, 523, 186, 826, 59, 61, 166, 53, 24, 118, 53, 758, 400, 95, 90, 158, 954, 549, 51, 271, 153, 49, 53, 914, 320, 185, 50, 193, 65, 164, 58, 50, 60, 217, 2632, 79, 187, 810, 57, 55, 976, 27, 74, 988, 8719, 865, 49, 56, 56, 59, 614, 77, 55, 55, 27, 79, 67, 74, 283, 897, 58, 57, 49, 157, 48, 7908, 153, 430, 77, 511, 575, 285, 46, 56, 904, 492, 96, 79, 80, 51, 123, 265, 108, 72, 175, 6523, 163, 78, 437, 122, 76, 88, 71, 67, 333, 83, 82, 326, 100, 64, 181, 86, 60, 57, 119, 64, 639, 62, 622, 806, 126, 55, 55, 60, 1051, 128, 48, 1104, 23, 47, 116, 68, 104, 4048, 55, 164, 11963, 61, 55, 605, 120, 50, 85, 55, 125, 60, 183, 600, 67, 464, 54, 631, 64, 199, 132, 71, 253, 59, 153, 295, 46, 210, 284, 233, 1168, 369, 390, 51, 204, 156, 48, 454, 13920, 1427, 90, 42, 967, 9234, 76, 43, 469, 117, 1506, 82, 49, 65, 1401, 82, 262, 172, 78, 131, 68, 54, 69, 64, 61, 438, 58, 59, 59, 395, 112, 192, 700, 51, 74, 64, 67, 137, 155, 125, 72, 63, 318, 173, 59, 120, 72, 61, 61, 34, 77, 941, 68, 152, 75, 1036, 2493, 67, 52, 66, 177, 75, 68, 120, 72, 23, 17, 66, 85, 59, 67, 1079, 21, 66, 143, 11880, 59, 113, 134, 71, 92, 48, 63, 812, 20, 1241, 446, 111, 45, 195, 64, 778, 609, 7556, 54, 60, 51, 944, 195, 95, 214, 77, 100, 716, 79, 51, 56, 72, 55, 52, 53, 155, 47, 58, 58, 51, 897, 53, 60, 297, 57, 2646, 59, 130, 313, 60, 178, 115, 911, 61, 300, 801, 317, 9038, 308, 102, 60, 158, 59, 70, 255, 111, 51, 1691, 112, 345, 133, 101, 77, 60, 66, 41, 147, 53, 449, 49, 1156, 76, 131, 717, 79, 1595, 54, 57, 507, 58, 134, 60, 52, 65, 60, 55, 56, 57, 61, 315, 2179, 53, 59, 94, 57, 987, 55, 266, 89, 105, 58, 78, 59, 61, 62, 613, 54, 65, 109, 870, 93, 248, 138, 94, 58, 53, 60, 785, 57, 911, 56, 491, 49, 57, 83, 64, 66, 120, 61, 132, 113, 1080, 77, 66, 54, 56, 1274, 84, 868, 69, 109, 217, 79, 70, 74, 23, 110, 55, 57, 57, 48, 65, 63, 223, 169, 123, 52, 47, 692, 58, 56, 2946, 61, 46, 43, 60, 67, 339, 407, 779, 2965, 325, 56, 298, 6838, 1303, 125, 108, 103, 49, 585, 39, 6512, 75, 852, 61, 298, 32, 74, 66, 68, 57, 64, 63, 59, 55, 145, 57, 58, 105, 62, 259, 1056, 528, 73, 54, 476, 325, 335, 501, 1382, 903, 29, 121, 67, 52, 47, 53, 846, 30, 69, 339, 438, 48, 103, 812, 10805, 400, 89, 3049, 211, 419, 223, 71, 80, 125, 938, 137, 693, 55, 52, 820, 294, 91, 59, 66, 71, 553, 118, 235, 207, 85, 74, 19, 60, 416, 66, 62, 1242, 113, 69, 1218, 98, 54, 88, 136, 65, 57, 70, 51, 65, 108, 129, 67, 72, 145, 710, 98, 53, 78, 21, 7564, 17, 120, 65, 61, 500, 611, 54, 350, 57, 60, 64, 58, 65, 50, 63, 56, 66, 52, 93, 38, 1462, 59, 59, 59, 684, 30, 130, 63, 69, 19, 1015, 59, 77, 762, 71, 64, 139, 45, 552, 49, 52, 529, 3101, 67, 46, 501, 592, 59, 70, 83, 59, 63, 46, 53, 56, 69, 153, 885, 16, 541, 981, 196, 841, 18, 45, 498, 75, 61, 115, 302, 836, 55, 114, 248, 233, 60, 68, 780, 225, 860, 60, 64, 649, 89, 175, 668, 1088, 925, 127, 52, 55, 48, 82, 979, 293, 55, 263, 59, 130, 78, 47, 121, 70, 57, 1886, 56, 61, 519, 172, 1172, 19, 88, 137, 18, 86, 4092, 118, 859, 139, 127, 489, 89, 74, 116, 68, 53, 210, 72, 55, 68, 63, 58, 71, 69, 123, 73, 842, 723, 775, 59, 139, 69, 74, 109, 73, 19, 58, 72, 29, 50, 59, 13, 115, 54, 124, 93, 43, 60, 57, 74, 56, 64, 126, 388, 50, 46, 144, 92, 97, 238, 67, 49, 55, 61, 59, 102, 58, 72, 679, 73, 763, 63, 59, 81, 52, 67, 66, 68, 54, 71, 53, 64, 1041, 38, 56, 92, 133, 60, 144, 294, 1454, 57, 60, 422, 86, 121, 67, 775, 93, 60, 66, 54, 58, 51, 61, 52, 159, 47, 60, 55, 18, 67, 71, 96, 40, 62, 156, 798, 54, 390, 64, 412, 121, 22, 52, 116, 21, 59, 195, 46, 1153, 356, 171, 64, 149, 66, 84, 762, 64, 80, 55, 441, 337, 67, 59, 76, 56, 71, 24, 90, 815, 80, 61, 85, 59, 65, 57, 51, 58, 58, 18, 51, 69, 50, 56, 551, 59, 572, 56, 102, 1107, 126, 87, 59, 983, 54, 53, 65, 77, 61, 56, 523, 59, 82, 21, 63, 802, 61, 8238, 60, 175, 55, 79, 64, 59, 1136, 134, 55, 994, 788, 59, 63, 21, 7677, 59, 1377, 51, 53, 81, 35, 53, 57, 96, 50, 932, 53, 61, 56, 126, 371, 18, 103, 229, 875, 382, 53, 56, 993, 56, 111, 59, 316, 96, 54, 85, 60, 62, 203, 51, 54, 66, 679, 61, 71, 42, 4768, 1085, 289, 4911, 59, 56, 68, 608, 59, 412, 66, 55, 604, 842, 817, 619, 110, 258, 642, 117, 668, 110, 58, 484, 57, 68, 58, 410, 127, 142, 437, 54, 617, 71, 147, 75, 95, 280, 62, 80, 216, 879, 59, 926, 88, 4185, 356, 48, 4600, 81, 69, 27, 1094, 100, 1870, 64, 548, 81, 328, 174, 170, 339, 31, 1122, 63, 28, 70, 1173, 111, 52, 719, 58, 160, 362, 352, 183, 53, 56, 781, 54, 60, 161, 562, 408, 19, 58, 20, 60, 21, 78, 60, 71, 486, 57, 53, 58, 51, 1170, 68, 72, 53, 60, 57, 51, 377, 46, 58, 439, 61, 58, 1085, 53, 129, 538, 1842, 598, 55, 126, 43, 201, 72, 113, 62, 339, 177, 62, 1294, 55, 57, 172, 7283, 91, 176, 54, 147, 1940, 282, 102, 288, 355, 167, 125, 328, 113, 71, 78, 39, 58, 164, 81, 56, 128, 60, 1299, 68, 116, 53, 7338, 72, 136, 78, 237, 1244, 57, 618, 54, 53, 66, 519, 61, 209, 1141, 148, 98, 64, 61, 65, 60, 126, 61, 59, 64, 51, 78, 54, 310, 336, 388, 56, 52, 77, 141, 691, 143, 929, 1094, 129, 151, 960, 93, 272, 989, 455, 64, 49, 4784, 12101, 27, 96, 959, 74, 176, 60, 12, 230, 87, 724, 1656, 51, 4285, 58, 32, 49, 659, 70, 54, 256, 67, 94, 736, 63, 146, 66, 48, 53, 61, 61, 64, 100, 55, 284, 63, 616, 97, 92, 48, 60, 583, 55, 5038, 189, 627, 420, 93, 48, 3879, 58, 289, 644, 522, 5278, 7955, 139, 266, 122, 622, 49, 240, 182, 46, 58, 623, 213, 745, 67, 22, 209, 216, 299, 207, 83, 899, 155, 1094, 69, 55, 59, 21, 440, 828, 68, 64, 68, 4618, 334, 121, 232, 511, 565, 79, 113, 67, 111, 71, 66, 56, 1396, 57, 134, 77, 49, 65, 1026, 632, 76, 68, 89, 549, 166, 72, 1224, 82, 104, 131, 120, 39, 394, 4543, 58, 56, 63, 5089, 98, 398, 78, 581, 194, 64, 78, 500, 50, 53, 148, 172, 52, 112, 129, 577, 286, 108, 53, 30, 59, 68, 987, 823, 58, 169, 52, 590, 333, 172, 64, 616, 80, 207, 181, 176, 104, 172, 85, 87, 87, 1255, 104, 95, 84, 95, 87, 63, 68, 49, 69, 96, 54, 75, 63, 70, 74, 72, 786, 3447, 63, 21, 55, 62, 219, 88, 148, 79, 52, 122, 167, 67, 59, 50, 19, 72, 74, 60, 62, 65, 69, 67, 52, 52, 69, 61, 72, 1047, 57, 451, 238, 35, 934, 908, 124, 364, 58, 46, 698, 1102] + }, + { + 'id': 'Height st width', + 'label': 'Height st width', + 'values': [236630, 326876, 347086, 437333, 457543, 105963, 568000, 216420, 236630, 326876, 347086, 437333, 457543, 105963, 568000, 216420, 236630, 326876, 347086, 437333, 457543, 105963, 568000, 216420, 236630, 326876, 350300, 210200, 106030, 349000, 288700, 328200, 262300, 251400, 384900, 435500, 224500, 273000, 276300, 224500, 222900, 202100, 394000, 418300, 302200, 475800, 338900, 296400, 115700, 276700, 298200, 163400, 380500, 282000, 226600, 233500, 404799, 451800, 424400, 493100, 397500, 337600, 157200, 242399, 421400, 403700, 397600, 239400, 416300, 441200, 354000, 354000, 315599, 151100, 269600, 255900, 270900, 422299, 488800, 240300, 376900, 318200, 302800, 262600, 238000, 277400, 122130, 405500, 455999, 353400, 287200, 269800, 292400, 290200, 357200, 417600, 519200, 544600, 318600, 345200, 352600, 283500, 172500, 168299, 427900, 332800, 84900, 307400, 418600, 214700, 280000, 407700, 366200, 114300, 86100, 393700, 239000, 341900, 358600, 413900, 382700, 412600, 344099, 375500, 372100, 428300, 365400, 436500, 390500, 288300, 403900, 301000, 376599, 470700, 460900, 374300, 246200, 333300, 349700, 106600, 514099, 341100, 364700, 229730, 388600, 339000, 466700, 491500, 419400, 478100, 398200, 372500, 493300, 498400, 396200, 445300, 367700, 164300, 487500, 402400, 388300, 496400, 405900, 453400, 376000, 470600, 440900, 396300, 469500, 523200, 275700, 457800, 474700, 409900, 167700, 425800, 402200, 418300, 441599, 426700, 364200, 435800, 433000, 427500, 432600, 485600, 464000, 431000, 365300, 440200, 467200, 467200, 384000, 433200, 425500, 437500, 474500, 424600, 416500, 421100, 429000, 451200, 429099, 507200, 430000, 414000, 431599, 475600, 385700, 465100, 454900, 450700, 425800, 451900, 449099, 420500, 447200, 480400, 389200, 244500, 430400, 437900, 430000, 452800, 452800, 300300, 449000, 348100, 313200, 425100, 227200, 448900, 421700, 446400, 445000, 494000, 453100, 394799, 223600, 460500, 352500, 448200, 457800, 500200, 424099, 456300, 428300, 464500, 225400, 109600, 461700, 465200, 381200, 449300, 461200, 418900, 445500, 451599, 440600, 465800, 380400, 464400, 469200, 469600, 248600, 462700, 451700, 441800, 303800, 469300, 496800, 463900, 459000, 291500, 458100, 459300, 450100, 469799, 393900, 465000, 448300, 222700, 203400, 461300, 455000, 447700, 456599, 444700, 463100, 310000, 470800, 457000, 442600, 459600, 458900, 457900, 447000, 457200, 456100, 456000, 446400, 453700, 463100, 472700, 514300, 440400, 440700, 449900, 452800, 454799, 463100, 166300, 452000, 462400, 244600, 460400, 462100, 463200, 466700, 447900, 465700, 132900, 465300, 461400, 469799, 461700, 449000, 473500, 505700, 450300, 461100, 469099, 457100, 469000, 462200, 499099, 509000, 476800, 456000, 484099, 424200, 399900, 192900, 463600, 453700, 306300, 75800, 467700, 458000, 202200, 464300, 456900, 467500, 474099, 481300, 447400, 430600, 453200, 456200, 461300, 322500, 479300, 465400, 401599, 475900, 429200, 466500, 456900, 480000, 441900, 280300, 475200, 466500, 472400, 465100, 462600, 476100, 473200, 470100, 463700, 468800, 459700, 482500, 232300, 409799, 464200, 476900, 466200, 295700, 325500, 464099, 471500, 377900, 472700, 350600, 464500, 159700, 468300, 473500, 470500, 462400, 467299, 470900, 462700, 452200, 470100, 469700, 506800, 461200, 460900, 466000, 525900, 463500, 448500, 534900, 462800, 465400, 454300, 465300, 308000, 471800, 486300, 474400, 237100, 500300, 319100, 186400, 469099, 452900, 468800, 152200, 372500, 432600, 448400, 444200, 354300, 131400, 461799, 436300, 456800, 326800, 469400, 449000, 273800, 467200, 272300, 466300, 471300, 473600, 464099, 425100, 236000, 456900, 510700, 223500, 457500, 457100, 375300, 464500, 320700, 221200, 467100, 458200, 388900, 463500, 472600, 454600, 462200, 533800, 455700, 461500, 491400, 459799, 465200, 407400, 497700, 296800, 456300, 193500, 465800, 427299, 507400, 407000, 392299, 449900, 506900, 451800, 414299, 374799, 456800, 98600, 463500, 453300, 407700, 455600, 459099, 441400, 382100, 426900, 462400, 49000, 133200, 459799, 451800, 464600, 456400, 407400, 419700, 456300, 236500, 500900, 437800, 439500, 435900, 465500, 477700, 451599, 240400, 438900, 438500, 464600, 494700, 369600, 427800, 483600, 437400, 482400, 456800, 102700, 401700, 478500, 425900, 147600, 212500, 482800, 478700, 465900, 458800, 458900, 464400, 459900, 444700, 394000, 211700, 459099, 455200, 434000, 195500, 482600, 435700, 282400, 323900, 386599, 257900, 86800, 504000, 337000, 301300, 299500, 390400, 376300, 390200, 488000, 271100, 426000, 283800, 456700, 459500, 314100, 344000, 352400, 274700, 404700, 471200, 336200, 336300, 510000, 283600, 484500, 280700, 248900, 447800, 379200, 486200, 294000, 337200, 383800, 305400, 305900, 338200, 378200, 366900, 405700, 313600, 372600, 320300, 303900, 365200, 365400, 349700, 284000, 339600, 322700, 334000, 334799, 261800, 369900, 290300, 283400, 309200, 319600, 343800, 359500, 242600, 360300, 334400, 361700, 488500, 315600, 470800, 311100, 506800, 374400, 295800, 344300, 343800, 322400, 359500, 369300, 138600, 376500, 127700, 383100, 351300, 336599, 435700, 355200, 368800, 392100, 366800, 351200, 353100, 364600, 396400, 401400, 393200, 342600, 89900, 330200, 405400, 364600, 479600, 279400, 307100, 407900, 265200, 422100, 283500, 422400, 367200, 302700, 352800, 347100, 373600, 379400, 373400, 505500, 383600, 411800, 428000, 385600, 380800, 278900, 366700, 54500, 384700, 443500, 362200, 362200, 248000, 441800, 388300, 374000, 386700, 400000, 347800, 293000, 409300, 315100, 395800, 390600, 373100, 384000, 392700, 401500, 380800, 380700, 475500, 391900, 454099, 429099, 389099, 373300, 444200, 369200, 427299, 373500, 414600, 359400, 491200, 433700, 370200, 372700, 357200, 287600, 281900, 390900, 445700, 430500, 423300, 375800, 362000, 445000, 441100, 415900, 415600, 356200, 441200, 447600, 279400, 437800, 355700, 423500, 437800, 443000, 395700, 393900, 467500, 445100, 438300, 391300, 442100, 443200, 438800, 448500, 433800, 444300, 458400, 460100, 450500, 468000, 469400, 447800, 421000, 278700, 446599, 452000, 472000, 411900, 459000, 454700, 452600, 448500, 466200, 441400, 449200, 451400, 466700, 456599, 467100, 444099, 442700, 325700, 460400, 443900, 462700, 452100, 304500, 442299, 98600, 438800, 464000, 219899, 435300, 316200, 334600, 265200, 458700, 295400, 441400, 454600, 503600, 444600, 179800, 361500, 467100, 472500, 463400, 486599, 458200, 410100, 372900, 476700, 391599, 441800, 458500, 401800, 401700, 433700, 462299, 431900, 433100, 486100, 203800, 257800, 464099, 452299, 141800, 456800, 459099, 430800, 309900, 454300, 520600, 352700, 460900, 448100, 455400, 466300, 459400, 461500, 456100, 448100, 470600, 445200, 462400, 306100, 451200, 361000, 449700, 461500, 375500, 457299, 480099, 458200, 226800, 446500, 466500, 459900, 452000, 468400, 451300, 470700, 465800, 184800, 456100, 463000, 465300, 447200, 467700, 474000, 269800, 441200, 451500, 463900, 444200, 446000, 346500, 444000, 444799, 457700, 459799, 464300, 376300, 345000, 242200, 217100, 466400, 457100, 473400, 462900, 457500, 424400, 461100, 191500, 458000, 460500, 319000, 265700, 188500, 344900, 458400, 461700, 462200, 462100, 93699, 458400, 438100, 458500, 457000, 455300, 322900, 250100, 215900, 465200, 474900, 459099, 457000, 109100, 459600, 457100, 479900, 459500, 442800, 459900, 468400, 458500, 457200, 162700, 462800, 460300, 457600, 462400, 461400, 472400, 447400, 466700, 452299, 328700, 266600, 476700, 456599, 443900, 480800, 471700, 452900, 429900, 334600, 461700, 463400, 469600, 376100, 457800, 464099, 429099, 466300, 457200, 459200, 463000, 68100, 465800, 460500, 455400, 241600, 466100, 462100, 467100, 469600, 452700, 461800, 459400, 460800, 465100, 461000, 506900, 470400, 465700, 465700, 457000, 467000, 316400, 464700, 462000, 465200, 470500, 472299, 471700, 459799, 462700, 466500, 465900, 466700, 468300, 469700, 463500, 463700, 462500, 465200, 462800, 414000, 473000, 280800, 461800, 465200, 462500, 470000, 468000, 459300, 460900, 464400, 456200, 457100, 463700, 449600, 463700, 466100, 460700, 465500, 466700, 457500, 465900, 453000, 467200, 462800, 466100, 467100, 456500, 463000, 478300, 463200, 462400, 465200, 293600, 460500, 463100, 465000, 361500, 464700, 464900, 465700, 469300, 173400, 454700, 454700, 406300, 482500, 417200, 509400, 461100, 459799, 410300, 452200, 471300, 455200, 429000, 444500, 495100, 473400, 445800, 470400, 534200, 466300, 449300, 454099, 385700, 468500, 451100, 453700, 470700, 476599, 472400, 467000, 370700, 474000, 451800, 458700, 352800, 460500, 475000, 466800, 262000, 465700, 202200, 466100, 463200, 473500, 163700, 275600, 462000, 471000, 323000, 471400, 461500, 321700, 462400, 359500, 473200, 358400, 463100, 464900, 467800, 458500, 453400, 463800, 464300, 451900, 467500, 472900, 117600, 456900, 465800, 205600, 460600, 474500, 471200, 473300, 270800, 309600, 467700, 473900, 196100, 469700, 469099, 453900, 468600, 464500, 467500, 472800, 471500, 464099, 470700, 459000, 464200, 478300, 461300, 466599, 456000, 454600, 470500, 465600, 441200, 477900, 263100, 464099, 469799, 464799, 434300, 340900, 413100, 395300, 475200, 138900, 468300, 490700, 460700, 349600, 303000, 465300, 294700, 451900, 470600, 464700, 234500, 460100, 349600, 468500, 431000, 470800, 312100, 454900, 363600, 465800, 468800, 449099, 143500, 281200, 322100, 318600, 460600, 461700, 468900, 475400, 283100, 458400, 466400, 466400, 335100, 461900, 353600, 459400, 476300, 455000, 461200, 455900, 461200, 465500, 291600, 416300, 461599, 358300, 415700, 295100, 465000, 395100, 427400, 461000, 542900, 343400, 463400, 311200, 264500, 305500, 480500, 444900, 480300, 456200, 493000, 446200, 429700, 494700, 450600, 441100, 452299, 133300, 251600, 462299, 461100, 474200, 444400, 181900, 460200, 478100, 471700, 459400, 238700, 351400, 461200, 239100, 437100, 475500, 507500, 463400, 462299, 462900, 437500, 458400, 452900, 457000, 458900, 466800, 388800, 473700, 459300, 459200, 453000, 469099, 471000, 458600, 275500, 336200, 293500, 381100, 380000, 401700, 479000, 417600, 463600, 327800, 380400, 474300, 461400, 399500, 328500, 127000, 467600, 468600, 457600, 475100, 357800, 420900, 453900, 348300, 413700, 466800, 422500, 400400, 293700, 287800, 455400, 406100, 418200, 473900, 462800, 441200, 475000, 426400, 468000, 460300, 459500, 267400, 457299, 452800, 466800, 181400, 459000, 454200, 456000, 479200, 466100, 454400, 464700, 339300, 458400, 461900, 426100, 388300, 485000, 457000, 462400, 354500, 288400, 316400, 460600, 462200, 305900, 455000, 382000, 446800, 375600, 464200, 455900, 465200, 467800, 444700, 460500, 200200, 425200, 126400, 453500, 76800, 151600, 514300, 464400, 460300, 433000, 220300, 453600, 437100, 442600, 468300, 395300, 212600, 278700, 448400, 404500, 241900, 435599, 441200, 418600, 383800, 451700, 526300, 459600, 465700, 319200, 382500, 451300, 364000, 397200, 470400, 485500, 461100, 474900, 461100, 468100, 467600, 407600, 434099, 441700, 432100, 401200, 455600, 456100, 450200, 444700, 457500, 470400, 462500, 358700, 459700, 454200, 452200, 454600, 261100, 442400, 392299, 375600, 456000, 449300, 449500, 421100, 463700, 473500, 454400, 457100, 447200, 278600, 342700, 445100, 387800, 457800, 141700, 451900, 263500, 298400, 448000, 268200, 461000, 405500, 393500, 461000, 453200, 332000, 175430, 431300, 192500, 389799, 465100, 386599, 443900, 429300, 223500, 380000, 389099, 446000, 425100, 409900, 432400, 429500, 453600, 231100, 465500, 443000, 453700, 471900, 441599, 445400, 447900, 164300, 413300, 400200, 278600, 453600, 448500, 443700, 434400, 465600, 92899, 450700, 469200, 466000, 132700, 427800, 308300, 490400, 331700, 463900, 446400, 454200, 352900, 450500, 405000, 444200, 432299, 391900, 343400, 427400, 441300, 441300, 459300, 447700, 401300, 421599, 439300, 441900, 391000, 434700, 467700, 107400, 439600, 458300, 449500, 432800, 446500, 324400, 446400, 440200, 330100, 452600, 435500, 434700, 442700, 443800, 363800, 332700, 450700, 400800, 333800, 448300, 332299, 441300, 445900, 437400, 456200, 451700, 463200, 336800, 434300, 409700, 440600, 464400, 157100, 407800, 343300, 431200, 240400, 343000, 447500, 467700, 458500, 297800, 432900, 510700, 363300, 457400, 360400, 437000, 460300, 474300, 442200, 451000, 464799, 466599, 447000, 461000, 450700, 461200, 442800, 441000, 469600, 448600, 335500, 443300, 87300, 450200, 427400, 463300, 447299, 313700, 441700, 458000, 469300, 466300, 250500, 164200, 379799, 379400, 414900, 459799, 436000, 444400, 446100, 395500, 429600, 467800, 443600, 456500, 167900, 424000, 465600, 452100, 459300, 459799, 426700, 247000, 459600, 355000, 467400, 452800, 435100, 458200, 514799, 435800, 455100, 463300, 458900, 278900, 462600, 454400, 473600, 446200, 460800, 445300, 466500, 472200, 463200, 477100, 286800, 438400, 457600, 452800, 464900, 455000, 459300, 449400, 484700, 477200, 320300, 453200, 352100, 460100, 450100, 457900, 365900, 466000, 445700, 453600, 470000, 485600, 185200, 276300, 457600, 469000, 459000, 458700, 358200, 446000, 284600, 455100, 150600, 463100, 468100, 302300, 462600, 477299, 356100, 361900, 422600, 445400, 459900, 474600, 406500, 456300, 465300, 454000, 448000, 467500, 465700, 274100, 229300, 440200, 467400, 443600, 338300, 279000, 465500, 465600, 461800, 409099, 466300, 463500, 208200, 509799, 489700, 452600, 457299, 385900, 456200, 455700, 474300, 461700, 466800, 470600, 449000, 462700, 352600, 343200, 384799, 473300, 466400, 400500, 162700, 333500, 491300, 476900, 456500, 453700, 419799, 410400, 413500, 211200, 260200, 258600, 460700, 389300, 520200, 440300, 195500, 448900, 475300, 453200, 455900, 466300, 456200, 453000, 461100, 296400, 527300, 458700, 212900, 457100, 380800, 492000, 449300, 319000, 345500, 181500, 316700, 466800, 281000, 365100, 408400, 413600, 457000, 454900, 463100, 263800, 353500, 496500, 354500, 318800, 455400, 454799, 468800, 318300, 174300, 505700, 460100, 352700, 261500, 200900, 504799, 539700, 391599, 390900, 471800, 404799, 464000, 468100, 343600, 204400, 501000, 479200, 497800, 481000, 346800, 395000, 415000, 429000, 488600, 491000, 341100, 465000, 345900, 447200, 481500, 516200, 455200, 498300, 392100, 444900, 238000, 452700, 477299, 449000, 478100, 479300, 458100, 476900, 462500, 483700, 498700, 460500, 448200, 213900, 454799, 392700, 453000, 443500, 383100, 461099, 456200, 450500, 472400, 50800, 460600, 468200, 323300, 471100, 462000, 332500, 462200, 458800, 383400, 468200, 454000, 274600, 450500, 461300, 411700, 139500, 464799, 457500, 462200, 345200, 378000, 418900, 466900, 448000, 336200, 333500, 343100, 351800, 394799, 349700, 447900, 493200, 463600, 102500, 459799, 469799, 388600, 449799, 349200, 446200, 459700, 247100, 471500, 464700, 435300, 464400, 449799, 518000, 455100, 476300, 450200, 437100, 476400, 332900, 133100, 463700, 505100, 466900, 325300, 470500, 264700, 456000, 474300, 444400, 125900, 445800, 457800, 398000, 434900, 362900, 457700, 457000, 447100, 251400, 246200, 459900, 466500, 416800, 385200, 440300, 418700, 456000, 450000, 394900, 453500, 443300, 467600, 436100, 462100, 282700, 441300, 341700, 426800, 464300, 437200, 467100, 304500, 448100, 455500, 499799, 462299, 467299, 263300, 268000, 448200, 343200, 451599, 448300, 483599, 445000, 416000, 459400, 267800, 428600, 460800, 79600, 390100, 449799, 400100, 450300, 467900, 199000, 327900, 467600, 452700, 454700, 398200, 444099, 448300, 210400, 455400, 500600, 244100, 449799, 420400, 350300, 451400, 455000, 452600, 455700, 412800, 427500, 451100, 397500, 415600, 481400, 349699, 443500, 427800, 399700, 408300, 455500, 437500, 444700, 432400, 462100, 441800, 463900, 185799, 458200, 437500, 392200, 411000, 434099, 289700, 409400, 459099, 449799, 422500, 445400, 424799, 458200, 420600, 412500, 412500, 470500, 458400, 456000, 455400, 393500, 449000, 433500, 366700, 458200, 434300, 474400, 447200, 439600, 441700, 443700, 196500, 336800, 434200, 492100, 166000, 468000, 453200, 442500, 285900, 442900, 442600, 435600, 317000, 465200, 440100, 446100, 452700, 435500, 453500, 424799, 470400, 236100, 479600, 442000, 448200, 348100, 444600, 444900, 416599, 379700, 443000, 243800, 302000, 447200, 422000, 454799, 166700, 230799, 335000, 445600, 362900, 336599, 441599, 167700, 450100, 448500, 185000, 316300, 453700, 315300, 428000, 332900, 344600, 435500, 467600, 464900, 374700, 194500, 442900, 438800, 374000, 452100, 446200, 390800, 304700, 384200, 362400, 436200, 419600, 438400, 437700, 460500, 437900, 440700, 445400, 349400, 459400, 455100, 445600, 463900, 451200, 475300, 456200, 462000, 484900, 358500, 459000, 517100, 438800, 400500, 450700, 460400, 444600, 465600, 447299, 446000, 254200, 447400, 528300, 468000, 444000, 295800, 453100, 325400, 449500, 434099, 438100, 446700, 445300, 442200, 480400, 437500, 445300, 438300, 370800, 453300, 441800, 309600, 381200, 456200, 367600, 448800, 443700, 526200, 468400, 453300, 456400, 524400, 461500, 380300, 456599, 458300, 455600, 461000, 87200, 343800, 435700, 416599, 399400, 273700, 456500, 464500, 466100, 476000, 402000, 462600, 480600, 429500, 450100, 428200, 458200, 458300, 188200, 470700, 456400, 459400, 175500, 460500, 457200, 341000, 350400, 453400, 194830, 106000, 460200, 458600, 443700, 459400, 458500, 313900, 447900, 459200, 133900, 434799, 431599, 161000, 455200, 326200, 214100, 360800, 456599, 469600, 466000, 142100, 458000, 457400, 462299, 343900, 386700, 342800, 293100, 461000, 156300, 222700, 346900, 418900, 288500, 201700, 454099, 223299, 399799, 452299, 459200, 467100, 504200, 408100, 149400, 466300, 469600, 451800, 462500, 340500, 472800, 455200, 244800, 462200, 140900, 453600, 474700, 427100, 465700, 389799, 334000, 360600, 470300, 254000, 464600, 469400, 461100, 470600, 350800, 471599, 188700, 386200, 401900, 288700, 461500, 460600, 500100, 468900, 456500, 380900, 143000, 296400, 341400, 458000, 300100, 467500, 367800, 450700, 476200, 410700, 62000, 464799, 465200, 468000, 474400, 465100, 461599, 423200, 469400, 467100, 481700, 477800, 349500, 463800, 485700, 381800, 474500, 464300, 466599, 471599, 477200, 113300, 493400, 311900, 274700, 478300, 420600, 165100, 302200, 471200, 475600, 433400, 262600, 480100, 398300, 482000, 454500, 264100, 302400, 513500, 365400, 454600, 333500, 333800, 400000, 423900, 108400, 399000, 447100, 469200, 433400, 457400, 460300, 476599, 516800, 476100, 457400, 450200, 467000, 451200, 454200, 450900, 449700, 463300, 465400, 200400, 462200, 230600, 470800, 470600, 486800, 463300, 120200, 473000, 469799, 436900, 370300, 445600, 340400, 446900, 407100, 448000, 458200, 448300, 453000, 463500, 464900, 456800, 469000, 455500, 352299, 486700, 452600, 475800, 212200, 89100, 476500, 471200, 430500, 470400, 204800, 456300, 335800, 364600, 440400, 389500, 380500, 506700, 354900, 464700, 278100, 461100, 303600, 219100, 397500, 359900, 449500, 445800, 468300, 451200, 459700, 316799, 212399, 425900, 452400, 441400, 461800, 198800, 458900, 351200, 469500, 437400, 476400, 427200, 419000, 448800, 345100, 297400, 479400, 188700, 447900, 459099, 461900, 451300, 465200, 428500, 350600, 452800, 181000, 456500, 119400, 452700, 444099, 462100, 439099, 467200, 458000, 290200, 505300, 455500, 387100, 464200, 458200, 248299, 451100, 463800, 140500, 110900, 157000, 434900, 391700, 204100, 343500, 263900, 458100, 456100, 509300, 200030, 462900, 390900, 451800, 251300, 461400, 348600, 449700, 430900, 442299, 434600, 452200, 375500, 273700, 487900, 460800, 471100, 472700, 319500, 244300, 349700, 461000, 342000, 480900, 478600, 450600, 424900, 410900, 565100, 387800, 382100, 428000, 456300, 424799, 471000, 451200, 474700, 432500, 407000, 451599, 462400, 470200, 476000, 452500, 466200, 442900, 495500, 442500, 124800, 352400, 462600, 444799, 457500, 463100, 404900, 523500, 397700, 232700, 397299, 481900, 457000, 474200, 403300, 482800, 375700, 450300, 262200, 314400, 417200, 450500, 156700, 465600, 466500, 326200, 441700, 462200, 502800, 433700, 92300, 243100, 275000, 372100, 533400, 460300, 454000, 364500, 249700, 456200, 435600, 470700, 190600, 358500, 434300, 456900, 138500, 401400, 368700, 465200, 399900, 439799, 446599, 454000, 426900, 470800, 364900, 459400, 441500, 471500, 483200, 490300, 452600, 462900, 461800, 442800, 464600, 450500, 418100, 456000, 440300, 445900, 427100, 240000, 191600, 452000, 344300, 458900, 457900, 289300, 513200, 204800, 446900, 449799, 440500, 183600, 461000, 475000, 445400, 503799, 438400, 444500, 447299, 488200, 388800, 442900, 439700, 473300, 394600, 460800, 452299, 438700, 465500, 470800, 354400, 116900, 377600, 195300, 341300, 515100, 245600, 415600, 528700, 188700, 163700] + }, + { + 'id': 'Min height width', + 'label': 'Min height width', + 'values': [5137, 113712, -5909, 102666, -16955, 135803, -28000, 124758, 5137, 113712, -5909, 102666, -16955, 135803, -28000, 124758, 5137, 113712, -5909, 102666, -16955, 135803, -28000, 124758, 5137, 113712, 42910, 126039, 135736, 46100, 54920, 113880, 100220, 91860, 52140, 104500, 110480, 82230, 69120, 136490, 97950, 79780, 44390, 23330, 86870, 1469, 130450, 114629, 184720, 32180, 56400, 131980, 58430, 63240, 59330, 58640, 29810, 11790, 25690, 13330, 39900, 70460, 160410, 55770, 25179, 18490, 27650, 79830, 40630, 16900, 41369, 118770, -2760, 190000, 119920, 85020, 73980, 49120, 51200, 41940, 71030, 51970, 75200, 80390, 70520, 69910, 119636, 40720, -16800, 48360, 70910, 66170, 54730, 66650, 70930, 41940, 8919, -8201, 48240, 50080, 44120, 70290, 74640, 94410, 30920, 56720, 187800, 170140, 45710, 124420, 59660, 90450, 24040, 129420, 173100, 45500, 37120, 34300, 52610, 59770, 89350, 59000, 32820, 23020, 26780, 19180, 19350, 22770, 37900, 56130, 21080, 41360, 49010, 16290, 14480, 23140, 90940, 39390, 43869, 138650, -19100, 34470, 34630, 12036, 102620, 24060, 14260, 9980, 71280, 5559, 19670, 141580, 37160, 9199, 23650, 17750, 22180, 99940, 7589, 17540, 16790, 5080, 34200, 7580, 25040, 7300, 13060, 17520, 6419, -1381, 41910, 10830, 4100, 20210, 188340, 5209, 12970, 14960, 15149, 11780, 105870, 10600, 16640, 9179, 9750, 7869, 9400, 9640, 34300, 10610, 7640, 12680, 21000, 76650, 12170, 13130, 6909, 19100, 16490, 13150, 12810, 7980, 97129, -2571, 12800, 13140, 14170, 59090, 4630, 5150, 6889, 6050, 13490, 3860, 10260, 13930, 3160, -1600, 40730, 88140, 11680, 11560, 10280, 5390, 9440, 131340, 7570, 144740, 60570, 12210, 142160, 8029, 70330, 6570, 8240, -1070, 5180, 75360, 64130, 4979, 73200, 7920, 2460, 3080, 60010, 7470, 10450, 2600, 99590, 134120, 5400, 1179, 76180, 4209, 3650, 38840, 8910, 4250, 14170, 3999, 76350, 4860, -15060, -341, 128230, 2330, 5859, 22060, 44500, 770, 4769, 1039, 539, 53740, 5130, 5729, 13939, 5580, 48450, 1110, 6199, 164570, 179370, 4720, 6339, 12740, 3569, 6740, 4089, 13730, -641, 2360, 8390, 12540, 5500, 4519, 5790, 8100, 4159, 6329, 7200, 2510, 2199, 9430, 1130, 7710, 11010, 11439, 9619, 8699, 5529, 99290, 6729, 7670, 60320, 8769, 3379, 4350, 2020, 10470, 2929, 187500, 5399, 839, 2790, 2430, 9999, 1970, 2979, 8070, 2849, 5110, 5679, 979, 4449, 2559, -410, 829, 3989, 279, 11130, 130020, 63780, 48590, 15020, 59370, 174670, 44850, 4510, 57900, 3340, 5340, 6710, -1150, -4031, 4400, 1400, 13450, 5500, 3909, 133800, 1570, 2959, 38050, 6499, 37810, 599, 1560, 1949, 38340, 66110, 13230, -1020, 9730, 3350, 2790, 8729, 109, 1679, 1690, 2440, 1910, 5659, 43820, 80340, 739, 47080, 1709, 164110, 58980, 5069, 1810, 16480, -1550, 81400, 3139, 133160, 2669, -821, 3349, 2360, 4120, 1960, 4129, 25520, 3660, 2260, 2959, 6350, 6830, 559, -3540, 5040, 62340, -8401, 4570, 6469, 14420, 3509, 172060, 4749, 38850, 3860, 167900, 1540, 59530, 176210, 2949, 13930, 819, 132560, 74890, 34410, 5559, 41260, 102000, 174330, -17380, 10730, 8950, 144260, 2560, 24580, 6370, 80, 22540, 2060, 1019, 160, 3180, 11580, 88900, 10470, 6260, 73860, 3119, 2980, 158220, 4309, 30660, 68780, 5040, 3770, 99260, 1980, 1970, 6829, 2289, -20080, 2310, 9650, -2251, 2529, 2530, 14700, 3959, 166700, 3599, 150930, 3459, 20810, 6590, 55690, 22690, 5139, 69, 6480, -12630, 37400, 9400, 186250, 9540, 10830, 14040, 9070, 4760, 7700, 56650, 11310, 4790, 194180, 128610, 6400, 7109, 2769, 9170, 14430, 104370, 9179, 178490, 1839, 3649, 9690, 20490, 339, 3980, 9289, 97370, 16590, 13480, 3039, 9209, 108480, 29490, 14640, 22230, 2340, 15880, 155060, 121920, 2909, 27250, 163260, 172970, 2660, 18100, 5159, 5870, 3790, 2880, 4320, 12500, 56360, 125710, 17810, 19190, 106000, 83140, 42550, 104300, 56000, 102609, 49720, 119469, 171680, 32940, 81140, 57710, 46010, 47900, 12410, 51430, 52000, 71890, 38220, 59550, 30110, 25690, 60750, 41920, 42970, 122470, 41700, 24520, 36670, 43590, 28380, 65420, 20490, 46900, 74830, 23260, 30570, 53800, 48360, 44400, 28940, 38850, 55090, 44390, 117250, 26040, 38180, 40279, 21509, 40690, 43770, 23870, 34920, 35680, 47920, 34530, 10209, 38060, 36900, 172090, 22500, 41440, 48970, 51970, 40759, 32670, 29570, 8320, 32190, 36220, 26469, 7490, 50070, 16550, 52680, -14320, 18900, 55380, 31810, 30419, 92140, 31910, 29040, 139770, 30299, 117280, 30630, 29670, 36720, -13690, 31170, 24230, -7440, 28120, 27790, 26429, 26000, 27230, 25920, 76240, 30360, 186670, 44830, 116240, 24560, 29890, 95180, 82150, 26890, 70680, 23220, 173160, 18330, 29520, 47580, 40140, 29100, 28250, 26230, 27280, 29190, 15910, 28300, 15970, 18410, 23929, 86500, 26960, 195790, 23360, 15049, 27500, 25880, 29740, 14950, 18950, 98230, 19830, 21830, 33440, 109480, 16040, 61550, 23600, 20700, 24970, 25500, 19860, 15920, 25010, 26910, 14280, 18950, 15430, 12709, 22380, 78950, 4990, 32920, 110000, 23040, 16230, 26429, 10009, 14770, 27599, 21410, 19900, 149800, 159730, 25800, 9250, 16530, 14280, 99670, 28780, 7340, 11060, 14120, 7850, 123859, 27430, 9960, 32360, 11210, 104469, 14710, 11570, 14290, 95429, 18660, 4369, 9129, 9270, 17570, 8890, 6709, 9220, 7710, 11250, 6599, 5370, 3400, 4270, 179, 2290, 4540, 13700, 93360, 59470, 8529, -851, 19020, 4139, 5289, 2350, 6269, 990, 8240, 7010, 8050, 1210, 4560, 1259, 9949, 8110, 64180, 3909, 6729, 2690, 5280, 150810, 6709, 148720, 32080, 2289, 171240, 6690, 79710, 122870, 39720, 3809, 122739, 30200, 5390, 5709, 8730, 118730, 74280, 13320, 5130, 4419, 3000, 3679, 9389, 63420, 6690, 95570, 20350, 5090, 44240, 120660, 29440, 2999, 35740, 63700, -1540, 155930, 145400, 5790, 939, 175990, 3370, 5030, 8129, 69630, 3980, 19400, 27460, 10430, 25930, 6300, 3050, 5360, 4789, 5870, 16930, 1360, 3990, 3170, 79640, 12030, 125269, 7050, 3980, 42910, 9890, -19210, 25280, 170010, 10610, 3749, 3420, 10510, 2749, 7790, 1890, 27759, 140190, 5329, 3289, 6660, 82810, 7319, 1650, 37550, 8889, 7769, 499, 9579, 6610, 35280, 11940, 7629, 2200, 1180, 7390, 159380, 29129, 172160, 108520, 1330, 5769, 1170, 2310, 4110, 54490, 2309, 90020, 1360, 3090, 147650, 79810, 53960, 148120, 5100, 1890, 669, 4730, 190970, -570, 14780, 2929, 3439, 8649, 133040, 96310, 110079, 9729, -151, 4940, 2090, 151720, 6060, 2439, -1190, 2919, 34290, 5939, 2029, 12110, 15930, 175700, 5290, 589, 4910, -1241, 14340, -2690, 1250, 10480, 10930, 116080, 17710, -1590, 6629, 25540, -11360, 2330, 11860, 27210, 153740, 5040, 5950, 1549, 37630, 4259, 2010, 34760, 2959, 4410, 6640, 6889, 179130, 2920, -60, 9899, 144140, 2350, 5719, 3420, 4159, 3330, 799, 2390, 5310, 3079, 4840, 18340, 3719, 6260, 5810, 7309, 3969, 132430, 7079, 5280, 549, 2090, 22160, 1699, 5679, 2509, 2129, 2999, 2469, 4830, 4780, 3960, 3040, 2710, 2440, 2859, 32670, 1659, 9360, 4670, 2080, 4059, 1059, 2789, 5639, 3589, 1709, 5050, 6039, 3850, 13180, 2140, 2079, 6579, -1821, 1389, 7799, 1739, 5910, 1610, 5020, 1809, -721, 4659, 2929, -4720, 1829, 5420, 2709, 50380, 6510, 4900, 1380, 78330, 6539, 5170, 4370, 409, 92280, 5740, -5240, 67910, 33020, 13450, 3690, 6899, 5139, 67240, 6620, 2099, 5599, 13440, 32679, 28520, -180, 30930, -421, 4630, -641, 8349, 5080, 129, 1480, 5289, 11870, 4140, 4360, 1450, 1629, 67510, -421, 21240, 4620, 106560, 2909, 1640, 1290, 35360, 3020, 158790, 2440, 1200, -911, 186220, 88630, 11220, 2760, 109090, 1729, 2269, 30290, 3889, 28940, 1820, 28870, 2559, 1930, 3350, 2659, 9469, 690, 1270, 5479, 1309, 1579, 149430, 6060, 2289, 55039, 1910, 699, -770, 1540, 6850, 64080, 2819, 850, 166420, -441, 1869, 13020, 480, 5479, 25160, -31, -981, 2100, 1620, 7470, 2270, 2390, 5259, 10760, 5520, 13850, 1910, 4650, 26980, 5580, 13470, 1379, 4770, -2110, 67810, 128539, 59940, 48220, 5219, 184470, 1770, 699, 2079, 11750, 124680, 6210, 59900, 14120, 2260, 1140, 110020, 1779, 23809, -1401, 34390, 1970, 67430, 8870, 44820, 4270, 3970, 20880, 123800, 80690, 74260, 98010, 5329, 1080, 1170, -1370, 60700, 3479, 1419, 2499, 57480, 2859, 87760, 3290, -2181, 4539, 859, 3010, 5810, -4340, 158760, 53230, 3790, -6940, 115210, -171, 389, 54720, 81370, 9070, -12800, 102100, 3790, 140870, 125290, 66200, 5500, 7980, 26760, 13240, 4789, 14150, 23180, 8039, 8580, 8720, 6790, 144350, 118030, 4259, 9330, 4600, 7759, 166130, 1229, 6909, -1090, 5270, 118510, 139370, 4460, 115410, 8939, 1140, -9890, 1809, 5070, 6720, 8089, 3749, 72070, 8120, 5770, 6959, 106649, -31, 6090, 5920, 6360, 3400, 2849, 7780, 97370, 157360, 62720, 21920, -2180, 75390, 69, 26280, 6740, 7990, 20550, 2700, 7050, 104860, 67500, 140930, 4179, 4890, 9140, 459, 2829, 31800, 3839, 142650, 86160, 1739, 22910, 25480, 175740, 136730, 2790, 68020, 41520, -771, 2410, 7269, 61130, 47270, 539, 12740, 7960, 74870, 5390, 2690, 4800, 107590, 11250, 13799, 12540, -2471, 3520, 4869, 3750, 7290, 11580, 4570, 93740, 141260, -2510, 4790, 3800, 22599, 144230, 36850, 3710, 3459, 12609, 13720, 21469, 13280, 76830, 2449, 5709, 3969, 19, 37430, 569, 166100, 40190, 163939, 13330, 190770, 178250, 25700, -721, 4369, 8630, 147620, 19530, 16770, 16040, 869, 37960, 111130, 55470, 12310, 49370, 164270, -14760, 15730, 60470, 39740, 13420, 4970, 10200, 7700, 98310, 27540, 15350, 1490, 30840, 5699, 7070, 15000, 3360, 4649, 6919, 6340, 5950, 10680, 8300, 6199, 20900, 4570, 4429, 7540, 9350, 10410, -871, 7570, 1659, 289, 8310, 10310, 5390, 106550, 6610, 49240, 127590, 6780, 5649, 6169, 32320, 1240, -1721, 4690, 2439, 7929, 77530, 128090, 10840, 100630, 3630, 188329, 8720, 84620, 59530, 11900, 95580, 5470, 43960, 74950, -381, 47110, 86950, 66336, 92680, 82720, 60920, 1459, 38380, 17530, 5669, 141360, 135700, 29940, 18850, 3299, 14900, 59000, 17080, -541, 141500, -381, 19600, 15020, -571, 11010, 17110, 15960, 122080, 47050, 22710, 63130, 10169, 5280, 12150, 11550, 5280, 174490, 6590, 3839, 4519, 156290, 28769, 73210, -7371, 22900, 10490, 9810, 9660, 50119, 8410, 36810, 13000, 11760, 78980, 43510, 10720, 28590, 13560, 6270, 8420, 2440, 18500, 7820, 11970, 46580, 15570, 5070, 143250, 12110, 2859, 9860, 44200, 13850, 8780, 10440, 13850, 5960, -15830, 12340, 19080, 8290, 11060, 164950, 3810, 9650, 42270, 170740, 7550, 47050, 14190, 12290, 20970, 1540, 8470, 479, 2050, 15610, 93040, 9579, -1440, 107410, 15830, 23360, 9890, 97820, 22490, 7990, 1110, 4190, 76240, 22679, 12740, 28560, 3850, 29120, 16780, 2210, 2070, 13200, 5299, 1759, 1940, 17310, -20, 6679, 4910, 4949, 6390, 1370, 7520, 88400, 7240, 155250, 7090, 33940, 62660, 8009, 68800, 10009, 3970, 4819, 59930, 174750, 94460, 136080, 80230, 28080, 6040, 19670, 8119, 12180, 67460, 28320, 739, 22780, 7090, 138100, 35450, 3299, 13560, 5820, 8109, 2330, 74480, 3000, 9140, -31, 10610, 15980, 10880, -11070, 16900, 7950, 2989, 4690, 133840, 4680, 12070, 3850, 4790, 7740, 8119, 2940, 2280, 4170, 3679, 103080, 31040, 3290, 6560, 1750, 5440, 5550, 5639, 50710, -1191, 46540, 6160, 31120, 5290, 7730, 7040, 123430, 2360, 9969, 6840, 699, 13000, 113960, 65610, 2749, 3590, 3329, 6059, 104040, 7060, 174760, 4980, 166740, 579, 3500, 41860, 7109, 5370, 44670, 22580, 35230, 26020, 7019, 9689, 16860, 3870, 3509, 12830, 16580, 1130, 8240, 56830, 96679, 16279, 8519, 13779, 4509, 56250, 2770, 3750, 4310, 8500, 7010, 6570, 102840, 27770, 4400, 3700, 619, 126290, 5859, 4740, 11070, 6030, -1230, -3230, 7840, 8179, 91370, 75930, 134770, 11439, 63700, 13590, 130160, 62680, 6040, 6850, 6279, 21589, 7609, 3599, 3469, 150150, 46160, 47580, 6130, 76360, -15750, 14380, 53620, 10820, 2150, 8590, 7600, 4670, 4599, 6539, 4560, 32280, 9640, 7049, 109840, 7030, 110150, 5699, 5200, 119300, 90730, 132780, 123130, 12360, 111580, 5070, 34940, 16240, 2900, 949, 2470, 59120, 7129, 3359, 90910, 16180, 1620, 5370, -530, 169590, 146010, 8650, 37420, 68050, 126130, 104560, 2890, 300, 39230, 18150, 27519, 7760, 3370, 1429, 92090, 119149, 9929, 2479, 2150, 6709, 121649, 36730, 35990, 51330, 10270, 6070, 629, 5249, 18510, 10270, 3240, -320, 24230, 3089, 117210, 21750, 40279, 17190, 7349, 9460, 1779, 6609, 2610, 4960, 5409, 4910, 2419, 10290, 7109, 130530, 19860, 13650, 13560, -12130, 98940, -17310, 8470, 9220, 4239, 196430, 4250, 1960, 100150, 3020, 5370, 28670, 4899, 8210, 14040, 5920, 5090, 39860, 3999, 17410, 3290, 105480, 4550, 5820, 5080, 136300, 3870, 35600, 6140, 11450, 1390, 33250, 24640, 30700, 130530, 28929, 9389, 24210, -1271, 189460, 1270, 809, 108290, 9919, 27180, 1999, 109, 153130, 3790, 8969, 18390, 4769, 8749, -8780, 3630, 1690, 10960, 18660, -570, -890, 178930, 4570, 34270, 560, 2660, -2411, 136430, 12180, 4140, 9649, 140230, 4380, 4079, 16540, 57939, 70360, 6430, 9289, 2630, 52080, 51340, 5849, 6270, 14300, 29160, 42280, 4750, 8489, 5850, 39080, 3519, 6339, -410, 17860, 4819, 15920, 6989, 80760, 10780, 2259, 16490, -900, 54960, 11800, 5480, 14190, 3900, 5109, 139540, 63650, 11880, 779, 17300, 13759, -19560, 17870, 60550, 8060, 45310, 35980, 9810, 186439, 28220, 12890, 18940, 10500, 1900, 101870, 33000, 2829, 10080, 7810, 14990, 12830, 11150, 74180, 11610, -5510, 168730, 12080, 11870, 51010, 10660, 12100, 7029, 11399, -9330, 10080, 11860, 29, 8480, 2259, -6170, 9830, 8520, 37520, 26400, -911, 9440, 7189, 15620, 4100, 10450, 1490, 140990, 2060, 3139, 44210, 25770, 23100, 87670, 17110, 1519, 5420, 12470, 7930, 26280, 5479, 16890, 118140, 18870, -2140, 7170, 5970, 14490, 13030, 10540, 12540, 24710, 3859, 14440, 709, 9459, 10670, -1331, 6929, 65310, 52000, 10220, 5870, 128660, -181, 5890, 8850, 120360, 18260, 11359, 12780, 152980, 819, 8909, 10380, 4769, 9190, 3159, 11880, 1019, 80250, -2871, 8630, 5849, -701, 11160, 12569, 25930, 9190, 9520, 77590, 159430, 5500, 82810, 8159, 150100, 69350, 4390, 4850, 42190, 3150, 8220, 105090, 1519, 11399, 135670, 66470, 8450, 60900, 13540, 36730, 144100, 11530, 12100, 3100, 100860, 129860, 11510, 8860, 26500, 5639, 12170, -2270, 44410, 16120, 30179, 10200, 21850, 8809, 11399, 4620, 5800, 8129, 7480, -741, 2209, 10109, 3860, 3560, 3750, 2869, 3609, 3930, 15860, 125970, 2250, 5980, 8679, 17280, 4880, 3100, 10260, 11310, 8189, 6340, 142520, 7639, 2520, -15210, 9689, 161580, 7429, 122080, 7520, 43620, 7400, 15089, 9739, 8429, 16130, 14840, 6140, 9810, 139320, 6690, 9819, 7380, 125320, 5950, 139190, 3900, 5490, 2730, -6791, 4170, 5029, 7589, 1279, 91120, 3300, 6729, 5110, 1869, 163990, -181, 24830, 58240, 139070, 117440, 3400, 3409, 3880, 1900, 33150, 5130, 59400, 23830, 5120, 20360, 6019, 6909, 102410, 629, 3950, 8239, 184140, 6149, 10530, 16750, 85740, 8930, 46936, 177860, 5280, 4449, 11610, 4369, 5900, 111890, 10290, 3850, 137810, 6650, 6610, 181180, 23420, 83300, 168490, 42670, 7079, 4789, 4069, 168130, 4780, 9250, 4890, 104120, 40890, 53380, 120630, 3310, 182369, 51350, 54050, 18320, 49000, 116900, 7780, 55430, 25810, 4270, 5470, 2610, 8530, 83570, 144990, -191, 50870, 15120, 9100, 6899, 5369, 4339, 95940, 7060, 177700, 14580, 62420, 44680, 36320, 82790, 11240, 29640, 5350, 21309, 8799, 7690, 6179, 909, 138260, 3059, 90480, 87110, -4101, 75260, 2719, 4339, 2549, 2070, 6279, 50830, 179020, 115620, 1230, 5409, 7520, 4549, -1141, 13970, 3320, 18240, 190990, 3740, 2349, 3870, -101, 8480, 8560, 16630, 1389, 4679, 1150, -531, 6899, -571, 1109, 3489, 3940, 4239, 6350, 989, 6099, 184330, 4029, 136120, 11500, 5270, 4470, 103190, 37550, 5079, 4369, 44680, 79400, 3469, 127120, 219, 5580, 77630, 122940, 7959, 34560, 4220, 56650, 53650, 71330, 26640, 141620, 83130, 19550, 7979, 71320, 7180, 10129, -4100, -11900, 2429, 36700, 15280, 3340, 11399, 6780, 13950, 10560, 7040, 2330, 161490, 10209, 74500, 10610, 16930, 5230, 4339, 193090, 1389, 1530, 11840, 111649, 8630, 70180, 11470, 42450, 5239, 7730, 8089, 9149, 5310, 26140, 6969, 3950, 8270, 19130, 8300, 4419, 59429, 35930, 166590, 1579, 669, 17340, 3090, 176800, 5580, 29690, 103940, 31200, 46640, 151130, 9630, 7710, 4560, 127080, 7350, 26160, 153950, 80670, 4330, 4460, 6990, 9869, 40380, 5870, -2880, 103500, 21309, 9840, 22010, 1879, 155440, 5320, 9159, -240, 10530, 7170, 8580, 62590, 10290, 38390, 154760, 4079, 86430, 10380, 709, 2680, 7610, 5500, 12500, 39100, 5030, 122840, 7719, 193080, 4229, 4550, 590, 9099, 1969, 4239, 130730, 32719, 5840, 95030, 1640, 1160, 77050, 6460, 32010, 190340, 182590, 160430, 86380, 43179, 113420, 47640, 151990, 1530, 52040, 30700, 41736, 4560, 118050, 47880, 168909, 8310, 2580, 47640, 29900, 64940, 27820, 15440, 20410, 71090, 2509, 9179, 2210, 3400, 5400, 133700, 91300, 8799, 27180, 5639, 28280, -6090, 31850, 59980, -25100, 112600, 26320, 29020, 9090, 29070, 8429, 9599, 1850, 19120, 13390, 12529, 11810, -130, 5140, 7759, 3960, 14660, 3279, 19110, 182550, 57820, 10169, 13660, 14190, 4360, 19180, 14070, 5679, 129820, 70070, 1580, 4700, 4869, 73520, -1301, 94730, 14280, 147660, 72330, 14620, 14260, 166400, 959, 1859, 58280, 41330, 2109, 15690, 32590, 195880, 24560, 56380, 17240, -18780, 5540, 9860, 116910, 177079, 5770, 41940, 990, 168950, 89070, 22450, 7950, 187390, 23220, 63840, 19090, 50460, 24420, 19780, 15800, 21300, 13850, 31820, 20840, 21370, 12700, 14140, 10550, 8199, 8609, 890, 12330, 17620, 4809, 18490, 7769, 12850, 13460, 15880, 176340, 145900, 8440, 1930, 4149, 6859, 83570, 6909, 83379, 15069, 4069, 29480, 93600, 8350, 3169, 3969, -21580, 13939, 13870, 7739, 2300, 19620, 12230, 12100, 549, 13010, 9090, 7509, 14090, 5739, 3050, 107120, 127899, 6969, 133470, 158020, 16530, 121510, 12350, -10570, 182369, 152200] + }, + { + 'id': 'Min width diameter', + 'label': 'Min width diameter', + 'values': [98453, 319366, 234498, 455411, 391333, 147711, 479081, 208910, 124041, 344954, 280876, 501789, 368624, 98453, 429823, 234498, 170419, 391333, 258167, 479081, 319366, 124041, 455411, 280876, 147711, 368624, 315981, 203423, 170419, 318081, 237211, 321023, 258211, 260481, 341011, 429823, 273989, 296489, 285589, 302889, 235581, 214989, 388889, 392489, 334089, 432089, 423289, 358489, 235589, 244989, 223823, 229989, 389489, 262681, 219489, 226389, 312723, 344923, 401889, 464489, 387789, 283223, 254689, 233089, 397989, 370889, 374289, 256489, 409489, 410789, 294711, 380711, 203011, 280789, 288211, 234211, 284989, 353623, 479081, 143423, 399489, 313089, 249823, 282889, 172623, 287689, 170419, 325623, 389789, 348189, 299689, 275089, 215523, 226323, 377489, 412389, 416623, 497789, 309389, 340989, 270623, 294889, 104423, 121723, 339623, 334589, 132823, 386011, 345723, 206623, 256481, 408911, 289011, 149881, 117823, 317823, 208589, 319789, 286723, 428089, 426289, 425789, 320589, 321881, 344989, 398989, 306581, 412089, 305823, 284489, 373989, 282189, 302723, 442889, 429989, 343389, 253681, 315889, 267123, 174289, 379823, 319089, 345489, 170419, 447589, 305189, 436189, 387023, 446989, 439189, 366089, 472989, 491189, 465789, 368289, 416289, 263023, 195389, 451889, 368389, 351889, 458989, 318823, 413989, 347389, 360823, 406189, 361589, 430589, 481589, 254689, 422489, 361823, 379689, 297389, 380689, 363089, 383189, 409289, 388989, 424089, 397789, 401389, 386989, 346911, 450089, 427789, 391389, 345789, 402689, 429389, 434989, 351789, 468289, 365381, 402489, 436689, 372081, 382889, 384289, 392689, 411989, 440111, 390523, 393789, 376389, 397089, 495889, 335489, 424289, 414889, 409289, 389889, 408189, 412189, 384489, 402189, 433789, 379489, 271389, 392989, 401189, 390989, 410889, 415389, 381389, 409089, 449389, 317089, 387689, 312189, 409489, 448489, 405089, 405389, 449489, 364611, 424189, 221489, 418989, 302823, 408589, 413189, 389023, 439689, 417089, 389289, 420789, 262889, 172589, 420789, 419989, 409989, 405689, 418289, 410389, 406689, 408289, 407089, 423789, 409289, 423189, 406389, 423189, 320489, 418489, 410189, 417189, 216823, 424089, 387123, 395681, 412389, 239011, 416489, 418489, 417389, 429989, 393289, 419689, 406789, 332089, 327089, 419589, 414389, 413389, 413089, 403389, 420889, 261489, 424189, 412189, 402889, 426389, 417789, 415589, 404889, 418789, 413189, 415489, 405789, 408689, 418789, 437489, 474489, 399689, 403689, 414389, 415589, 416789, 422489, 196889, 411489, 424089, 217881, 423089, 418989, 421289, 422589, 411089, 422489, 211411, 424789, 415389, 426889, 417489, 411789, 430089, 395023, 411089, 417289, 428689, 415989, 423989, 420289, 387223, 394923, 432489, 390181, 439989, 313523, 490589, 115023, 398923, 399881, 236123, 180089, 399323, 343723, 190789, 421389, 415389, 405981, 427289, 432089, 403789, 381789, 420289, 414789, 418689, 408789, 436089, 422189, 318323, 437789, 420689, 420789, 411189, 437289, 435389, 286689, 444489, 418989, 437489, 422289, 418889, 440489, 427689, 354023, 418889, 425389, 414689, 444189, 208589, 446389, 418389, 483989, 421689, 412689, 328989, 423089, 427689, 339989, 425289, 381789, 421389, 227189, 353123, 426989, 428289, 418189, 425589, 427189, 420489, 432589, 428189, 426189, 396223, 421289, 421489, 420189, 435811, 422389, 446681, 486789, 421089, 426089, 422589, 422689, 435189, 359323, 485289, 433189, 351789, 387423, 322489, 304689, 426289, 420489, 423589, 146223, 398889, 397981, 406189, 418481, 408789, 241489, 395589, 398489, 419289, 425189, 426189, 405281, 141123, 398281, 229389, 422189, 426589, 428189, 420989, 386989, 262789, 421089, 476189, 232189, 413589, 412989, 494589, 422689, 269481, 223989, 426389, 368711, 397811, 418989, 429089, 414489, 417889, 426211, 410689, 425289, 445289, 415489, 421489, 370789, 387223, 416789, 412789, 284489, 351223, 399689, 472889, 415889, 290923, 407389, 393123, 410989, 348089, 359789, 419789, 218289, 427389, 417489, 370389, 395381, 417189, 400789, 389289, 388689, 420889, 171989, 146311, 419789, 388981, 421089, 396381, 370489, 484089, 418989, 362889, 388423, 392289, 400889, 408889, 419389, 365023, 413889, 277089, 407889, 403989, 421389, 461689, 432989, 409889, 455389, 412489, 440389, 426989, 188189, 483589, 436689, 405289, 247189, 330089, 441189, 453789, 425189, 418089, 415889, 374611, 417589, 409789, 330223, 276689, 408981, 406181, 501789, 211389, 413323, 455411, 277789, 375689, 314623, 274711, 188989, 452011, 366389, 300689, 285689, 316823, 333689, 320523, 501789, 282889, 345623, 283289, 442689, 440889, 318289, 330589, 341089, 271123, 325823, 452589, 316089, 323889, 477281, 289589, 390923, 265789, 261489, 353223, 310711, 501789, 210223, 325789, 288423, 284289, 302889, 326889, 380323, 338389, 394989, 294989, 339689, 302889, 288089, 334089, 346589, 329989, 270589, 317489, 271689, 315189, 314789, 383889, 337789, 270389, 248381, 303089, 302189, 320089, 334089, 134211, 337889, 313589, 333089, 452889, 308089, 443289, 305989, 448989, 338789, 291989, 296981, 317589, 362389, 336689, 344389, 211089, 353789, 173989, 289523, 325089, 316589, 370689, 331089, 338489, 329189, 340589, 322889, 323489, 335789, 372489, 376589, 423389, 316189, 209089, 318489, 481389, 334189, 467889, 246023, 334289, 384889, 274989, 396589, 409189, 391489, 342589, 290989, 338389, 319789, 348289, 352489, 346989, 449511, 345689, 318823, 395089, 350689, 351489, 285081, 339189, 179889, 355189, 411289, 334789, 332989, 210389, 409289, 354289, 426489, 353489, 370489, 325389, 348989, 302423, 320289, 367789, 358789, 344089, 356789, 360189, 365589, 352689, 354689, 445989, 358289, 423489, 392689, 358989, 404289, 400889, 348589, 498789, 342389, 380489, 258523, 458689, 353711, 343789, 339689, 320789, 387789, 392489, 364789, 407289, 398489, 387989, 430089, 313281, 404389, 404189, 379589, 372289, 435189, 422489, 410189, 248189, 400689, 413089, 316723, 401089, 409889, 447489, 360189, 426089, 406489, 399089, 356089, 402889, 401689, 399589, 408689, 396289, 402789, 417089, 416789, 407089, 421989, 425889, 404389, 384789, 315189, 464089, 390781, 425289, 380589, 416389, 412889, 407289, 407089, 420889, 401389, 408689, 412289, 421689, 367811, 422189, 406289, 402689, 288611, 394981, 402489, 418889, 409989, 407689, 400689, 176589, 424989, 419889, 336389, 392889, 341689, 410089, 240589, 415689, 343681, 425789, 412889, 467689, 405489, 161523, 385989, 435589, 432489, 421589, 445789, 414989, 367889, 386589, 438889, 443089, 415289, 416889, 397389, 482189, 416389, 418789, 421389, 453789, 440189, 301489, 303411, 423889, 405389, 254889, 413089, 417489, 343111, 323489, 410989, 501789, 324189, 425489, 428489, 414789, 423289, 418189, 419889, 415089, 418489, 426189, 400889, 419089, 330389, 416489, 442089, 409289, 418989, 366689, 420889, 413889, 438989, 342689, 409689, 424289, 393881, 415689, 425289, 411889, 426889, 450189, 262889, 414489, 419889, 354223, 490689, 429589, 430289, 243289, 329923, 412089, 417789, 334023, 404689, 325989, 408389, 404489, 412789, 413989, 425889, 496989, 317489, 362189, 263589, 421489, 416089, 429089, 418689, 414689, 411181, 416689, 214589, 412189, 416889, 420289, 285689, 171189, 449589, 416789, 416889, 416089, 420489, 146123, 410489, 404989, 414489, 413389, 417289, 408389, 286689, 263989, 429489, 429289, 417389, 411889, 191589, 419189, 412389, 433689, 415589, 431889, 419389, 424489, 424689, 427489, 277789, 421889, 413889, 415689, 414189, 430389, 423689, 400289, 431989, 416489, 395989, 217689, 429689, 416489, 423389, 351423, 428489, 418189, 409689, 444389, 420389, 423289, 425289, 361489, 415189, 419689, 417189, 423189, 414689, 419389, 423889, 176489, 422589, 413389, 418789, 330389, 422289, 421589, 424589, 405481, 408489, 415789, 392181, 419689, 421989, 419389, 485389, 428589, 426189, 425689, 417689, 425089, 400489, 425989, 420989, 419289, 426889, 428481, 427789, 418989, 418689, 422489, 422789, 423089, 404781, 428989, 421189, 420389, 418689, 421389, 419189, 398089, 429189, 224189, 420089, 349023, 420189, 425189, 424889, 418389, 417889, 419689, 414289, 416389, 421289, 415989, 419389, 421989, 420989, 416989, 421889, 418789, 421389, 411689, 422689, 421589, 421689, 419989, 414189, 419489, 427989, 418489, 421589, 349723, 283989, 420689, 421789, 419989, 390489, 425389, 424089, 424089, 423689, 196989, 413389, 401189, 428689, 474589, 380289, 471889, 421789, 418389, 432389, 411589, 427789, 413789, 393389, 431989, 483589, 427589, 431489, 423989, 500489, 419189, 410289, 411989, 330489, 423989, 408889, 419089, 429389, 436189, 428289, 350523, 342311, 427989, 355423, 416589, 412189, 416689, 431389, 421889, 232189, 422589, 302889, 422389, 417789, 426889, 290589, 306489, 427589, 428189, 381889, 427489, 417089, 292889, 419889, 333389, 429589, 332089, 419189, 420489, 425289, 414189, 416089, 417889, 419089, 409989, 422689, 428989, 198489, 416189, 421889, 191389, 415689, 429789, 424489, 429389, 210289, 316989, 424589, 429289, 281881, 423189, 425089, 420589, 422989, 423989, 449189, 427089, 424589, 419789, 426589, 420089, 420089, 435889, 420189, 432189, 414589, 422289, 426689, 424289, 421989, 438989, 209089, 418989, 429089, 415889, 459689, 423389, 427389, 394589, 435589, 261089, 424089, 447789, 415989, 303289, 376989, 425689, 295789, 419589, 427189, 419389, 284589, 414989, 316689, 420789, 372511, 427089, 323489, 417089, 355589, 424089, 427089, 423989, 198789, 303889, 342189, 364689, 419489, 415989, 424089, 428489, 283789, 414989, 421589, 422789, 337989, 418189, 392189, 415889, 428589, 412389, 415189, 339723, 420689, 414189, 402189, 423489, 346923, 292189, 445311, 229489, 418889, 401589, 467089, 424089, 490789, 396789, 420889, 404089, 334889, 242823, 441789, 404989, 465189, 423389, 408511, 413289, 382281, 460389, 411989, 401589, 411889, 210289, 312489, 420189, 424489, 433789, 404189, 242111, 414489, 440689, 424689, 418089, 298689, 447089, 419189, 295689, 397389, 431389, 431981, 418689, 421089, 423589, 396889, 415289, 485089, 418589, 418089, 428189, 452289, 428089, 418889, 418589, 412189, 426789, 428289, 419989, 316089, 450189, 297589, 349589, 321589, 431889, 434089, 394989, 424389, 274889, 347289, 431789, 422289, 462189, 341789, 153111, 425989, 427889, 374011, 430189, 302489, 404789, 410389, 447289, 457189, 399681, 396689, 352281, 423389, 373489, 410889, 428589, 412589, 427489, 418689, 400089, 497489, 428089, 422389, 381011, 421189, 282089, 415889, 407889, 425789, 222889, 377911, 421789, 376011, 431489, 423589, 412089, 422289, 286889, 423989, 420089, 479389, 490189, 437889, 414889, 419789, 320789, 382489, 294289, 417689, 419189, 255689, 422589, 350089, 412989, 404489, 420289, 414689, 423089, 421589, 437489, 414089, 308789, 418889, 224389, 420489, 199089, 268289, 479081, 416989, 418089, 392489, 310589, 427489, 406089, 411389, 423089, 383189, 261489, 273089, 413689, 406089, 353089, 369389, 409489, 411381, 372389, 418589, 492089, 423789, 427789, 365689, 357389, 420289, 307889, 377389, 430789, 402711, 430789, 433189, 419289, 406881, 428389, 361289, 395989, 401789, 388789, 298823, 413089, 413489, 410389, 406289, 398981, 423489, 424089, 302189, 412889, 392981, 415689, 340923, 310289, 400689, 392389, 460889, 415989, 407289, 408089, 405589, 418389, 403281, 411889, 366011, 407489, 297489, 424889, 408389, 444489, 414489, 268489, 413589, 288589, 299489, 412789, 305989, 420089, 401189, 422289, 413589, 457689, 367289, 124041, 437611, 161211, 379881, 420189, 302023, 342523, 385089, 307189, 474789, 367389, 418289, 377789, 373789, 401411, 397989, 405189, 315789, 372211, 415789, 422589, 425489, 404689, 415689, 417189, 219989, 413289, 371689, 281489, 417089, 405989, 408289, 397289, 424989, 198889, 409889, 427389, 424589, 222889, 409089, 325689, 438489, 295789, 428889, 408689, 417189, 349589, 365311, 392689, 409789, 395189, 424989, 259723, 388589, 423889, 407189, 419089, 408589, 350389, 390789, 398589, 406089, 387989, 402089, 427089, 180289, 403689, 414189, 412189, 431789, 413289, 225611, 386681, 406289, 275189, 387089, 399389, 405989, 402889, 407189, 489289, 275689, 413289, 394089, 462389, 408289, 323289, 335923, 410889, 411089, 410389, 413089, 416989, 278289, 401689, 460389, 330023, 416189, 195689, 372489, 309189, 391889, 205623, 307889, 407889, 422689, 415889, 317389, 407989, 411423, 337189, 342323, 334589, 405989, 415689, 431089, 407789, 408789, 420189, 422389, 394981, 413989, 409989, 419689, 399289, 398889, 425089, 408589, 372789, 402389, 171289, 409889, 414389, 486189, 407689, 326789, 380981, 415089, 428589, 486489, 374289, 166481, 474989, 412489, 393989, 419389, 385381, 404589, 410989, 416189, 410589, 422389, 419989, 394181, 241789, 412289, 400081, 419189, 418589, 421689, 378489, 258989, 415789, 306389, 421089, 416689, 402989, 400281, 461489, 404789, 393581, 419889, 416889, 360389, 420989, 397381, 432289, 402889, 422389, 405589, 423389, 428989, 421089, 435989, 334989, 423389, 413889, 412189, 397581, 413389, 418289, 407389, 496689, 407981, 309389, 412189, 327589, 418889, 410489, 418389, 445489, 422189, 408089, 390681, 424789, 455789, 234189, 281689, 390581, 426889, 415489, 418189, 392681, 405189, 412189, 412989, 254389, 416989, 425789, 284189, 423689, 438089, 347089, 328989, 410489, 425589, 420589, 439889, 372189, 413089, 422689, 420489, 417989, 422489, 428389, 269489, 263989, 408989, 430589, 409989, 282689, 274289, 422089, 423289, 419689, 365789, 427689, 424089, 247389, 499089, 428081, 408789, 410589, 470889, 415189, 413389, 394711, 421489, 419089, 421089, 409389, 424989, 395089, 295523, 479089, 394011, 490789, 361889, 227189, 270023, 454389, 416581, 393281, 429889, 376689, 361789, 365089, 303289, 242189, 241989, 420489, 419189, 462289, 406989, 178589, 412589, 432289, 414889, 416789, 425089, 413789, 366011, 419189, 266989, 498389, 419289, 260389, 417489, 447289, 454789, 406789, 388789, 386489, 250989, 390489, 434189, 291611, 313089, 394389, 379389, 412789, 408289, 419089, 260589, 302489, 457189, 396689, 273989, 409589, 390381, 422089, 443889, 257689, 473289, 454589, 369289, 332489, 241189, 465889, 501789, 380489, 356289, 456589, 360189, 421089, 423489, 339511, 261289, 469489, 436989, 457289, 443689, 422289, 381489, 380181, 435489, 456089, 454089, 281489, 424289, 306689, 410089, 440389, 474989, 434489, 458889, 395723, 420289, 210989, 423889, 368323, 411189, 434989, 441689, 413689, 437189, 398981, 372723, 458589, 424889, 361311, 261781, 429189, 353289, 420189, 381089, 437389, 394889, 346123, 412589, 431389, 176489, 418289, 424189, 372289, 428589, 421089, 303089, 420789, 420689, 343389, 428589, 411889, 251189, 406789, 433689, 362889, 173989, 423289, 416589, 420989, 436789, 326089, 406789, 427389, 412289, 276889, 309289, 310389, 326789, 485489, 322489, 409889, 476689, 415489, 226189, 414089, 424689, 453889, 340623, 319989, 399789, 412689, 346489, 429889, 428089, 405889, 423089, 411289, 467589, 411489, 432889, 414189, 385481, 430489, 270689, 248489, 422089, 501089, 421189, 266189, 421889, 347489, 421989, 433389, 334323, 197489, 401989, 414989, 339681, 449389, 383189, 417489, 419889, 401489, 192611, 232389, 419289, 427089, 380789, 362189, 437989, 372289, 417889, 408289, 383989, 409589, 401389, 420889, 406189, 420589, 233589, 399889, 371189, 387989, 373811, 405889, 419789, 301189, 412789, 413989, 472889, 419789, 426689, 349389, 198323, 412989, 283989, 422789, 392481, 417389, 416089, 431289, 398481, 249689, 417989, 401981, 197389, 366589, 415889, 295423, 413789, 423789, 236089, 302789, 424489, 415989, 415689, 360889, 409489, 412289, 217989, 420689, 451889, 360489, 414989, 382089, 347689, 415189, 420789, 389781, 420789, 350089, 387989, 416189, 343489, 372989, 439189, 283489, 382781, 386589, 387589, 384789, 406889, 398389, 403889, 399589, 419789, 404289, 372511, 264889, 413189, 391389, 386689, 387089, 409789, 321089, 375689, 413589, 407589, 385089, 405489, 402989, 416989, 387889, 491389, 381089, 422189, 419089, 415089, 423889, 353489, 412389, 397389, 336689, 415189, 400389, 429689, 409189, 402089, 391089, 402489, 192689, 333789, 395589, 383123, 229189, 349623, 411889, 403289, 353189, 414189, 334223, 399989, 423989, 347623, 400689, 408989, 410089, 395889, 409189, 386989, 425589, 253289, 431489, 402489, 406289, 287789, 408189, 410089, 393489, 333889, 404589, 258889, 414489, 404789, 462689, 416189, 253789, 235289, 278889, 402289, 351889, 279289, 401589, 204889, 403589, 412789, 258089, 327089, 415289, 319789, 392389, 312489, 444789, 398489, 434789, 421789, 430189, 262189, 406689, 399189, 346789, 410389, 411089, 333489, 289689, 346589, 337989, 397789, 392289, 398689, 400789, 418589, 394789, 400489, 404989, 289189, 414689, 418689, 401189, 421189, 407289, 433089, 412689, 419489, 458189, 417381, 367911, 482989, 398989, 365989, 407989, 416789, 407189, 431689, 407889, 404389, 342589, 407389, 491589, 404889, 405889, 409989, 413489, 398989, 409589, 432589, 396789, 414889, 407389, 402489, 453489, 332423, 403389, 399689, 468589, 412889, 403589, 253989, 464589, 415289, 442181, 404789, 400889, 489489, 414689, 410089, 414489, 492889, 415989, 379211, 412789, 418489, 413689, 369711, 180889, 283589, 413489, 429389, 500089, 336389, 412789, 421689, 423989, 432789, 385289, 421489, 501789, 405489, 407589, 400189, 417589, 418689, 224689, 425489, 413289, 421389, 301389, 420289, 421489, 299289, 386389, 415489, 170419, 217189, 418989, 416289, 407689, 417089, 417789, 374889, 410889, 416289, 180981, 392289, 388689, 281989, 433589, 356789, 326889, 350089, 416989, 406181, 424089, 246489, 415989, 420289, 420889, 399589, 376889, 341989, 361489, 417689, 278089, 206289, 347289, 387589, 276789, 255789, 414989, 211489, 328311, 409089, 418089, 423689, 471489, 448089, 228889, 419689, 480089, 420589, 425789, 287789, 433089, 340423, 280389, 423189, 255789, 421989, 498589, 425989, 459589, 426889, 285389, 335389, 430289, 207689, 427789, 431889, 398281, 425689, 445189, 429189, 211989, 427689, 343789, 306189, 417589, 418389, 460289, 425089, 415989, 381489, 259589, 359589, 282489, 416689, 243589, 426289, 309189, 418089, 434589, 378389, 182889, 422389, 421289, 426089, 428789, 427989, 424189, 390489, 424889, 425989, 438289, 432089, 297789, 416489, 442689, 329889, 433389, 422389, 427289, 426889, 366823, 232489, 431781, 399589, 173411, 367123, 374089, 127923, 279289, 408281, 435089, 361023, 281789, 439089, 462881, 437589, 412989, 281489, 374389, 481189, 323481, 411589, 335289, 332289, 425489, 402389, 179589, 437489, 397581, 409281, 462589, 395281, 424489, 404081, 462789, 433489, 450789, 418989, 424389, 393081, 413989, 418289, 413189, 401681, 421489, 303889, 426689, 240789, 436689, 397111, 448489, 421389, 249889, 428889, 425489, 400389, 437289, 406489, 357989, 411089, 401289, 333423, 419489, 408889, 415289, 422689, 447389, 417089, 427289, 417089, 314489, 451789, 409589, 496489, 177489, 185889, 432989, 426089, 399389, 381511, 325789, 368611, 307889, 376011, 425789, 386389, 492489, 475489, 304689, 423189, 351989, 422289, 268189, 316289, 386711, 306489, 334223, 404889, 433089, 447989, 419089, 250589, 252789, 398689, 415389, 416689, 416989, 295389, 417589, 302189, 423189, 399489, 439089, 385989, 436889, 411889, 327889, 404189, 438989, 207489, 410989, 412689, 417989, 411689, 424789, 391789, 334789, 410489, 239389, 417589, 248989, 386781, 328323, 415889, 399789, 423089, 415389, 369489, 499589, 414389, 437489, 396681, 412189, 216911, 410189, 380723, 269389, 227889, 254489, 480989, 384989, 254589, 336389, 363889, 412489, 466389, 501789, 170419, 421189, 467289, 456989, 368689, 423689, 291989, 454389, 341823, 465389, 343623, 421389, 341689, 284889, 446689, 423989, 427689, 430789, 262789, 321789, 345411, 423789, 311989, 442389, 393023, 395689, 409289, 424989, 501789, 457789, 355589, 409589, 418889, 406089, 434489, 413789, 431289, 403589, 368889, 394781, 428689, 424089, 436389, 413189, 424189, 410189, 455989, 414689, 243289, 357589, 427089, 411189, 425889, 398481, 350281, 499089, 349989, 304589, 421089, 438989, 414789, 434089, 431589, 364823, 424489, 417989, 357189, 331489, 381589, 418189, 260789, 420189, 422189, 328989, 438489, 417689, 477889, 419889, 221989, 199189, 269989, 334389, 473589, 419389, 417189, 413981, 375989, 415089, 432389, 425889, 301289, 399089, 386581, 418289, 263889, 373589, 382389, 417181, 402189, 417589, 348023, 423789, 399789, 440289, 342589, 435389, 416089, 439789, 454389, 458289, 413789, 425689, 415889, 407489, 437589, 407689, 386889, 417089, 405289, 412189, 393989, 364389, 276789, 413389, 286489, 416289, 418189, 316089, 479689, 221989, 415089, 406089, 423989, 209789, 423289, 433089, 401089, 437589, 404389, 411089, 407389, 446789, 355589, 407489, 403789, 428289, 354689, 423889, 412689, 404889, 425389, 428289, 414589, 173789, 329089, 220711, 456589, 492489, 309689, 377289, 477489, 314089, 206411] + }, + { + 'id': 'RF block', + 'label': 'RF block', + 'values': [1417, 23377, 3376, 33336, 5635, 10812, 6898, 21273, 2484, 35126, 5626, 51096, 7384, 22020, 18912, 52449, 7498, 87528, 11359, 107154, 9197, 18159, 13115, 41120, 4254, 53966, 17129, 14957, 12469, 12882, 19875, 23547, 16325, 15238, 15452, 31817, 18210, 16237, 13815, 24070, 14163, 10748, 16292, 12787, 19559, 10597, 34781, 25859, 23121, 7331, 19298, 17056, 18788, 12009, 8997, 9280, 10990, 9825, 13690, 14547, 15443, 14758, 22429, 9324, 13396, 10915, 12615, 13307, 16842, 12533, 11312, 29347, 2923, 28796, 42332, 12953, 14401, 16151, 23973, 4730, 21716, 13116, 13175, 15085, 8140, 14046, 15629, 13231, 5612, 14571, 14929, 12812, 9048, 10826, 20129, 17258, 12673, 11513, 12391, 14423, 10741, 14543, 4797, 6770, 12516, 15056, 26071, 38770, 15137, 15072, 11241, 26828, 8765, 10555, 10704, 13486, 6364, 10951, 12683, 21652, 27201, 21344, 10776, 9748, 11037, 12370, 8567, 13685, 11766, 12085, 11494, 20165, 13118, 14030, 13022, 10399, 14657, 11485, 10530, 13011, 6136, 10941, 24564, 2983, 44046, 27024, 13288, 11442, 25304, 11719, 10889, 42292, 21241, 13750, 11650, 12963, 7752, 11368, 12729, 10642, 9786, 12557, 11922, 10954, 10880, 9807, 11606, 10332, 11490, 12266, 8847, 11958, 9329, 11618, 30498, 9096, 9656, 10880, 12137, 10590, 30171, 10776, 12029, 10048, 9194, 12699, 11935, 10320, 12246, 10999, 11670, 12919, 10448, 28090, 9996, 11446, 11869, 11452, 11130, 10617, 10938, 10938, 61633, 9401, 10986, 10264, 11382, 26443, 7246, 10959, 10865, 10461, 15205, 10010, 11370, 10761, 9628, 10072, 15113, 15277, 10752, 15445, 10415, 10409, 11365, 42807, 10732, 80687, 14568, 10607, 25736, 10835, 25227, 10372, 10690, 10861, 9204, 24356, 9578, 10690, 16420, 32922, 9966, 10328, 22516, 11073, 10370, 10319, 16053, 12519, 10850, 10016, 23430, 9967, 10409, 16565, 33216, 10086, 11852, 10717, 71528, 10854, 6473, 9864, 24531, 10169, 10465, 13817, 8117, 10114, 10539, 9383, 9575, 9905, 10607, 10809, 12302, 11300, 17273, 19981, 10379, 62047, 32661, 10668, 10740, 11887, 10168, 10328, 10606, 5848, 19699, 9904, 10606, 12471, 10735, 10454, 10221, 11269, 10282, 10788, 10518, 13610, 10157, 12402, 12469, 10341, 11117, 11692, 11407, 11290, 10950, 11411, 10684, 15902, 9235, 11594, 10388, 10673, 10287, 11358, 10456, 21224, 11029, 9757, 10623, 20290, 11303, 10606, 10576, 10914, 10215, 11150, 10688, 20300, 10648, 10158, 9969, 10490, 9674, 14900, 8394, 58012, 9555, 18938, 12074, 10625, 16410, 18293, 8646, 7452, 10486, 10598, 10851, 9883, 9527, 9921, 8487, 12350, 21204, 10475, 33939, 10793, 10449, 12448, 11840, 16981, 9941, 9714, 10921, 17966, 13494, 13501, 9559, 12461, 10527, 10273, 12408, 10142, 8618, 10065, 10490, 19855, 11973, 6992, 27078, 9865, 22933, 10190, 39964, 15056, 10890, 10469, 9225, 9722, 22231, 10448, 16940, 8739, 9933, 10792, 10162, 10820, 10476, 10596, 15300, 10848, 10490, 10626, 11052, 11152, 9908, 10688, 10853, 23939, 10974, 10706, 11293, 25292, 10575, 44141, 9329, 42453, 11111, 33703, 9989, 14744, 29684, 10627, 12450, 10102, 10804, 22365, 15455, 10235, 17927, 28090, 22636, 5696, 10830, 11452, 37616, 10548, 14079, 2381, 9319, 5708, 10278, 10270, 10173, 10438, 10466, 14781, 11824, 13649, 11169, 10106, 10054, 48407, 10727, 8452, 10180, 11032, 9142, 27478, 10124, 10562, 10836, 10135, 7096, 9831, 11865, 10439, 10077, 10337, 10278, 10402, 40924, 10160, 24221, 8787, 12698, 13555, 20043, 9006, 10211, 30486, 10615, 5012, 13470, 11561, 21404, 11943, 35820, 10150, 10799, 10569, 10388, 18464, 10494, 10739, 17119, 10382, 10994, 10169, 10365, 10862, 10219, 35420, 11482, 36677, 10085, 9303, 10751, 26201, 9832, 9444, 11268, 16820, 24669, 11580, 10429, 13545, 31487, 14811, 28689, 13605, 22274, 13142, 15556, 39192, 11083, 28305, 22002, 32055, 11237, 14968, 15304, 10818, 14371, 9237, 10504, 11672, 15811, 20320, 13030, 18281, 37483, 10853, 18766, 33670, 11700, 25359, 13903, 19952, 17043, 18835, 21038, 13206, 10850, 13772, 8348, 14495, 25290, 14003, 13966, 12454, 16773, 15792, 14666, 12615, 18555, 20326, 13386, 16211, 11108, 12505, 18943, 13578, 13475, 9963, 13037, 24033, 10640, 25696, 8173, 12725, 9708, 9863, 12975, 12783, 29488, 10613, 15552, 10566, 9981, 11013, 10682, 10087, 12383, 11656, 10325, 10872, 8027, 11261, 11077, 38056, 10047, 9527, 9601, 12561, 10987, 10731, 10944, 6680, 11525, 10922, 10432, 38982, 12574, 19619, 12819, 8162, 9543, 12403, 9836, 14314, 22537, 11423, 11359, 16214, 12020, 11313, 9979, 10532, 11140, 5538, 11040, 10342, 7274, 11035, 10156, 9986, 10486, 12454, 12438, 24463, 20432, 20455, 12397, 37736, 10196, 18212, 15145, 18863, 13024, 13364, 12974, 41227, 11856, 11346, 11326, 12760, 10202, 15894, 11309, 22422, 17922, 9380, 11075, 11609, 9989, 21795, 16305, 10791, 18100, 10980, 12215, 10666, 10339, 7981, 12100, 10235, 28922, 10339, 11453, 15440, 24216, 8614, 14903, 11618, 10720, 10714, 11399, 10649, 10249, 11125, 11523, 13787, 10415, 12882, 10920, 11001, 23505, 19807, 12172, 76180, 10338, 10975, 8062, 13561, 20564, 11107, 9966, 8921, 34621, 36878, 11835, 10960, 11871, 10982, 29514, 10178, 10481, 11149, 10573, 9197, 34702, 15114, 11222, 7482, 11016, 28924, 9036, 11100, 12007, 30205, 10454, 10890, 10902, 10595, 10095, 10696, 10249, 10609, 10740, 10824, 10277, 10679, 10296, 13965, 9912, 10483, 9972, 10735, 19105, 24162, 10498, 9856, 11457, 10418, 10479, 9695, 10405, 20038, 21024, 10611, 10964, 10095, 18471, 10126, 11042, 10546, 13961, 9864, 10287, 10254, 10350, 36948, 10205, 19478, 16141, 10222, 32500, 9865, 19020, 32054, 7968, 10325, 26167, 15826, 10497, 26223, 10784, 11040, 21312, 13074, 11326, 10699, 11514, 10271, 9270, 27080, 11929, 29848, 13399, 10618, 16773, 38775, 15158, 10308, 16630, 24280, 10359, 26577, 25968, 11063, 9358, 24236, 10131, 10633, 8785, 16274, 10153, 17928, 10168, 12024, 15155, 10751, 10514, 10726, 10694, 10684, 12918, 10318, 9723, 10353, 18212, 11901, 35670, 10645, 10501, 14751, 11704, 5960, 21709, 33016, 11319, 10692, 9730, 11579, 10545, 10898, 10450, 16733, 20856, 10557, 10411, 9420, 31288, 35500, 10552, 7849, 8744, 10903, 9795, 9018, 10362, 11398, 11504, 21077, 9900, 19523, 22921, 48955, 10100, 35563, 17163, 10109, 10710, 10407, 10174, 10338, 19927, 10088, 11713, 9719, 10242, 37731, 15195, 6232, 41049, 10615, 10017, 9755, 10709, 14637, 9291, 11864, 10109, 10156, 11304, 67519, 17390, 17379, 12079, 10161, 10612, 9842, 15579, 10903, 9928, 10148, 10154, 16966, 10889, 10372, 12307, 13177, 26663, 10878, 9647, 10531, 9319, 13014, 9437, 9204, 12344, 11695, 29491, 4829, 9900, 33272, 14803, 6452, 10605, 11949, 14380, 41594, 10764, 11066, 10315, 13599, 10388, 10160, 22538, 10492, 10394, 11021, 11273, 16408, 10459, 9505, 11608, 27802, 10337, 10946, 10642, 10364, 19852, 9766, 9477, 10783, 10463, 32639, 33506, 10877, 11257, 11148, 11070, 10769, 32854, 11405, 10836, 9867, 10488, 14866, 10453, 10822, 10211, 10304, 10483, 10395, 10455, 11100, 10595, 10385, 10249, 10315, 10299, 14743, 10506, 4196, 10680, 8481, 10569, 10217, 10535, 10788, 10380, 10104, 10496, 10774, 10578, 12092, 10172, 10273, 11082, 28496, 10138, 11213, 10182, 10541, 10214, 10813, 10209, 9657, 10418, 10325, 9225, 10075, 10889, 8608, 11322, 11055, 10799, 10054, 22351, 34451, 10954, 10801, 10028, 10797, 10584, 8069, 23265, 19284, 10490, 12889, 11179, 10694, 23407, 10668, 10530, 10576, 33861, 16659, 18867, 10082, 16290, 9883, 14526, 9639, 10930, 10400, 6394, 10245, 10304, 11994, 10994, 11345, 10426, 8470, 17899, 10053, 16420, 10516, 29232, 10200, 10599, 10119, 14293, 10478, 27110, 10359, 9926, 9912, 29435, 17805, 12276, 10674, 26997, 10445, 20195, 9146, 10524, 10816, 10555, 10744, 10242, 10180, 14829, 10046, 11402, 13681, 9995, 10387, 10157, 10482, 15997, 21537, 20617, 7234, 19940, 10347, 9837, 10492, 3567, 15063, 10527, 14404, 26219, 9845, 10367, 12283, 10012, 11008, 16150, 10090, 9801, 10182, 10385, 11210, 10227, 10945, 10796, 12408, 10596, 12523, 10445, 10863, 15001, 11714, 4158, 10011, 11102, 18453, 25567, 34427, 21636, 17312, 11486, 25894, 10305, 11143, 10014, 7083, 29212, 11225, 13217, 12442, 10534, 30505, 18992, 9916, 9305, 9562, 14432, 10474, 15954, 11336, 14433, 10782, 10858, 13947, 13731, 16533, 18216, 23681, 32935, 9827, 10190, 9891, 12630, 10233, 10130, 10387, 15376, 10256, 24143, 10237, 9739, 10317, 9752, 8255, 10923, 8741, 37789, 61374, 8664, 4220, 34907, 3366, 9820, 18920, 28985, 11698, 10181, 82710, 10549, 34749, 25408, 11746, 16455, 10624, 17395, 12460, 11048, 12144, 12643, 13238, 11049, 10607, 10713, 16579, 22372, 10607, 11766, 11282, 10549, 22312, 9792, 12057, 9784, 10705, 21263, 39010, 10601, 20597, 10461, 10502, 8825, 10079, 10800, 11227, 20574, 10297, 28465, 11264, 10799, 11484, 32910, 10132, 10895, 21699, 10646, 10735, 10696, 11264, 19742, 42988, 41859, 10492, 5759, 24954, 10411, 13437, 11267, 5603, 10173, 10822, 11230, 33464, 17149, 11761, 10849, 11071, 10266, 10318, 5839, 14954, 10101, 39692, 29152, 9676, 12924, 11540, 43420, 30908, 9929, 23278, 17192, 9964, 10193, 20560, 27021, 19244, 9997, 11196, 11353, 14331, 10630, 9783, 10959, 14011, 21597, 12489, 10930, 19611, 10617, 10366, 32400, 5912, 12172, 32577, 65364, 44139, 10069, 10473, 10503, 9310, 33098, 10077, 10394, 10412, 5522, 12512, 10444, 11968, 23134, 20539, 10636, 10680, 9865, 17915, 9652, 57471, 17323, 19811, 12337, 19754, 25944, 18475, 9532, 10535, 20382, 26345, 13869, 12280, 12403, 10090, 14846, 17309, 11379, 11821, 18237, 46284, 7399, 12253, 21048, 14545, 12262, 14172, 11900, 11608, 23811, 11756, 12709, 11665, 13314, 11359, 11199, 13162, 11013, 10641, 10930, 11373, 16875, 10709, 14663, 19210, 9117, 10354, 10345, 10785, 33407, 11203, 9776, 22824, 5670, 9550, 10557, 11541, 8667, 41163, 10187, 17357, 76115, 10894, 10300, 14510, 15094, 9959, 9200, 10324, 8811, 10727, 15676, 34492, 11302, 30983, 10239, 27184, 11148, 16012, 13382, 11702, 18726, 10832, 16952, 24133, 9454, 21152, 22064, 5202, 29716, 8219, 18975, 10078, 11633, 10604, 9357, 25145, 82471, 25294, 13270, 8653, 20891, 41040, 11945, 9080, 25991, 8592, 26568, 12760, 9918, 11163, 25627, 12672, 15235, 18263, 11658, 12806, 11580, 10176, 11538, 10923, 11015, 18276, 10587, 10847, 10852, 18896, 14635, 16942, 18271, 8292, 12197, 11126, 11489, 14929, 9764, 15179, 11765, 10865, 25110, 10109, 10387, 15412, 11745, 10938, 10866, 7458, 11852, 31513, 11403, 16621, 11869, 22140, 27762, 11317, 10083, 11296, 18886, 12088, 4649, 10649, 11756, 5362, 5696, 11160, 12697, 10587, 11287, 49254, 5111, 11307, 16226, 65648, 10693, 12976, 9795, 11685, 13300, 9676, 11079, 19515, 4971, 36232, 30848, 8851, 9364, 12046, 10543, 27251, 14449, 25057, 8742, 10756, 10119, 31794, 16824, 13457, 13126, 10940, 8487, 15164, 12277, 10026, 10669, 11707, 10301, 10134, 10264, 12246, 9538, 10608, 10708, 9828, 30769, 10272, 10700, 22730, 10375, 28088, 10679, 15887, 26494, 10750, 16367, 10320, 20659, 11089, 25920, 37391, 9229, 57506, 24371, 13704, 10908, 12191, 10632, 11670, 22268, 14633, 10035, 28198, 10394, 18725, 16048, 9974, 12317, 10831, 11404, 8516, 12843, 10178, 13677, 9834, 23288, 11986, 11347, 18648, 12240, 21040, 10354, 10543, 29142, 10722, 11426, 11068, 9953, 11366, 10677, 10497, 10617, 10630, 11202, 22069, 48435, 10150, 10683, 9589, 10529, 21533, 10302, 24630, 9491, 12154, 10609, 10864, 10744, 10824, 11051, 35643, 10335, 11128, 10196, 20262, 14029, 15512, 13132, 9473, 10776, 10227, 10858, 27460, 10466, 41882, 10425, 23124, 9776, 10710, 10243, 11306, 11631, 13932, 9667, 15904, 15014, 34062, 12569, 10702, 10223, 10575, 24485, 12828, 20228, 11740, 11350, 15787, 12331, 11897, 11918, 5419, 11540, 10408, 10647, 10595, 9036, 11470, 11221, 15296, 19651, 11423, 10007, 9515, 38820, 10686, 10398, 23090, 11000, 9523, 9228, 10795, 11570, 25015, 16290, 41501, 23156, 27076, 9705, 16633, 39615, 25068, 11360, 10211, 14392, 9340, 16150, 8181, 51944, 8740, 17771, 10974, 24164, 8383, 11886, 6533, 11492, 10738, 11183, 11084, 10903, 10390, 9487, 10620, 8266, 15542, 11094, 17072, 33639, 33150, 12483, 10196, 29392, 24209, 18940, 30223, 25634, 20366, 6509, 14943, 10926, 10030, 9480, 10221, 15497, 6424, 12117, 25062, 13167, 9658, 9925, 19563, 62188, 21058, 14014, 57943, 19077, 25315, 15032, 12432, 13616, 14913, 20394, 17053, 26546, 10478, 10214, 21465, 18236, 14091, 11012, 11873, 12159, 33008, 14540, 14730, 20518, 13484, 12526, 4889, 10978, 11327, 11275, 11315, 37227, 15152, 12142, 30949, 13920, 6760, 13238, 10143, 11176, 10785, 12044, 10015, 11509, 10305, 9929, 11989, 11969, 9381, 19884, 14021, 9348, 12366, 6139, 60031, 5686, 9360, 11195, 11103, 17782, 14637, 10345, 24660, 10742, 10857, 9383, 10755, 11377, 8993, 11301, 10398, 8455, 9976, 13778, 8067, 31746, 10800, 10741, 10798, 37306, 6794, 15761, 11289, 11595, 4846, 20598, 9148, 10764, 41269, 10303, 11103, 17525, 9367, 22586, 9782, 10147, 33394, 28569, 9935, 9319, 13227, 30809, 10949, 11866, 12566, 10833, 11049, 10057, 10110, 10675, 11593, 12021, 30957, 4385, 23884, 21501, 21241, 19901, 4683, 9416, 28303, 12191, 11174, 9041, 15090, 19681, 10345, 9568, 22790, 20433, 10896, 11544, 19006, 7436, 17652, 10867, 11300, 14826, 12256, 18901, 17356, 22603, 20761, 15085, 10008, 10169, 9754, 12484, 21462, 10322, 10221, 21330, 10370, 9100, 12219, 9615, 12862, 11684, 10562, 30345, 10522, 11059, 28976, 8969, 23416, 4984, 13203, 11497, 6010, 12975, 44056, 10758, 18000, 16477, 11233, 19186, 12322, 12033, 8707, 11488, 10317, 14374, 9960, 10525, 11512, 11073, 9890, 11719, 11539, 10378, 12021, 20131, 34812, 16470, 10299, 14957, 11583, 12118, 10190, 11986, 5592, 10248, 11855, 6832, 9332, 11067, 4082, 10369, 9916, 15017, 12934, 9081, 10595, 10432, 11759, 10559, 11043, 8917, 21134, 9891, 9176, 16130, 12942, 13627, 18725, 10904, 9808, 10271, 10536, 10638, 13854, 10695, 11433, 39161, 11455, 18960, 11107, 10703, 12723, 9257, 11431, 11105, 10333, 10313, 11585, 10344, 11084, 21966, 8377, 10323, 8185, 14299, 10609, 10551, 16646, 11337, 10546, 10707, 26303, 12953, 9294, 11267, 39151, 8228, 10602, 11245, 10260, 10439, 9924, 10518, 10226, 13153, 9727, 10631, 10293, 4908, 11351, 11699, 13297, 7873, 10887, 13199, 39299, 10164, 28920, 11162, 21162, 10873, 5283, 9938, 13808, 5140, 10517, 12483, 9389, 23219, 19894, 16043, 11175, 14779, 11053, 10940, 39710, 10974, 12795, 10458, 29754, 19573, 11346, 10526, 11079, 10434, 11672, 6137, 10845, 18903, 11224, 10704, 12516, 10495, 11055, 10604, 9788, 10452, 10533, 4945, 9983, 11643, 9712, 10519, 13844, 10913, 14131, 10514, 14742, 33770, 8857, 13931, 10485, 20982, 10189, 10240, 11140, 12490, 10792, 10299, 28767, 10669, 13604, 6395, 10977, 39186, 10903, 61691, 10745, 18824, 10159, 12396, 11054, 10595, 20240, 9738, 10219, 21439, 41329, 10739, 10896, 4868, 52815, 10708, 38900, 9872, 9994, 13546, 8304, 10149, 10501, 14794, 9865, 24487, 10105, 10997, 10480, 8867, 15620, 4849, 14141, 21448, 44760, 24356, 10123, 10512, 32705, 10711, 14130, 10830, 26961, 13539, 10216, 12642, 10823, 11040, 13619, 10147, 10247, 11415, 30393, 10969, 11854, 7609, 46668, 22548, 7873, 62534, 10747, 10471, 11411, 14595, 10810, 26857, 11315, 10359, 13682, 19665, 19345, 27815, 14945, 20679, 31038, 13784, 15296, 10509, 10744, 22472, 10520, 11555, 10757, 27673, 14992, 14989, 27100, 10319, 27530, 7593, 15409, 11668, 10774, 17530, 11036, 8222, 10799, 20249, 10742, 20896, 13897, 38765, 18303, 9745, 71755, 12680, 11783, 5892, 22802, 8486, 23485, 11273, 24528, 12647, 27395, 18613, 19047, 25991, 6369, 22035, 11269, 4850, 11819, 23594, 10413, 10210, 38584, 10776, 11590, 26886, 12407, 15941, 10203, 10543, 16827, 10406, 10801, 16961, 25091, 26117, 4995, 10669, 4570, 10934, 5509, 12342, 11069, 11221, 18032, 10606, 10294, 10794, 10149, 23535, 11605, 11509, 10267, 10945, 10808, 10208, 12462, 9539, 10996, 13746, 11135, 10701, 22650, 10277, 9871, 22744, 23044, 33427, 3378, 9747, 8703, 7656, 9463, 10656, 11297, 15888, 14886, 11302, 38639, 10594, 10537, 14643, 57349, 14269, 11499, 10223, 15088, 28919, 23684, 13888, 13690, 26912, 12774, 11234, 26520, 10459, 11919, 8800, 9204, 10845, 18581, 12632, 10618, 11108, 10805, 24695, 11472, 10718, 10299, 55165, 12039, 11745, 12596, 12705, 36938, 10675, 25627, 10441, 10320, 11116, 32508, 10810, 18654, 23086, 16685, 8342, 11231, 10819, 11306, 10918, 16246, 10979, 10863, 11223, 8547, 12869, 10174, 26564, 10143, 16311, 10658, 10181, 12059, 9562, 32135, 9438, 29761, 26396, 16018, 16535, 46584, 14336, 9155, 21595, 27259, 11287, 7579, 38688, 46567, 6178, 8256, 31900, 12278, 19151, 10862, 3608, 15766, 12738, 15914, 42111, 10020, 36021, 10692, 6690, 9883, 15079, 12033, 9900, 22825, 11361, 11951, 37286, 11418, 10924, 11337, 9619, 10213, 10856, 11048, 10842, 12414, 10325, 16869, 11143, 25523, 9572, 8037, 9731, 10596, 14328, 10393, 41055, 20795, 14812, 29254, 9532, 9682, 22098, 10576, 14922, 27530, 22068, 44823, 62466, 15851, 17035, 13790, 32455, 9763, 22771, 20480, 5260, 10708, 36714, 21263, 35770, 11534, 5466, 21040, 12474, 25403, 12246, 12780, 19804, 14025, 22915, 11714, 10546, 10914, 4907, 25442, 21807, 11633, 9574, 11884, 20814, 10725, 15213, 21476, 24079, 34650, 11473, 14708, 11460, 14527, 12063, 11321, 10635, 38457, 9976, 11387, 12442, 9942, 11507, 21903, 14923, 12090, 12044, 13137, 23724, 16638, 12050, 23906, 12763, 10095, 10450, 16574, 7953, 23314, 46235, 10924, 10452, 11349, 49136, 8569, 28080, 12395, 31054, 17199, 10749, 12401, 23741, 9983, 10240, 14952, 18745, 10093, 15763, 15947, 22766, 9734, 11323, 9103, 8183, 10813, 11526, 31744, 37984, 10665, 18484, 10234, 28322, 24927, 12733, 11218, 26552, 11835, 19255, 13685, 18189, 14281, 11213, 12967, 12791, 13413, 23402, 14537, 13631, 13160, 14190, 13652, 11060, 11685, 9787, 11534, 14020, 10163, 11664, 11130, 11526, 11963, 11541, 36500, 31777, 11087, 5208, 10415, 11008, 17780, 13966, 11527, 12402, 9959, 15587, 11744, 11524, 10972, 9728, 6301, 11682, 11987, 10687, 11419, 10401, 11515, 11320, 10253, 9305, 11693, 10882, 11733, 22243, 10735, 29551, 12129, 7360, 16884, 43866, 16754, 22618, 10169, 10098, 31603, 17397] + } + ] + }] +} diff --git a/test/image/mocks/table.json b/test/image/mocks/table.json new file mode 100644 index 00000000000..2be579aab6c --- /dev/null +++ b/test/image/mocks/table.json @@ -0,0 +1,117 @@ +{ + "layout": { + "width": 1000, + "height": 610, + "title": "Widget parameters and cost", + "margin": {"t": 380, "r": 60, "b": 54, "l": 60} + }, + + "data": [{ + + "type": "table", + + "domain": { + "x": [0.05, 0.95], + "y": [0, 1] + }, + + "columnwidth": [50, 90, 70, 60, 90, 80, 70, 80, 60, 100, 70], + "columnorder": [1, 0, 2, 3, 4, 5, 6, 7, 8, 9, 10], + + "header": { + + "height": 25, + + "values": [ + ["Index" , "#"], + ["Cylinder", "class"], + ["Height" , "m"], + ["Width" , "mm"], + ["Weight" , "kg"], + ["Cost" , "USD"], + ["Penalty" , "USD"], + ["H/W" , "ratio"], + ["Min" , "mm"], + ["Diameter", "mm"], + ["RF block", "m"] + ], + + "align": ["right", "center", "right", "center", "right", "right", "right", "left", "right", "right", "right"], + "valign": "middle", + + "line": { + "color": "lightgray", + "width": 0.5 + }, + + "fill": { + "color": "grey" + }, + + "font": { + "family": "Arial", + "size": 12, + "color": "white" + } + }, + + "cells": { + + "values": [ + [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19].slice(0, 20), + ["A", "X
B
C
D", "A", "B", "Y", "Z", "Z", "A", "B", "B", "Y", "Y", "Z", "A", "A", "B", "Y", "Y", "Z", "Z"].slice(0, 20), + [32000, 162666, 32000, 162666, 32000, 162666, 32000, 162666, 32000, 162666, 32000, 162666, 32000, 162666, 32000, 162666, 32000, 162666, 32000, 162666].slice(0, 20), + [268630, 489543, 379086, 600000, 489543, 268630, 600000, 379086, 268630, 489543, 379086, 600000, 489543, 268630, 600000, 379086, 268630, 489543, 379086, 600000].slice(0, 20), + [160, 1324, 252, 1711, 173, 624, 228, 2474, 371, 3103, 312, 2408, 460, 1727, 754, 2457, 227, 1963, 354, 2797].slice(0, 20), + [1125, 9274, 2735, 16920, 2193, 20704, 4814, 34689, 5565, 46554, 5225, 38887, 9746, 37715, 17798, 55250, 5697, 49083, 11226, 81939].slice(0, 20), + [9, 794, 34, 1409, 17, 536, 39, 7133, 115, 9843, 107, 7017, 273, 5131, 1210, 9032, 82, 7312, 252, 16778].slice(0, 20), + [0.2366, 0.3269, 0.3471, 0.4373, 0.4575, 0.106, 0.568, 0.2164, 0.2366, 0.3269, 0.3471, 0.4373, 0.4575, 0.106, 0.568, 0.2164, 0.2366, 0.3269, 0.3471, 0.4373].slice(0, 20), + [5137, 113712, -5909, 102666, -16955, 135803, -28000, 124758, 5137, 113712, -5909, 102666, -16955, 135803, -28000, 124758, 5137, 113712, -5909, 102666].slice(0, 20), + [98453, 319366, 234498, 455411, 391333, 147711, 479081, 208910, 124041, 344954, 280876, 501789, 368624, 98453, 429823, 234498, 170419, 391333, 258167, 479081].slice(0, 20), + [1417, 23377, 3376, 33336, 5635, 10812, 6898, 21273, 2484, 35126, 5626, 51096, 7384, 22020, 18912, 52449, 7498, 87528, 11359, 107154].slice(0, 20), + ], + + "format": [ + null, + null, + ".2s", + "#0x", + [",.0f", ",.1f", ",.2f", ",.3f", ",.2f"], + "$,", + "_>5", + ",.1%", + ".3s", + ",.0f", + ",.0f" + ], + + "prefix": ["#", "", "", "", "", "US ", ""], + "suffix": ["", " class", "m", ""], + + "height": 20, + + "align": ["right", "center", "right", "center", "right", "right", "right", "left", "right", "right", "right"], + "valign": ["bottom"], + + "line": { + "color": [ + "grey" + ], + "width": 1 + }, + + "fill": { + "color": [ + ["#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1"], + ["#f7fbff", "#deebf7", "#f7fbff", "#deebf7", "#f7fbff", "#deebf7", "#f7fbff", "#deebf7", "#f7fbff", "#deebf7", "#f7fbff", "#deebf7", "#f7fbff", "#deebf7", "#f7fbff", "#deebf7", "#f7fbff", "#deebf7", "#f7fbff", "#deebf7"] + ] + }, + + "font": { + "family": "verdana", + "size": 12, + "color": ["black", "red", "black"] + } + } + }] +} diff --git a/test/image/mocks/table_latex.json b/test/image/mocks/table_latex.json new file mode 100644 index 00000000000..a67e19b482b --- /dev/null +++ b/test/image/mocks/table_latex.json @@ -0,0 +1,142 @@ +{ + "layout": { + "width": 600, + "height": 330 + 380 - 150, + "title": "Widget parameters and cost", + "margin": {"t": 0 || 380, "r": 60, "b": 54, "l": 60} + }, + + "data": [{ + + "type": "table", + + "domain": { + "x": [0.05, 0.95], + "y": [0, 1] + }, + + "columnwidth": [20, 50, 50], + "columnorder": [0, 1, 2], + + "header": { + + "height": 20, // fixme for some reason it doesn't recognize arrays here + + "values": [ + ["Index" , "#"], + ["Column 2" , "ASDF
GHJKLWW" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$" || "1AX
B
 Plotly
CD"], + ["Column 3" , "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1 \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$"] + ].map(function(r) {return r.slice(0, 100)}).slice(0, 4), + + "align": ["right"], + "valign": "middle", + + "line": { + "color": "lightgray", + "width": 0.5 + }, + + "fill": { + "color": "grey" + }, + + "font": { + "family": "Arial", + "size": 12, + "color": "white" + } + }, + + "cells": { + + "values": [ + [ + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "1AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "2AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "3AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "4AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "5AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "6AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "7AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "8AX
B
Plotly
CD", + ].map(function(d, i) {return i}), + [ + "0 A" || "$\\begin{eqnarray*} 1*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "1AX
B
Plotly
CD", + "$\\begin{eqnarray*} 2*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "2AX
B
Plotly
CD", + "$\\begin{eqnarray*} 3*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "3AX
B
Plotly
CD", + "$\\begin{eqnarray*} 4*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "4AX
B
Plotly
CD", + "$\\begin{eqnarray*} 5*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "5AX
B
Plotly
CD", + "$\\begin{eqnarray*} 6*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "6AX
B
Plotly
CD", + "$\\begin{eqnarray*} 7*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "7AX
B
Plotly
CD", + "$\\begin{eqnarray*} 8*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "8AX
B
Plotly
CD", + ].map(function(d, i) {return d}), + [ + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x1AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x2AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x3AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x4AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x5AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x6AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x7AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x8AX
B
Plotly
CD", + ].map(function(d, i) {return d}) + + ].map(function(a) {return a.slice(0, 19)}).slice(0, 4), + + "format": [ + null + ], + + //"prefix": ["#"], + //"suffix": ["cell"], + + "height": 40, + + "align": ["right"], + "valign": ["bottom"], + + "line": { + "color": [ + "grey" + ], + "width": 1 + }, + + "fill": { + "color": [ + ["#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1"] + ] + }, + + "font": { + "family": "verdana", + "size": 12, + "color": ["black"] + } + } + }] +} diff --git a/test/image/mocks/table_multicolumn_mixed_content.json b/test/image/mocks/table_multicolumn_mixed_content.json new file mode 100644 index 00000000000..8e2d671d88f --- /dev/null +++ b/test/image/mocks/table_multicolumn_mixed_content.json @@ -0,0 +1,169 @@ +{ + "layout": { + "width": 800, + "height": 0.2 * 750 + 380 - 150, + "title": "Widget parameters and cost", + "margin": {"t": 0|| 80, "r": 60, "b": 54, "l": 60} + }, + + "data": [{ + + "type": "table", + + "domain": { + "x": [0.05, 0.95], + "y": [0, 1] + }, + + "columnwidth": [30], + "columnorder": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19], + + "header": { + + "height": 30, // fixme for some reason it doesn't recognize arrays here + + "values": [ + ["C00" , "0AX
B
Plotly
CD"], + ["C01" , "#" || "ASDF
GHJKLWW" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$" || "1AX
B
Plotly
CD"], + ["C02" , "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1 \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$"], + ["C03" , "#" || "#"], + ["C04" , "#" || "ASDF
GHJKLWW" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$" || "1AX
B
Plotly
CD"], + ["C05" , "#" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1 \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$"], + ["C06" , "#" || "#"], + ["C07" , "#" || "ASDF
GHJKLWW" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$" || "1AX
B
Plotly
CD"], + ["C08" , "#" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1 \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$"], + ["C09" , "#" || "#"], + ["C10" , "#"], + ["C11" , "#" || "ASDF
GHJKLWW" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$" || "1AX
B
Plotly
CD"], + ["C12" , "#" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1 \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$"], + ["C13" , "#" || "#"], + ["C14" , "#" || "ASDF
GHJKLWW" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$" || "1AX
B
Plotly
CD"], + ["C15" , "#" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1 \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$"], + ["C16" , "#" || "#"], + ["C17" , "#" || "ASDF
GHJKLWW" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$" || "1AX
B
Plotly
CD"], + ["C18" , "#" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1 \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$"], + ["C19" , "#" || "#"], + ].map(function(r) {return r.slice(0, 2)}).slice(0, 3), + + "align": ["right"], + "valign": "middle", + + "line": { + "color": "lightgray", + "width": 0.5 + }, + + "fill": { + "color": "grey" + }, + + "font": { + "family": "Arial", + "size": 18, + "color": "white" + } + }, + + "cells": { + + "values": [ + [ + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "1AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "2AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "3AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "4AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "5AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "6AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "7AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "8AX
B
Plotly
CD", + ].map(function(d, i) {return i}), + [ + "Hello1", + "Try-hard bushwick irony humblebrag activated charcoal, thundercats air plant drinking vinegar knausgaard stumptown normcore readymade af prism. Master cleanse pork belly mumblecore, godard 8-bit wolf mlkshk dreamcatcher narwhal kickstarter williamsburg hoodie meh tumblr brunch." || "$\\begin{eqnarray*} 1*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "Hello2", + //"1AX
B
Plotly
CD", + "$\\begin{eqnarray*} 2*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "2AX
B
Plotly
CD", + "$\\begin{eqnarray*} 3*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "3AXB PlotlyCD", + "$\\begin{eqnarray*} 4*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "4AX
B
Plotly
CD", + "$\\begin{eqnarray*} 5*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "5AX
B
Plotly
CD", + "$\\begin{eqnarray*} 6*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "6AX
B
Plotly
CD", + "$\\begin{eqnarray*} 7*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "7AX
B
Plotly
CD", + "$\\begin{eqnarray*} 8*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "8AX
B
Plotly
CD", + ].map(function(d, i) {return d}), + [ + //"$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x1AX
B
Plotly
CD", + "x1AX
B
Plotly
CD", + //"$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x2AX
B
Plotly
CD", + "x2AX
B
Plotly
CD", + //"$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x3AX
B
Plotly
CD", + "x3AX
B
Plotly
CD", + //"$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x4AX
B
Plotly
CD", + "x4AX
B
Plotly
CD", + //"$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x5AX
B
Plotly
CD", + "x5AX
B
Plotly
CD", + //"$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x6AX
B
Plotly
CD", + "x6AX
B
Plotly
CD", + //"$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x7AX
B
Plotly
CD", + "x7AXB PlotlyCD", + //"$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x8AX
B
Plotly
CD", + "x8AX
B
Plotly
CD", + ].map(function(d, i) {return d}).slice(0, 16) + + ].filter(function(d,i) {return i < 4}), + + "format": [ + null + ], + + //"prefix": ["#"], + //"suffix": ["cell"], + + "height": 40, + + "align": ["right"], + "valign": ["bottom"], + + "line": { + "color": [ + "grey" + ], + "width": 1 + }, + + "fille": { + "color": [ + ["#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1"] + ] + }, + + "font": { + "family": "Courier", + "size": 15, + "color": ["black"] + } + } + }] +} diff --git a/test/image/mocks/table_one_cell_latex.json b/test/image/mocks/table_one_cell_latex.json new file mode 100644 index 00000000000..06e20c178d2 --- /dev/null +++ b/test/image/mocks/table_one_cell_latex.json @@ -0,0 +1,169 @@ +{ + "layout": { + "width": 800, + "height": 0.2 * 750 + 380 - 210, + "title": "Widget parameters and cost", + "margin": {"t": 0|| 80, "r": 60, "b": 54, "l": 60} + }, + + "data": [{ + + "type": "table", + + "domain": { + "x": [0.05, 0.95], + "y": [0, 1] + }, + + "columnwidth": [30], + "columnorder": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19], + + "header": { + + "height": 20, // fixme for some reason it doesn't recognize arrays here + + "values": [ + ["C00" , "$\\begin{eqnarray*} \\cos 0\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1 \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$"], + ["C01" , "#" || "ASDF
GHJKLWW" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$" || "1AX
B
Plotly
CD"], + ["C02" , "#" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1 \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$"], + ["C03" , "#" || "#"], + ["C04" , "#" || "ASDF
GHJKLWW" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$" || "1AX
B
Plotly
CD"], + ["C05" , "#" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1 \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$"], + ["C06" , "#" || "#"], + ["C07" , "#" || "ASDF
GHJKLWW" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$" || "1AX
B
Plotly
CD"], + ["C08" , "#" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1 \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$"], + ["C09" , "#" || "#"], + ["C10" , "#"], + ["C11" , "#" || "ASDF
GHJKLWW" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$" || "1AX
B
Plotly
CD"], + ["C12" , "#" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1 \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$"], + ["C13" , "#" || "#"], + ["C14" , "#" || "ASDF
GHJKLWW" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$" || "1AX
B
Plotly
CD"], + ["C15" , "#" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1 \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$"], + ["C16" , "#" || "#"], + ["C17" , "#" || "ASDF
GHJKLWW" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$" || "1AX
B
Plotly
CD"], + ["C18" , "#" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1 \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$"], + ["C19" , "#" || "#"], + ].map(function(r) {return r.slice(0, 2)}).slice(0, 1), + + "align": ["right"], + "valign": "middle", + + "line": { + "color": "lightgray", + "width": 0.5 + }, + + "fill": { + "color": "grey" + }, + + "font": { + "family": "Arial", + "size": 18, + "color": "white" + } + }, + + "cells": { + + "values": [ + [ + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "1AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "2AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "3AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "4AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "5AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "6AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "7AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "8AX
B
Plotly
CD", + ].map(function(d, i) {return i}), + [ + "Hello1", + "Try-hard bushwick irony humblebrag activated charcoal, thundercats air plant drinking vinegar knausgaard stumptown normcore readymade af prism. Master cleanse pork belly mumblecore, godard 8-bit wolf mlkshk dreamcatcher narwhal kickstarter williamsburg hoodie meh tumblr brunch." || "$\\begin{eqnarray*} 1*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "Hello2", + //"1AX
B
Plotly
CD", + "$\\begin{eqnarray*} 2*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "2AX
B
Plotly
CD", + "$\\begin{eqnarray*} 3*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "3AXB PlotlyCD", + "$\\begin{eqnarray*} 4*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "4AX
B
Plotly
CD", + "$\\begin{eqnarray*} 5*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "5AX
B
Plotly
CD", + "$\\begin{eqnarray*} 6*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "6AX
B
Plotly
CD", + "$\\begin{eqnarray*} 7*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "7AX
B
Plotly
CD", + "$\\begin{eqnarray*} 8*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "8AX
B
Plotly
CD", + ].map(function(d, i) {return d}), + [ + "$\\begin{eqnarray*} \\cos 1\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + //"x1AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 3\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "$\\begin{eqnarray*} \\cos 4\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + //"x2AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 5\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "$\\begin{eqnarray*} \\cos 6\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + //"x3AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 7\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "$\\begin{eqnarray*} \\cos 8\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + //"x4AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 9\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "$\\begin{eqnarray*} \\cos 10\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + //"x5AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 11\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "$\\begin{eqnarray*} \\cos 12\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + //"x6AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 13\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "$\\begin{eqnarray*} \\cos 14\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + //"x7AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 15\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "$\\begin{eqnarray*} \\cos 16\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + //"x8AX
B
Plotly
CD", + ].map(function(d, i) {return d}).filter(function(d, i) {return i < 400;}) + + ].filter(function(d,i) {return i === 2}), + + "format": [ + null + ], + + //"prefix": ["#"], + //"suffix": ["cell"], + + "height": 60, + + "align": ["right"], + "valign": ["bottom"], + + "line": { + "color": [ + "grey" + ], + "width": 1 + }, + + "fille": { + "color": [ + ["#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1"] + ] + }, + + "font": { + "family": "Courier", + "size": 15, + "color": ["black"] + } + } + }] +} diff --git a/test/image/mocks/table_one_cell_linebroken.json b/test/image/mocks/table_one_cell_linebroken.json new file mode 100644 index 00000000000..25ab3b9b107 --- /dev/null +++ b/test/image/mocks/table_one_cell_linebroken.json @@ -0,0 +1,169 @@ +{ + "layout": { + "width": 800, + "height": 0.2 * 750 + 380 - 150, + "title": "Widget parameters and cost", + "margin": {"t": 0|| 80, "r": 60, "b": 54, "l": 60} + }, + + "data": [{ + + "type": "table", + + "domain": { + "x": [0.05, 0.95], + "y": [0, 1] + }, + + "columnwidth": [30], + "columnorder": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19], + + "header": { + + "height": 30, // fixme for some reason it doesn't recognize arrays here + + "values": [ + ["C00" , "0AX
B
Plotly
CD"], + ["C01" , "#" || "ASDF
GHJKLWW" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$" || "1AX
B
Plotly
CD"], + ["C02" , "#" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1 \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$"], + ["C03" , "#" || "#"], + ["C04" , "#" || "ASDF
GHJKLWW" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$" || "1AX
B
Plotly
CD"], + ["C05" , "#" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1 \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$"], + ["C06" , "#" || "#"], + ["C07" , "#" || "ASDF
GHJKLWW" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$" || "1AX
B
Plotly
CD"], + ["C08" , "#" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1 \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$"], + ["C09" , "#" || "#"], + ["C10" , "#"], + ["C11" , "#" || "ASDF
GHJKLWW" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$" || "1AX
B
Plotly
CD"], + ["C12" , "#" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1 \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$"], + ["C13" , "#" || "#"], + ["C14" , "#" || "ASDF
GHJKLWW" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$" || "1AX
B
Plotly
CD"], + ["C15" , "#" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1 \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$"], + ["C16" , "#" || "#"], + ["C17" , "#" || "ASDF
GHJKLWW" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$" || "1AX
B
Plotly
CD"], + ["C18" , "#" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1 \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$"], + ["C19" , "#" || "#"], + ].map(function(r) {return r.slice(0, 2)}).slice(0, 1), + + "align": ["right"], + "valign": "middle", + + "line": { + "color": "lightgray", + "width": 0.5 + }, + + "fill": { + "color": "grey" + }, + + "font": { + "family": "Arial", + "size": 18, + "color": "white" + } + }, + + "cells": { + + "values": [ + [ + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "1AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "2AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "3AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "4AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "5AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "6AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "7AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "8AX
B
Plotly
CD", + ].map(function(d, i) {return i}), + [ + "Hello1", + "Try-hard bushwick irony humblebrag activated charcoal, thundercats air plant drinking vinegar knausgaard stumptown normcore readymade af prism. Master cleanse pork belly mumblecore, godard 8-bit wolf mlkshk dreamcatcher narwhal kickstarter williamsburg hoodie meh tumblr brunch." || "$\\begin{eqnarray*} 1*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "Hello2", + //"1AX
B
Plotly
CD", + "$\\begin{eqnarray*} 2*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "2AX
B
Plotly
CD", + "$\\begin{eqnarray*} 3*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "3AXB PlotlyCD", + "$\\begin{eqnarray*} 4*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "4AX
B
Plotly
CD", + "$\\begin{eqnarray*} 5*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "5AX
B
Plotly
CD", + "$\\begin{eqnarray*} 6*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "6AX
B
Plotly
CD", + "$\\begin{eqnarray*} 7*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "7AX
B
Plotly
CD", + "$\\begin{eqnarray*} 8*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "8AX
B
Plotly
CD", + ].map(function(d, i) {return d}), + [ + //"$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x1AX
B
Plotly
CD", + "x1AX
B
Plotly
CD", + //"$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x2AX
B
Plotly
CD", + "x2AX
B
Plotly
CD", + //"$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x3AX
B
Plotly
CD", + "x3AX
B
Plotly
CD", + //"$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x4AX
B
Plotly
CD", + "x4AX
B
Plotly
CD", + //"$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x5AX
B
Plotly
CD", + "x5AX
B
Plotly
CD", + //"$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x6AX
B
Plotly
CD", + "x6AX
B
Plotly
CD", + //"$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x7AX
B
Plotly
CD", + "x7AX
B
Plotly
CD", + //"$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x8AX
B
Plotly
CD", + "x8AX
B
Plotly
CD", + ].map(function(d, i) {return d}) + + ].filter(function(d,i) {return i === 2}), + + "format": [ + null + ], + + //"prefix": ["#"], + //"suffix": ["cell"], + + "height": 40, + + "align": ["right"], + "valign": ["bottom"], + + "line": { + "color": [ + "grey" + ], + "width": 1 + }, + + "fille": { + "color": [ + ["#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1"] + ] + }, + + "font": { + "family": "Courier", + "size": 15, + "color": ["black"] + } + } + }] +} diff --git a/test/image/mocks/table_one_cell_plain.json b/test/image/mocks/table_one_cell_plain.json new file mode 100644 index 00000000000..c3917f4179f --- /dev/null +++ b/test/image/mocks/table_one_cell_plain.json @@ -0,0 +1,172 @@ +{ + "layout": { + "width": 1400, + "height": 750 + 380 - 150, + "title": "Widget parameters and cost", + "margin": {"t": 0|| 80, "r": 20, "b": 54, "l": 20} + }, + + "data": [{ + + "type": "table", + + "domain": { + "x": [0, 1], + "y": [0, 1] + }, + + "columnwidth": [30], + "columnorder": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19], + + "header": { + + "height": 30, // fixme for some reason it doesn't recognize arrays here + + "values": [ + ["C00" , "#"], + ["C01" , "#" || "ASDF
GHJKLWW" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$" || "1AX
B
Plotly
CD"], + ["C02" , "#" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1 \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$"], + ["C03" , "#" || "#"], + ["C04" , "#" || "ASDF
GHJKLWW" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$" || "1AX
B
Plotly
CD"], + ["C05" , "#" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1 \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$"], + ["C06" , "#" || "#"], + ["C07" , "#" || "ASDF
GHJKLWW" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$" || "1AX
B
Plotly
CD"], + ["C08" , "#" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1 \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$"], + ["C09" , "#" || "#"], + ["C10" , "#"], + ["C11" , "#" || "ASDF
GHJKLWW" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$" || "1AX
B
Plotly
CD"], + ["C12" , "#" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1 \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$"], + ["C13" , "#" || "#"], + ["C14" , "#" || "ASDF
GHJKLWW" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$" || "1AX
B
Plotly
CD"], + ["C15" , "#" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1 \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$"], + ["C16" , "#" || "#"], + ["C17" , "#" || "ASDF
GHJKLWW" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$" || "1AX
B
Plotly
CD"], + ["C18" , "#" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1 \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$"], + ["C19" , "#" || "#"], + ].map(function(r) {return r.slice(0, 2)}).slice(0, 20), + + "align": ["right"], + "valign": "middle", + + "line": { + "color": "lightgray", + "width": 0.5 + }, + + "fill": { + "color": "grey" + }, + + "font": { + "family": "Arial", + "size": 18, + "color": "white" + } + }, + + "cells": { + + "values": [ + Array.from(Array(1000000).keys()),Array.from(Array(1000000).keys()),Array.from(Array(1000000).keys()),Array.from(Array(1000000).keys()),Array.from(Array(1000000).keys()),Array.from(Array(1000000).keys()),Array.from(Array(1000000).keys()),Array.from(Array(1000000).keys()),Array.from(Array(1000000).keys()),Array.from(Array(1000000).keys()), + Array.from(Array(1000000).keys()),Array.from(Array(1000000).keys()),Array.from(Array(1000000).keys()),Array.from(Array(1000000).keys()),Array.from(Array(1000000).keys()),Array.from(Array(1000000).keys()),Array.from(Array(1000000).keys()),Array.from(Array(1000000).keys()),Array.from(Array(1000000).keys()),Array.from(Array(1000000).keys()), + ] + .slice(0, 20) || [ + [ + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "1AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "2AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "3AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "4AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "5AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "6AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "7AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "8AX
B
Plotly
CD", + ].map(function(d, i) {return i}), + [ + "Hello1", + "Try-hard bushwick irony humblebrag activated charcoal, thundercats air plant drinking vinegar knausgaard stumptown normcore readymade af prism. Master cleanse pork belly mumblecore, godard 8-bit wolf mlkshk dreamcatcher narwhal kickstarter williamsburg hoodie meh tumblr brunch." || "$\\begin{eqnarray*} 1*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "Hello2", + //"1AX
B
Plotly
CD", + "$\\begin{eqnarray*} 2*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "2AX
B
Plotly
CD", + "$\\begin{eqnarray*} 3*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "3AXB PlotlyCD", + "$\\begin{eqnarray*} 4*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "4AX
B
Plotly
CD", + "$\\begin{eqnarray*} 5*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "5AX
B
Plotly
CD", + "$\\begin{eqnarray*} 6*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "6AX
B
Plotly
CD", + "$\\begin{eqnarray*} 7*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "7AX
B
Plotly
CD", + "$\\begin{eqnarray*} 8*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "8AX
B
Plotly
CD", + ].map(function(d, i) {return d}), + [ + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x1AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x2AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x3AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x4AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x5AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x6AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x7AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x8AX
B
Plotly
CD", + ].map(function(d, i) {return d}) + + ].map(function(a, i) {return a + + //25k + .concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a).concat(a) + + .map(function(d, i) {return i} ) + + }).slice(0, 1), + + "format": [ + null + ], + + //"prefix": ["#"], + //"suffix": ["cell"], + + "height": 40, + + "align": [["center", "right"], "left", "center", "right"], + "valign": ["bottom"], + + "line": { + "color": [ + "grey" + ], + "width": 1 + }, + + "fill": { + "color": [ + Array.from(Array(1000000).keys()).map(function(d, i) {return i % 2 ? "#c6dbef" : "#9ecae1"}) + ] + }, + + "font": { + "family": "Courier", + "size": 15, + "color": ["black"] + } + } + }] +} diff --git a/test/image/mocks/table_one_cell_styled.json b/test/image/mocks/table_one_cell_styled.json new file mode 100644 index 00000000000..e2c95f75a82 --- /dev/null +++ b/test/image/mocks/table_one_cell_styled.json @@ -0,0 +1,169 @@ +{ + "layout": { + "width": 800, + "height": 0 * 750 + 380 - 150, + "title": "Widget parameters and cost", + "margin": {"t": 0|| 80, "r": 60, "b": 54, "l": 60} + }, + + "data": [{ + + "type": "table", + + "domain": { + "x": [0.05, 0.95], + "y": [0, 1] + }, + + "columnwidth": [30], + "columnorder": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19], + + "header": { + + "height": 30, // fixme for some reason it doesn't recognize arrays here + + "values": [ + ["C00" , "#"], + ["C01" , "#" || "ASDF
GHJKLWW" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$" || "1AX
B
Plotly
CD"], + ["C02" , "#" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1 \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$"], + ["C03" , "#" || "#"], + ["C04" , "#" || "ASDF
GHJKLWW" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$" || "1AX
B
Plotly
CD"], + ["C05" , "#" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1 \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$"], + ["C06" , "#" || "#"], + ["C07" , "#" || "ASDF
GHJKLWW" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$" || "1AX
B
Plotly
CD"], + ["C08" , "#" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1 \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$"], + ["C09" , "#" || "#"], + ["C10" , "#"], + ["C11" , "#" || "ASDF
GHJKLWW" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$" || "1AX
B
Plotly
CD"], + ["C12" , "#" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1 \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$"], + ["C13" , "#" || "#"], + ["C14" , "#" || "ASDF
GHJKLWW" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$" || "1AX
B
Plotly
CD"], + ["C15" , "#" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1 \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$"], + ["C16" , "#" || "#"], + ["C17" , "#" || "ASDF
GHJKLWW" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$" || "1AX
B
Plotly
CD"], + ["C18" , "#" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1 \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$"], + ["C19" , "#" || "#"], + ].map(function(r) {return r.slice(0, 2)}).slice(0, 1), + + "align": ["right"], + "valign": "middle", + + "line": { + "color": "lightgray", + "width": 0.5 + }, + + "fill": { + "color": "grey" + }, + + "font": { + "family": "Arial", + "size": 18, + "color": "white" + } + }, + + "cells": { + + "values": [ + [ + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "1AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "2AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "3AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "4AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "5AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "6AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "7AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "8AX
B
Plotly
CD", + ].map(function(d, i) {return i}), + [ + "Hello1", + "Try-hard bushwick irony humblebrag activated charcoal, thundercats air plant drinking vinegar knausgaard stumptown normcore readymade af prism. Master cleanse pork belly mumblecore, godard 8-bit wolf mlkshk dreamcatcher narwhal kickstarter williamsburg hoodie meh tumblr brunch." || "$\\begin{eqnarray*} 1*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "Hello2", + //"1AX
B
Plotly
CD", + "$\\begin{eqnarray*} 2*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "2AX
B
Plotly
CD", + "$\\begin{eqnarray*} 3*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "3AXB PlotlyCD", + "$\\begin{eqnarray*} 4*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "4AX
B
Plotly
CD", + "$\\begin{eqnarray*} 5*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "5AX
B
Plotly
CD", + "$\\begin{eqnarray*} 6*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "6AX
B
Plotly
CD", + "$\\begin{eqnarray*} 7*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "7AX
B
Plotly
CD", + "$\\begin{eqnarray*} 8*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "8AX
B
Plotly
CD", + ].map(function(d, i) {return d}), + [ + //"$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x1AXB PlotlyCD", + "x1AXB PlotlyCD", + //"$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x2AXB PlotlyCD", + "x2AXB PlotlyCD", + //"$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x3AXB PlotlyCD", + "x3AXB PlotlyCD", + //"$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x4AXB PlotlyCD", + "x4AXB PlotlyCD", + //"$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x5AXB PlotlyCD", + "x5AXB PlotlyCD", + //"$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x6AXB PlotlyCD", + "x6AXB PlotlyCD", + //"$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x7AXB PlotlyCD", + "x7AXB PlotlyCD", + //"$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x8AXB PlotlyCD", + "x8AXB PlotlyCD", + ].map(function(d, i) {return d}) + + ].filter(function(d,i) {return i === 2}), + + "format": [ + null + ], + + //"prefix": ["#"], + //"suffix": ["cell"], + + "height": 20, + + "align": ["center"], + "valign": ["bottom"], + + "line": { + "color": [ + "grey" + ], + "width": 1 + }, + + "fille": { + "color": [ + ["#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1"] + ] + }, + + "font": { + "family": "Courier", + "size": 15, + "color": ["black"] + } + } + }] +} diff --git a/test/image/mocks/table_one_cell_textwrap.json b/test/image/mocks/table_one_cell_textwrap.json new file mode 100644 index 00000000000..7c4802ddd0b --- /dev/null +++ b/test/image/mocks/table_one_cell_textwrap.json @@ -0,0 +1,169 @@ +{ + "layout": { + "width": 800, + "height": 0.2 * 750 + 380 - 150, + "title": "Widget parameters and cost", + "margin": {"t": 0|| 80, "r": 60, "b": 54, "l": 60} + }, + + "data": [{ + + "type": "table", + + "domain": { + "x": [0.05, 0.95], + "y": [0, 1] + }, + + "columnwidth": [30], + "columnorder": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19], + + "header": { + + "height": 30, // fixme for some reason it doesn't recognize arrays here + + "values": [ + ["C00" , "0AX
B
Plotly
CD"], + ["C01" , "#" || "ASDF
GHJKLWW" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$" || "1AX
B
Plotly
CD"], + ["C02" , "#" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1 \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$"], + ["C03" , "#" || "#"], + ["C04" , "#" || "ASDF
GHJKLWW" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$" || "1AX
B
Plotly
CD"], + ["C05" , "#" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1 \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$"], + ["C06" , "#" || "#"], + ["C07" , "#" || "ASDF
GHJKLWW" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$" || "1AX
B
Plotly
CD"], + ["C08" , "#" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1 \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$"], + ["C09" , "#" || "#"], + ["C10" , "#"], + ["C11" , "#" || "ASDF
GHJKLWW" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$" || "1AX
B
Plotly
CD"], + ["C12" , "#" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1 \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$"], + ["C13" , "#" || "#"], + ["C14" , "#" || "ASDF
GHJKLWW" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$" || "1AX
B
Plotly
CD"], + ["C15" , "#" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1 \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$"], + ["C16" , "#" || "#"], + ["C17" , "#" || "ASDF
GHJKLWW" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$" || "1AX
B
Plotly
CD"], + ["C18" , "#" || "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1 \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$"], + ["C19" , "#" || "#"], + ].map(function(r) {return r.slice(0, 2)}).slice(0, 1), + + "align": ["right"], + "valign": "middle", + + "line": { + "color": "lightgray", + "width": 0.5 + }, + + "fill": { + "color": "grey" + }, + + "font": { + "family": "Arial", + "size": 18, + "color": "white" + } + }, + + "cells": { + + "values": [ + [ + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "1AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "2AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "3AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "4AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "5AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "6AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "7AX
B
Plotly
CD", + "$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "8AX
B
Plotly
CD", + ].map(function(d, i) {return i}), + [ + "Hello1", + "Try-hard bushwick irony humblebrag activated charcoal, thundercats air plant drinking vinegar knausgaard stumptown normcore readymade af prism. Master cleanse pork belly mumblecore, godard 8-bit wolf mlkshk dreamcatcher narwhal kickstarter williamsburg hoodie meh tumblr brunch." || "$\\begin{eqnarray*} 1*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "Hello2", + //"1AX
B
Plotly
CD", + "$\\begin{eqnarray*} 2*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "2AX
B
Plotly
CD", + "$\\begin{eqnarray*} 3*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "3AXB PlotlyCD", + "$\\begin{eqnarray*} 4*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "4AX
B
Plotly
CD", + "$\\begin{eqnarray*} 5*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "5AX
B
Plotly
CD", + "$\\begin{eqnarray*} 6*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "6AX
B
Plotly
CD", + "$\\begin{eqnarray*} 7*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "7AX
B
Plotly
CD", + "$\\begin{eqnarray*} 8*\\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "8AX
B
Plotly
CD", + ].map(function(d, i) {return d}), + [ + //"$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x1AX
B
Plotly
CD", + "x1AX
B
Plotly
CD", + //"$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x2AX
B
Plotly
CD", + "x2AX
B
Plotly
CD", + //"$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x3AX
B
Plotly
CD", + "x3AX
B
Plotly
CD", + //"$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x4AX
B
Plotly
CD", + "x4AX
B
Plotly
CD", + //"$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x5AX
B
Plotly
CD", + "x5AX
B
Plotly
CD", + //"$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x6AX
B
Plotly
CD", + "x6AX
B
Plotly
CD", + //"$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x7AX
B
Plotly
CD", + "x7AX
B
Plotly
CD", + //"$\\begin{eqnarray*} \\cos 2\\theta & = & \\cos^2 \\theta - \\sin^2 \\theta \\\\ & = & 2 \\cos^2 \\theta - 1. \\end{eqnarray*}$", + "x8AX
B
Plotly
CD", + "x8AX
B
Plotly
CD", + ].map(function(d, i) {return d}) + + ].filter(function(d,i) {return i === 1}), + + "format": [ + null + ], + + //"prefix": ["#"], + //"suffix": ["cell"], + + "height": 40, + + "align": ["right"], + "valign": ["bottom"], + + "line": { + "color": [ + "grey" + ], + "width": 1 + }, + + "fill": { + "color": [ + ["#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1"] + ] + }, + + "font": { + "family": "Courier", + "size": 15, + "color": ["black"] + } + } + }] +} diff --git a/test/image/mocks/table_one_column.json b/test/image/mocks/table_one_column.json new file mode 100644 index 00000000000..6647be209e6 --- /dev/null +++ b/test/image/mocks/table_one_column.json @@ -0,0 +1,86 @@ +{ + "layout": { + "width": 1000, + "height": 800, + "title": "Widget parameters and cost", + "margin": {"t": 380, "r": 60, "b": 54, "l": 60} + }, + + "data": [{ + + "type": "table", + + "domain": { + "x": [0.05, 0.95], + "y": [0, 1] + }, + + "columnwidth": [50], + "columnorder": [0], + + "header": { + + "height": 27, + + "values": [ + ["Index" , "#"] + ], + + "align": ["right"], + "valign": "middle", + + "line": { + "color": "lightgray", + "width": 0.5 + }, + + "fill": { + "color": "grey" + }, + + "font": { + "family": "Arial", + "size": 16, + "color": "white" + } + }, + + "cells": { + + "values": [ + [0,0 || "1
B
C",2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19].slice(0, 20) + ], + + "format": [ + null + ], + + "prefix": ["#"], + "suffix": ["cell"], + + "height": 15, + + "align": ["right"], + "valign": ["bottom"], + + "line": { + "color": [ + "grey" + ], + "width": 1 + }, + + "fill": { + "color": [ + ["#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1", "#c6dbef", "#9ecae1"] + ] + }, + + "font": { + "family": "verdana", + "size": 12, + "color": ["black"] + } + } + }] +} diff --git a/test/jasmine/tests/table_test.js b/test/jasmine/tests/table_test.js new file mode 100644 index 00000000000..b95c05c25d2 --- /dev/null +++ b/test/jasmine/tests/table_test.js @@ -0,0 +1,972 @@ +var Plotly = require('@lib/index'); +var Lib = require('@src/lib'); +var d3 = require('d3'); +var Plots = require('@src/plots/plots'); +var Table = require('@src/traces/table'); +var attributes = require('@src/traces/table/attributes'); + +var createGraphDiv = require('../assets/create_graph_div'); +var destroyGraphDiv = require('../assets/destroy_graph_div'); +var mouseEvent = require('../assets/mouse_event'); + +// mock with two dimensions (one panel); special case, e.g. left and right panel is obv. the same +var mock2 = require('@mocks/table_2.json'); + +// mock with one dimension (zero panels); special case, as no panel can be rendered +var mock1 = require('@mocks/table_1.json'); + +// mock with zero dimensions; special case, as no dimension can be rendered +var mock0 = Lib.extendDeep({}, mock1); +mock0.data[0].dimensions = []; + +var mock = require('@mocks/table_large.json'); + +var lineStart = 30; +var lineCount = 10; + +describe('table initialization tests', function() { + + 'use strict'; + + describe('table global defaults', function() { + + it('should not coerce trace opacity', function() { + var gd = Lib.extendDeep({}, mock1); + + Plots.supplyDefaults(gd); + + expect(gd._fullData[0].opacity).toBeUndefined(); + }); + + it('should use global font as label, tick and range font defaults', function() { + var gd = Lib.extendDeep({}, mock1); + gd.layout.font = { + family: 'Gravitas', + size: 20, + color: 'blue' + }; + + Plots.supplyDefaults(gd); + + var expected = { + family: 'Gravitas', + size: 17, + color: 'blue' + }; + + expect(gd._fullData[0].labelfont).toEqual(expected); + expect(gd._fullData[0].tickfont).toEqual(expected); + expect(gd._fullData[0].rangefont).toEqual(expected); + }); + }); + + describe('table defaults', function() { + + function _supply(traceIn) { + var traceOut = { visible: true }, + defaultColor = '#444', + layout = { font: Plots.layoutAttributes.font }; + + Table.supplyDefaults(traceIn, traceOut, defaultColor, layout); + + return traceOut; + } + + it('\'line\' specification should yield a default color', function() { + var fullTrace = _supply({}); + expect(fullTrace.line.color).toEqual('#444'); + }); + + it('\'colorscale\' should assume a default value if the \'color\' array is specified', function() { + var fullTrace = _supply({ + line: { + color: [35, 63, 21, 42] + }, + dimensions: [ + {values: [321, 534, 542, 674]}, + {values: [562, 124, 942, 189]}, + {values: [287, 183, 385, 884]}, + {values: [113, 489, 731, 454]} + ] + }); + expect(fullTrace.line).toEqual({ + color: [35, 63, 21, 42], + colorscale: attributes.line.colorscale.dflt, + cauto: true, + autocolorscale: false, + reversescale: false, + showscale: false + }); + }); + + it('\'domain\' specification should have a default', function() { + var fullTrace = _supply({}); + expect(fullTrace.domain).toEqual({x: [0, 1], y: [0, 1]}); + }); + + it('\'dimension\' specification should have a default of an empty array', function() { + var fullTrace = _supply({}); + expect(fullTrace.dimensions).toEqual([]); + }); + + it('\'dimension\' should be used with default values where attributes are not provided', function() { + var fullTrace = _supply({ + dimensions: [{ + values: [1], + alienProperty: 'Alpha Centauri' + }] + }); + expect(fullTrace.dimensions).toEqual([{values: [1], visible: true, valueformat: '3s', _index: 0}]); + }); + + it('\'dimension.visible\' should be set to false, and other props just passed through if \'values\' is not provided', function() { + var fullTrace = _supply({ + dimensions: [{ + alienProperty: 'Alpha Centauri' + }] + }); + expect(fullTrace.dimensions).toEqual([{visible: false, values: [], _index: 0}]); + }); + + it('\'dimension.visible\' should be set to false, and other props just passed through if \'values\' is an empty array', function() { + var fullTrace = _supply({ + dimensions: [{ + values: [], + alienProperty: 'Alpha Centauri' + }] + }); + expect(fullTrace.dimensions).toEqual([{visible: false, values: [], _index: 0}]); + }); + + it('\'dimension.visible\' should be set to false, and other props just passed through if \'values\' is not an array', function() { + var fullTrace = _supply({ + dimensions: [{ + values: null, + alienProperty: 'Alpha Centauri' + }] + }); + expect(fullTrace.dimensions).toEqual([{visible: false, values: [], _index: 0}]); + }); + + it('\'dimension.values\' should get truncated to a common shortest length', function() { + var fullTrace = _supply({dimensions: [ + {values: [321, 534, 542, 674]}, + {values: [562, 124, 942]}, + {values: [], visible: true}, + {values: [1, 2], visible: false} // shouldn't be truncated to as false + ]}); + expect(fullTrace.dimensions).toEqual([ + {values: [], visible: true, valueformat: '3s', _index: 0}, + {values: [], visible: true, valueformat: '3s', _index: 1}, + {values: [], visible: true, valueformat: '3s', _index: 2}, + {values: [1, 2], visible: false, _index: 3} + ]); + }); + }); + + describe('table calc', function() { + + function _calc(trace) { + var gd = { data: [trace] }; + + Plots.supplyDefaults(gd); + + var fullTrace = gd._fullData[0]; + Table.calc(gd, fullTrace); + return fullTrace; + } + + var base = { type: 'table' }; + + it('\'colorscale\' should assume a default value if the \'color\' array is specified', function() { + + var fullTrace = _calc(Lib.extendDeep({}, base, { + line: { + color: [35, 63, 21, 42] + }, + dimensions: [ + {values: [321, 534, 542, 674]}, + {values: [562, 124, 942, 189]}, + {values: [287, 183, 385, 884]}, + {values: [113, 489, 731, 454]} + ] + })); + + expect(fullTrace.line).toEqual({ + color: [35, 63, 21, 42], + colorscale: attributes.line.colorscale.dflt, + cauto: true, + cmin: 21, + cmax: 63, + autocolorscale: false, + reversescale: false, + showscale: false + }); + }); + + it('use a singular \'color\' if it is not an array', function() { + + var fullTrace = _calc(Lib.extendDeep({}, base, { + line: { + color: '#444' + }, + dimensions: [ + {values: [321, 534, 542, 674]}, + {values: [562, 124, 942, 189]} + ] + })); + + expect(fullTrace.line).toEqual({ + color: '#444' + }); + }); + + it('use a singular \'color\' even if a \'colorscale\' is supplied as \'color\' is not an array', function() { + + var fullTrace = _calc(Lib.extendDeep({}, base, { + line: { + color: '#444', + colorscale: 'Jet' + }, + dimensions: [ + {values: [321, 534, 542, 674]}, + {values: [562, 124, 942, 189]} + ] + })); + + expect(fullTrace.line).toEqual({ + color: '#444' + }); + }); + }); +}); + +describe('@noCI table', function() { + + beforeAll(function() { + mock.data[0].dimensions.forEach(function(d) { + d.values = d.values.slice(lineStart, lineStart + lineCount); + }); + mock.data[0].line.color = mock.data[0].line.color.slice(lineStart, lineStart + lineCount); + }); + + afterEach(destroyGraphDiv); + + describe('edge cases', function() { + + it('Works fine with one panel only', function(done) { + + var mockCopy = Lib.extendDeep({}, mock2); + var gd = createGraphDiv(); + Plotly.plot(gd, mockCopy.data, mockCopy.layout).then(function() { + + expect(gd.data.length).toEqual(1); + expect(gd.data[0].dimensions.length).toEqual(2); + expect(document.querySelectorAll('.axis').length).toEqual(2); + expect(gd.data[0].dimensions[0].visible).not.toBeDefined(); + expect(gd.data[0].dimensions[0].range).not.toBeDefined(); + expect(gd.data[0].dimensions[0].constraintrange).toBeDefined(); + expect(gd.data[0].dimensions[0].constraintrange).toEqual([200, 700]); + expect(gd.data[0].dimensions[1].range).toBeDefined(); + expect(gd.data[0].dimensions[1].range).toEqual([0, 700000]); + expect(gd.data[0].dimensions[1].constraintrange).not.toBeDefined(); + + done(); + }); + }); + + it('Do something sensible if there is no panel i.e. dimension count is less than 2', function(done) { + + var mockCopy = Lib.extendDeep({}, mock1); + var gd = createGraphDiv(); + Plotly.plot(gd, mockCopy.data, mockCopy.layout).then(function() { + + expect(gd.data.length).toEqual(1); + expect(gd.data[0].dimensions.length).toEqual(1); + expect(document.querySelectorAll('.axis').length).toEqual(1); // sole axis still shows up + expect(gd.data[0].line.cmin).toEqual(-4000); + expect(gd.data[0].dimensions[0].visible).not.toBeDefined(); + expect(gd.data[0].dimensions[0].range).not.toBeDefined(); + expect(gd.data[0].dimensions[0].constraintrange).toBeDefined(); + expect(gd.data[0].dimensions[0].constraintrange).toEqual([200, 700]); + + done(); + }); + }); + + it('Does not error with zero dimensions', function(done) { + + var mockCopy = Lib.extendDeep({}, mock0); + var gd = createGraphDiv(); + + Plotly.plot(gd, mockCopy.data, mockCopy.layout).then(function() { + expect(gd.data.length).toEqual(1); + expect(gd.data[0].dimensions.length).toEqual(0); + expect(document.querySelectorAll('.axis').length).toEqual(0); + done(); + }); + }); + + it('Works with duplicate dimension labels', function(done) { + + var mockCopy = Lib.extendDeep({}, mock2); + + mockCopy.layout.width = 320; + mockCopy.data[0].dimensions[1].label = mockCopy.data[0].dimensions[0].label; + + var gd = createGraphDiv(); + Plotly.plot(gd, mockCopy.data, mockCopy.layout).then(function() { + + expect(gd.data.length).toEqual(1); + expect(gd.data[0].dimensions.length).toEqual(2); + expect(document.querySelectorAll('.axis').length).toEqual(2); + done(); + }); + }); + + it('Works with a single line; also, use a longer color array than the number of lines', function(done) { + + var mockCopy = Lib.extendDeep({}, mock2); + var dim, i, j; + + mockCopy.layout.width = 320; + for(i = 0; i < mockCopy.data[0].dimensions.length; i++) { + dim = mockCopy.data[0].dimensions[i]; + delete dim.constraintrange; + dim.range = [1, 2]; + dim.values = []; + for(j = 0; j < 1; j++) { + dim.values[j] = 1 + Math.random(); + } + } + + var gd = createGraphDiv(); + Plotly.plot(gd, mockCopy.data, mockCopy.layout).then(function() { + + expect(gd.data.length).toEqual(1); + expect(gd.data[0].dimensions.length).toEqual(2); + expect(document.querySelectorAll('.axis').length).toEqual(2); + expect(gd.data[0].dimensions[0].values.length).toEqual(1); + done(); + }); + }); + + it('Does not raise an error with zero lines and no specified range', function(done) { + + var mockCopy = Lib.extendDeep({}, mock2); + var dim, i; + + mockCopy.layout.width = 320; + for(i = 0; i < mockCopy.data[0].dimensions.length; i++) { + dim = mockCopy.data[0].dimensions[i]; + delete dim.range; + delete dim.constraintrange; + dim.values = []; + } + + var gd = createGraphDiv(); + Plotly.plot(gd, mockCopy.data, mockCopy.layout).then(function() { + + expect(gd.data.length).toEqual(1); + expect(gd.data[0].dimensions.length).toEqual(2); + expect(document.querySelectorAll('.axis').length).toEqual(0); + expect(gd.data[0].dimensions[0].values.length).toEqual(0); + done(); + }); + }); + + it('Works with non-finite `values` elements', function(done) { + + var mockCopy = Lib.extendDeep({}, mock2); + var dim, i, j; + var values = [[0, 1, 2, 3, 4], [Infinity, NaN, void(0), null, 1]]; + + mockCopy.layout.width = 320; + for(i = 0; i < values.length; i++) { + dim = mockCopy.data[0].dimensions[i]; + delete dim.range; + delete dim.constraintrange; + dim.values = []; + for(j = 0; j < values[0].length; j++) { + dim.values[j] = values[i][j]; + } + } + + var gd = createGraphDiv(); + Plotly.plot(gd, mockCopy.data, mockCopy.layout).then(function() { + + expect(gd.data.length).toEqual(1); + expect(gd.data[0].dimensions.length).toEqual(2); + expect(document.querySelectorAll('.axis').length).toEqual(2); + expect(gd.data[0].dimensions[0].values.length).toEqual(values[0].length); + done(); + }); + }); + + it('Works with 60 dimensions', function(done) { + + var mockCopy = Lib.extendDeep({}, mock1); + var newDimension, i, j; + + mockCopy.layout.width = 1680; + mockCopy.data[0].dimensions = []; + for(i = 0; i < 60; i++) { + newDimension = Lib.extendDeep({}, mock1.data[0].dimensions[0]); + newDimension.id = 'S' + i; + newDimension.label = 'S' + i; + delete newDimension.constraintrange; + newDimension.range = [1, 2]; + newDimension.values = []; + for(j = 0; j < 100; j++) { + newDimension.values[j] = 1 + Math.random(); + } + mockCopy.data[0].dimensions[i] = newDimension; + } + + var gd = createGraphDiv(); + Plotly.plot(gd, mockCopy.data, mockCopy.layout).then(function() { + + expect(gd.data.length).toEqual(1); + expect(gd.data[0].dimensions.length).toEqual(60); + expect(document.querySelectorAll('.axis').length).toEqual(60); + done(); + }); + }); + + it('Truncates 60+ dimensions to 60', function(done) { + + var mockCopy = Lib.extendDeep({}, mock1); + var newDimension, i, j; + + mockCopy.layout.width = 1680; + for(i = 0; i < 70; i++) { + newDimension = Lib.extendDeep({}, mock1.data[0].dimensions[0]); + newDimension.id = 'S' + i; + newDimension.label = 'S' + i; + delete newDimension.constraintrange; + newDimension.range = [0, 999]; + for(j = 0; j < 10; j++) { + newDimension.values[j] = Math.floor(1000 * Math.random()); + } + mockCopy.data[0].dimensions[i] = newDimension; + } + + var gd = createGraphDiv(); + Plotly.plot(gd, mockCopy.data, mockCopy.layout).then(function() { + + expect(gd.data.length).toEqual(1); + expect(gd.data[0].dimensions.length).toEqual(60); + expect(document.querySelectorAll('.axis').length).toEqual(60); + done(); + }); + }); + + it('Truncates dimension values to the shortest array, retaining only 3 lines', function(done) { + + var mockCopy = Lib.extendDeep({}, mock1); + var newDimension, i, j; + + mockCopy.layout.width = 1680; + for(i = 0; i < 60; i++) { + newDimension = Lib.extendDeep({}, mock1.data[0].dimensions[0]); + newDimension.id = 'S' + i; + newDimension.label = 'S' + i; + delete newDimension.constraintrange; + newDimension.range = [0, 999]; + newDimension.values = []; + for(j = 0; j < 65 - i; j++) { + newDimension.values[j] = Math.floor(1000 * Math.random()); + } + mockCopy.data[0].dimensions[i] = newDimension; + } + + var gd = createGraphDiv(); + Plotly.plot(gd, mockCopy.data, mockCopy.layout).then(function() { + + expect(gd.data.length).toEqual(1); + expect(gd.data[0].dimensions.length).toEqual(60); + expect(document.querySelectorAll('.axis').length).toEqual(60); + done(); + }); + }); + + it('Skip dimensions which are not plain objects or whose `values` is not an array', function(done) { + + var mockCopy = Lib.extendDeep({}, mock1); + var newDimension, i, j; + + mockCopy.layout.width = 680; + mockCopy.data[0].dimensions = []; + for(i = 0; i < 5; i++) { + newDimension = Lib.extendDeep({}, mock1.data[0].dimensions[0]); + newDimension.id = 'S' + i; + newDimension.label = 'S' + i; + delete newDimension.constraintrange; + newDimension.range = [1, 2]; + newDimension.values = []; + for(j = 0; j < 100; j++) { + newDimension.values[j] = 1 + Math.random(); + } + mockCopy.data[0].dimensions[i] = newDimension; + } + + mockCopy.data[0].dimensions[0] = 'This is not a plain object'; + mockCopy.data[0].dimensions[1].values = 'This is not an array'; + + var gd = createGraphDiv(); + Plotly.plot(gd, mockCopy.data, mockCopy.layout).then(function() { + + expect(gd.data.length).toEqual(1); + expect(gd.data[0].dimensions.length).toEqual(5); // it's still five, but ... + expect(document.querySelectorAll('.axis').length).toEqual(3); // only 3 axes shown + done(); + }); + }); + + + }); + + describe('basic use', function() { + var mockCopy, + gd; + + beforeEach(function(done) { + mockCopy = Lib.extendDeep({}, mock); + mockCopy.data[0].domain = { + x: [0.1, 0.9], + y: [0.05, 0.85] + }; + gd = createGraphDiv(); + Plotly.plot(gd, mockCopy.data, mockCopy.layout).then(done); + }); + + it('`Plotly.plot` should have proper fields on `gd.data` on initial rendering', function() { + + expect(gd.data.length).toEqual(1); + expect(gd.data[0].dimensions.length).toEqual(11); + expect(document.querySelectorAll('.axis').length).toEqual(10); // one dimension is `visible: false` + expect(gd.data[0].line.cmin).toEqual(-4000); + expect(gd.data[0].dimensions[0].visible).not.toBeDefined(); + expect(gd.data[0].dimensions[4].visible).toEqual(true); + expect(gd.data[0].dimensions[5].visible).toEqual(false); + expect(gd.data[0].dimensions[0].range).not.toBeDefined(); + expect(gd.data[0].dimensions[0].constraintrange).toBeDefined(); + expect(gd.data[0].dimensions[0].constraintrange).toEqual([100000, 150000]); + expect(gd.data[0].dimensions[1].range).toBeDefined(); + expect(gd.data[0].dimensions[1].range).toEqual([0, 700000]); + expect(gd.data[0].dimensions[1].constraintrange).not.toBeDefined(); + + }); + + it('Calling `Plotly.plot` again should add the new table', function(done) { + + var reversedMockCopy = Lib.extendDeep({}, mockCopy); + reversedMockCopy.data[0].dimensions = reversedMockCopy.data[0].dimensions.slice().reverse(); + reversedMockCopy.data[0].dimensions.forEach(function(d) {d.id = 'R_' + d.id;}); + reversedMockCopy.data[0].dimensions.forEach(function(d) {d.label = 'R_' + d.label;}); + + Plotly.plot(gd, reversedMockCopy.data, reversedMockCopy.layout).then(function() { + + expect(gd.data.length).toEqual(2); + + expect(gd.data[0].dimensions.length).toEqual(11); + expect(gd.data[0].line.cmin).toEqual(-4000); + expect(gd.data[0].dimensions[0].constraintrange).toBeDefined(); + expect(gd.data[0].dimensions[0].constraintrange).toEqual([100000, 150000]); + expect(gd.data[0].dimensions[1].constraintrange).not.toBeDefined(); + + expect(gd.data[1].dimensions.length).toEqual(11); + expect(gd.data[1].line.cmin).toEqual(-4000); + expect(gd.data[1].dimensions[10].constraintrange).toBeDefined(); + expect(gd.data[1].dimensions[10].constraintrange).toEqual([100000, 150000]); + expect(gd.data[1].dimensions[1].constraintrange).not.toBeDefined(); + + expect(document.querySelectorAll('.axis').length).toEqual(20); // one dimension is `visible: false` + + done(); + }); + + }); + + it('Calling `Plotly.restyle` with a string path should amend the preexisting table', function(done) { + + expect(gd.data.length).toEqual(1); + + Plotly.restyle(gd, 'line.colorscale', 'Viridis').then(function() { + + expect(gd.data.length).toEqual(1); + + expect(gd.data[0].line.colorscale).toEqual('Viridis'); + expect(gd.data[0].dimensions.length).toEqual(11); + expect(gd.data[0].line.cmin).toEqual(-4000); + expect(gd.data[0].dimensions[0].constraintrange).toBeDefined(); + expect(gd.data[0].dimensions[0].constraintrange).toEqual([100000, 150000]); + expect(gd.data[0].dimensions[1].constraintrange).not.toBeDefined(); + + done(); + }); + + }); + + it('Calling `Plotly.restyle` for a dimension should amend the preexisting dimension', function(done) { + + function restyleDimension(key, setterValue) { + + // array values need to be wrapped in an array; unwrapping here for value comparison + var value = Lib.isArray(setterValue) ? setterValue[0] : setterValue; + + return function() { + return Plotly.restyle(gd, 'dimensions[2].' + key, setterValue).then(function() { + expect(gd.data[0].dimensions[2][key]).toEqual(value, 'for dimension attribute \'' + key + '\''); + }); + }; + } + + restyleDimension('label', 'new label')() + .then(restyleDimension('tickvals', [[0, 0.1, 0.4, 1, 2]])) + .then(restyleDimension('ticktext', [['alpha', 'gamma', 'beta', 'omega', 'epsilon']])) + .then(restyleDimension('valueformat', '4s')) + .then(restyleDimension('range', [[0, 2]])) + .then(restyleDimension('constraintrange', [[0, 1]])) + .then(restyleDimension('values', [[0, 0.1, 0.4, 1, 2, 0, 0.1, 0.4, 1, 2]])) + .then(restyleDimension('visible', false)) + .then(done); + }); + + it('Calling `Plotly.restyle` with an object should amend the preexisting table', function(done) { + + var newStyle = Lib.extendDeep({}, mockCopy.data[0].line); + newStyle.colorscale = 'Viridis'; + newStyle.reversescale = false; + + Plotly.restyle(gd, {line: newStyle}).then(function() { + + expect(gd.data.length).toEqual(1); + + expect(gd.data[0].line.colorscale).toEqual('Viridis'); + expect(gd.data[0].line.reversescale).toEqual(false); + expect(gd.data[0].dimensions.length).toEqual(11); + expect(gd.data[0].line.cmin).toEqual(-4000); + expect(gd.data[0].dimensions[0].constraintrange).toBeDefined(); + expect(gd.data[0].dimensions[0].constraintrange).toEqual([100000, 150000]); + expect(gd.data[0].dimensions[1].constraintrange).not.toBeDefined(); + + done(); + }); + + + }); + + it('Should emit a \'plotly_restyle\' event', function(done) { + + var tester = (function() { + + var eventCalled = false; + + return { + set: function(d) {eventCalled = d;}, + get: function() {return eventCalled;} + }; + })(); + + gd.on('plotly_restyle', function() { + tester.set(true); + }); + + expect(tester.get()).toBe(false); + Plotly.restyle(gd, 'line.colorscale', 'Viridis') + .then(window.setTimeout(function() { + expect(tester.get()).toBe(true); + done(); + }, 0)); + + }); + + it('Should emit a \'plotly_hover\' event', function(done) { + + function testMaker() { + + var eventCalled = false; + + return { + set: function() {eventCalled = eventCalled || true;}, + get: function() {return eventCalled;} + }; + } + + var hoverTester = testMaker(); + var unhoverTester = testMaker(); + + gd.on('plotly_hover', function(d) { + hoverTester.set({hover: d}); + }); + + gd.on('plotly_unhover', function(d) { + unhoverTester.set({unhover: d}); + }); + + expect(hoverTester.get()).toBe(false); + expect(unhoverTester.get()).toBe(false); + + mouseEvent('mousemove', 324, 216); + mouseEvent('mouseover', 324, 216); + mouseEvent('mousemove', 315, 218); + mouseEvent('mouseover', 315, 218); + + window.setTimeout(function() { + + expect(hoverTester.get()).toBe(true); + + mouseEvent('mousemove', 329, 153); + mouseEvent('mouseover', 329, 153); + + window.setTimeout(function() { + + expect(unhoverTester.get()).toBe(true); + done(); + }, 20); + + }, 20); + + }); + + it('Calling `Plotly.relayout` with string should amend the preexisting table', function(done) { + + expect(gd.layout.width).toEqual(1184); + + Plotly.relayout(gd, 'width', 500).then(function() { + + expect(gd.data.length).toEqual(1); + + expect(gd.layout.width).toEqual(500); + expect(gd.data[0].line.colorscale).toEqual('Jet'); + expect(gd.data[0].dimensions.length).toEqual(11); + expect(gd.data[0].line.cmin).toEqual(-4000); + expect(gd.data[0].dimensions[0].constraintrange).toBeDefined(); + expect(gd.data[0].dimensions[0].constraintrange).toEqual([100000, 150000]); + expect(gd.data[0].dimensions[1].constraintrange).not.toBeDefined(); + + done(); + }); + + }); + + it('Calling `Plotly.relayout`with object should amend the preexisting table', function(done) { + + expect(gd.layout.width).toEqual(1184); + + Plotly.relayout(gd, {width: 500}).then(function() { + + expect(gd.data.length).toEqual(1); + + expect(gd.layout.width).toEqual(500); + expect(gd.data[0].line.colorscale).toEqual('Jet'); + expect(gd.data[0].dimensions.length).toEqual(11); + expect(gd.data[0].line.cmin).toEqual(-4000); + expect(gd.data[0].dimensions[0].constraintrange).toBeDefined(); + expect(gd.data[0].dimensions[0].constraintrange).toEqual([100000, 150000]); + expect(gd.data[0].dimensions[1].constraintrange).not.toBeDefined(); + + done(); + }); + + }); + + }); + + describe('Lifecycle methods', function() { + + it('Plotly.deleteTraces with one trace removes the plot', function(done) { + + var gd = createGraphDiv(); + var mockCopy = Lib.extendDeep({}, mock); + + mockCopy.data[0].line.showscale = false; + + Plotly.plot(gd, mockCopy).then(function() { + + expect(gd.data.length).toEqual(1); + + Plotly.deleteTraces(gd, 0).then(function() { + expect(d3.selectAll('.table-line-layers').node()).toEqual(null); + expect(gd.data.length).toEqual(0); + done(); + }); + }); + }); + + it('Plotly.deleteTraces with two traces removes the deleted plot', function(done) { + + var gd = createGraphDiv(); + var mockCopy = Lib.extendDeep({}, mock); + var mockCopy2 = Lib.extendDeep({}, mock); + mockCopy2.data[0].dimensions.splice(3, 4); + mockCopy.data[0].line.showscale = false; + + Plotly.plot(gd, mockCopy) + .then(function() { + expect(gd.data.length).toEqual(1); + expect(document.querySelectorAll('.yAxis').length).toEqual(10); + return Plotly.plot(gd, mockCopy2); + }) + .then(function() { + expect(gd.data.length).toEqual(2); + expect(document.querySelectorAll('.yAxis').length).toEqual(10 + 7); + return Plotly.deleteTraces(gd, [0]); + }) + .then(function() { + expect(document.querySelectorAll('.table-line-layers').length).toEqual(1); + expect(document.querySelectorAll('.yAxis').length).toEqual(7); + expect(gd.data.length).toEqual(1); + return Plotly.deleteTraces(gd, 0); + }) + .then(function() { + expect(document.querySelectorAll('.table-line-layers').length).toEqual(0); + expect(document.querySelectorAll('.yAxis').length).toEqual(0); + expect(gd.data.length).toEqual(0); + done(); + }); + }); + + it('Calling `Plotly.restyle` with zero panels left should erase lines', function(done) { + + var mockCopy = Lib.extendDeep({}, mock2); + var gd = createGraphDiv(); + Plotly.plot(gd, mockCopy.data, mockCopy.layout); + + function restyleDimension(key, dimIndex, setterValue) { + var value = Lib.isArray(setterValue) ? setterValue[0] : setterValue; + return function() { + return Plotly.restyle(gd, 'dimensions[' + dimIndex + '].' + key, setterValue).then(function() { + expect(gd.data[0].dimensions[dimIndex][key]).toEqual(value, 'for dimension attribute \'' + key + '\''); + }); + }; + } + + restyleDimension('values', 1, [[]])() + .then(function() { + d3.selectAll('.table-lines').each(function(d) { + var imageArray = d.lineLayer.readPixels(0, 0, d.model.canvasWidth, d.model.canvasHeight); + var foundPixel = false; + var i = 0; + do { + foundPixel = foundPixel || imageArray[i++] !== 0; + } while(!foundPixel && i < imageArray.length); + expect(foundPixel).toEqual(false); + }); + done(); + }); + }); + + describe('Having two datasets', function() { + + it('Two subsequent calls to Plotly.plot should create two table rows', function(done) { + + var gd = createGraphDiv(); + var mockCopy = Lib.extendDeep({}, mock); + var mockCopy2 = Lib.extendDeep({}, mock); + mockCopy.data[0].domain = {x: [0, 0.45]}; + mockCopy2.data[0].domain = {x: [0.55, 1]}; + mockCopy2.data[0].dimensions.splice(3, 4); + + expect(document.querySelectorAll('.table-line-layers').length).toEqual(0); + + Plotly.plot(gd, mockCopy) + .then(function() { + + expect(1).toEqual(1); + expect(document.querySelectorAll('.table-line-layers').length).toEqual(1); + expect(gd.data.length).toEqual(1); + + return Plotly.plot(gd, mockCopy2); + }) + .then(function() { + + expect(1).toEqual(1); + expect(document.querySelectorAll('.table-line-layers').length).toEqual(2); + expect(gd.data.length).toEqual(2); + + done(); + }); + }); + + it('Plotly.addTraces should add a new table row', function(done) { + + var gd = createGraphDiv(); + var mockCopy = Lib.extendDeep({}, mock); + var mockCopy2 = Lib.extendDeep({}, mock); + mockCopy.data[0].domain = {y: [0, 0.35]}; + mockCopy2.data[0].domain = {y: [0.65, 1]}; + mockCopy2.data[0].dimensions.splice(3, 4); + + expect(document.querySelectorAll('.table-line-layers').length).toEqual(0); + + Plotly.plot(gd, mockCopy) + .then(function() { + + expect(document.querySelectorAll('.table-line-layers').length).toEqual(1); + expect(gd.data.length).toEqual(1); + + return Plotly.addTraces(gd, [mockCopy2.data[0]]); + }) + .then(function() { + + expect(document.querySelectorAll('.table-line-layers').length).toEqual(2); + expect(gd.data.length).toEqual(2); + + done(); + }); + + }); + + it('Plotly.restyle should update the existing table row', function(done) { + + var gd = createGraphDiv(); + var mockCopy = Lib.extendDeep({}, mock); + var mockCopy2 = Lib.extendDeep({}, mock); + + delete mockCopy.data[0].dimensions[0].constraintrange; + delete mockCopy2.data[0].dimensions[0].constraintrange; + + // in this example, the brush range doesn't change... + mockCopy.data[0].dimensions[2].constraintrange = [0, 2]; + mockCopy2.data[0].dimensions[2].constraintrange = [0, 2]; + + // .. but what's inside the brush does: + function numberUpdater(v) { + switch(v) { + case 0.5: return 2.5; + default: return v; + } + } + + // shuffle around categorical values + mockCopy2.data[0].dimensions[2].ticktext = ['A', 'B', 'Y', 'AB', 'Z']; + mockCopy2.data[0].dimensions[2].tickvals = [0, 1, 2, 2.5, 3]; + mockCopy2.data[0].dimensions[2].values = mockCopy2.data[0].dimensions[2].values.map(numberUpdater); + + expect(document.querySelectorAll('.table-line-layers').length).toEqual(0); + + Plotly.plot(gd, mockCopy) + .then(function() { + + expect(document.querySelectorAll('.table-line-layers').length).toEqual(1); + expect(gd.data.length).toEqual(1); + + return Plotly.restyle(gd, { + // wrap the `dimensions` array + dimensions: [mockCopy2.data[0].dimensions] + }); + }) + .then(function() { + + expect(document.querySelectorAll('.table-line-layers').length).toEqual(1); + expect(gd.data.length).toEqual(1); + + done(); + }); + + }); + }); + }); +});