office-viewer 0.3.11 → 0.3.13

package/lib/node_modules/zrender/lib/tool/morphPath.js

@@ -0,0 +1,602 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var curve = require('../core/curve.js');
+var Path = require('../graphic/Path.js');
+var util = require('../core/util.js');
+var vector = require('../core/vector.js');
+var path = require('./path.js');
+var Transformable = require('../core/Transformable.js');
+var dividePath = require('./dividePath.js');
+var convertPath = require('./convertPath.js');
+
+function alignSubpath(subpath1, subpath2) {
+    var len1 = subpath1.length;
+    var len2 = subpath2.length;
+    if (len1 === len2) {
+        return [subpath1, subpath2];
+    }
+    var tmpSegX = [];
+    var tmpSegY = [];
+    var shorterPath = len1 < len2 ? subpath1 : subpath2;
+    var shorterLen = Math.min(len1, len2);
+    var diff = Math.abs(len2 - len1) / 6;
+    var shorterBezierCount = (shorterLen - 2) / 6;
+    var eachCurveSubDivCount = Math.ceil(diff / shorterBezierCount) + 1;
+    var newSubpath = [shorterPath[0], shorterPath[1]];
+    var remained = diff;
+    for (var i = 2; i < shorterLen;) {
+        var x0 = shorterPath[i - 2];
+        var y0 = shorterPath[i - 1];
+        var x1 = shorterPath[i++];
+        var y1 = shorterPath[i++];
+        var x2 = shorterPath[i++];
+        var y2 = shorterPath[i++];
+        var x3 = shorterPath[i++];
+        var y3 = shorterPath[i++];
+        if (remained <= 0) {
+            newSubpath.push(x1, y1, x2, y2, x3, y3);
+            continue;
+        }
+        var actualSubDivCount = Math.min(remained, eachCurveSubDivCount - 1) + 1;
+        for (var k = 1; k <= actualSubDivCount; k++) {
+            var p = k / actualSubDivCount;
+            curve.cubicSubdivide(x0, x1, x2, x3, p, tmpSegX);
+            curve.cubicSubdivide(y0, y1, y2, y3, p, tmpSegY);
+            x0 = tmpSegX[3];
+            y0 = tmpSegY[3];
+            newSubpath.push(tmpSegX[1], tmpSegY[1], tmpSegX[2], tmpSegY[2], x0, y0);
+            x1 = tmpSegX[5];
+            y1 = tmpSegY[5];
+            x2 = tmpSegX[6];
+            y2 = tmpSegY[6];
+        }
+        remained -= actualSubDivCount - 1;
+    }
+    return shorterPath === subpath1 ? [newSubpath, subpath2] : [subpath1, newSubpath];
+}
+function createSubpath(lastSubpathSubpath, otherSubpath) {
+    var len = lastSubpathSubpath.length;
+    var lastX = lastSubpathSubpath[len - 2];
+    var lastY = lastSubpathSubpath[len - 1];
+    var newSubpath = [];
+    for (var i = 0; i < otherSubpath.length;) {
+        newSubpath[i++] = lastX;
+        newSubpath[i++] = lastY;
+    }
+    return newSubpath;
+}
+function alignBezierCurves(array1, array2) {
+    var _a;
+    var lastSubpath1;
+    var lastSubpath2;
+    var newArray1 = [];
+    var newArray2 = [];
+    for (var i = 0; i < Math.max(array1.length, array2.length); i++) {
+        var subpath1 = array1[i];
+        var subpath2 = array2[i];
+        var newSubpath1 = void 0;
+        var newSubpath2 = void 0;
+        if (!subpath1) {
+            newSubpath1 = createSubpath(lastSubpath1 || subpath2, subpath2);
+            newSubpath2 = subpath2;
+        }
+        else if (!subpath2) {
+            newSubpath2 = createSubpath(lastSubpath2 || subpath1, subpath1);
+            newSubpath1 = subpath1;
+        }
+        else {
+            _a = alignSubpath(subpath1, subpath2), newSubpath1 = _a[0], newSubpath2 = _a[1];
+            lastSubpath1 = newSubpath1;
+            lastSubpath2 = newSubpath2;
+        }
+        newArray1.push(newSubpath1);
+        newArray2.push(newSubpath2);
+    }
+    return [newArray1, newArray2];
+}
+function centroid(array) {
+    var signedArea = 0;
+    var cx = 0;
+    var cy = 0;
+    var len = array.length;
+    for (var i = 0, j = len - 2; i < len; j = i, i += 2) {
+        var x0 = array[j];
+        var y0 = array[j + 1];
+        var x1 = array[i];
+        var y1 = array[i + 1];
+        var a = x0 * y1 - x1 * y0;
+        signedArea += a;
+        cx += (x0 + x1) * a;
+        cy += (y0 + y1) * a;
+    }
+    if (signedArea === 0) {
+        return [array[0] || 0, array[1] || 0];
+    }
+    return [cx / signedArea / 3, cy / signedArea / 3, signedArea];
+}
+function findBestRingOffset(fromSubBeziers, toSubBeziers, fromCp, toCp) {
+    var bezierCount = (fromSubBeziers.length - 2) / 6;
+    var bestScore = Infinity;
+    var bestOffset = 0;
+    var len = fromSubBeziers.length;
+    var len2 = len - 2;
+    for (var offset = 0; offset < bezierCount; offset++) {
+        var cursorOffset = offset * 6;
+        var score = 0;
+        for (var k = 0; k < len; k += 2) {
+            var idx = k === 0 ? cursorOffset : ((cursorOffset + k - 2) % len2 + 2);
+            var x0 = fromSubBeziers[idx] - fromCp[0];
+            var y0 = fromSubBeziers[idx + 1] - fromCp[1];
+            var x1 = toSubBeziers[k] - toCp[0];
+            var y1 = toSubBeziers[k + 1] - toCp[1];
+            var dx = x1 - x0;
+            var dy = y1 - y0;
+            score += dx * dx + dy * dy;
+        }
+        if (score < bestScore) {
+            bestScore = score;
+            bestOffset = offset;
+        }
+    }
+    return bestOffset;
+}
+function reverse(array) {
+    var newArr = [];
+    var len = array.length;
+    for (var i = 0; i < len; i += 2) {
+        newArr[i] = array[len - i - 2];
+        newArr[i + 1] = array[len - i - 1];
+    }
+    return newArr;
+}
+function findBestMorphingRotation(fromArr, toArr, searchAngleIteration, searchAngleRange) {
+    var result = [];
+    var fromNeedsReverse;
+    for (var i = 0; i < fromArr.length; i++) {
+        var fromSubpathBezier = fromArr[i];
+        var toSubpathBezier = toArr[i];
+        var fromCp = centroid(fromSubpathBezier);
+        var toCp = centroid(toSubpathBezier);
+        if (fromNeedsReverse == null) {
+            fromNeedsReverse = fromCp[2] < 0 !== toCp[2] < 0;
+        }
+        var newFromSubpathBezier = [];
+        var newToSubpathBezier = [];
+        var bestAngle = 0;
+        var bestScore = Infinity;
+        var tmpArr = [];
+        var len = fromSubpathBezier.length;
+        if (fromNeedsReverse) {
+            fromSubpathBezier = reverse(fromSubpathBezier);
+        }
+        var offset = findBestRingOffset(fromSubpathBezier, toSubpathBezier, fromCp, toCp) * 6;
+        var len2 = len - 2;
+        for (var k = 0; k < len2; k += 2) {
+            var idx = (offset + k) % len2 + 2;
+            newFromSubpathBezier[k + 2] = fromSubpathBezier[idx] - fromCp[0];
+            newFromSubpathBezier[k + 3] = fromSubpathBezier[idx + 1] - fromCp[1];
+        }
+        newFromSubpathBezier[0] = fromSubpathBezier[offset] - fromCp[0];
+        newFromSubpathBezier[1] = fromSubpathBezier[offset + 1] - fromCp[1];
+        if (searchAngleIteration > 0) {
+            var step = searchAngleRange / searchAngleIteration;
+            for (var angle = -searchAngleRange / 2; angle <= searchAngleRange / 2; angle += step) {
+                var sa = Math.sin(angle);
+                var ca = Math.cos(angle);
+                var score = 0;
+                for (var k = 0; k < fromSubpathBezier.length; k += 2) {
+                    var x0 = newFromSubpathBezier[k];
+                    var y0 = newFromSubpathBezier[k + 1];
+                    var x1 = toSubpathBezier[k] - toCp[0];
+                    var y1 = toSubpathBezier[k + 1] - toCp[1];
+                    var newX1 = x1 * ca - y1 * sa;
+                    var newY1 = x1 * sa + y1 * ca;
+                    tmpArr[k] = newX1;
+                    tmpArr[k + 1] = newY1;
+                    var dx = newX1 - x0;
+                    var dy = newY1 - y0;
+                    score += dx * dx + dy * dy;
+                }
+                if (score < bestScore) {
+                    bestScore = score;
+                    bestAngle = angle;
+                    for (var m = 0; m < tmpArr.length; m++) {
+                        newToSubpathBezier[m] = tmpArr[m];
+                    }
+                }
+            }
+        }
+        else {
+            for (var i_1 = 0; i_1 < len; i_1 += 2) {
+                newToSubpathBezier[i_1] = toSubpathBezier[i_1] - toCp[0];
+                newToSubpathBezier[i_1 + 1] = toSubpathBezier[i_1 + 1] - toCp[1];
+            }
+        }
+        result.push({
+            from: newFromSubpathBezier,
+            to: newToSubpathBezier,
+            fromCp: fromCp,
+            toCp: toCp,
+            rotation: -bestAngle
+        });
+    }
+    return result;
+}
+function isCombineMorphing(path) {
+    return path.__isCombineMorphing;
+}
+var SAVED_METHOD_PREFIX = '__mOriginal_';
+function saveAndModifyMethod(obj, methodName, modifiers) {
+    var savedMethodName = SAVED_METHOD_PREFIX + methodName;
+    var originalMethod = obj[savedMethodName] || obj[methodName];
+    if (!obj[savedMethodName]) {
+        obj[savedMethodName] = obj[methodName];
+    }
+    var replace = modifiers.replace;
+    var after = modifiers.after;
+    var before = modifiers.before;
+    obj[methodName] = function () {
+        var args = arguments;
+        var res;
+        before && before.apply(this, args);
+        if (replace) {
+            res = replace.apply(this, args);
+        }
+        else {
+            res = originalMethod.apply(this, args);
+        }
+        after && after.apply(this, args);
+        return res;
+    };
+}
+function restoreMethod(obj, methodName) {
+    var savedMethodName = SAVED_METHOD_PREFIX + methodName;
+    if (obj[savedMethodName]) {
+        obj[methodName] = obj[savedMethodName];
+        obj[savedMethodName] = null;
+    }
+}
+function applyTransformOnBeziers(bezierCurves, mm) {
+    for (var i = 0; i < bezierCurves.length; i++) {
+        var subBeziers = bezierCurves[i];
+        for (var k = 0; k < subBeziers.length;) {
+            var x = subBeziers[k];
+            var y = subBeziers[k + 1];
+            subBeziers[k++] = mm[0] * x + mm[2] * y + mm[4];
+            subBeziers[k++] = mm[1] * x + mm[3] * y + mm[5];
+        }
+    }
+}
+function prepareMorphPath(fromPath, toPath) {
+    var fromPathProxy = fromPath.getUpdatedPathProxy();
+    var toPathProxy = toPath.getUpdatedPathProxy();
+    var _a = alignBezierCurves(convertPath.pathToBezierCurves(fromPathProxy), convertPath.pathToBezierCurves(toPathProxy)), fromBezierCurves = _a[0], toBezierCurves = _a[1];
+    var fromPathTransform = fromPath.getComputedTransform();
+    var toPathTransform = toPath.getComputedTransform();
+    function updateIdentityTransform() {
+        this.transform = null;
+    }
+    fromPathTransform && applyTransformOnBeziers(fromBezierCurves, fromPathTransform);
+    toPathTransform && applyTransformOnBeziers(toBezierCurves, toPathTransform);
+    saveAndModifyMethod(toPath, 'updateTransform', { replace: updateIdentityTransform });
+    toPath.transform = null;
+    var morphingData = findBestMorphingRotation(fromBezierCurves, toBezierCurves, 10, Math.PI);
+    var tmpArr = [];
+    saveAndModifyMethod(toPath, 'buildPath', { replace: function (path) {
+            var t = toPath.__morphT;
+            var onet = 1 - t;
+            var newCp = [];
+            for (var i = 0; i < morphingData.length; i++) {
+                var item = morphingData[i];
+                var from = item.from;
+                var to = item.to;
+                var angle = item.rotation * t;
+                var fromCp = item.fromCp;
+                var toCp = item.toCp;
+                var sa = Math.sin(angle);
+                var ca = Math.cos(angle);
+                vector.lerp(newCp, fromCp, toCp, t);
+                for (var m = 0; m < from.length; m += 2) {
+                    var x0_1 = from[m];
+                    var y0_1 = from[m + 1];
+                    var x1 = to[m];
+                    var y1 = to[m + 1];
+                    var x = x0_1 * onet + x1 * t;
+                    var y = y0_1 * onet + y1 * t;
+                    tmpArr[m] = (x * ca - y * sa) + newCp[0];
+                    tmpArr[m + 1] = (x * sa + y * ca) + newCp[1];
+                }
+                var x0 = tmpArr[0];
+                var y0 = tmpArr[1];
+                path.moveTo(x0, y0);
+                for (var m = 2; m < from.length;) {
+                    var x1 = tmpArr[m++];
+                    var y1 = tmpArr[m++];
+                    var x2 = tmpArr[m++];
+                    var y2 = tmpArr[m++];
+                    var x3 = tmpArr[m++];
+                    var y3 = tmpArr[m++];
+                    if (x0 === x1 && y0 === y1 && x2 === x3 && y2 === y3) {
+                        path.lineTo(x3, y3);
+                    }
+                    else {
+                        path.bezierCurveTo(x1, y1, x2, y2, x3, y3);
+                    }
+                    x0 = x3;
+                    y0 = y3;
+                }
+            }
+        } });
+}
+function morphPath(fromPath, toPath, animationOpts) {
+    if (!fromPath || !toPath) {
+        return toPath;
+    }
+    var oldDone = animationOpts.done;
+    var oldDuring = animationOpts.during;
+    prepareMorphPath(fromPath, toPath);
+    toPath.__morphT = 0;
+    function restoreToPath() {
+        restoreMethod(toPath, 'buildPath');
+        restoreMethod(toPath, 'updateTransform');
+        toPath.__morphT = -1;
+        toPath.createPathProxy();
+        toPath.dirtyShape();
+    }
+    toPath.animateTo({
+        __morphT: 1
+    }, util.defaults({
+        during: function (p) {
+            toPath.dirtyShape();
+            oldDuring && oldDuring(p);
+        },
+        done: function () {
+            restoreToPath();
+            oldDone && oldDone();
+        }
+    }, animationOpts));
+    return toPath;
+}
+function hilbert(x, y, minX, minY, maxX, maxY) {
+    var bits = 16;
+    x = (maxX === minX) ? 0 : Math.round(32767 * (x - minX) / (maxX - minX));
+    y = (maxY === minY) ? 0 : Math.round(32767 * (y - minY) / (maxY - minY));
+    var d = 0;
+    var tmp;
+    for (var s = (1 << bits) / 2; s > 0; s /= 2) {
+        var rx = 0;
+        var ry = 0;
+        if ((x & s) > 0) {
+            rx = 1;
+        }
+        if ((y & s) > 0) {
+            ry = 1;
+        }
+        d += s * s * ((3 * rx) ^ ry);
+        if (ry === 0) {
+            if (rx === 1) {
+                x = s - 1 - x;
+                y = s - 1 - y;
+            }
+            tmp = x;
+            x = y;
+            y = tmp;
+        }
+    }
+    return d;
+}
+function sortPaths(pathList) {
+    var xMin = Infinity;
+    var yMin = Infinity;
+    var xMax = -Infinity;
+    var yMax = -Infinity;
+    var cps = util.map(pathList, function (path) {
+        var rect = path.getBoundingRect();
+        var m = path.getComputedTransform();
+        var x = rect.x + rect.width / 2 + (m ? m[4] : 0);
+        var y = rect.y + rect.height / 2 + (m ? m[5] : 0);
+        xMin = Math.min(x, xMin);
+        yMin = Math.min(y, yMin);
+        xMax = Math.max(x, xMax);
+        yMax = Math.max(y, yMax);
+        return [x, y];
+    });
+    var items = util.map(cps, function (cp, idx) {
+        return {
+            cp: cp,
+            z: hilbert(cp[0], cp[1], xMin, yMin, xMax, yMax),
+            path: pathList[idx]
+        };
+    });
+    return items.sort(function (a, b) { return a.z - b.z; }).map(function (item) { return item.path; });
+}
+function defaultDividePath(param) {
+    return dividePath.split(param.path, param.count);
+}
+function createEmptyReturn() {
+    return {
+        fromIndividuals: [],
+        toIndividuals: [],
+        count: 0
+    };
+}
+function combineMorph(fromList, toPath, animationOpts) {
+    var fromPathList = [];
+    function addFromPath(fromList) {
+        for (var i = 0; i < fromList.length; i++) {
+            var from = fromList[i];
+            if (isCombineMorphing(from)) {
+                addFromPath(from.childrenRef());
+            }
+            else if (from instanceof Path["default"]) {
+                fromPathList.push(from);
+            }
+        }
+    }
+    addFromPath(fromList);
+    var separateCount = fromPathList.length;
+    if (!separateCount) {
+        return createEmptyReturn();
+    }
+    var dividePath = animationOpts.dividePath || defaultDividePath;
+    var toSubPathList = dividePath({
+        path: toPath, count: separateCount
+    });
+    if (toSubPathList.length !== separateCount) {
+        console.error('Invalid morphing: unmatched splitted path');
+        return createEmptyReturn();
+    }
+    fromPathList = sortPaths(fromPathList);
+    toSubPathList = sortPaths(toSubPathList);
+    var oldDone = animationOpts.done;
+    var oldDuring = animationOpts.during;
+    var individualDelay = animationOpts.individualDelay;
+    var identityTransform = new Transformable["default"]();
+    for (var i = 0; i < separateCount; i++) {
+        var from = fromPathList[i];
+        var to = toSubPathList[i];
+        to.parent = toPath;
+        to.copyTransform(identityTransform);
+        if (!individualDelay) {
+            prepareMorphPath(from, to);
+        }
+    }
+    toPath.__isCombineMorphing = true;
+    toPath.childrenRef = function () {
+        return toSubPathList;
+    };
+    function addToSubPathListToZr(zr) {
+        for (var i = 0; i < toSubPathList.length; i++) {
+            toSubPathList[i].addSelfToZr(zr);
+        }
+    }
+    saveAndModifyMethod(toPath, 'addSelfToZr', {
+        after: function (zr) {
+            addToSubPathListToZr(zr);
+        }
+    });
+    saveAndModifyMethod(toPath, 'removeSelfFromZr', {
+        after: function (zr) {
+            for (var i = 0; i < toSubPathList.length; i++) {
+                toSubPathList[i].removeSelfFromZr(zr);
+            }
+        }
+    });
+    function restoreToPath() {
+        toPath.__isCombineMorphing = false;
+        toPath.__morphT = -1;
+        toPath.childrenRef = null;
+        restoreMethod(toPath, 'addSelfToZr');
+        restoreMethod(toPath, 'removeSelfFromZr');
+    }
+    var toLen = toSubPathList.length;
+    if (individualDelay) {
+        var animating_1 = toLen;
+        var eachDone = function () {
+            animating_1--;
+            if (animating_1 === 0) {
+                restoreToPath();
+                oldDone && oldDone();
+            }
+        };
+        for (var i = 0; i < toLen; i++) {
+            var indivdualAnimationOpts = individualDelay ? util.defaults({
+                delay: (animationOpts.delay || 0) + individualDelay(i, toLen, fromPathList[i], toSubPathList[i]),
+                done: eachDone
+            }, animationOpts) : animationOpts;
+            morphPath(fromPathList[i], toSubPathList[i], indivdualAnimationOpts);
+        }
+    }
+    else {
+        toPath.__morphT = 0;
+        toPath.animateTo({
+            __morphT: 1
+        }, util.defaults({
+            during: function (p) {
+                for (var i = 0; i < toLen; i++) {
+                    var child = toSubPathList[i];
+                    child.__morphT = toPath.__morphT;
+                    child.dirtyShape();
+                }
+                oldDuring && oldDuring(p);
+            },
+            done: function () {
+                restoreToPath();
+                for (var i = 0; i < fromList.length; i++) {
+                    restoreMethod(fromList[i], 'updateTransform');
+                }
+                oldDone && oldDone();
+            }
+        }, animationOpts));
+    }
+    if (toPath.__zr) {
+        addToSubPathListToZr(toPath.__zr);
+    }
+    return {
+        fromIndividuals: fromPathList,
+        toIndividuals: toSubPathList,
+        count: toLen
+    };
+}
+function separateMorph(fromPath, toPathList, animationOpts) {
+    var toLen = toPathList.length;
+    var fromPathList = [];
+    var dividePath = animationOpts.dividePath || defaultDividePath;
+    function addFromPath(fromList) {
+        for (var i = 0; i < fromList.length; i++) {
+            var from = fromList[i];
+            if (isCombineMorphing(from)) {
+                addFromPath(from.childrenRef());
+            }
+            else if (from instanceof Path["default"]) {
+                fromPathList.push(from);
+            }
+        }
+    }
+    if (isCombineMorphing(fromPath)) {
+        addFromPath(fromPath.childrenRef());
+        var fromLen = fromPathList.length;
+        if (fromLen < toLen) {
+            var k = 0;
+            for (var i = fromLen; i < toLen; i++) {
+                fromPathList.push(path.clonePath(fromPathList[k++ % fromLen]));
+            }
+        }
+        fromPathList.length = toLen;
+    }
+    else {
+        fromPathList = dividePath({ path: fromPath, count: toLen });
+        var fromPathTransform = fromPath.getComputedTransform();
+        for (var i = 0; i < fromPathList.length; i++) {
+            fromPathList[i].setLocalTransform(fromPathTransform);
+        }
+        if (fromPathList.length !== toLen) {
+            console.error('Invalid morphing: unmatched splitted path');
+            return createEmptyReturn();
+        }
+    }
+    fromPathList = sortPaths(fromPathList);
+    toPathList = sortPaths(toPathList);
+    var individualDelay = animationOpts.individualDelay;
+    for (var i = 0; i < toLen; i++) {
+        var indivdualAnimationOpts = individualDelay ? util.defaults({
+            delay: (animationOpts.delay || 0) + individualDelay(i, toLen, fromPathList[i], toPathList[i])
+        }, animationOpts) : animationOpts;
+        morphPath(fromPathList[i], toPathList[i], indivdualAnimationOpts);
+    }
+    return {
+        fromIndividuals: fromPathList,
+        toIndividuals: toPathList,
+        count: toPathList.length
+    };
+}
+
+exports.defaultDividePath = dividePath.split;
+exports.alignBezierCurves = alignBezierCurves;
+exports.centroid = centroid;
+exports.combineMorph = combineMorph;
+exports.isCombineMorphing = isCombineMorphing;
+exports.morphPath = morphPath;
+exports.separateMorph = separateMorph;