| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| import { prepareDataCoordInfo, getStackedOnPoint } from './helper'; // var arrayDiff = require('zrender/src/core/arrayDiff'); |
| // 'zrender/src/core/arrayDiff' has been used before, but it did |
| // not do well in performance when roam with fixed dataZoom window. |
| // function convertToIntId(newIdList, oldIdList) { |
| // // Generate int id instead of string id. |
| // // Compare string maybe slow in score function of arrDiff |
| // // Assume id in idList are all unique |
| // var idIndicesMap = {}; |
| // var idx = 0; |
| // for (var i = 0; i < newIdList.length; i++) { |
| // idIndicesMap[newIdList[i]] = idx; |
| // newIdList[i] = idx++; |
| // } |
| // for (var i = 0; i < oldIdList.length; i++) { |
| // var oldId = oldIdList[i]; |
| // // Same with newIdList |
| // if (idIndicesMap[oldId]) { |
| // oldIdList[i] = idIndicesMap[oldId]; |
| // } |
| // else { |
| // oldIdList[i] = idx++; |
| // } |
| // } |
| // } |
| |
| function diffData(oldData, newData) { |
| var diffResult = []; |
| newData.diff(oldData).add(function (idx) { |
| diffResult.push({ |
| cmd: '+', |
| idx: idx |
| }); |
| }).update(function (newIdx, oldIdx) { |
| diffResult.push({ |
| cmd: '=', |
| idx: oldIdx, |
| idx1: newIdx |
| }); |
| }).remove(function (idx) { |
| diffResult.push({ |
| cmd: '-', |
| idx: idx |
| }); |
| }).execute(); |
| return diffResult; |
| } |
| |
| export default function (oldData, newData, oldStackedOnPoints, newStackedOnPoints, oldCoordSys, newCoordSys, oldValueOrigin, newValueOrigin) { |
| var diff = diffData(oldData, newData); // var newIdList = newData.mapArray(newData.getId); |
| // var oldIdList = oldData.mapArray(oldData.getId); |
| // convertToIntId(newIdList, oldIdList); |
| // // FIXME One data ? |
| // diff = arrayDiff(oldIdList, newIdList); |
| |
| var currPoints = []; |
| var nextPoints = []; // Points for stacking base line |
| |
| var currStackedPoints = []; |
| var nextStackedPoints = []; |
| var status = []; |
| var sortedIndices = []; |
| var rawIndices = []; |
| var newDataOldCoordInfo = prepareDataCoordInfo(oldCoordSys, newData, oldValueOrigin); |
| var oldDataNewCoordInfo = prepareDataCoordInfo(newCoordSys, oldData, newValueOrigin); |
| |
| for (var i = 0; i < diff.length; i++) { |
| var diffItem = diff[i]; |
| var pointAdded = true; // FIXME, animation is not so perfect when dataZoom window moves fast |
| // Which is in case remvoing or add more than one data in the tail or head |
| |
| switch (diffItem.cmd) { |
| case '=': |
| var currentPt = oldData.getItemLayout(diffItem.idx); |
| var nextPt = newData.getItemLayout(diffItem.idx1); // If previous data is NaN, use next point directly |
| |
| if (isNaN(currentPt[0]) || isNaN(currentPt[1])) { |
| currentPt = nextPt.slice(); |
| } |
| |
| currPoints.push(currentPt); |
| nextPoints.push(nextPt); |
| currStackedPoints.push(oldStackedOnPoints[diffItem.idx]); |
| nextStackedPoints.push(newStackedOnPoints[diffItem.idx1]); |
| rawIndices.push(newData.getRawIndex(diffItem.idx1)); |
| break; |
| |
| case '+': |
| var idx = diffItem.idx; |
| currPoints.push(oldCoordSys.dataToPoint([newData.get(newDataOldCoordInfo.dataDimsForPoint[0], idx), newData.get(newDataOldCoordInfo.dataDimsForPoint[1], idx)])); |
| nextPoints.push(newData.getItemLayout(idx).slice()); |
| currStackedPoints.push(getStackedOnPoint(newDataOldCoordInfo, oldCoordSys, newData, idx)); |
| nextStackedPoints.push(newStackedOnPoints[idx]); |
| rawIndices.push(newData.getRawIndex(idx)); |
| break; |
| |
| case '-': |
| var idx = diffItem.idx; |
| var rawIndex = oldData.getRawIndex(idx); // Data is replaced. In the case of dynamic data queue |
| // FIXME FIXME FIXME |
| |
| if (rawIndex !== idx) { |
| currPoints.push(oldData.getItemLayout(idx)); |
| nextPoints.push(newCoordSys.dataToPoint([oldData.get(oldDataNewCoordInfo.dataDimsForPoint[0], idx), oldData.get(oldDataNewCoordInfo.dataDimsForPoint[1], idx)])); |
| currStackedPoints.push(oldStackedOnPoints[idx]); |
| nextStackedPoints.push(getStackedOnPoint(oldDataNewCoordInfo, newCoordSys, oldData, idx)); |
| rawIndices.push(rawIndex); |
| } else { |
| pointAdded = false; |
| } |
| |
| } // Original indices |
| |
| |
| if (pointAdded) { |
| status.push(diffItem); |
| sortedIndices.push(sortedIndices.length); |
| } |
| } // Diff result may be crossed if all items are changed |
| // Sort by data index |
| |
| |
| sortedIndices.sort(function (a, b) { |
| return rawIndices[a] - rawIndices[b]; |
| }); |
| var sortedCurrPoints = []; |
| var sortedNextPoints = []; |
| var sortedCurrStackedPoints = []; |
| var sortedNextStackedPoints = []; |
| var sortedStatus = []; |
| |
| for (var i = 0; i < sortedIndices.length; i++) { |
| var idx = sortedIndices[i]; |
| sortedCurrPoints[i] = currPoints[idx]; |
| sortedNextPoints[i] = nextPoints[idx]; |
| sortedCurrStackedPoints[i] = currStackedPoints[idx]; |
| sortedNextStackedPoints[i] = nextStackedPoints[idx]; |
| sortedStatus[i] = status[idx]; |
| } |
| |
| return { |
| current: sortedCurrPoints, |
| next: sortedNextPoints, |
| stackedOnCurrent: sortedCurrStackedPoints, |
| stackedOnNext: sortedNextStackedPoints, |
| status: sortedStatus |
| }; |
| } |