Some dirty optimizations.

src/chart/helper/createListFromArray.js

@@ -75,6 +75,9 @@ function createListFromArray(data, seriesModel, ecModel) {
     var categories = {};
     var dimValueGetter = (categoryIndex >= 0 && ifNeedCompleteOrdinalData(data))
         ? function (itemOpt, dimName, dataIndex, dimIndex) {
+            if (isDataTypedArray) {
+                return itemOpt[dimIndex];
+            }
             // If any dataItem is like { value: 10 }
             if (isDataItemOption(itemOpt)) {
                 list.hasItemOption = true;
@@ -86,6 +89,9 @@ function createListFromArray(data, seriesModel, ecModel) {
                 : converDataValue(getDataItemValue(itemOpt), dimensions[dimIndex]);
         }
         : function (itemOpt, dimName, dataIndex, dimIndex) {
+            if (isDataTypedArray) {
+                return itemOpt[dimIndex];
+            }
             var value = getDataItemValue(itemOpt);
             var val = converDataValue(value && value[dimIndex], dimensions[dimIndex]);
             // If any dataItem is like { value: 10 }

src/chart/scatter.js

 import * as echarts from '../echarts';
+import * as zrUtil from 'zrender/src/core/util';
 
 import './scatter/ScatterSeries';
 import './scatter/ScatterView';
 
-// import './scatter/StreamScatterSeries';
-// import './scatter/StreamScatterView';
-
 import visualSymbol from '../visual/symbol';
 import layoutPoints from '../layout/points';
 
@@ -15,5 +13,23 @@ import '../component/gridSimple';
 echarts.registerVisual(visualSymbol('scatter', 'circle'));
 echarts.registerLayout(layoutPoints('scatter'));
 
-// echarts.registerVisual(zrUtil.curry(visualSymbol, 'streamScatter', 'circle', null));
-// echarts.registerLayout(zrUtil.curry(layoutPoints, 'streamScatter'));
+// echarts.registerProcessor(function (ecModel, api) {
+//     ecModel.eachSeriesByType('scatter', function (seriesModel) {
+//         var data = seriesModel.getData();
+//         var coordSys = seriesModel.coordinateSystem;
+//         if (coordSys.type !== 'geo') {
+//             return;
+//         }
+//         var startPt = coordSys.pointToData([0, 0]);
+//         var endPt = coordSys.pointToData([api.getWidth(), api.getHeight()]);
+
+//         var dims = zrUtil.map(coordSys.dimensions, function (dim) {
+//             return seriesModel.coordDimToDataDim(dim)[0];
+//         });
+//         var range = {};
+//         range[dims[0]] = [Math.min(startPt[0], endPt[0]), Math.max(startPt[0], endPt[0])];
+//         range[dims[1]] = [Math.min(startPt[1], endPt[1]), Math.max(startPt[1], endPt[1])];
+
+//         data.selectRange(range);
+//     });
+// });
\ No newline at end of file

src/data/List.js

@@ -561,6 +561,9 @@ listProto._initDataFromProvider = function (start, end) {
         rawData.clean();
     }
     this._count = end;
+
+    // Reset data extent
+    this._extent = {};
 };
 
 /**
@@ -702,9 +705,7 @@ listProto.getDataExtent = function (dim, stack) {
 
     // Make more strict checkings to ensure hitting cache.
     var currEnd = this.count();
-    // Consider that the data is incremental, the extent should be
-    // cached by not only dim, but also the end index.
-    var cacheName = [dim, !!stack, currEnd].join('_');
+    var cacheName = [dim, !!stack].join('_');
 
     // Consider the most cases when using data zoom, `getDataExtent`
     // happened before filtering. We cache raw extent, which is not
@@ -983,6 +984,10 @@ function validateDimensions(list, dims) {
 listProto.each = function (dims, cb, stack, context) {
     'use strict';
 
+    if (!this._count) {
+        return;
+    }
+
     if (typeof dims === 'function') {
         context = stack;
         stack = cb;
@@ -1035,6 +1040,10 @@ listProto.each = function (dims, cb, stack, context) {
 listProto.filterSelf = function (dimensions, cb, stack, context) {
     'use strict';
 
+    if (!this._count) {
+        return;
+    }
+
     if (typeof dimensions === 'function') {
         context = stack;
         stack = cb;
@@ -1105,6 +1114,10 @@ listProto.filterSelf = function (dimensions, cb, stack, context) {
 listProto.selectRange = function (range, stack) {
     'use strict';
 
+    if (!this._count) {
+        return;
+    }
+
     stack = stack || false;
 
     var dimensions = [];
@@ -1130,15 +1143,15 @@ listProto.selectRange = function (range, stack) {
     var offset = 0;
     var dim0 = dimensions[0];
 
-    if (dimSize === 1) {
-        var min = range[dim0][0];
-        var max = range[dim0][1];
-        stack = stack || isStacked(this, dim0);
+    var min = range[dim0][0];
+    var max = range[dim0][1];
 
-        var dimStorage = this._storage[dim0];
-        if (!this._indices && !stack) {
-            // Extreme optimization for common case. About 2x faster in chrome.
-            var idx = 0;
+    var quickFinished = false;
+    if (!this._indices && !stack) {
+        // Extreme optimization for common case. About 2x faster in chrome.
+        var idx = 0;
+        if (dimSize === 1) {
+            var dimStorage = this._storage[dimensions[0]];
             for (var k = 0; k < this._chunkCount; k++) {
                 var chunkStorage = dimStorage[k];
                 var len = Math.min(this._count - k * this._chunkSize, this._chunkSize);
@@ -1150,8 +1163,32 @@ listProto.selectRange = function (range, stack) {
                     idx++;
                 }
             }
+            quickFinished = true;
         }
-        else {
+        else if (dimSize === 2) {
+            var dimStorage = this._storage[dim0];
+            var dimStorage2 = this._storage[dimensions[1]];
+            var min2 = range[dimensions[1]][0];
+            var max2 = range[dimensions[1]][1];
+            for (var k = 0; k < this._chunkCount; k++) {
+                var chunkStorage = dimStorage[k];
+                var chunkStorage2= dimStorage2[k];
+                var len = Math.min(this._count - k * this._chunkSize, this._chunkSize);
+                for (var i = 0; i < len; i++) {
+                    var val = chunkStorage[i];
+                    var val2 = chunkStorage2[i];
+                    if (val >= min && val <= max && val2 >= min2 && val2 <= max2) {
+                        newIndices[offset++] = idx;
+                    }
+                    idx++;
+                }
+            }
+            quickFinished = true;
+        }
+    }
+    if (!quickFinished) {
+        if (dimSize === 1) {
+            stack = stack || isStacked(this, dim0);
             for (var i = 0; i < originalCount; i++) {
                 var rawIndex = this.getRawIndex(i);
                 var val = stack ? this.get(dim0, i, true) : this._getFast(dim0, rawIndex);
@@ -1160,20 +1197,20 @@ listProto.selectRange = function (range, stack) {
                 }
             }
         }
-    }
-    else {
-        for (var i = 0; i < originalCount; i++) {
-            var keep = true;
-            var rawIndex = this.getRawIndex(i);
-            for (var k = 0; k < dimSize; k++) {
-                var dimk = dimensions[k];
-                var val = stack ? this.get(dimk, i, true) : this._getFast(dim, rawIndex);
-                if (val < range[dimk][0] || val > range[dimk][1]) {
-                    keep = false;
+        else {
+            for (var i = 0; i < originalCount; i++) {
+                var keep = true;
+                var rawIndex = this.getRawIndex(i);
+                for (var k = 0; k < dimSize; k++) {
+                    var dimk = dimensions[k];
+                    var val = stack ? this.get(dimk, i, true) : this._getFast(dim, rawIndex);
+                    if (val < range[dimk][0] || val > range[dimk][1]) {
+                        keep = false;
+                    }
+                }
+                if (keep) {
+                    newIndices[offset++] = this.getRawIndex(i);
                 }
-            }
-            if (keep) {
-                newIndices[offset++] = this.getRawIndex(i);
             }
         }
     }